Learnable gaussian filter or bilateral filter for time series data

Question

I implemented gaussian filter and bilateral filter for time series as below.

class BaseSpatialFilter():
    def __init__(self, win_size=3, padding="same", n_iter=1):
        assert win_size % 2 == 1, "window size must be odd value."
        assert padding in ("zero", "same", "identical"),\
            "padding method has to be `zero`, `same` or `identical`."

        self.win_size = win_size
        self.padder = get_padder(padding, {"padding_size": win_size // 2})
        self.med_idx = win_size // 2
        self.n_iter = n_iter

    def fit(self, seq):
        self.seq_ = seq  # keep original signal internal
        # padding
        self.seq_padded_ = self.padder.transform(seq)

        return self
    
    def transform(self, seq):
        for i in range(self.n_iter):
            x = self.seq_padded_
            # do filtering for each sub-sequence
            filt = []
            for xs in window(x, n=self.win_size):
                filt.append(self._filt(xs))
            x = np.hstack(filt)
            self.seq_padded_ = self.padder.transform(x)

        return x

    def fit_transform(self, seq):
        self.fit(seq)
        return self.transform(seq)

    @abc.abstractmethod
    def _filt(self, sub_seq):
        """Execute filtering for sub sequence.
        """
        pass

class GaussianFilter(BaseSpatialFilter):
    def __init__(self, win_size, padding="same", n_iter=1, sigma_d=None):
        super(GaussianFilter, self).__init__(win_size, padding, n_iter)
        if sigma_d is None:
            sigma_d = self._suggest_sigma_d()
        self.sigma_d = sigma_d
        self.weight = norm.pdf(np.arange(win_size), loc=self.med_idx, scale=self.sigma_d)
        self.weight /= self.weight.sum()

    def _filt(self, sub_seq):
        prod = self.weight.reshape(1, -1) @ sub_seq.reshape(-1, 1)
        return prod[0, 0]

class BilateralFilter(GaussianFilter):
    def __init__(self, win_size, padding="same", n_iter=100, sigma_d=None, sigma_i=None):
        super(BilateralFilter, self).__init__(win_size, padding, n_iter, sigma_d)
        self.sigma_i = sigma_i

    def _filt(self, sub_seq):
        if self.sigma_i is None:
            self.sigma_i = self._suggest_sigma_i()

        w = norm.pdf(sub_seq, loc=sub_seq[self.med_idx], scale=self.sigma_i)
        weight = self.weight * w
        weight /= weight.sum()

        prod = weight.reshape(1, -1) @ sub_seq.reshape(-1, 1)
        return prod[0, 0]

and I can apply this filter as below code

filt = GaussianFilter(WIN_SIZE, n_iter=iter_param, sigma_d=d_param)
filterd_y = filt.fit_transform(x).reshape((-1,1)) 

However, I want to make this parameters(sigma_d for gaussian, sigma_i for bilateral) learnable such as apply this kernel to Convlayer.

How can I do that?

Thx for reading my question.

ps. sorry for my poor English skills.