Struct MultiScaleRBFSampler 

pub struct MultiScaleRBFSampler<State = Untrained> {
    pub n_components_per_scale: usize,
    pub n_scales: usize,
    pub gamma_min: Float,
    pub gamma_max: Float,
    pub manual_gammas: Vec<Float>,
    pub bandwidth_strategy: BandwidthStrategy,
    pub combination_strategy: CombinationStrategy,
    pub scale_weights: Vec<Float>,
    pub random_state: Option<u64>,
    /* private fields */
}

Multi-scale RBF sampler that generates random Fourier features at multiple scales

This sampler generates RBF kernel approximations using multiple bandwidth parameters (gamma values) to capture patterns at different scales. Each scale captures different frequency characteristics of the data, providing a more comprehensive representation.

Mathematical Background

For multiple scales with bandwidths γ₁, γ₂, …, γₖ, the multi-scale RBF kernel is: K(x,y) = Σᵢ wᵢ * exp(-γᵢ||x-y||²)

The random Fourier features for each scale i are: zᵢ(x) = √(2/nᵢ) * [cos(ωᵢⱼᵀx + bᵢⱼ), sin(ωᵢⱼᵀx + bᵢⱼ)] where ωᵢⱼ ~ N(0, 2γᵢI) and bᵢⱼ ~ Uniform[0, 2π]

Examples

use sklears_kernel_approximation::{MultiScaleRBFSampler, BandwidthStrategy, CombinationStrategy};
use sklears_core::traits::{Transform, Fit, Untrained}
use scirs2_core::ndarray::array;

let x = array![[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]];

let sampler = MultiScaleRBFSampler::new(100)
    .n_scales(3)
    .gamma_range(0.1, 10.0)
    .bandwidth_strategy(BandwidthStrategy::LogarithmicSpacing)
    .combination_strategy(CombinationStrategy::Concatenation);

let fitted = sampler.fit(&x, &()).unwrap();
let features = fitted.transform(&x).unwrap();

MultiScaleRBFSampler

Fields

n_components_per_scale: usize

Number of components per scale

n_scales: usize

Number of scales

gamma_min: Float

Minimum gamma value

gamma_max: Float

Maximum gamma value

manual_gammas: Vec<Float>

Manual gamma values (used when strategy is Manual)

bandwidth_strategy: BandwidthStrategy

Bandwidth selection strategy

combination_strategy: CombinationStrategy

Feature combination strategy

scale_weights: Vec<Float>

Scale weights for weighted combination

random_state: Option<u64>

Random seed for reproducibility

Implementations

impl MultiScaleRBFSampler<Untrained>

pub fn new(n_components_per_scale: usize) -> Self

Create a new multi-scale RBF sampler

Arguments

• n_components_per_scale - Number of random features per scale

pub fn n_scales(self, n_scales: usize) -> Self

Set the number of scales

pub fn gamma_range(self, gamma_min: Float, gamma_max: Float) -> Self

Set the gamma range for automatic bandwidth selection

pub fn manual_gammas(self, gammas: Vec<Float>) -> Self

Set manual gamma values

pub fn bandwidth_strategy(self, strategy: BandwidthStrategy) -> Self

Set the bandwidth selection strategy

pub fn combination_strategy(self, strategy: CombinationStrategy) -> Self

Set the feature combination strategy

pub fn scale_weights(self, weights: Vec<Float>) -> Self

Set weights for different scales (used in weighted combination)

pub fn random_state(self, seed: u64) -> Self

Set the random state for reproducibility

Trait Implementations

impl<State: Clone> Clone for MultiScaleRBFSampler<State>

fn clone(&self) -> MultiScaleRBFSampler<State>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State: Debug> Debug for MultiScaleRBFSampler<State>

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

Formats the value using the given formatter.

impl Fit<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ()> for MultiScaleRBFSampler<Untrained>

type Fitted = MultiScaleRBFSampler<Trained>

The fitted model type

fn fit(self, x: &Array2<Float>, _y: &()) -> 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

impl Transform<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>> for MultiScaleRBFSampler<Trained>

fn transform(&self, x: &Array2<Float>) -> Result<Array2<Float>>

Transform the input data