Struct DeepKernel 

pub struct DeepKernel<F: NeuralFeatureMap, K: Kernel> { /* private fields */ }

Composition of a neural feature extractor with a classical kernel.

F — the neural feature extractor (e.g. crate::deep_kernel::MLPFeatureExtractor).

K — the base kernel (e.g. crate::RbfKernel).

Implementations

impl<F: NeuralFeatureMap, K: Kernel> DeepKernel<F, K>

pub fn new(extractor: F, base: K) -> Self

Compose a feature extractor with a base kernel.

pub fn feature_extractor(&self) -> &F

Immutable view of the feature extractor.

pub fn feature_extractor_mut(&mut self) -> &mut F

Mutable view of the feature extractor — needed by optimisers that write into parameters_mut() and then call sync_from_flat on a concrete MLP.

pub fn base_kernel(&self) -> &K

Immutable view of the base kernel.

pub fn features(&self, x: &[f64]) -> Result<Vec<f64>>

Apply the feature map to a single input.

pub fn evaluate(&self, x: &[f64], y: &[f64]) -> Result<f64>

Evaluate the composed kernel on a single input pair.

pub fn compute_gram( &self, xs: &[&[f64]], ys: &[&[f64]], ) -> Result<Vec<Vec<f64>>>

Compute a Gram matrix G[i,j] = K_DKL(xs[i], ys[j]).

Feature maps are cached — each xs[i] is passed through the extractor at most once, same for ys[j]. For square xs == ys callers should prefer Self::compute_symmetric_gram.

pub fn compute_symmetric_gram(&self, xs: &[Vec<f64>]) -> Result<Vec<Vec<f64>>>

Symmetric Gram matrix for a single input set.

Takes advantage of K(a, b) == K(b, a) to halve the base-kernel evaluations; still calls the feature extractor n times.

Trait Implementations

impl<F: Clone + NeuralFeatureMap, K: Clone + Kernel> Clone for DeepKernel<F, K>

fn clone(&self) -> DeepKernel<F, K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + NeuralFeatureMap, K: Debug + Kernel> Debug for DeepKernel<F, K>

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

Formats the value using the given formatter.

impl<F: NeuralFeatureMap, K: Kernel> Kernel for DeepKernel<F, K>

fn compute(&self, x: &[f64], y: &[f64]) -> Result<f64>

Compute kernel value between two inputs.

fn name(&self) -> &str

Get kernel name for identification.

fn is_psd(&self) -> bool

Check if kernel is positive semi-definite.

fn compute_matrix(&self, inputs: &[Vec<f64>]) -> Result<Vec<Vec<f64>>>

Compute kernel matrix for a set of inputs.