Struct TargetEncoder 

pub struct TargetEncoder<F> { /* private fields */ }

An unfitted target encoder.

Takes a matrix of categorical integer features and a continuous (or binary) target vector at fit time. Each category is encoded as the smoothed mean of the target for that category.

Parameters

• smooth — the smoothing strategy (Smooth). The DEFAULT is Smooth::Auto (empirical Bayes), matching scikit-learn’s constructor default smooth="auto" (_target_encoder.py:199). Smooth::Fixed selects the fixed m-estimate; higher values regularise more toward the global mean, Fixed(0) is no smoothing.
• cv — the number of cross-fitting folds used by fit_transform (default 5, matching scikit-learn’s cv=5, _target_encoder.py:200).

Examples

use ferrolearn_preprocess::target_encoder::TargetEncoder;
use ferrolearn_core::traits::{Fit, Transform};
use ndarray::array;

let enc = TargetEncoder::<f64>::new(1.0);
let x = array![[0usize, 1], [0, 0], [1, 1], [1, 0]];
let y = array![1.0, 2.0, 3.0, 4.0];
let fitted = enc.fit(&x, &y).unwrap();
let out = fitted.transform(&x).unwrap();
assert_eq!(out.shape(), &[4, 2]);

Implementations

impl<F: Float + Send + Sync + 'static> TargetEncoder<F>

pub fn new(smooth: F) -> Self

Create a new TargetEncoder with a FIXED smoothing factor.

This is shorthand for with_smooth with Smooth::Fixed and cv = 5.

pub fn with_smooth(smooth: Smooth<F>) -> Self

Create a new TargetEncoder with the given smoothing strategy and cv = 5 (matching scikit-learn’s default).

pub fn with_cv(self, cv: usize) -> Self

Set the number of cross-fitting folds used by fit_transform.

pub fn smooth(&self) -> Smooth<F>

Return the smoothing strategy.

pub fn cv(&self) -> usize

Return the number of cross-fitting folds.

impl<F: Float + Send + Sync + 'static> TargetEncoder<F>

pub fn fit_transform( &self, x: &Array2<usize>, y: &Array1<F>, ) -> Result<Array2<F>, FerroError>

Cross-fitting fit_transform: encode each row using encodings learned on the OTHER folds, preventing target leakage.

Mirrors scikit-learn’s TargetEncoder.fit_transform (sklearn/preprocessing/_target_encoder.py:232-303): for the continuous/binary single-output case it uses a deterministic KFold (cv folds, NO shuffle — ferrolearn exposes no shuffle/random_state, so this is sklearn’s reproducible shuffle=False path, :262); for each (train, test) fold it fits the per-feature encodings on the TRAIN rows (with that fold’s y_train_mean) and writes the TEST rows through those train-encodings (:277-302). A category unseen in the train fold encodes to y_train_mean (the count == 0 -> y_mean rule, mirroring _transform_X_ordinal’s unknown-category fallback, :494-497).

Note fit(X,y).transform(X) does NOT equal fit_transform(X,y) (:235-238): transform uses the full-data encodings_, fit_transform is cross-fit.

Errors

• FerroError::InsufficientSamples if the input has zero rows.
• FerroError::ShapeMismatch if x rows and y length differ.
• FerroError::InvalidParameter if a Smooth::Fixed factor is negative, or if cv < 2 / cv exceeds the sample count (sklearn requires cv >= 2, _target_encoder.py:190, and KFold rejects more splits than samples, _split.py:408-414).

Trait Implementations

impl<F: Clone> Clone for TargetEncoder<F>

fn clone(&self) -> TargetEncoder<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug> Debug for TargetEncoder<F>

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

Formats the value using the given formatter.

impl<F: Float + Send + Sync + 'static> Default for TargetEncoder<F>

fn default() -> Self

The default uses Smooth::Auto (empirical Bayes) and cv = 5, matching scikit-learn’s TargetEncoder() (smooth="auto", cv=5, _target_encoder.py:199-200).

impl<F: Float + Send + Sync + 'static> Fit<ArrayBase<OwnedRepr<usize>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<F>, Dim<[usize; 1]>>> for TargetEncoder<F>

fn fit( &self, x: &Array2<usize>, y: &Array1<F>, ) -> Result<FittedTargetEncoder<F>, FerroError>

Fit the encoder by computing smoothed target means per category.

Errors

• FerroError::InsufficientSamples if the input has zero rows.
• FerroError::ShapeMismatch if x rows and y length differ.
• FerroError::InvalidParameter if smooth is negative.

type Fitted = FittedTargetEncoder<F>

The fitted model type returned by fit.

type Error = FerroError

The error type returned by fit.