Struct LearnedMixtureKernel 

pub struct LearnedMixtureKernel { /* private fields */ }

A differentiable mixture over a library of base kernels.

The mixture is parameterised by a vector of logits w. Weights p = softmax(w) are always strictly positive and sum to 1. The evaluation is

K_mix(x, y) = sum_i p_i * K_i(x, y).

Logits are unconstrained real numbers; the softmax parameterisation guarantees a valid convex combination on the simplex, which keeps the mixture positive semi-definite when every base kernel is PSD.

Implementations

impl LearnedMixtureKernel

pub fn new(base_kernels: Vec<Arc<dyn Kernel>>, logits: Vec<f64>) -> Result<Self>

Build a mixture from a non-empty library and matching logits.

Errors when the library is empty, the vectors disagree in length, or any logit is non-finite.

pub fn uniform(base_kernels: Vec<Arc<dyn Kernel>>) -> Result<Self>

Build a mixture with uniform logits (all zeros → equal weights).

pub fn num_kernels(&self) -> usize

Number of base kernels in the library.

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

Immutable view of the raw logits.

pub fn weights(&self) -> Vec<f64>

Softmax weights p_i = softmax(w)_i. Always strictly positive, always sums to 1 in exact arithmetic.

pub fn set_logits(&mut self, new_logits: Vec<f64>) -> Result<()>

Replace the logits. The new vector must match num_kernels() and every element must be finite.

pub fn apply_gradient_step( &mut self, gradient: &[f64], learning_rate: f64, ) -> Result<()>

Apply a raw gradient update w_i <- w_i - lr * g_i in place. Used by crate::learned_composition::TrainableKernelMixture.

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

Evaluate the mixture on a single input pair.

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

Return the analytical gradient dK_mix/dw_i = p_i * (K_i - K_mix).

This form is numerically cleaner than routing through the full softmax Jacobian (it stays bounded as p_i concentrates mass).

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

Return the forward value and the full gradient in one pass — the preferred API for optimizer steps (avoids redundant evaluations).

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

Compute a Gram matrix G[i,j] = K_mix(xs[i], ys[j]) over two sets of raw slices. Works for square xs == ys and rectangular cross- evaluation alike.

Trait Implementations

impl Clone for LearnedMixtureKernel

fn clone(&self) -> LearnedMixtureKernel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LearnedMixtureKernel

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

Formats the value using the given formatter.

impl From<LearnedMixtureKernel> for TrainableKernelMixture

fn from(inner: LearnedMixtureKernel) -> Self

Converts to this type from the input type.

impl Kernel for LearnedMixtureKernel

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.