package sklearn

You can search for identifiers within the package.

in-package search v0.2.0

sklearn
- Sklearn

Legend:
Library
Module
Module type
Parameter
Class
Class type

type tag = [

| `Matern

]

type t =
  [ `Matern | `NormalizedKernelMixin | `Object | `StationaryKernelMixin ] Obj.t

val of_pyobject : Py.Object.t -> t

val to_pyobject : [> tag ] Obj.t -> Py.Object.t

val as_normalized_kernel : t -> [ `NormalizedKernelMixin ] Obj.t

val as_stationary_kernel : t -> [ `StationaryKernelMixin ] Obj.t

val create : 
  ?length_scale:[> `ArrayLike ] Np.Obj.t ->
  ?length_scale_bounds:[ `Tuple of float * float | `Fixed ] ->
  ?nu:float ->
  unit ->
  t

Matern kernel.

The class of Matern kernels is a generalization of the :class:`RBF`. It has an additional parameter :math:`\nu` which controls the smoothness of the resulting function. The smaller :math:`\nu`, the less smooth the approximated function is. As :math:`\nu\rightarrow\infty`, the kernel becomes equivalent to the :class:`RBF` kernel. When :math:`\nu = 1/2`, the Matérn kernel becomes identical to the absolute exponential kernel. Important intermediate values are :math:`\nu=1.5` (once differentiable functions) and :math:`\nu=2.5` (twice differentiable functions).

The kernel is given by:

.. math:: k(x_i, x_j) = \frac

\Gamma(\nu)2^{\nu-1

}

\Bigg( \frac\sqrt{2\nu

}

l d(x_i , x_j ) \Bigg)^\nu K_\nu\Bigg( \frac\sqrt{2\nu

}

l d(x_i , x_j )\Bigg)

where :math:`d(\cdot,\cdot)` is the Euclidean distance, :math:`K_\nu(\cdot)` is a modified Bessel function and :math:`\Gamma(\cdot)` is the gamma function. See 1_, Chapter 4, Section 4.2, for details regarding the different variants of the Matern kernel.

Read more in the :ref:`User Guide <gp_kernels>`.

.. versionadded:: 0.18

Parameters ---------- length_scale : float or ndarray of shape (n_features,), default=1.0 The length scale of the kernel. If a float, an isotropic kernel is used. If an array, an anisotropic kernel is used where each dimension of l defines the length-scale of the respective feature dimension.

length_scale_bounds : pair of floats >= 0 or 'fixed', default=(1e-5, 1e5) The lower and upper bound on 'length_scale'. If set to 'fixed', 'length_scale' cannot be changed during hyperparameter tuning.

nu : float, default=1.5 The parameter nu controlling the smoothness of the learned function. The smaller nu, the less smooth the approximated function is. For nu=inf, the kernel becomes equivalent to the RBF kernel and for nu=0.5 to the absolute exponential kernel. Important intermediate values are nu=1.5 (once differentiable functions) and nu=2.5 (twice differentiable functions). Note that values of nu not in 0.5, 1.5, 2.5, inf incur a considerably higher computational cost (appr. 10 times higher) since they require to evaluate the modified Bessel function. Furthermore, in contrast to l, nu is kept fixed to its initial value and not optimized.

References ---------- .. 1 `Carl Edward Rasmussen, Christopher K. I. Williams (2006). 'Gaussian Processes for Machine Learning'. The MIT Press. <http://www.gaussianprocess.org/gpml/>`_

Examples -------- >>> from sklearn.datasets import load_iris >>> from sklearn.gaussian_process import GaussianProcessClassifier >>> from sklearn.gaussian_process.kernels import Matern >>> X, y = load_iris(return_X_y=True) >>> kernel = 1.0 * Matern(length_scale=1.0, nu=1.5) >>> gpc = GaussianProcessClassifier(kernel=kernel, ... random_state=0).fit(X, y) >>> gpc.score(X, y) 0.9866... >>> gpc.predict_proba(X:2,:) array([0.8513..., 0.0368..., 0.1117...], [0.8086..., 0.0693..., 0.1220...])

val clone_with_theta : 
  theta:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  Py.Object.t

Returns a clone of self with given hyperparameters theta.

Parameters ---------- theta : ndarray of shape (n_dims,) The hyperparameters

val diag : 
  x:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  [> `ArrayLike ] Np.Obj.t

Returns the diagonal of the kernel k(X, X).

The result of this method is identical to np.diag(self(X)); however, it can be evaluated more efficiently since only the diagonal is evaluated.

Parameters ---------- X : ndarray of shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y)

Returns ------- K_diag : ndarray of shape (n_samples_X,) Diagonal of kernel k(X, X)

val get_params : ?deep:bool -> [> tag ] Obj.t -> Dict.t

Get parameters of this kernel.

Parameters ---------- deep : bool, default=True If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns ------- params : dict Parameter names mapped to their values.

val is_stationary : [> tag ] Obj.t -> Py.Object.t

Returns whether the kernel is stationary.

val set_params : ?params:(string * Py.Object.t) list -> [> tag ] Obj.t -> t

Set the parameters of this kernel.

The method works on simple kernels as well as on nested kernels. The latter have parameters of the form ``<component>__<parameter>`` so that it's possible to update each component of a nested object.

Returns ------- self

val to_string : t -> string

Print the object to a human-readable representation.

val show : t -> string

Print the object to a human-readable representation.

val pp : Format.formatter -> t -> unit

Pretty-print the object to a formatter.