Struct GaussianProcess 

pub struct GaussianProcess<KernelType: Kernel, PriorType: Prior> {
    pub prior: PriorType,
    pub kernel: KernelType,
    pub noise: f64,
    pub cholesky_epsilon: Option<f64>,
    /* private fields */
}

A Gaussian process that can be used to make predictions based on its training data

Fields

prior: PriorType

Value to which the process will regress in the absence of information.

kernel: KernelType

Kernel used to fit the process on the data.

noise: f64

Amplitude of the noise of the data as provided by the user or deduced by the optimizer.

cholesky_epsilon: Option<f64>

During Cholesky decomposition, this epsilon is used in place of the diagonal term if and only if the decomposition would otherwise fail. This is especially useful for noiseless sampling processes where very small covariance can result in numerical errors causing Cholesky to fail. See https://github.com/nestordemeure/friedrich/issues/43 for details.

Implementations

impl GaussianProcess<Gaussian, ConstantPrior>

pub fn default<T: Input>( training_inputs: T, training_outputs: T::InVector, ) -> Self

Returns a gaussian process with a Gaussian kernel and a constant prior, both fitted to the data.

// training data
let training_inputs = vec![vec![0.8], vec![1.2], vec![3.8], vec![4.2]];
let training_outputs = vec![3.0, 4.0, -2.0, -2.0];

// defining and training a model
let gp = GaussianProcess::default(training_inputs, training_outputs);

pub fn builder<T: Input>( training_inputs: T, training_outputs: T::InVector, ) -> GaussianProcessBuilder<Gaussian, ConstantPrior>

Returns a builder to define specific parameters of the gaussian process.

// model parameters
let input_dimension = 1;
let output_noise = 0.1;
let exponential_kernel = Exponential::default();
let linear_prior = LinearPrior::default(input_dimension);

// defining and training a model
let gp = GaussianProcess::builder(training_inputs, training_outputs).set_noise(output_noise)
                                                                    .set_kernel(exponential_kernel)
                                                                    .fit_kernel()
                                                                    .set_prior(linear_prior)
                                                                    .fit_prior()
                                                                    .train();

impl<KernelType: Kernel, PriorType: Prior> GaussianProcess<KernelType, PriorType>

pub fn new<T: Input>( prior: PriorType, kernel: KernelType, noise: f64, cholesky_epsilon: Option<f64>, training_inputs: T, training_outputs: T::InVector, ) -> Self

Raw method to create a new gaussian process with the given parameters / data. We recommend that you use either the default parameters or the builder to simplify the definition process.

pub fn add_samples<T: Input>(&mut self, inputs: &T, outputs: &T::InVector)

Adds new samples to the model.

Updates the model (which is faster than a retraining from scratch) but does not refit the parameters.

pub fn likelihood(&self) -> f64

Computes the log likelihood of the current model given the training data.

This quantity can be used for model selection. Given two models, the one with the highest score would be the one with the highest probability of producing the data.

pub fn predict<T: Input>(&self, inputs: &T) -> T::OutVector

Makes a prediction (the mean of the gaussian process) for each row of the input.

pub fn predict_variance<T: Input>(&self, inputs: &T) -> T::OutVector

Predicts the variance of the gaussian process for each row of the input. This quantity (and its square root) can be used as a proxy for the uncertainty of the prediction.

pub fn predict_mean_variance<T: Input>( &self, inputs: &T, ) -> (T::OutVector, T::OutVector)

Predicts both the mean and the variance of the gaussian process for each row of the input.

Faster than calling predict and predict_variance separately.

let gp = GaussianProcess::default(training_inputs, training_outputs);
let input = vec![1.];
let (mean, var) = gp.predict_mean_variance(&input);
println!("prediction: {} ± {}", mean, var.sqrt());

pub fn predict_covariance<T: Input>(&self, inputs: &T) -> DMatrix<f64>

Returns the covariance matrix for the rows of the input.

pub fn sample_at<T: Input>(&self, inputs: &T) -> MultivariateNormal<T>

Produces a multivariate gaussian that can be used to sample at the input points.

The sampling requires a random number generator compatible with the rand crate:

// computes the distribution at some new coordinates
let new_inputs = vec![vec![1.], vec![2.]];
let sampler = gp.sample_at(&new_inputs);

// samples from the distribution
let mut rng = rand::rng();
println!("samples a vector : {:?}", sampler.sample(&mut rng));

pub fn fit_parameters( &mut self, fit_prior: bool, fit_kernel: bool, max_iter: usize, convergence_fraction: f64, max_time: Duration, )

Fits the requested parameters and retrains the model.

The fit of the noise and kernel parameters is done by gradient descent. It runs for a maximum of max_iter iterations and stops prematurely if all gradients are below convergence_fraction time their associated parameter or if it runs for more than max_time.

Good default values for max_iter, convergence_fraction and max_time are 100, 0.05 and chrono::Duration::seconds(3600) (one hour)

Note that, if the noise parameter ends up unnaturally large after the fit, it is a good sign that the kernel is unadapted to the data.

Trait Implementations

impl<'de, KernelType, PriorType> Deserialize<'de> for GaussianProcess<KernelType, PriorType>

where KernelType: Deserialize<'de> + Kernel, PriorType: Deserialize<'de> + Prior,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<KernelType, PriorType> Serialize for GaussianProcess<KernelType, PriorType>

where KernelType: Serialize + Kernel, PriorType: Serialize + Prior,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.