skopt.learning
.GaussianProcessRegressor¶

class
skopt.learning.
GaussianProcessRegressor
(kernel=None, alpha=1e10, optimizer='fmin_l_bfgs_b', n_restarts_optimizer=0, normalize_y=False, copy_X_train=True, random_state=None, noise=None)[source][source]¶ GaussianProcessRegressor that allows noise tunability.
The implementation is based on Algorithm 2.1 of Gaussian Processes for Machine Learning (GPML) by Rasmussen and Williams.
In addition to standard scikitlearn estimator API, GaussianProcessRegressor:
allows prediction without prior fitting (based on the GP prior);
provides an additional method sample_y(X), which evaluates samples drawn from the GPR (prior or posterior) at given inputs;
exposes a method log_marginal_likelihood(theta), which can be used externally for other ways of selecting hyperparameters, e.g., via Markov chain Monte Carlo.
 Parameters
 kernelkernel object
The kernel specifying the covariance function of the GP. If None is passed, the kernel “1.0 * RBF(1.0)” is used as default. Note that the kernel’s hyperparameters are optimized during fitting.
 alphafloat or arraylike, optional (default: 1e10)
Value added to the diagonal of the kernel matrix during fitting. Larger values correspond to increased noise level in the observations and reduce potential numerical issue during fitting. If an array is passed, it must have the same number of entries as the data used for fitting and is used as datapointdependent noise level. Note that this is equivalent to adding a WhiteKernel with c=alpha. Allowing to specify the noise level directly as a parameter is mainly for convenience and for consistency with Ridge.
 optimizerstring or callable, optional (default: “fmin_l_bfgs_b”)
Can either be one of the internally supported optimizers for optimizing the kernel’s parameters, specified by a string, or an externally defined optimizer passed as a callable. If a callable is passed, it must have the signature:
def optimizer(obj_func, initial_theta, bounds): # * 'obj_func' is the objective function to be maximized, which # takes the hyperparameters theta as parameter and an # optional flag eval_gradient, which determines if the # gradient is returned additionally to the function value # * 'initial_theta': the initial value for theta, which can be # used by local optimizers # * 'bounds': the bounds on the values of theta .... # Returned are the best found hyperparameters theta and # the corresponding value of the target function. return theta_opt, func_min
Per default, the ‘fmin_l_bfgs_b’ algorithm from scipy.optimize is used. If None is passed, the kernel’s parameters are kept fixed. Available internal optimizers are:
'fmin_l_bfgs_b'
 n_restarts_optimizerint, optional (default: 0)
The number of restarts of the optimizer for finding the kernel’s parameters which maximize the logmarginal likelihood. The first run of the optimizer is performed from the kernel’s initial parameters, the remaining ones (if any) from thetas sampled loguniform randomly from the space of allowed thetavalues. If greater than 0, all bounds must be finite. Note that n_restarts_optimizer == 0 implies that one run is performed.
 normalize_yboolean, optional (default: False)
Whether the target values y are normalized, i.e., the mean of the observed target values become zero. This parameter should be set to True if the target values’ mean is expected to differ considerable from zero. When enabled, the normalization effectively modifies the GP’s prior based on the data, which contradicts the likelihood principle; normalization is thus disabled per default.
 copy_X_trainbool, optional (default: True)
If True, a persistent copy of the training data is stored in the object. Otherwise, just a reference to the training data is stored, which might cause predictions to change if the data is modified externally.
 random_stateinteger or numpy.RandomState, optional
The generator used to initialize the centers. If an integer is given, it fixes the seed. Defaults to the global numpy random number generator.
 noisestring, “gaussian”, optional
If set to “gaussian”, then it is assumed that
y
is a noisy estimate off(x)
where the noise is gaussian.
 Attributes
 X_train_arraylike, shape = (n_samples, n_features)
Feature values in training data (also required for prediction)
 y_train_arraylike, shape = (n_samples, [n_output_dims])
Target values in training data (also required for prediction)
 kernel_ kernel object
The kernel used for prediction. The structure of the kernel is the same as the one passed as parameter but with optimized hyperparameters
 L_arraylike, shape = (n_samples, n_samples)
Lowertriangular Cholesky decomposition of the kernel in
X_train_
 alpha_arraylike, shape = (n_samples,)
Dual coefficients of training data points in kernel space
 log_marginal_likelihood_value_float
The logmarginallikelihood of
self.kernel_.theta
 noise_float
Estimate of the gaussian noise. Useful only when noise is set to “gaussian”.
Methods
fit
(X, y)Fit Gaussian process regression model.
get_params
([deep])Get parameters for this estimator.
log_marginal_likelihood
([theta, …])Returns logmarginal likelihood of theta for training data.
predict
(X[, return_std, return_cov, …])Predict output for X.
sample_y
(X[, n_samples, random_state])Draw samples from Gaussian process and evaluate at X.
score
(X, y[, sample_weight])Return the coefficient of determination R^2 of the prediction.
set_params
(**params)Set the parameters of this estimator.

__init__
(kernel=None, alpha=1e10, optimizer='fmin_l_bfgs_b', n_restarts_optimizer=0, normalize_y=False, copy_X_train=True, random_state=None, noise=None)[source][source]¶ Initialize self. See help(type(self)) for accurate signature.

fit
(X, y)[source][source]¶ Fit Gaussian process regression model.
 Parameters
 Xarraylike, shape = (n_samples, n_features)
Training data
 yarraylike, shape = (n_samples, [n_output_dims])
Target values
 Returns
 self
Returns an instance of self.

get_params
(deep=True)[source]¶ Get parameters for this estimator.
 Parameters
 deepbool, default=True
If True, will return the parameters for this estimator and contained subobjects that are estimators.
 Returns
 paramsmapping of string to any
Parameter names mapped to their values.

log_marginal_likelihood
(theta=None, eval_gradient=False, clone_kernel=True)[source][source]¶ Returns logmarginal likelihood of theta for training data.
 Parameters
 thetaarraylike of shape (n_kernel_params,) default=None
Kernel hyperparameters for which the logmarginal likelihood is evaluated. If None, the precomputed log_marginal_likelihood of
self.kernel_.theta
is returned. eval_gradientbool, default=False
If True, the gradient of the logmarginal likelihood with respect to the kernel hyperparameters at position theta is returned additionally. If True, theta must not be None.
 clone_kernelbool, default=True
If True, the kernel attribute is copied. If False, the kernel attribute is modified, but may result in a performance improvement.
 Returns
 log_likelihoodfloat
Logmarginal likelihood of theta for training data.
 log_likelihood_gradientndarray of shape (n_kernel_params,), optional
Gradient of the logmarginal likelihood with respect to the kernel hyperparameters at position theta. Only returned when eval_gradient is True.

predict
(X, return_std=False, return_cov=False, return_mean_grad=False, return_std_grad=False)[source][source]¶ Predict output for X.
In addition to the mean of the predictive distribution, also its standard deviation (return_std=True) or covariance (return_cov=True), the gradient of the mean and the standarddeviation with respect to X can be optionally provided.
 Parameters
 Xarraylike, shape = (n_samples, n_features)
Query points where the GP is evaluated.
 return_stdbool, default: False
If True, the standarddeviation of the predictive distribution at the query points is returned along with the mean.
 return_covbool, default: False
If True, the covariance of the joint predictive distribution at the query points is returned along with the mean.
 return_mean_gradbool, default: False
Whether or not to return the gradient of the mean. Only valid when X is a single point.
 return_std_gradbool, default: False
Whether or not to return the gradient of the std. Only valid when X is a single point.
 Returns
 y_meanarray, shape = (n_samples, [n_output_dims])
Mean of predictive distribution a query points
 y_stdarray, shape = (n_samples,), optional
Standard deviation of predictive distribution at query points. Only returned when return_std is True.
 y_covarray, shape = (n_samples, n_samples), optional
Covariance of joint predictive distribution a query points. Only returned when return_cov is True.
 y_mean_gradshape = (n_samples, n_features)
The gradient of the predicted mean
 y_std_gradshape = (n_samples, n_features)
The gradient of the predicted std.

sample_y
(X, n_samples=1, random_state=0)[source][source]¶ Draw samples from Gaussian process and evaluate at X.
 Parameters
 Xarraylike of shape (n_samples, n_features) or list of object
Query points where the GP is evaluated.
 n_samplesint, default=1
The number of samples drawn from the Gaussian process
 random_stateint, RandomState, default=0
Determines random number generation to randomly draw samples. Pass an int for reproducible results across multiple function calls. See :term:
Glossary <random_state>
.
 Returns
 y_samplesndarray of shape (n_samples_X, [n_output_dims], n_samples)
Values of n_samples samples drawn from Gaussian process and evaluated at query points.

score
(X, y, sample_weight=None)[source]¶ Return the coefficient of determination R^2 of the prediction.
The coefficient R^2 is defined as (1  u/v), where u is the residual sum of squares ((y_true  y_pred) ** 2).sum() and v is the total sum of squares ((y_true  y_true.mean()) ** 2).sum(). The best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of y, disregarding the input features, would get a R^2 score of 0.0.
 Parameters
 Xarraylike of shape (n_samples, n_features)
Test samples. For some estimators this may be a precomputed kernel matrix or a list of generic objects instead, shape = (n_samples, n_samples_fitted), where n_samples_fitted is the number of samples used in the fitting for the estimator.
 yarraylike of shape (n_samples,) or (n_samples, n_outputs)
True values for X.
 sample_weightarraylike of shape (n_samples,), default=None
Sample weights.
 Returns
 scorefloat
R^2 of self.predict(X) wrt. y.
Notes
The R2 score used when calling
score
on a regressor usesmultioutput='uniform_average'
from version 0.23 to keep consistent with default value ofr2_score()
. This influences thescore
method of all the multioutput regressors (except forMultiOutputRegressor
).

set_params
(**params)[source]¶ Set the parameters of this estimator.
The method works on simple estimators as well as on nested objects (such as pipelines). The latter have parameters of the form
<component>__<parameter>
so that it’s possible to update each component of a nested object. Parameters
 **paramsdict
Estimator parameters.
 Returns
 selfobject
Estimator instance.