featrs 0.2.0

Feature engineering library for Rust, inspired by scikit-learn
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

# featrs

[![Crates.io](https://img.shields.io/crates/v/featrs)](https://crates.io/crates/featrs)
[![Docs.rs](https://img.shields.io/docsrs/featrs)](https://docs.rs/featrs)
[![CI](https://github.com/DeathSurfing/featrs/actions/workflows/ci.yml/badge.svg)](https://github.com/DeathSurfing/featrs/actions/workflows/ci.yml)
[![GitHub Stars](https://img.shields.io/github/stars/DeathSurfing/featrs?style=social)](https://github.com/DeathSurfing/featrs)
[![MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

Feature engineering library for Rust, inspired by scikit-learn.

Built on [Polars](https://pola.rs) — all transformations operate natively on `DataFrame` and preserve column names.

## Installation

```toml
[dependencies]
featrs = "0.1"
```

## Quick start

```rust
use polars::prelude::*;
use featrs::prelude::*;

let mut scaler = StandardScaler::new();
scaler.fit(data.clone(), target)?;
let scaled = scaler.transform(data)?;
```

## Features

| Component | Description |
|---|---|
| `StandardScaler` | Z-score normalization (mean 0, variance 1) |
| `MinMaxScaler` | Scale to `[0, 1]` or custom range |
| `RobustScaler` | Scale using median and IQR (outlier-robust) |
| `Normalizer` | Row-wise L1, L2, or Max normalization |
| `OneHotEncoder` | Create binary dummy columns for categories |
| `LabelEncoder` | Encode labels as `0..n_classes-1` integers |
| `OrdinalEncoder` | Per-column category → integer encoding |
| `Binarizer` | Threshold-based binarization |
| `SimpleImputer` | Fill nulls with mean, median, mode, or constant |
| `PolynomialFeatures` | Generate polynomial and interaction features |
| `Pipeline` | Sequentially chain multiple transformers |
| `ColumnTransformer` | Apply different transformers to different columns |
| `VarianceThreshold` | Remove low-variance features |
| `SelectKBest` | Select top-k features by statistical test (ANOVA F) |
| `FeatureHasher` | Hash string features into a fixed number of buckets |
| `AutoTypeDetector` | Auto-detect column types and apply default transforms |
| `MissingIndicator` | Add binary columns marking missing values |
| `Lagger` | Create lag features for time-series forecasting |
| `RollingAggregator` | Rolling window mean, std, min, max, sum |
| `Difference` | Differencing and percentage change |
| `CyclicalEncoder` | Sin/cos encoding for cyclical features (hour, month, etc.) |

## Examples

### StandardScaler

```rust
use featrs::preprocessing::scaler::StandardScaler;
use featrs::traits::{Fit, Transform};

let mut scaler = StandardScaler::new();
scaler.fit(df.clone(), target.clone())?;
let scaled = scaler.transform(df)?;
```

### Pipeline

```rust
use featrs::pipeline::Pipeline;
use featrs::preprocessing::scaler::StandardScaler;
use featrs::preprocessing::polynomial_features::PolynomialFeatures;

let mut pipeline = Pipeline::new(vec![
    ("scaler".into(), Box::new(StandardScaler::new())),
    ("poly".into(), Box::new(PolynomialFeatures::new(2))),
]);
pipeline.fit(df.clone(), target)?;
let result = pipeline.transform(df)?;
```

### ColumnTransformer

```rust
use featrs::pipeline::ColumnTransformer;
use featrs::pipeline::column_transformer::Remainder;
use featrs::preprocessing::scaler::StandardScaler;

let ct = ColumnTransformer::new(
    vec![("scale".into(), Box::new(StandardScaler::new()), vec!["feat_a".into()])],
    Remainder::Passthrough,
);
```

### Feature Selection

```rust
use featrs::feature_selection::VarianceThreshold;
use featrs::feature_selection::SelectKBest;
use featrs::feature_selection::select_kbest::FClassif;

let mut vt = VarianceThreshold::new(0.01);
vt.fit(features.clone(), target.clone())?;
let filtered = vt.transform(features)?;

let mut skb = SelectKBest::new(5, Box::new(FClassif::new()));
skb.fit(features.clone(), target)?;
let selected = skb.transform(features)?;
```

### PolynomialFeatures

```rust
use featrs::preprocessing::polynomial_features::PolynomialFeatures;

// Builder pattern (recommended)
let pf = PolynomialFeatures::builder()
    .degree(3)
    .include_bias(false)
    .interaction_only(true)
    .build();

// Or direct construction
let pf = PolynomialFeatures::new(2).include_bias(true);
```

## Resources

- [Crates.io](https://crates.io/crates/featrs)
- [Docs.rs](https://docs.rs/featrs)
- [GitHub](https://github.com/DeathSurfing/featrs)

## Star History

[![Star History](https://starchart.cc/DeathSurfing/featrs.svg?variant=adaptive)](https://starchart.cc/DeathSurfing/featrs)

## License

MIT