Q3jhddlZddlmZddlZddlmZmZddlm Z ddl m Z m Z ddl mZmZddlmZmZmZmZmZddlmZmZdd lmZdd lmZmZmZmZGd d ee Z y) N)Real)OneToOneFeatureMixin _fit_context) _BaseEncoder)_fit_encoding_fast_fit_encoding_fast_auto_smooth)Bunch indexable)MetadataRouter MethodMapping_raise_for_params_routing_enabledprocess_routing)Interval StrOptions)type_of_target)_check_feature_names_in_check_ycheck_consistent_lengthcheck_is_fittedc ,eZdZUdZedhegehdgedheedddgdgd ed hgd ed hgd Ze e d < ddZ e ddZ e ddZdZdZdZdZdZddZdZfdZxZS) TargetEncoderu{#Target Encoder for regression and classification targets. Each category is encoded based on a shrunk estimate of the average target values for observations belonging to the category. The encoding scheme mixes the global target mean with the target mean conditioned on the value of the category (see [MIC]_). When the target type is "multiclass", encodings are based on the conditional probability estimate for each class. The target is first binarized using the "one-vs-all" scheme via :class:`~sklearn.preprocessing.LabelBinarizer`, then the average target value for each class and each category is used for encoding, resulting in `n_features` * `n_classes` encoded output features. :class:`TargetEncoder` considers missing values, such as `np.nan` or `None`, as another category and encodes them like any other category. Categories that are not seen during :meth:`fit` are encoded with the target mean, i.e. `target_mean_`. For a demo on the importance of the `TargetEncoder` internal :term:`cross fitting`, see :ref:`sphx_glr_auto_examples_preprocessing_plot_target_encoder_cross_val.py`. For a comparison of different encoders, refer to :ref:`sphx_glr_auto_examples_preprocessing_plot_target_encoder.py`. Read more in the :ref:`User Guide `. .. note:: `fit(X, y).transform(X)` does not equal `fit_transform(X, y)` because a :term:`cross fitting` scheme is used in `fit_transform` for encoding. See the :ref:`User Guide ` for details. .. versionadded:: 1.3 Parameters ---------- categories : "auto" or list of shape (n_features,) of array-like, default="auto" Categories (unique values) per feature: - `"auto"` : Determine categories automatically from the training data. - list : `categories[i]` holds the categories expected in the i-th column. The passed categories should not mix strings and numeric values within a single feature, and should be sorted in case of numeric values. The used categories are stored in the `categories_` fitted attribute. target_type : {"auto", "continuous", "binary", "multiclass"}, default="auto" Type of target. - `"auto"` : Type of target is inferred with :func:`~sklearn.utils.multiclass.type_of_target`. - `"continuous"` : Continuous target - `"binary"` : Binary target - `"multiclass"` : Multiclass target .. note:: The type of target inferred with `"auto"` may not be the desired target type used for modeling. For example, if the target consisted of integers between 0 and 100, then :func:`~sklearn.utils.multiclass.type_of_target` will infer the target as `"multiclass"`. In this case, setting `target_type="continuous"` will specify the target as a regression problem. The `target_type_` attribute gives the target type used by the encoder. .. versionchanged:: 1.4 Added the option 'multiclass'. smooth : "auto" or float, default="auto" The amount of mixing of the target mean conditioned on the value of the category with the global target mean. A larger `smooth` value will put more weight on the global target mean. If `"auto"`, then `smooth` is set to an empirical Bayes estimate. cv : int, cross-validation generator or an iterable, default=None Determines the splitting strategy used in the internal :term:`cross fitting` during :meth:`fit_transform`. Splitters where each sample index doesn't appear in the validation fold exactly once, raise a `ValueError`. Possible inputs for cv are: - `None`, to use a 5-fold cross-validation chosen internally based on `target_type`, - integer, to specify the number of folds for the cross-validation chosen internally based on `target_type`, - :term:`CV splitter` that does not repeat samples across validation folds, - an iterable yielding (train, test) splits as arrays of indices. For integer/None inputs, if `target_type` is `"continuous"`, :class:`KFold` is used, otherwise :class:`StratifiedKFold` is used. Refer :ref:`User Guide ` for more information on cross-validation strategies. .. versionchanged:: 1.9 Cross-validation generators and iterables can also be passed as `cv`. shuffle : bool, default=True Whether to shuffle the data in :meth:`fit_transform` before splitting into folds. Note that the samples within each split will not be shuffled. Only applies if `cv` is an int or `None`. If `cv` is a cross-validation generator or an iterable, `shuffle` is ignored. .. deprecated:: 1.9 `shuffle` is deprecated and will be removed in 1.11. Pass a cross-validation generator as `cv` argument to specify the shuffling instead. random_state : int, RandomState instance or None, default=None When `shuffle` is True, `random_state` affects the ordering of the indices, which controls the randomness of each fold. Otherwise, this parameter has no effect. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. .. deprecated:: 1.9 `random_state` is deprecated and will be removed in 1.11. Pass a cross-validation generator as `cv` argument to specify the random state of the shuffling instead. Attributes ---------- encodings_ : list of shape (n_features,) or (n_features * n_classes) of ndarray Encodings learnt on all of `X`. For feature `i`, `encodings_[i]` are the encodings matching the categories listed in `categories_[i]`. When `target_type_` is "multiclass", the encoding for feature `i` and class `j` is stored in `encodings_[j + (i * len(classes_))]`. E.g., for 2 features (f) and 3 classes (c), encodings are ordered: f0_c0, f0_c1, f0_c2, f1_c0, f1_c1, f1_c2, categories_ : list of shape (n_features,) of ndarray The categories of each input feature determined during fitting or specified in `categories` (in order of the features in `X` and corresponding with the output of :meth:`transform`). target_type_ : str Type of target. target_mean_ : float The overall mean of the target. This value is only used in :meth:`transform` to encode categories. n_features_in_ : int Number of features seen during :term:`fit`. feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. classes_ : ndarray or None If `target_type_` is 'binary' or 'multiclass', holds the label for each class, otherwise `None`. See Also -------- OrdinalEncoder : Performs an ordinal (integer) encoding of the categorical features. Contrary to TargetEncoder, this encoding is not supervised. Treating the resulting encoding as a numerical features therefore lead arbitrarily ordered values and therefore typically lead to lower predictive performance when used as preprocessing for a classifier or regressor. OneHotEncoder : Performs a one-hot encoding of categorical features. This unsupervised encoding is better suited for low cardinality categorical variables as it generate one new feature per unique category. References ---------- .. [MIC] :doi:`Micci-Barreca, Daniele. "A preprocessing scheme for high-cardinality categorical attributes in classification and prediction problems" SIGKDD Explor. Newsl. 3, 1 (July 2001), 27–32. <10.1145/507533.507538>` Examples -------- With `smooth="auto"`, the smoothing parameter is set to an empirical Bayes estimate: >>> import numpy as np >>> from sklearn.preprocessing import TargetEncoder >>> X = np.array([["dog"] * 20 + ["cat"] * 30 + ["snake"] * 38], dtype=object).T >>> y = [90.3] * 5 + [80.1] * 15 + [20.4] * 5 + [20.1] * 25 + [21.2] * 8 + [49] * 30 >>> enc_auto = TargetEncoder(smooth="auto") >>> X_trans = enc_auto.fit_transform(X, y) >>> # A high `smooth` parameter puts more weight on global mean on the categorical >>> # encodings: >>> enc_high_smooth = TargetEncoder(smooth=5000.0).fit(X, y) >>> enc_high_smooth.target_mean_ np.float64(44.3) >>> enc_high_smooth.encodings_ [array([44.1, 44.4, 44.3])] >>> # On the other hand, a low `smooth` parameter puts more weight on target >>> # conditioned on the value of the categorical: >>> enc_low_smooth = TargetEncoder(smooth=1.0).fit(X, y) >>> enc_low_smooth.encodings_ [array([21, 80.8, 43.2])] auto>rbinary continuous multiclassrNleft)closed cv_objectboolean deprecated random_state) categories target_typesmoothcvshuffler"_parameter_constraintscX||_||_||_||_||_||_yN)r#r%r$r&r'r")selfr#r$r%r&r'r"s R/DATA/.local/lib/python3.12/site-packages/sklearn/preprocessing/_target_encoder.py__init__zTargetEncoder.__init__s0% & (T)prefer_skip_nested_validationc*|j|||S)aFit the :class:`TargetEncoder` to X and y. It is discouraged to use this method because it can introduce data leakage. Use `fit_transform` on training data instead. .. note:: `fit(X, y).transform(X)` does not equal `fit_transform(X, y)` because a :term:`cross fitting` scheme is used in `fit_transform` for encoding. See the :ref:`User Guide ` for details. Parameters ---------- X : array-like of shape (n_samples, n_features) The data to determine the categories of each feature. y : array-like of shape (n_samples,) The target data used to encode the categories. Returns ------- self : object Fitted encoder. )_fit_encodings_all)r+Xys r,fitzTargetEncoder.fits2 1% r.c ddlm}m}m}m}ddlm}t||d|j||\} } } } |jdk7s|jdk7rtjdt|jdk(rdn |j} d| i}|jdk7r|j|d <||j|fd |jd k7i|}t!r*|d t#|||d \}}|d <t%|dfi|}nt't'i}t)|||||fst+j,|j.d}|j0||fi|j2j0D]\}}||xxdz cc<t+j4|dk(s t7d|jdk(rXt+j8| j.d| j.dt;|j<zft*j>}n%t+j@| t*j>}|j0||fi|j2j0D]y\}}| |d d f| |}}t+jB|d}|jdk(r|jE||| |}n|jG||| |}|jI|| | |||{|S)aFit :class:`TargetEncoder` and transform `X` with the target encoding. This method uses a :term:`cross fitting` scheme to prevent target leakage and overfitting in downstream predictors. It is the recommended method for encoding training data. .. note:: `fit(X, y).transform(X)` does not equal `fit_transform(X, y)` because a :term:`cross fitting` scheme is used in `fit_transform` for encoding. See the :ref:`User Guide ` for details. Parameters ---------- X : array-like of shape (n_samples, n_features) The data to determine the categories of each feature. y : array-like of shape (n_samples,) The target data used to encode the categories. **params : dict Parameters to route to the internal CV object. Can only be used in conjunction with a cross-validation generator as CV object. For instance, `groups` (array-like of shape `(n_samples,)`) can be routed to a CV splitter that accepts `groups`, such as :class:`GroupKFold` or :class:`StratifiedGroupKFold`. .. versionadded:: 1.9 Only available if `enable_metadata_routing=True`, which can be set by using ``sklearn.set_config(enable_metadata_routing=True)``. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- X_trans : ndarray of shape (n_samples, n_features) or (n_samples, (n_features * n_classes)) Transformed input. r) GroupKFoldKFoldStratifiedGroupKFoldStratifiedKFold)check_cv fit_transformr!z`TargetEncoder.shuffle` and `TargetEncoder.random_state` are deprecated in version 1.9 and will be removed in version 1.11. Pass a cross-validation generator as `cv` argument to specify the shuffling behaviour instead.Tr'r" classifierrgroupsN)split)splitterzValidation indices from `cv` must cover each sample index exactly once with no overlap. Pass a splitter with non-overlapping validation folds as `cv` or refer to the docs for other options.rdtypeaxis)%sklearn.model_selectionr6r7r8r9sklearn.model_selection._splitr:r r1r'r"warningswarn FutureWarningr& target_type_rr rr isinstancenpzerosshaper>r?all ValueErroremptylenclasses_float64 empty_likemean_fit_encoding_multiclass"_fit_encoding_binary_or_continuous_transform_X_ordinal)r+r2r3paramsr6r7r8r9r: X_ordinal X_known_mask y_encoded n_categoriesr' cv_kwargsr& routed_params seen_count_test_idxX_out train_idxX_trainy_train y_train_mean encodingss r,r;zTargetEncoder.fit_transformsX  <&$8;?;R;RSTVW;X8 <L <<< '4+<+< +L MM%  ,,,6$DLL(    ,(,(9(9In %  GG  ((L8     h+)21a9I)J&1fX&+D/LVLM!5r?;M  UO5IJ !''!*-J'rxx1M 0F0F0L0LM 88$)$ N66*/* W    ,HH#Y__Q%7#dmm:L%LMjjE MM)2::>E#+288Aq#QM4J4J4P4P#Q Ix(A6 )8LWG7773L  L0 99   !CC    % %   %$R4 r.c|j|dd\}}|jdk(rXtj|jd|jdt |j zftj}n%tj|tj}|j|||td|j|j|S) aTransform X with the target encoding. This method internally uses the `encodings_` attribute learnt during :meth:`TargetEncoder.fit_transform` to transform test data. .. note:: `fit(X, y).transform(X)` does not equal `fit_transform(X, y)` because a :term:`cross fitting` scheme is used in `fit_transform` for encoding. See the :ref:`User Guide ` for details. Parameters ---------- X : array-like of shape (n_samples, n_features) The data to determine the categories of each feature. Returns ------- X_trans : ndarray of shape (n_samples, n_features) or (n_samples, (n_features * n_classes)) Transformed input. ignore allow-nanhandle_unknownensure_all_finiterrr@rAN) _transformrJrLrQrNrRrSrTrUrYslice encodings_ target_mean_)r+r2r[r\rds r, transformzTargetEncoder.transforms,#'// h+#2#  <    ,HH#Y__Q%7#dmm:L%LMjjE MM)2::>E !!   M $K OO      r.cddlm}m}t|||j |dd|j dk(r-d}t |d }||vrtd |d |d ||_n|j |_d |_ |jdk(r*|}|j|}|j|_ nG|jdk(r*|}|j|}|j|_ nt|d|}tj|d|_|j|dd\} } tj d|j"Dtj$t'|j"} |jdk(r|j)| || |j} n|j+| || |j} | |_| | || fS)z(Fit a target encoding with all the data.r)LabelBinarizer LabelEncoderrkrlrmr)rrrr3) input_namez3Unknown label type: Target type was inferred to be z. Only z are supported.NrrT) y_numeric estimatorrCc32K|]}t|ywr*)rR).0category_for_features r, z3TargetEncoder._fit_encodings_all..s TCS+?S% &CSs)rBcount)sklearn.preprocessingrvrwr_fitr$rrPrJrSr;rrLrVrsrpfromiter categories_int64rRrWrXrr) r+r2r3rvrwaccepted_target_typesinferred_type_of_target label_encoderlabel_binarizerr[r\r^ris r,r1z TargetEncoder._fit_encodings_alls G1% !H L   v %$J !&4Q3&G #&.CC I.19N8OP!! !8D  $ 0 0D     ((NM++A.A)22DM   , .,.O--a0A+44DMdd;AGGAA."&// h+#2#  <{{ T4CSCS T((d&&'    ,55!! I??!! I $,<77r.c|jdk(r&tj|}t|||||}|St ||||j|}|S)zLearn target encodings.r)r%rLvarrr)r+r[r3r^ target_mean y_varianceris r,rXz0TargetEncoder._fit_encoding_binary_or_continuousse ;;& J6 I+  Ir.c( |j t|j g}t D]3}|dd|f}|j |||||}|j |5 fdt D} | D cgc]} ||  c} Scc} w)aDLearn multiclass encodings. Learn encodings for each class (c) then reorder encodings such that the same features (f) are grouped together. `reorder_index` enables converting from: f0_c0, f1_c0, f0_c1, f1_c1, f0_c2, f1_c2 to: f0_c0, f0_c1, f0_c2, f1_c0, f1_c1, f1_c2 Nc3LK|]}t|zD]}|ywr*)range)r|startidx n_classes n_featuress r,r~z9TargetEncoder._fit_encoding_multiclass..As4 *UY%;jI I *s!$)n_features_in_rRrSrrXextend) r+r[r3r^rriiy_classencoding reorder_indexrrrs @@r,rWz&TargetEncoder._fit_encoding_multiclass)s((  &  y!A1gG>>A H   X &" z* +88-3 #-888s Bc(|jdk(rSt|j}t|D]/\}} ||z} ||z} | ||| f|||f<|| ||dd| f|f<1yt|D]"\}} | |||f|||f<|||dd|f|f<$y)aTransform X_ordinal using encodings. In the multiclass case, `X_ordinal` and `X_unknown_mask` have column (axis=1) size `n_features`, while `encodings` has length of size `n_features * n_classes`. `feat_idx` deals with this by repeating feature indices by `n_classes` E.g., for 3 features, 2 classes: 0,0,1,1,2,2 Additionally, `target_mean` is of shape (`n_classes`,) so `mean_idx` cycles through 0 to `n_classes` - 1, `n_features` times. rN)rJrRrS enumerate) r+rdr[X_unknown_mask row_indicesrirre_idxrfeat_idxmean_idxs r,rYz"TargetEncoder._transform_X_ordinalHs(    ,DMM*I#,Y#7x I- 9,,4Y{H?T5U,Vk5()_'. rrrbrA)rrrJrSrLasarrayobject)r+input_features feature_names feature_name class_names r,get_feature_names_outz#TargetEncoder.get_feature_names_outjs" .//nE    ,%2$1L"&--J .*."//$1  ::m6: : sA,ct|}|j|jtjdd|S)ajGet metadata routing of this object. Please check :ref:`User Guide ` on how the routing mechanism works. .. versionadded:: 1.9 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information. )ownerr;r>)callercallee)r?method_mapping)r addr&r )r+routers r,get_metadata_routingz"TargetEncoder.get_metadata_routingsD d+ WW(?..og.V   r.cFt|}d|j_|S)NT)super__sklearn_tags__ target_tagsrequired)r+tags __class__s r,rzTargetEncoder.__sklearn_tags__s#w')$(! r.)rrrr!r!r*)__name__ __module__ __qualname____doc__rlistrrr(dict__annotations__r-rr4r;rtr1rXrWrYrrr __classcell__)rs@r,rr!sAH"6(+T2"#QRSvh'$4)OPmz<.9:'\N)CD $D !) 5665J6JX+Z;8z.9> ED!:6r.r)!rGnumbersrnumpyrL sklearn.baserrsklearn.preprocessing._encodersr*sklearn.preprocessing._target_encoder_fastrr sklearn.utilsr r sklearn.utils._metadata_requestsr r r rrsklearn.utils._param_validationrrsklearn.utils.multiclassrsklearn.utils.validationrrrrrr.r,rsN;8+A3D (,D r.