Can taper functions be learnable in gpytorch?

[Tomas-Pierce-at-NIA]

I'm currently trying to implement an approach described in https://pubmed.ncbi.nlm.nih.gov/34890155/.
Part of the approach is use a tapering function to promote sparsity.
I have tried to implement this by creating a kernel which implements the tapering behavior and is then multiplied with other kernels using a product kernel, which works to an extent but runs into some issues.

First is that this tends not to learn a tapering distance, and tends to keep the tapering distance it is initialized with.
The second is that a previous variation on this would allow its tapering distance to reach zero.
Third is that under some conditions, previous revisions would fail to maintain the positive semidefinite matrix condition.

I am also curious if a better, more correct implementation is possible.

My implementation of a tapering function as a kernel follows.

import torch
from gpytorch import kernels
import gpytorch

class TaperKernel(kernels.Kernel):

    is_stationary=True

    def __init__(self, taper_prior=None, taper_constraint=None, **kwargs):

        super().__init__(**kwargs)

        self.register_parameter(
                name='raw_taperlength',
                parameter=torch.nn.Parameter(torch.zeros(*self.batch_shape, 1, 1))
                )

        if taper_constraint is None:
            taper_constraint = Positive()

        self.register_constraint("raw_taperlength", taper_constraint)

        if taper_prior is not None:
            self.register_prior(
                    "taperlength_prior",
                    taper_prior,
                    self._taperlength_param,
                    self._taperlength_closure
                    )

    @staticmethod
    def _taperlength_closure(m, v):
        m._set_taperlength(v)

    @staticmethod
    def _taperlength_param(m):
        return m.taperlength

    @property
    def taperlength(self):
        return self.raw_taperlength_constraint.transform(self.raw_taperlength)

    @taperlength.setter
    def taperlength(self, value):
        return self._set_taperlength(value)

    def _set_taperlength(self, value):
        if not torch.is_tensor(value):
            value = torch.as_tensor(value).to(self.raw_taperlength)
        self.initialize(raw_taperlength=self.raw_taperlength_constraint.inverse_transform(value))

    def forward(self, x1, x2, diag=False, **params):
        diff = self.covar_dist(x1, x2, **params)
        intaper = torch.where(diff < self.taperlength, 1.0, 0.0)
        if diag:
            return intaper.diagonal(dim1=-1, dim2=-2)
        else:
            return intaper

I would be very grateful for any help on this.