ferrolearn-preprocess 0.3.0

Preprocessing transformers for the ferrolearn ML framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! # ferrolearn-preprocess
//!
//! Data preprocessing transformers for the ferrolearn machine learning framework.
//!
//! This crate provides standard scalers, encoders, imputers, and feature
//! selection utilities that follow the ferrolearn `Fit`/`Transform` trait
//! pattern.
//!
//! ## Scalers
//!
//! All scalers are generic over `F: Float + Send + Sync + 'static` and implement
//! [`Fit<Array2<F>, ()>`](ferrolearn_core::Fit) (returning a `Fitted*` type) and
//! [`FitTransform<Array2<F>>`](ferrolearn_core::FitTransform). The fitted types
//! implement [`Transform<Array2<F>>`](ferrolearn_core::Transform).
//!
//! - [`StandardScaler`] — zero-mean, unit-variance scaling
//! - [`MinMaxScaler`] — scale features to a given range (default `[0, 1]`)
//! - [`RobustScaler`] — median / IQR-based scaling, robust to outliers
//! - [`MaxAbsScaler`] — scale by maximum absolute value so values are in `[-1, 1]`
//! - [`normalizer::Normalizer`] — normalize each sample (row) to unit norm
//! - [`power_transformer::PowerTransformer`] — Yeo-Johnson power transform
//!
//! ## Encoders
//!
//! - [`OneHotEncoder`] — encode `Array2<usize>` categorical columns as binary columns
//! - [`LabelEncoder`] — map `Array1<String>` labels to integer indices
//! - [`ordinal_encoder::OrdinalEncoder`] — map string categories to integers in
//!   order of first appearance
//!
//! ## Imputers
//!
//! - [`imputer::SimpleImputer`] — fill missing (NaN) values per feature column
//!   using Mean, Median, MostFrequent, or Constant strategy.
//!
//! ## Feature Selection
//!
//! - [`feature_selection::VarianceThreshold`] — remove features with variance
//!   below a configurable threshold.
//! - [`feature_selection::SelectKBest`] — keep the K features with the highest
//!   ANOVA F-scores against class labels.
//! - [`feature_selection::SelectFromModel`] — keep features whose importance
//!   weight (from a pre-fitted model) meets a configurable threshold.
//!
//! ## Feature Engineering
//!
//! - [`polynomial_features::PolynomialFeatures`] — generate polynomial and interaction features
//! - [`binarizer::Binarizer`] — threshold features to binary values
//! - [`function_transformer::FunctionTransformer`] — apply a user-provided function element-wise
//!
//! ## Pipeline Integration
//!
//! `StandardScaler<f64>`, `MinMaxScaler<f64>`, `RobustScaler<f64>`,
//! `MaxAbsScaler<f64>`, `Normalizer<f64>`, `PowerTransformer<f64>`,
//! `PolynomialFeatures<f64>`, `SimpleImputer<f64>`, `VarianceThreshold<f64>`,
//! `SelectKBest<f64>`, and `SelectFromModel<f64>` each implement
//! [`PipelineTransformer`](ferrolearn_core::pipeline::PipelineTransformer)
//! so they can be used as steps inside a
//! [`Pipeline`](ferrolearn_core::pipeline::Pipeline).
//!
//! # Examples
//!
//! ```
//! use ferrolearn_preprocess::StandardScaler;
//! use ferrolearn_core::traits::FitTransform;
//! use ndarray::array;
//!
//! let x = array![[1.0_f64, 10.0], [2.0, 20.0], [3.0, 30.0]];
//! let scaled = StandardScaler::<f64>::new().fit_transform(&x).unwrap();
//! // scaled columns now have mean ≈ 0 and std ≈ 1
//! ```

pub mod binarizer;
pub mod binary_encoder;
pub mod column_transformer;
pub mod count_vectorizer;
pub mod feature_scoring;
pub mod feature_selection;
pub mod function_transformer;
pub mod imputer;
pub mod iterative_imputer;
pub mod kbins_discretizer;
pub mod knn_imputer;
pub mod label_binarizer;
pub mod label_encoder;
pub mod max_abs_scaler;
pub mod min_max_scaler;
pub mod multi_label_binarizer;
pub mod normalizer;
pub mod one_hot_encoder;
pub mod ordinal_encoder;
pub mod polynomial_features;
pub mod power_transformer;
pub mod quantile_transformer;
pub mod random_projection;
pub mod rfe;
pub mod robust_scaler;
pub mod select_percentile;
pub mod sequential_feature_selector;
pub mod spline_transformer;
pub mod standard_scaler;
pub mod stat_selectors;
pub mod target_encoder;
pub mod tfidf;

// Re-exports
pub use binarizer::Binarizer;
pub use column_transformer::{
    ColumnSelector, ColumnTransformer, FittedColumnTransformer, Remainder, make_column_transformer,
};
pub use feature_selection::{
    FittedSelectKBest, FittedVarianceThreshold, ScoreFunc, SelectFromModel, SelectKBest,
    VarianceThreshold,
};
pub use function_transformer::FunctionTransformer;
pub use imputer::{FittedSimpleImputer, ImputeStrategy, SimpleImputer};
pub use label_encoder::{FittedLabelEncoder, LabelEncoder};
pub use max_abs_scaler::{FittedMaxAbsScaler, MaxAbsScaler};
pub use min_max_scaler::{FittedMinMaxScaler, MinMaxScaler};
pub use normalizer::Normalizer;
pub use one_hot_encoder::{FittedOneHotEncoder, OneHotEncoder};
pub use ordinal_encoder::{FittedOrdinalEncoder, OrdinalEncoder};
pub use polynomial_features::PolynomialFeatures;
pub use power_transformer::{FittedPowerTransformer, PowerTransformer};
pub use robust_scaler::{FittedRobustScaler, RobustScaler};
pub use standard_scaler::{FittedStandardScaler, StandardScaler};

// Phase 3 re-exports
pub use binary_encoder::{BinaryEncoder, FittedBinaryEncoder};
pub use iterative_imputer::{FittedIterativeImputer, InitialStrategy, IterativeImputer};
pub use kbins_discretizer::{BinEncoding, BinStrategy, FittedKBinsDiscretizer, KBinsDiscretizer};
pub use knn_imputer::{FittedKNNImputer, KNNImputer, KNNWeights};
pub use quantile_transformer::{
    FittedQuantileTransformer, OutputDistribution, QuantileTransformer,
};
pub use rfe::{RFE, RFECV};
pub use select_percentile::{FittedSelectPercentile, SelectPercentile};
pub use spline_transformer::{FittedSplineTransformer, KnotStrategy, SplineTransformer};
pub use target_encoder::{FittedTargetEncoder, TargetEncoder};

// Text processing re-exports
pub use count_vectorizer::{CountVectorizer, FittedCountVectorizer};
pub use tfidf::{FittedTfidfTransformer, TfidfNorm, TfidfTransformer};

// Random projection re-exports
pub use random_projection::{
    FittedGaussianRandomProjection, FittedSparseRandomProjection, GaussianRandomProjection,
    SparseRandomProjection,
};

// Newly wired (previously orphaned) re-exports
pub use feature_scoring::{chi2, compute_scores_classif, compute_scores_regression, f_classif, f_regression};
pub use label_binarizer::{FittedLabelBinarizer, LabelBinarizer};
pub use multi_label_binarizer::{FittedMultiLabelBinarizer, MultiLabelBinarizer};
pub use sequential_feature_selector::{
    Direction, FittedSequentialFeatureSelector, SequentialFeatureSelector,
};
pub use stat_selectors::{
    FittedSelectFdr, FittedSelectFpr, FittedSelectFwe, SelectFdr, SelectFpr, SelectFwe,
};