mojolearn.GaussianProcessClassifier#

class mojolearn.GaussianProcessClassifier(kernel=None, *, optimizer=None, n_restarts_optimizer=0, max_iter_predict=100, warm_start=False, copy_X_train=True, random_state=None, multi_class='one_vs_rest', n_jobs=None)#

Gaussian process classification by the Laplace approximation.

Follows scikit-learn’s GaussianProcessClassifier: a latent Gaussian process with a logistic likelihood, fitted by Newton iteration (Rasmussen and Williams, Algorithms 3.1 and 3.2). Two classes give one binary model; more classes give one binary model per class against the rest, with probabilities normalized per row as in scikit-learn’s one-vs-rest wrapper. X is dense float32 in C order (other inputs are converted).

Differences from scikit-learn that change results:

  • There is no hyperparameter optimizer. optimizer must be None (the default here; scikit-learn’s is "fmin_l_bfgs_b"), so kernel_ is the kernel you pass.

  • Every fit starts from zero latent values; warm_start=True is refused.

Parameters:

  • kernel (Kernel or None, default None) – A combination of RBF, Matern, ConstantKernel and WhiteKernel with + and *. None means ConstantKernel(1.0) * RBF(1.0). Other kernel types raise TypeError.

  • optimizer (None, default None) – Only None (or "none") is accepted; anything else raises NotImplementedError.

  • n_restarts_optimizer (int, default 0) – Only 0 is accepted (NotImplementedError otherwise).

  • max_iter_predict (int, default 100) – Maximum number of Newton iterations per binary fit; the iteration can stop earlier on convergence. Must be an int (TypeError) of at least 1 (ValueError).

  • warm_start (bool, default False) – Only False is accepted (NotImplementedError otherwise).

  • copy_X_train (bool, default True) – Only True is accepted: X is always copied to float32 memory.

  • random_state (None, default None) – Only None is accepted; without an optimizer nothing is random.

  • multi_class (“one_vs_rest”, default “one_vs_rest”) – "one_vs_one" raises NotImplementedError; any other value raises ValueError.

  • n_jobs (None, default None) – Only None is accepted; the binary fits run on one device.

  • numeric_mode (str or None, default None) – The numeric mode for this estimator; None uses the process default. See the numeric modes guide.

Variables:

  • classes_ (list) – The class labels, in sorted order.

  • n_classes_ (int) – Number of classes.

  • X_train_ (Array of shape (n_train, n_features), float32) – The training inputs.

  • estimators_ (list) – The binary fits: one for two classes, one per class past two. Each has y_train_, L_, pi_, W_sr_, log_marginal_likelihood_value_ and n_iter_.

  • W_sr_ (y_train_, L_, pi_,) – Two classes only: the 0/1 targets, the lower Cholesky factor of I + W_sr K W_sr, the training probabilities and the square root of the likelihood Hessian of the single binary fit.

  • log_marginal_likelihood_value_ (float) – The binary fit’s log marginal likelihood, or the mean over the binary fits past two classes.

  • n_iter_ (int or list of int) – Newton iterations run: an int for two classes, one int per class past two.

  • kernel_ (Kernel) – The kernel passed in.

  • n_features_in_ (int) – Number of features seen during fit.

  • input_copied_ (bool) – Whether fit had to copy X to reach float32 C order.

Examples

>>> import numpy as np, mojolearn
>>> rng = np.random.default_rng(0)
>>> X = rng.random((200, 4), dtype=np.float32)
>>> y = (X[:, 0] + X[:, 1] > 1.0).astype(np.int32)
>>> model = mojolearn.GaussianProcessClassifier(mojolearn.RBF(0.5)).fit(X, y)
>>> proba = model.predict_proba(X[:5])

See also

GaussianProcessRegressor

User guide: Gaussian processes

Choosing an estimator

Methods

fit(X, y)

Fit the classifier.

get_params([deep])

latent_mean_and_variance(X)

Mean and variance of the latent function at X.

load(path)

Load a model written by save.

log_marginal_likelihood([theta, ...])

Log marginal likelihood of the fitted model.

numeric_mode_used()

The numeric mode this estimator runs in.

predict(X)

Predict class labels for X.

predict_proba(X)

Class probabilities for X.

save(path)

Save the fitted model to path as an .npz file.

score(X, y)

Mean accuracy of predict on X against y.

set_params(**params)

Set constructor parameters.

vendor_used()

The GPU backend this estimator runs on.
fit(X, y)#

Fit the classifier.

Encodes the classes, then runs one binary Laplace fit for two classes or one per class against the rest.

Parameters:

  • X (array-like of shape (n_samples, n_features)) – Training inputs, converted to float32.

  • y (array-like of shape (n_samples,)) – Class labels; at least two distinct classes (ValueError otherwise).

Returns:

self (GaussianProcessClassifier)

latent_mean_and_variance(X)#

Mean and variance of the latent function at X.

Binary models only, as in scikit-learn; a model with more than two classes raises ValueError.

Parameters:

X (array-like of shape (n_query, n_features)) – Query points, converted to float32.

Returns:

  • mean (Array of shape (n_query,), float32)

  • var (Array of shape (n_query,), float32)

predict_proba(X)#

Class probabilities for X.

Past two classes, each row of the per-class probabilities is divided by its sum, as in scikit-learn’s one-vs-rest wrapper.

Parameters:

X (array-like of shape (n_query, n_features)) – Query points, converted to float32.

Returns:

Array of shape (n_query, n_classes), float64 – Columns follow classes_.

predict(X)#

Predict class labels for X.

With two classes, classes_[1] where the latent mean is positive and classes_[0] elsewhere. Past two, the class with the largest one-vs-rest probability; a tie goes to the first such class.

Parameters:

X (array-like of shape (n_query, n_features)) – Query points, converted to float32.

Returns:

labels (Array or list of shape (n_query,)) – Labels drawn from classes_: an int64 or float64 Array for numeric classes, a list for string or bool classes.

log_marginal_likelihood(theta=None, eval_gradient=False, clone_kernel=True)#

Log marginal likelihood of the fitted model.

Only theta=None is supported: it returns log_marginal_likelihood_value_. A theta raises NotImplementedError and eval_gradient=True raises ValueError.

Parameters:

  • theta (None, default None)

  • eval_gradient (bool, default False)

  • clone_kernel (bool, default True) – Accepted for scikit-learn compatibility; ignored.

Returns:

float

score(X, y)#

Mean accuracy of predict on X against y.

Parameters:

  • X (array-like of shape (n_samples, n_features)) – Test inputs.

  • y (array-like of shape (n_samples,)) – True labels.

Returns:

float

save(path)#

Save the fitted model to path as an .npz file.

The file holds everything prediction reads, byte for byte: the kernel, the float32 training inputs, the classes, the numeric mode and each binary fit’s state. Raises RuntimeError if the model is not fitted.

Parameters:

path (str or path-like) – Destination file.

classmethod load(path)#

Load a model written by save.

The loaded model supports predict, predict_proba and latent_mean_and_variance, including on a CPU-only install. Every array is read at its saved dtype and never cast; a file saved by a different estimator or with inconsistent contents raises ValueError.

Parameters:

path (str or path-like) – File written by save.

Returns:

GaussianProcessClassifier

numeric_mode_used()#

The numeric mode this estimator runs in.

Returns:

str – 'identical' or 'fast', read from the compiled binary the estimator uses, not from the argument it was given.

set_params(**params)#

Set constructor parameters. The estimator is rebuilt through its constructor, so every constructor check runs again and any fitted state is dropped, as a new setting invalidates it.

vendor_used()#

The GPU backend this estimator runs on.

Returns:

str – 'metal', 'cuda' or 'hip', read from the compiled binary the estimator uses.