Struct StandardScaler 

pub struct StandardScaler {
    pub means: Vec<f32>,
    pub stds: Vec<f32>,
    /* private fields */
}

StandardScaler: (x - μ) / σ

Transforms features to have zero mean and unit variance.

Why it helps GBDTs

Even though trees are scale-invariant, scaling improves:

• Regularization fairness: L1/L2 penalties applied uniformly
• Binning uniformity: Quantiles distributed evenly
• Numerical stability: Gradient/Hessian calculations
• Mixed ensembles: Combining linear + tree models

Example

use treeboost::preprocessing::{StandardScaler, Scaler};

let mut train = vec![1.0, 10.0, 2.0, 20.0, 3.0, 30.0]; // 3 rows × 2 features
let mut test = vec![1.5, 15.0, 2.5, 25.0]; // 2 rows × 2 features

let mut scaler = StandardScaler::new();
scaler.fit(&train, 2)?;
scaler.transform(&mut train, 2)?;
scaler.transform(&mut test, 2)?; // Use same mean/std from training

Fields

means: Vec<f32>

Mean of each feature (learned during fit)

stds: Vec<f32>

Standard deviation of each feature (learned during fit)

Implementations

impl StandardScaler

pub fn new() -> Self

Create a new unfitted StandardScaler

pub fn with_forget_factor(forget_factor: f32) -> Self

Create a StandardScaler with EMA-based rolling window updates

Arguments

• forget_factor - Alpha value between 0.0 and 1.0 (clamped if out of range)

Example

// Create scaler with alpha=0.1 (10% blend from each new batch)
let mut scaler = StandardScaler::with_forget_factor(0.1);
scaler.partial_fit(&batch1, num_features)?;  // 100% batch1
scaler.partial_fit(&batch2, num_features)?;  // 90% batch1, 10% batch2
scaler.partial_fit(&batch3, num_features)?;  // 81% batch1, 9% batch2, 10% batch3

pub fn set_forget_factor(&mut self, factor: Option<f32>)

Set the forget factor for EMA-based updates

Arguments

• factor - Value between 0.0 and 1.0, or None to disable EMA mode

pub fn forget_factor(&self) -> Option<f32>

Get the current forget factor

pub fn means(&self) -> &[f32]

Get the means (only valid after fit)

pub fn stds(&self) -> &[f32]

Get the standard deviations (only valid after fit)

Trait Implementations

impl Clone for StandardScaler

fn clone(&self) -> StandardScaler

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StandardScaler

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

Formats the value using the given formatter.

impl Default for StandardScaler

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for StandardScaler

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<StandardScaler> for Preprocessor

fn from(scaler: StandardScaler) -> Self

Converts to this type from the input type.

impl IncrementalScaler for StandardScaler

fn partial_fit(&mut self, data: &[f32], num_features: usize) -> Result<()>

Update internal state with a new batch of data

fn n_samples(&self) -> u64

Get the total number of samples seen across all partial_fit calls

fn merge(&mut self, other: &Self) -> Result<()>

Merge state from another scaler of the same type

impl Scaler for StandardScaler

fn fit(&mut self, data: &[f32], num_features: usize) -> Result<()>

Fit scaler on training data (row-major: num_rows × num_features)

fn transform(&self, data: &mut [f32], num_features: usize) -> Result<()>

Transform data in-place using fitted parameters

fn is_fitted(&self) -> bool

Check if scaler has been fitted

fn fit_transform(&mut self, data: &mut [f32], num_features: usize) -> Result<()>

Fit and transform in one step (convenience)

impl Serialize for StandardScaler

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.