Class RBFKernel

numpy_ml/utils/kernels.py:184–238

class RBFKernel(KernelBase):
    def __init__(self, sigma=None):
        """
        Radial basis function (RBF) / squared exponential kernel.

        Notes
        -----
        For input vectors :math:`\mathbf{x}` and :math:`\mathbf{y}`, the radial
        basis function kernel is:

        .. math::

            k(\mathbf{x}, \mathbf{y}) = \exp \left\{ -0.5
                \left\lVert \\frac{\mathbf{x} -
                    \mathbf{y}}{\sigma} \\right\\rVert_2^2 \\right\}

        The RBF kernel decreases with distance and ranges between zero (in the
        limit) to one (when **x** = **y**). Notably, the implied feature space
        of the kernel has an infinite number of dimensions.

        Parameters
        ----------
        sigma : float or array of shape `(C,)` or None
            A scaling parameter for the vectors **x** and **y**, producing an
            isotropic kernel if a float, or an anistropic kernel if an array of
            length `C`.  Larger values result in higher resolution / greater
            smoothing. If None, defaults to :math:`\sqrt(C / 2)`. Sometimes
            referred to as the kernel 'bandwidth'. Default is None.
        """
        super().__init__()
        self.hyperparameters = {"id": "RBFKernel"}
        self.parameters = {"sigma": sigma}

    def _kernel(self, X, Y=None):
        """
        Computes the radial basis function (RBF) kernel between all pairs of
        rows in `X` and `Y`.

        Parameters
        ----------
        X : :py:class:`ndarray <numpy.ndarray>` of shape `(N, C)`
            Collection of `N` input vectors, each with dimension `C`.
        Y : :py:class:`ndarray <numpy.ndarray>` of shape `(M, C)`
            Collection of `M` input vectors. If None, assume `Y` = `X`. Default
            is None.

        Returns
        -------
        out : :py:class:`ndarray <numpy.ndarray>` of shape `(N, M)`
            Similarity between `X` and `Y` where index (i, j) gives :math:`k(x_i, y_j)`.
        """
        P = self.parameters
        X, Y = kernel_checks(X, Y)
        sigma = np.sqrt(X.shape[1] / 2) if P["sigma"] is None else P["sigma"]
        return np.exp(-0.5 * pairwise_l2_distances(X / sigma, Y / sigma) ** 2)


class KernelInitializer(object):