Count Target Encoding

class category_encoders.count_target.CountTargetEncoder(verbose: int = 0, cols: list[str] = None, drop_invariant: bool = False, return_df: bool = True, handle_missing: str = 'value', handle_unknown: str = 'value', min_samples_leaf: int = 20, smoothing: float = 10)[source]

Count-based target encoding with smoothing-adjusted log-odds.

Supported targets: binary and multiclass classification. A continuous target raises NotImplementedError; regression via target binning is a planned follow-up (see issue #420).

For every category of every encoded column, fit stores the per-class observation counts, the category size, and smoothing-adjusted log-odds against the global target prior. Transform emits those log-odds:

binary target: a single output column per encoded feature, matching the WOEEncoder column convention
multiclass target: one output column per class per encoded feature, named <column>_<class>

For a category c and class k let n_k(c) be the number of training rows in category c with class k, n(c) their sum, and prior_k the global class probability. The empirical class shares are blended with the prior by an S-shaped weight:

w(c) = expit((n(c) - min_samples_leaf) / smoothing)
p_smooth(k | c) = w(c) * n_k(c) / n(c) + (1 - w(c)) * prior_k

and the encoded value is the log-evidence of the smoothed probability against the prior:

binary:     log(p_smooth(1 | c) / p_smooth(0 | c)) - log(prior_1 / prior_0)
multiclass: log(p_smooth(k | c) / prior_k)            (one column per class)

Small categories are shrunk toward zero evidence, which tames the overfitting that raw counts would otherwise introduce on id-like columns. A category never observed at fit time encodes to 0 (“no evidence against the prior”) under the default handle_unknown='value'.

Parameters:

verbose: int: integer indicating verbosity of the output. 0 for none.
cols: list: a list of columns to encode, if None, all string columns will be encoded.
drop_invariant: bool: boolean for whether or not to drop columns with 0 variance.
return_df: bool: boolean for whether to return a pandas DataFrame from transform (otherwise it will be a numpy array).
handle_missing: str: options are ‘error’, ‘return_nan’ and ‘value’, defaults to ‘value’, which treats missing values as a countable category at fit time.
handle_unknown: str: options are ‘error’, ‘return_nan’ and ‘value’, defaults to ‘value’, which maps unseen categories to zero evidence against the prior.
min_samples_leaf: int: category size at which the S-curve weight reaches 0.5. Categories smaller than this are dominated by the prior, larger ones by their own counts (parameter k in the original target-encoding paper).
smoothing: float: slope of the S-curve between category size and the prior/count blend. Higher values mean stronger regularization. The value must be strictly bigger than 0.

Attributes:

counts_dict: Maps every encoded column to a DataFrame with the per-class counts observed at fit time (rows are the categories, columns the classes).

Methods

`fit`(X[, y])	Fits the encoder according to X and y.
`fit_transform`(X[, y])	Fit and transform using the target information.
`get_feature_names`()	Deprecated method to get feature names.
`get_feature_names_in`()	Get the names of all input columns present when fitting.
`get_feature_names_out`([input_features])	Get the names of all transformed / added columns.
`get_metadata_routing`()	Get metadata routing of this object.
`get_params`([deep])	Get parameters for this estimator.
`set_output`(*[, transform])	Set output container.
`set_params`(**params)	Set the parameters of this estimator.
`set_transform_request`(*[, override_return_df])	Configure whether metadata should be requested to be passed to the `transform` method.
`transform`(X[, y, override_return_df])	Perform the transformation to new categorical data.

References

[1]

Big Learning Made Easy with Counts (the “Dracula” count-based target scheme), from https://learn.microsoft.com/en-us/archive/blogs/machinelearning/big-learning-made-easy-with-counts

Examples

>>> from category_encoders import CountTargetEncoder
>>> import pandas as pd
>>> X = pd.DataFrame({'city': ['chicago', 'chicago', 'denver', 'denver', 'denver']})
>>> y = [1, 0, 1, 1, 0]
>>> enc = CountTargetEncoder().fit(X, y)
>>> enc.transform(X)
       city
0 -0.058774
1 -0.058774
2  0.043099
3  0.043099
4  0.043099

Fits the encoder according to X and y.

Parameters:

Xarray-like, shape = [n_samples, n_features]: Training vectors, where n_samples is the number of samples and n_features is the number of features.
yarray-like, shape = [n_samples]: Target values.

Returns:

selfencoder: Returns self.

Fit and transform using the target information.

This also uses the target for transforming, not only for training.

get_feature_names() → ndarray: Deprecated method to get feature names. Use get_feature_names_out instead.

get_feature_names_in() → ndarray

Get the names of all input columns present when fitting.

These columns are necessary for the transform step.

get_feature_names_out(input_features=None) → ndarray

Get the names of all transformed / added columns.

Note that in sklearn the get_feature_names_out function takes the feature_names_in as an argument and determines the output feature names using the input. A fit is usually not necessary and if so a NotFittedError is raised. We just require a fit all the time and return the fitted output columns.

Returns:

feature_names: np.ndarray: A numpy array with all feature names transformed or added. Note: potentially dropped features (because the feature is constant/invariant) are not included!

get_metadata_routing()

Get metadata routing of this object.

Please check User Guide on how the routing mechanism works.

Returns:

routingMetadataRequest: A MetadataRequest encapsulating routing information.

get_params(deep=True)

Get parameters for this estimator.

Parameters:

deepbool, default=True: If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns:

paramsdict: Parameter names mapped to their values.

set_output(*, transform=None)

Set output container.

Refer to the user guide for more details and sphx_glr_auto_examples_miscellaneous_plot_set_output.py for an example on how to use the API.

Parameters:

transform{“default”, “pandas”, “polars”}, default=None

Configure output of transform and fit_transform.

“default”: Default output format of a transformer
“pandas”: DataFrame output
“polars”: Polars output
None: Transform configuration is unchanged

Added in version 1.4: “polars” option was added.

Returns:

selfestimator instance: Estimator instance.

set_params(**params)

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as Pipeline). The latter have parameters of the form <component>__<parameter> so that it’s possible to update each component of a nested object.

Parameters:

**paramsdict: Estimator parameters.

Returns:

selfestimator instance: Estimator instance.

set_transform_request(*, override_return_df: bool | None | str = '$UNCHANGED$') → CountTargetEncoder

Configure whether metadata should be requested to be passed to the transform method.

Note that this method is only relevant when this estimator is used as a sub-estimator within a meta-estimator and metadata routing is enabled with enable_metadata_routing=True (see sklearn.set_config()). Please check the User Guide on how the routing mechanism works.

The options for each parameter are:

True: metadata is requested, and passed to transform if provided. The request is ignored if metadata is not provided.
False: metadata is not requested and the meta-estimator will not pass it to transform.
None: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
str: metadata should be passed to the meta-estimator with this given alias instead of the original name.

The default (sklearn.utils.metadata_routing.UNCHANGED) retains the existing request. This allows you to change the request for some parameters and not others.

Added in version 1.3.

Parameters:

override_return_dfstr, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED: Metadata routing for override_return_df parameter in transform.

Returns:

selfobject: The updated object.

Perform the transformation to new categorical data.

Some encoders behave differently on whether or not y is given. This is mainly due to regularisation in order to avoid overfitting. On training data transform should be called with y, on test data without.

Parameters:

Xarray-like, shape = [n_samples, n_features]
yarray-like, shape = [n_samples] or None
override_return_dfbool: override self.return_df to force to return a data frame

Returns:

parray or DataFrame, shape = [n_samples, n_features_out]: Transformed values with encoding applied.

Notes

If the encoder was fitted on a DataFrame, arraylike input (e.g. the numpy array emitted by the previous step of a scikit-learn pipeline) is accepted: the fitted column names are re-attached positionally, so the result matches transforming the equivalent DataFrame (GH #406). A DataFrame may additionally carry extra pass-through columns beyond the encoded ones (GH #367).