Encoders & Vectorizers

Binarize labels in a one-vs-all fashion.

This transformer creates a binary matrix representation of labels where each class gets its own column. For multi-class problems, this creates a one-hot encoding of the labels.

Time Complexity: - fit: O(n) where n is the number of samples - transform: O(n*k) where k is the number of classes

Space Complexity: O(n*k) for the output matrix

Encode target labels with value between 0 and n_classes-1.

This transformer encodes categorical labels (strings or numbers) into integers in the range [0, n_classes-1]. It maintains a mapping of unique classes to their integer representations and can reverse the transformation. Classes are sorted: numbers numerically, bigints numerically and strings by Unicode code point (so "B" sorts before "a", as in NumPy).

Time Complexity: - fit: O(n + k log k) where n is the number of samples and k the number of classes - transform: O(n) with O(1) lookup per sample - inverseTransform: O(n)

Space Complexity: O(k) where k is the number of unique classes

Transform multi-label classification data to binary format.

This transformer handles multi-label classification where each sample can belong to multiple classes simultaneously. It creates a binary matrix where each column represents a class and multiple columns can be active (set to 1) for a single sample.

Time Complexity: - fit: O(n*k) where n is samples, k is avg labels per sample - transform: O(n*k*c) where c is total unique classes

Space Complexity: O(n*c) for the output matrix

Encode categorical features as one-hot numeric array.

This encoder transforms categorical features into a binary one-hot encoding. Each categorical feature with n unique values is transformed into n binary features, with only one active (set to 1) per sample. Categories of each feature are sorted (numbers numerically, strings by Unicode code point) unless given explicitly through the categories option.

Time Complexity: - fit: O(n*m + sum(k_i log k_i)) where n is samples, m is features, k_i the categories of feature i - transform: O(n*m) with O(1) lookup per value, plus O(n * sum(k_i)) to allocate the dense output - Sparse mode avoids the dense allocation, which matters for high-cardinality features

Space Complexity: - Dense: O(n * sum(k_i)) where k_i is unique categories for feature i - Sparse: O(nnz) where nnz is number of non-zero elements

Encode categorical features as integer array.

This encoder transforms categorical features into ordinal integers. Each feature's categories are mapped to integers [0, n_categories-1] based on their sorted order (or the order of the categories option). Unlike OneHotEncoder, this maintains a single column per feature.

Time Complexity: - fit: O(n*m + sum(k_j log k_j)) where n=samples, m=features, k_j=categories of feature j - transform: O(n*m) with O(1) map lookup per value

Space Complexity: O(m*k) where m=features, k=avg categories per feature

Target-based encoding for categorical features.

Replaces each category with a smoothed mean of the target for that category: (n * categoryMean + smooth * targetMean) / (n + smooth), which pulls rare categories toward the overall target mean. Categories not seen during fit encode as the overall target mean. Features may be numbers, bigints or strings.

fitTransform uses cross-fitting (as scikit-learn does), so the training encoding of a row never uses that row's own target. Rows are assigned to cv folds deterministically (row i goes to fold i % cv).

Convert a collection of text documents to a matrix of token counts.

Implements the bag-of-words model: each document becomes a vector of word counts. The vocabulary is learned from the training data and sorted alphabetically by UTF-16 code unit, which is scikit-learn's order except for rare characters outside the Basic Multilingual Plane. Features whose document frequency is outside [minDf, maxDf] are dropped, then at most maxFeatures of the most frequent terms are kept. Fitting throws a DataValidationError when no term survives.

The result is a dense matrix of the default float dtype; for very large vocabularies use maxFeatures or HashingVectorizer.

Convert text documents to a fixed-size feature matrix using the hashing trick.

Unlike CountVectorizer and TfidfVectorizer, HashingVectorizer does not need to build a vocabulary, making it suitable for large-scale or streaming data. Features are token hashes mapped to a fixed number of buckets.

Trade-offs: - No need to fit (stateless transform) - Fixed memory usage regardless of vocabulary size - Cannot retrieve feature names (hash collisions are possible) - Signed hashing (alternateSign) reduces collision bias

The output is a dense [nDocs, nFeatures] matrix, so the default of 2^20 features costs 8 MB per document; choose a smaller nFeatures for many documents.

Convert a collection of text documents to a TF-IDF feature matrix.

Combines CountVectorizer with TF-IDF weighting. TF-IDF (Term Frequency - Inverse Document Frequency) down-weights terms that appear in many documents and up-weights rare, discriminative terms.

IDF formula: log((1 + n) / (1 + df)) + 1 with smoothIdf (default), or log(n / df) + 1 without it, where n is the number of fitted documents and df the number of documents containing the term. Rows are normalized to unit L2 norm by default. The results match scikit-learn's TfidfVectorizer for the same options.