Struct rv::process::gaussian::GaussianProcess

pub struct GaussianProcess<K>
where
    K: Kernel,
{
    pub kernel: K,
    pub noise_model: NoiseModel,
    /* private fields */
}

Fields

kernel: K

Covariance Kernel

noise_model: NoiseModel

Noise Model

Implementations

impl<K> GaussianProcess<K>

where K: Kernel,

pub fn train( kernel: K, x_train: DMatrix<f64>, y_train: DVector<f64>, noise_model: NoiseModel ) -> Result<Self, GaussianProcessError>

Train a Gaussian Process on the given data points

Arguments

• kernel - Kernel to use to determine covariance
• x_train - Values to use for input into f
• y_train - Known values for f(x)
• noise_model - Noise model to use for fitting

pub fn k_inv(&self) -> &DMatrix<f64>

Return the inverse of K.

pub fn k_chol(&self) -> &Cholesky<f64, Dyn>

Return the Cholesky decomposition of K

pub fn kernel(&self) -> &K

Return the kernel being used in this GP

Trait Implementations

impl<K> Clone for GaussianProcess<K>

where K: Kernel + Clone,

fn clone(&self) -> GaussianProcess<K>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K> Debug for GaussianProcess<K>

where K: Kernel + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, K> Deserialize<'de> for GaussianProcess<K>

where K: Kernel + Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K> RandomProcess<f64> for GaussianProcess<K>

where K: Kernel,

type Index = Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>

Type of the indexing set.

type SampleFunction = GaussianProcessPrediction<K>

Type of the sample function, aka trajectory of the process.

type Error = GaussianProcessError

Error from

fn sample_function(&self, indicies: &[Self::Index]) -> Self::SampleFunction

Create a sample function at the indices given.

fn ln_m(&self) -> f64

Compute the log marginal likelihood

fn ln_m_with_params( &self, parameter: &DVector<f64> ) -> Result<(f64, DVector<f64>), GaussianProcessError>

Compute the log marginal likelihood with an different set of parameters and compute the gradient.

fn parameters(&self) -> DVector<f64>

Get the parameters

fn set_parameters( self, parameters: &DVector<f64> ) -> Result<Self, GaussianProcessError>

Set with the given parameters

impl<K> RandomProcessMle<f64> for GaussianProcess<K>

where K: Kernel,

type Solver = LBFGS<MoreThuenteLineSearch<Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, f64>, Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, f64>

Error type from Optimization errors

fn generate_solver() -> Self::Solver

Generator for optimizer

fn random_params<R: Rng>(&self, rng: &mut R) -> DVector<f64>

Create random parameters for this Process

fn optimize<R: Rng>( self, max_iters: u64, random_reinits: usize, rng: &mut R ) -> Result<Self, Error>

Run the optimization

impl<K> Serialize for GaussianProcess<K>

where K: Kernel + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.