Enum FeatureTransform 

pub enum FeatureTransform {
    StandardScaler,
    MinMaxScaler {
        min: f64,
        max: f64,
    },
    RobustScaler,
    LogTransform {
        offset: f64,
    },
    PowerTransform {
        lambda: f64,
    },
    RollingMean {
        window: usize,
    },
    RollingStd {
        window: usize,
    },
    RollingSum {
        window: usize,
    },
    EWMA {
        alpha: f64,
    },
    LagFeatures {
        lags: Vec<usize>,
    },
    RateOfChange {
        period: usize,
    },
    Binning {
        bins: Vec<f64>,
    },
    OneHotEncoder {
        columns: Vec<String>,
    },
    LabelEncoder {
        columns: Vec<String>,
    },
    TargetEncoder {
        column: String,
    },
    PolynomialFeatures {
        degree: usize,
    },
    InteractionFeatures {
        pairs: Vec<(String, String)>,
    },
    Imputation {
        strategy: ImputationStrategy,
    },
    FeatureSelection {
        top_k: usize,
    },
    PCA {
        n_components: usize,
    },
    Custom {
        name: String,
    },
}

Feature transformation types

Variants

StandardScaler

Standard scaling (mean=0, std=1)

MinMaxScaler

Min-max scaling (range [0, 1])

Fields

min: f64

max: f64

RobustScaler

Robust scaling (using median and IQR)

LogTransform

Log transformation

Fields

offset: f64

PowerTransform

Power transformation (Box-Cox like)

Fields

lambda: f64

RollingMean

Rolling mean over window

Fields

window: usize

RollingStd

Rolling standard deviation

Fields

window: usize

RollingSum

Rolling sum

Fields

window: usize

EWMA

Exponential weighted moving average

Fields

alpha: f64

LagFeatures

Lag features (previous values)

Fields

lags: Vec<usize>

RateOfChange

Rate of change (derivative)

Fields

period: usize

Binning

Binning/discretization

Fields

bins: Vec<f64>

OneHotEncoder

One-hot encoding for categorical features

Fields

columns: Vec<String>

LabelEncoder

Label encoding for categorical features

Fields

columns: Vec<String>

TargetEncoder

Target encoding for categorical features

Fields

column: String

PolynomialFeatures

Polynomial features

Fields

degree: usize

InteractionFeatures

Interaction features (cross products)

Fields

pairs: Vec<(String, String)>

Imputation

Missing value imputation

Fields

strategy: ImputationStrategy

FeatureSelection

Feature selection (keep top k by importance)

Fields

top_k: usize

PCA

PCA dimensionality reduction

Fields

n_components: usize

Custom

Custom transformation (user-defined function)

Fields

name: String

Trait Implementations

impl Clone for FeatureTransform

fn clone(&self) -> FeatureTransform

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FeatureTransform

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FeatureTransform

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FeatureTransform

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

where __S: Serializer,

Serialize this value into the given Serde serializer.