API reference — Encoders & scalers¶
Pipeline tools for feeding downstream algorithms (sklearn and friends) — never invoked by the tree. Guide: Data.
IndexMapper¶
pythonclass IndexMapper(())
Categorical string <-> stable code mapping (sklearn-style fit/transform).
IndexMapper.fit¶
pythonfit((self, /, name, values))
Learn the vocabulary of name (first-seen order). Re-fitting resets it.
IndexMapper.get_all_names¶
pythonget_all_names((self, /, name))
All fitted levels in code order.
Raises: ValueError: column not fitted.
IndexMapper.get_index¶
pythonget_index((self, /, name, value))
Code for one level (None when the level is unseen).
Raises: ValueError: column not fitted.
IndexMapper.get_name¶
pythonget_name((self, /, name, index))
Level for one code.
Raises: ValueError: column not fitted or code out of range.
IndexMapper.inverse_transform¶
pythoninverse_transform((self, /, name, codes))
Map codes back to their string levels.
Args: name: fitted column name. codes: codes per row (None = missing).
Returns: string levels (None where the code is missing).
Raises: ValueError: column not fitted or code out of range.
IndexMapper.transform¶
pythontransform((self, /, name, values))
Codes for values; unseen levels map to None (missing).
VariableScaler¶
pythonclass VariableScaler(())
Per-column distributional scaling — each variable transformed
independently (legacy VariableTransformation semantics).
Same strategy names as GroupedScaler, applied per column, with exact
inverse_transform. None/NaN are missing and pass through as missing;
degenerate scales give missing, never inf.
VariableScaler.fit¶
pythonfit((self, /, columns, strategy))
Fit all columns at once under the given strategy.
Args:
columns: {name: values} for every column to scale (None/NaN =
missing; counted in each column's n_missing).
strategy: strategy name (see GroupedScaler).
Raises: ValueError: unknown strategy.
VariableScaler.inverse_transform¶
pythoninverse_transform((self, /, name, values))
Exact inverse of transform under the fitted statistics.
Args: name: fitted column name. values: previously transformed values.
Returns: original-scale values (up to floating-point error).
Raises: ValueError: not fitted or unknown column.
VariableScaler.transform¶
pythontransform((self, /, name, values))
Scale one fitted column's values.
Args: name: fitted column name. values: numeric values (None/NaN = missing).
Returns: scaled values; None for missing inputs and degenerate scales.
Raises: ValueError: not fitted or unknown column.
GroupedScaler¶
pythonclass GroupedScaler(())
Fit/transform group distributional scaling with exact inverse
(sklearn-shaped: fit once, then transform / inverse_transform).
Strategies: centered family — "zscore", "min-max", "median-iqr", "mean-iqr", "median-qd", "median-std", "median-range", "mean-range", "min-qd", "min-iqr"; ratio family — "min", "max", "mean", "median", "iqr", "qd", "std", "range". Missing in -> missing out; degenerate (zero) scales give missing, never inf.
GroupedScaler.fit¶
pythonfit((self, /, keys, values, strategy))
Fit group statistics of values under the given strategy.
Args:
keys: group label per row (None = missing).
values: numeric value per row (None/NaN = missing; counted in
each group's n_missing).
strategy: strategy name (see the class docstring).
Raises: ValueError: unknown strategy or mismatched lengths.
GroupedScaler.inverse_transform¶
pythoninverse_transform((self, /, keys, values))
Exact inverse of transform under the fitted statistics.
Args: keys: group label per row. values: previously transformed values.
Returns: original-scale values (up to floating-point error).
Raises: ValueError: not fitted or mismatched lengths.
GroupedScaler.transform¶
pythontransform((self, /, keys, values))
Scale values against the fitted group statistics.
Args: keys: group label per row. values: numeric value per row.
Returns: scaled values; None for missing key/value, unseen groups and degenerate scales.
Raises: ValueError: not fitted or mismatched lengths.
BaseNEncoder¶
pythonclass BaseNEncoder((base))
Base-N / binary encoding: each level becomes its base-base digits as
indicator columns (base = 2 is the classic Binary encoder). Task:
both (unsupervised). Unseen and missing rows are all-zero.
BaseNEncoder.fit¶
pythonfit((self, /, values))
Fit the level vocabulary on values.
BaseNEncoder.transform¶
pythontransform((self, /, values))
Returns {digit name: indicator list}.
CatBoostEncoder¶
pythonclass CatBoostEncoder((prior, permutations, seed))
CatBoost-style ordered target statistics — the leakage-safe flavour.
fit_transform gives each row the running statistic of its level using
only rows earlier in a shuffled order: (sum_y_prefix + prior * global) /
(n_prefix + 1), averaged over permutations seeded passes. The same level
gets different values in different rows — that row-dependence is the
anti-leakage mechanism. transform (new data) uses prior-smoothed fitted
level means.
CatBoostEncoder.fit¶
pythonfit((self, /, values, y))
Fit prior-smoothed level means (used by transform on new data).
CatBoostEncoder.fit_transform¶
pythonfit_transform((self, /, values, y))
Leakage-safe ordered encodings of the training rows themselves.
CatBoostEncoder.transform¶
pythontransform((self, /, values))
Encode new rows from the fitted level means; unseen -> global mean,
missing -> None.
CountEncoder¶
pythonclass CountEncoder((normalize))
Count / frequency encoding: occurrence count per category (normalize
gives the share of rows). Task: both (unsupervised). Unseen levels give
0.0; missing stays missing.
CountEncoder.fit¶
pythonfit((self, /, values))
Fit counts on values.
CountEncoder.transform¶
pythontransform((self, /, values))
Count (or share) per row; unseen -> 0.0, missing -> None.
EmbeddingEncoder¶
pythonclass EmbeddingEncoder((dim, lr, epochs, seed, task))
NN-style learned embeddings per category: a small embedding table and a
linear head trained by SGD, one table per categorical feature. Task:
both — softmax head for classification; for regression a ReLU output
when all fitted targets are non-negative, linear otherwise. transform
returns the embeddings, predict the trained head. Unseen levels give
zeros; missing stays missing.
EmbeddingEncoder.fit¶
pythonfit((self, /, values, y, n_classes=None))
Train on (values, y); n_classes is inferred for classification when
omitted, ignored for regression.
EmbeddingEncoder.predict¶
pythonpredict((self, /, values))
Predictions of the trained head (class label or activated value).
EmbeddingEncoder.transform¶
pythontransform((self, /, values))
Learned embedding per row (None = missing, zeros = unseen).
HashingEncoder¶
pythonclass HashingEncoder((n_buckets))
Hashed one-hot: levels are hashed into n_buckets indicator columns, so
unseen levels still land somewhere. Deterministic.
HashingEncoder.transform¶
pythontransform((self, /, values))
Returns {bucket name: indicator list}.
JamesSteinEncoder¶
pythonclass JamesSteinEncoder(())
James-Stein encoding: level means shrunk toward the grand mean with
B = max(0, 1 - ((L - 3) * sigma2) / sum((mean_i - global)^2)); fewer than
three levels collapse to the grand mean. Task: both. Unseen -> global;
missing -> None.
JamesSteinEncoder.fit¶
pythonfit((self, /, values, y))
Fit shrunk means on (values, y).
JamesSteinEncoder.transform¶
pythontransform((self, /, values))
Shrunk mean per row; unseen -> global, missing -> None.
LeaveOneOutEncoder¶
pythonclass LeaveOneOutEncoder(())
Leave-one-out encoding: fit_transform gives each row its level's mean
target without that row (leakage-aware); transform on new data uses
the full fitted level mean. Task: both. Unseen -> global mean;
missing -> None.
LeaveOneOutEncoder.fit¶
pythonfit((self, /, values, y))
Fit level means on (values, y).
LeaveOneOutEncoder.fit_transform¶
pythonfit_transform((self, /, values, y))
Row-level means excluding each row's own target.
LeaveOneOutEncoder.transform¶
pythontransform((self, /, values))
Full fitted level means for new rows.
MEstimatorEncoder¶
pythonclass MEstimatorEncoder((m))
M-estimate encoding: (sum_y + m * global) / (n_level + m) — target
smoothing with fixed strength m. Task: both (leaky on training data;
prefer CatBoostEncoder or LeaveOneOutEncoder there). Unseen -> global;
missing -> None.
MEstimatorEncoder.fit¶
pythonfit((self, /, values, y))
Fit smoothed level means on (values, y).
MEstimatorEncoder.transform¶
pythontransform((self, /, values))
Smoothed mean per row; unseen -> global, missing -> None.
OneHotEncoder¶
pythonclass OneHotEncoder(())
One-hot expansion: one indicator column per fitted level (first-seen
order). Missing values and levels unseen at fit produce an all-zero row.
OneHotEncoder.fit¶
pythonfit((self, /, values))
Learn the levels (first-seen order). Re-fitting resets them.
OneHotEncoder.levels¶
pythonlevels((self, /))
Fitted levels, in column order.
OneHotEncoder.transform¶
pythontransform((self, /, values))
Returns {level: indicator list}; unseen/missing rows are all-zero.
QuantileEncoder¶
pythonclass QuantileEncoder((q, smoothing))
Quantile encoding: each level becomes its smoothed target quantile
(default median), w * level_quantile + (1 - w) * global_quantile with
w = n / (n + smoothing). Task: regression. Unseen -> global
quantile; missing -> None.
QuantileEncoder.fit¶
pythonfit((self, /, values, y))
Fit quantiles on (values, y).
QuantileEncoder.transform¶
pythontransform((self, /, values))
Smoothed quantile per row; unseen -> global, missing -> None.
SumEncoder¶
pythonclass SumEncoder(())
Sum contrast coding: k-1 columns; level i < k-1 gets +1 in column
i, the last level gets -1 across all columns. Task: both
(unsupervised). Unseen rows give zeros; missing stays missing.
SumEncoder.fit¶
pythonfit((self, /, values))
Fit the level vocabulary on values.
SumEncoder.transform¶
pythontransform((self, /, values))
Contrast row per row (None = missing).
TargetEncoder¶
pythonclass TargetEncoder((smoothing))
Smoothed target encoding (fitted-mean flavour).
w * level_mean + (1 - w) * global_mean with w = n / (n + smoothing).
Leaky on training data (the row's own target is in its level mean) —
prefer CatBoostEncoder.fit_transform for training features. Unseen levels
fall back to the global mean; missing stays missing.
TargetEncoder.fit¶
pythonfit((self, /, values, y))
Fit level means on (values, y).
TargetEncoder.prior¶
pythonprior((self, /))
The global mean used as the unseen-level fallback.
TargetEncoder.transform¶
pythontransform((self, /, values))
Encode values; unseen -> global mean, missing -> None.
TfidfEncoder¶
pythonclass TfidfEncoder((normalize))
Class-level TF-IDF: each category becomes a vector over the target
classes — tf(v,j) = count(v,j)/count(v) times
idf(j) = ln(1 + n/(1 + count(j))) + 1; normalize scales each level
vector to unit L2 norm. Task: classification. Unseen levels fall back
to the global class shares; missing stays missing.
TfidfEncoder.fit¶
pythonfit((self, /, values, y, n_classes))
Fit class counts on (values, y, n_classes).
TfidfEncoder.transform¶
pythontransform((self, /, values))
One class-space vector per row (None = missing).
WoEEncoder¶
pythonclass WoEEncoder((prior))
Weight of Evidence (credit-risk classic): one-vs-rest
ln(distr_j(v) / distr_not_j(v)) per category, smoothed with additive
prior. Task: classification. Positive = over-representation of the
class in that level. Unseen levels give neutral zeros; missing stays
missing.
WoEEncoder.fit¶
pythonfit((self, /, values, y, n_classes))
Fit class counts on (values, y, n_classes).
WoEEncoder.transform¶
pythontransform((self, /, values))
One WoE vector per row (None = missing).