# Sum#

class sklearn.gaussian_process.kernels.Sum(k1, k2)[source]#

The Sum kernel takes two kernels $$k_1$$ and $$k_2$$ and combines them via

$k_{sum}(X, Y) = k_1(X, Y) + k_2(X, Y)$

Note that the __add__ magic method is overridden, so Sum(RBF(), RBF()) is equivalent to using the + operator with RBF() + RBF().

Read more in the User Guide.

Parameters:
k1Kernel

The first base-kernel of the sum-kernel

k2Kernel

The second base-kernel of the sum-kernel

Examples

>>> from sklearn.datasets import make_friedman2
>>> from sklearn.gaussian_process import GaussianProcessRegressor
>>> from sklearn.gaussian_process.kernels import RBF, Sum, ConstantKernel
>>> X, y = make_friedman2(n_samples=500, noise=0, random_state=0)
>>> kernel = Sum(ConstantKernel(2), RBF())
>>> gpr = GaussianProcessRegressor(kernel=kernel,
...         random_state=0).fit(X, y)
>>> gpr.score(X, y)
1.0
>>> kernel
1.41**2 + RBF(length_scale=1)


Return the kernel k(X, Y) and optionally its gradient.

Parameters:
Xarray-like of shape (n_samples_X, n_features) or list of object

Left argument of the returned kernel k(X, Y)

Yarray-like of shape (n_samples_X, n_features) or list of object, default=None

Right argument of the returned kernel k(X, Y). If None, k(X, X) is evaluated instead.

Determines whether the gradient with respect to the log of the kernel hyperparameter is computed.

Returns:
Kndarray of shape (n_samples_X, n_samples_Y)

Kernel k(X, Y)

K_gradientndarray of shape (n_samples_X, n_samples_X, n_dims), optional

The gradient of the kernel k(X, X) with respect to the log of the hyperparameter of the kernel. Only returned when eval_gradient is True.

property bounds#

Returns the log-transformed bounds on the theta.

Returns:
boundsndarray of shape (n_dims, 2)

The log-transformed bounds on the kernel’s hyperparameters theta

clone_with_theta(theta)[source]#

Returns a clone of self with given hyperparameters theta.

Parameters:
thetandarray of shape (n_dims,)

The hyperparameters

diag(X)[source]#

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:
Xarray-like of shape (n_samples_X, n_features) or list of object

Argument to the kernel.

Returns:
K_diagndarray of shape (n_samples_X,)

Diagonal of kernel k(X, X)

get_params(deep=True)[source]#

Get parameters of this kernel.

Parameters:
deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns:
paramsdict

Parameter names mapped to their values.

property hyperparameters#

Returns a list of all hyperparameter.

is_stationary()[source]#

Returns whether the kernel is stationary.

property n_dims#

Returns the number of non-fixed hyperparameters of the kernel.

property requires_vector_input#

Returns whether the kernel is stationary.

set_params(**params)[source]#

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
property theta#

Returns the (flattened, log-transformed) non-fixed hyperparameters.

Note that theta are typically the log-transformed values of the kernel’s hyperparameters as this representation of the search space is more amenable for hyperparameter search, as hyperparameters like length-scales naturally live on a log-scale.

Returns:
thetandarray of shape (n_dims,)

The non-fixed, log-transformed hyperparameters of the kernel