Struct SparseGaussianProcess 

pub struct SparseGaussianProcess<K> {
    pub num_inducing: usize,
    pub kernel: K,
    pub approximation: SparseApproximation,
    pub inducing_strategy: InducingPointStrategy,
    pub noise_variance: f64,
    pub max_iter: usize,
    pub tol: f64,
}

Core sparse Gaussian Process structure with configuration parameters

Fields

num_inducing: usize

Number of inducing points

kernel: K

Kernel function

approximation: SparseApproximation

Sparse approximation method

inducing_strategy: InducingPointStrategy

Strategy for selecting inducing points

noise_variance: f64

Observation noise variance

max_iter: usize

Maximum optimization iterations

tol: f64

Convergence tolerance

Implementations

impl<K> SparseGaussianProcess<K>

Builder-style methods for sparse GP configuration

pub fn approximation(self, approximation: SparseApproximation) -> Self

Set the sparse approximation method

pub fn inducing_strategy(self, strategy: InducingPointStrategy) -> Self

Set the inducing point selection strategy

pub fn noise_variance(self, noise_variance: f64) -> Self

Set the observation noise variance

pub fn optimization_params(self, max_iter: usize, tol: f64) -> Self

Set optimization parameters

impl<K: SparseKernel> SparseGaussianProcess<K>

Main sparse Gaussian Process implementation

pub fn new(num_inducing: usize, kernel: K) -> Self

Create new sparse Gaussian Process with specified inducing points and kernel

pub fn select_inducing_points(&self, x: &Array2<f64>) -> Result<Array2<f64>>

Select inducing points based on the configured strategy

Trait Implementations

impl<K: Clone> Clone for SparseGaussianProcess<K>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug> Debug for SparseGaussianProcess<K>

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

Formats the value using the given formatter.

impl<K: SparseKernel> Fit<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>> for SparseGaussianProcess<K>

Fit implementation for sparse GP

type Fitted = FittedSparseGP<K>

The fitted model type

fn fit(self, x: &Array2<f64>, y: &Array1<f64>) -> Result<Self::Fitted>

Fit the model to the provided data with validation

fn fit_with_validation( self, x: &X, y: &Y, _x_val: Option<&X>, _y_val: Option<&Y>, ) -> Result<(Self::Fitted, FitMetrics), SklearsError>

where Self: Sized,

Fit with custom validation and early stopping