Struct KRLS 

pub struct KRLS { /* private fields */ }

Kernel Recursive Least Squares with ALD sparsification.

Maintains a dictionary of support vectors and learns dual weights in the kernel space defined by the provided Kernel function.

Sparsification (ALD)

The Approximate Linear Dependency test measures whether a new sample lies within the span of existing dictionary entries (in RKHS). The test computes:

delta = k(x,x) - k_t^T * P * k_t

where k_t is the vector of kernel evaluations between the new sample and all dictionary entries, and P is the inverse kernel matrix. If delta < ald_threshold, the sample is linearly dependent and only the weights are updated.

Budget

When the dictionary reaches budget entries, no new entries are added. Subsequent independent samples fall through to weight-only updates.

Example

use irithyll::learners::krls::{KRLS, RBFKernel};
use irithyll::learner::StreamingLearner;

let mut model = KRLS::new(Box::new(RBFKernel::new(0.5)), 100, 1e-4);
model.train(&[1.0], 1.0_f64.sin());
model.train(&[2.0], 2.0_f64.sin());
let pred = model.predict(&[1.5]);
assert!(pred.is_finite());

Implementations

impl KRLS

pub fn new(kernel: Box<dyn Kernel>, budget: usize, ald_threshold: f64) -> Self

Create a new KRLS learner with no forgetting.

Arguments

• kernel – kernel function (e.g., RBFKernel, PolynomialKernel)
• budget – maximum dictionary size (caps memory usage)
• ald_threshold – ALD sparsification threshold. Typical values: 1e-4 to 1e-2. Smaller = more dictionary entries (closer approximation).

pub fn with_forgetting( kernel: Box<dyn Kernel>, budget: usize, ald_threshold: f64, forgetting_factor: f64, ) -> Self

Create a KRLS learner with exponential forgetting.

forgetting_factor in (0, 1]. Values like 0.99 introduce exponential discounting of older data for non-stationary environments.

pub fn dict_size(&self) -> usize

Current dictionary size (number of support vectors).

pub fn budget(&self) -> usize

Maximum dictionary size.

pub fn ald_threshold(&self) -> f64

The ALD threshold.

pub fn forgetting_factor(&self) -> f64

The forgetting factor.

pub fn dictionary(&self) -> &[Vec<f64>]

Immutable access to the dictionary (support vectors).

pub fn weights(&self) -> &[f64]

Immutable access to the dual weights.

Trait Implementations

impl Debug for KRLS

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

Formats the value using the given formatter.

impl DiagnosticSource for KRLS

fn config_diagnostics(&self) -> Option<ConfigDiagnostics>

Return config diagnostics, or None if not supported.

impl StreamingLearner for KRLS

fn train_one(&mut self, features: &[f64], target: f64, _weight: f64)

Train on a single observation with explicit sample weight.

fn predict(&self, features: &[f64]) -> f64

Predict the target for the given feature vector.

fn n_samples_seen(&self) -> u64

Total number of observations trained on since creation or last reset.

fn reset(&mut self)

Reset the model to its initial (untrained) state.

fn train(&mut self, features: &[f64], target: f64)

Train on a single observation with unit weight.

fn predict_batch(&self, feature_matrix: &[&[f64]]) -> Vec<f64>

Predict for each row in a feature matrix.