0Ph4 &ddlZddlZddlmZddlZddlmZddlmZm Z m Z m Z ddl m Z mZddlmZmZmZmZddlmZdd lmZdd lmZmZmZdd lmZdd lmZm Z m!Z!m"Z"d dgZ#Gdde eZ$Gdd e$Z%Gdde e$Z&dS)N)Integral)sparse) BaseEstimatorOneToOneFeatureMixinTransformerMixin _fit_context)_safe_indexing check_array)_check_unknown_encode _get_counts_unique) _get_mask) is_scalar_nan)Interval RealNotInt StrOptions)_get_output_config)_check_feature_names_check_feature_names_in_check_n_featurescheck_is_fitted OneHotEncoderOrdinalEncodercxeZdZdZddZ ddZ ddZed Zd Z d Z d Z d Z fdZ xZS) _BaseEncoderzm Base class for encoders that includes the code to categorize and transform the input features. Tct|drt|dddksct|d|}t|dsUnsorted categories are not supported for numerical categoriesr<z5Found unknown categories {0} in column {1} during fitr4category_countsr#missing_indices)"_check_infrequent_enabledrrr:n_features_in_ categorieslen ValueError categories__infrequent_enabledr.rr/r)r*r!r+r,array isinstancebyteskindtype__name__rsizesortisnananyr formatr enumerate _fit_infrequent_category_mapping)r0r1handle_unknownr"rB(return_and_ignore_missing_for_infrequentX_listr4r5rGcompute_countsr7r8resultcatscountsXi_dtypemsgcategory sorted_cats error_msgstop_idxdiffoutputrH feature_idxcategories_for_idxs r9_fitz_BaseEncoder._fitHsE &&((($....T1D1111(, !2)6) ) % :) ?f $ $4?##z11 < &B$*Bz""E *E *AB&(( >BBB!"#)LD&#**62222!DD=2733( &HH!xHx 2(CCCJ&(("47E22) ,,6Q66!"Q%[[1666 %S//)!%SbS H$X..(/DH//+,//9GDMM 2 2227Q777%S//)8=--"$'$--KX&(Xk"o%>%>HrrDHvk)8)4YhYGHH4(333!W,,)"d33D.**0&q//)oo-!B#**;r4+@+@AAA   # #D ) ) ) )y)  8(7F$ % 3 83rCT) return_maskr<z;Found unknown categories {0} in column {1} during transform)UrDOrqr)uniques check_unknownz$Found unknown categories in columns zH during transform. These unknown categories will be encoded as all zeros)r:rrr)zerosintonesboolr.r rNallrZrMr/r!rSitemsizeastypecopyr warningswarn UserWarning_map_infrequent_categories)r0r1r]r"warn_on_unknownignore_category_indicesr_r4r5X_intX_maskcolumns_with_unknownr7r8rj valid_maskres r9 _transformz_BaseEncoder._transforms)- !2)6) ) % : T1E2222$////)Z0<<<)Z0===!z""$ X$ XAB-b$2B12ESWXXX D*6*%% =!W,,,,2F4OO%S//)&7,33A666$.F111a4L(+16*DD ,Q/82;FFYYt'7':'@AA)!,273>>28=TWCWCW YYs^^WWYY&*&6q&9!&q.AQVWWWE!!!Q$KK   MF+FFF     ''v7NOOOf}r;cN|j}dt|j|DS)z'Infrequent categories for each feature.c,g|]\}}|dn||SN).0rfr$s r9 z7_BaseEncoder.infrequent_categories_..s9   !'ODD'):   r;)_infrequent_indicesziprN)r0infrequent_indicess r9infrequent_categories_z#_BaseEncoder.infrequent_categories_s<"5  %()9;M%N%N    r;cpt|dd}t|dd}|duo|dkp|du|_dS)z This functions checks whether _infrequent_enabled is True or False. This has to be called after parameter validation in the fit function. max_categoriesN min_frequencyr#)r(rO)r0rrs r9rIz&_BaseEncoder._check_infrequent_enabled sT !'7>>ot<< $ & >>Q+>$' $ &    r;c$t|jtjr ||jk}nVt|jtjr||jz}||k}n&t j|jdt}|j | z dz}|j G|j |kr<|j dz }|dkrd|dd<n$t j |dd| }d||<t j |} | j dkr| ndS)aCompute the infrequent indices. Parameters ---------- category_count : ndarray of shape (n_cardinality,) Category counts. n_samples : int Number of samples. col_idx : int Index of the current category. Only used for the error message. Returns ------- output : ndarray of shape (n_infrequent_categories,) or None If there are infrequent categories, indices of infrequent categories. Otherwise None. rrCr#NT mergesort)rS)rQrnumbersrRealr)rur-rxrVsumrargsort flatnonzero) r0category_countr4col_idxinfrequent_maskmin_frequency_absn_current_featuresfrequent_category_countsmallest_levelsrks r9_identify_infrequentz!_BaseEncoder._identify_infrequents1( d('*: ; ; L,t/AAOO *GL 9 9 L )D,> > ,/@@OO h~';A'>dKKKO+0?3F3F3H3HH1L   *t/BEW/W/W&*&9A&= #&!++%)""#%*^+"N"N"N----#48000qvvd2r;c|r`g}t|D]M\}}||vr/|tj|||8||Nn|}fdt|D_g_tjD]\}}j|}|jd/t|} ||vr| dz} tj| tj } |j } | | z } | | |<tj tj | |} tj | | | <j| dS)ahFit infrequent categories. Defines the private attribute: `_default_to_infrequent_mappings`. For feature `i`, `_default_to_infrequent_mappings[i]` defines the mapping from the integer encoding returned by `super().transform()` into infrequent categories. If `_default_to_infrequent_mappings[i]` is None, there were no infrequent categories in the training set. For example if categories 0, 2 and 4 were frequent, while categories 1, 3, 5 were infrequent for feature 7, then these categories are mapped to a single output: `_default_to_infrequent_mappings[7] = array([0, 3, 1, 3, 2, 3])` Defines private attribute: `_infrequent_indices`. `_infrequent_indices[i]` is an array of indices such that `categories_[i][_infrequent_indices[i]]` are all the infrequent category labels. If the feature `i` has no infrequent categories `_infrequent_indices[i]` is None. .. versionadded:: 1.1 Parameters ---------- n_samples : int Number of samples in training set. category_counts: list of ndarray `category_counts[i]` is the category counts corresponding to `self.categories_[i]`. missing_indices : dict Dict mapping from feature_idx to category index with a missing value. cDg|]\}}||Sr)r)rrrr4r0s r9rzA_BaseEncoder._fit_infrequent_category_mapping..ss?$ $ $ '  % %ni I I$ $ $ r;Nr#rC) r[r/r)deleter_default_to_infrequent_mappingsrNrLemptyint64rV setdiff1darange)r0r4rGrHcategory_counts_rlcount infreq_idxrbn_catsmappingn_infrequent_catsn_frequent_catsfrequent_indicess`` r9r\z-_BaseEncoder._fit_infrequent_category_mappingDsF  /! &/&@&@ 3 3" U/11$++ %)EFF%++E2222  3 / $ $ $ $ $ +45E+F+F$ $ $  02,'01I'J'J A A #K#K0D!4;;DAAAYYFo--! hvRX666G * %'88O"1GJ !|BIf,=,=zJJ (* /(B(BG$ %  0 7 7 @ @ @ @3 A Ar;c|jsdS|pi}t|jdD]>}|j|}||d||dd|f|f<|jdkr d|dd|f<?t |jD]T\}}|||vr|dd|f||k}ntd}tj ||||f|||f<UdS)aMap infrequent categories to integer representing the infrequent category. This modifies X_int in-place. Values that were invalid based on `X_mask` are mapped to the infrequent category if there was an infrequent category for that feature. Parameters ---------- X_int: ndarray of shape (n_samples, n_features) Integer encoded categories. X_mask: ndarray of shape (n_samples, n_features) Bool mask for valid values in `X_int`. ignore_category_indices : dict Dictionary mapping from feature_idx to category index to ignore. Ignored indexes will not be grouped and the original ordinal encoding will remain. Nr#rinfrequent_if_existT) rOr.r-rr]r[rslicer)take) r0rrrrinfrequent_idxr7rrows_to_updates r9rz'_BaseEncoder._map_infrequent_categoriess-('  F"9"?RU[^,, * *G!5g>N%2@2CE6!!!W*%%w. /"&;;; &*qqq'z"$D$HII R RJAw+++!&qqq!t0G0J!J!&t')wwna>O8P'Q'QE.!# $ $ R Rr;cxt}d|j_d|j_|S)NT)super__sklearn_tags__ input_tags categorical allow_nan)r0tags __class__s r9rz_BaseEncoder.__sklearn_tags__s1ww''))&*#$(! r;T)r<TFF)r<TFN)rU __module__ __qualname____doc__r:rnrpropertyrrIrr\rr __classcell__)rs@r9rrs #0#0#0#0P16 ttttr $ BBBBH  X  ' ' '+3+3+3ZPAPAPAd2R2R2Rhr;rc |eZdZUdZedhegeddhddgdehdgeed dd dgeed dd eed d d dgdgedhe gdZ e e d<ddde jddddddZdZdZd!dZdZdZedd"dZdZdZd"dZd ZdS)#ra. Encode categorical features as a one-hot numeric array. The input to this transformer should be an array-like of integers or strings, denoting the values taken on by categorical (discrete) features. The features are encoded using a one-hot (aka 'one-of-K' or 'dummy') encoding scheme. This creates a binary column for each category and returns a sparse matrix or dense array (depending on the ``sparse_output`` parameter). By default, the encoder derives the categories based on the unique values in each feature. Alternatively, you can also specify the `categories` manually. This encoding is needed for feeding categorical data to many scikit-learn estimators, notably linear models and SVMs with the standard kernels. Note: a one-hot encoding of y labels should use a LabelBinarizer instead. Read more in the :ref:`User Guide `. For a comparison of different encoders, refer to: :ref:`sphx_glr_auto_examples_preprocessing_plot_target_encoder.py`. Parameters ---------- categories : 'auto' or a list 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 ith 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 can be found in the ``categories_`` attribute. .. versionadded:: 0.20 drop : {'first', 'if_binary'} or an array-like of shape (n_features,), default=None Specifies a methodology to use to drop one of the categories per feature. This is useful in situations where perfectly collinear features cause problems, such as when feeding the resulting data into an unregularized linear regression model. However, dropping one category breaks the symmetry of the original representation and can therefore induce a bias in downstream models, for instance for penalized linear classification or regression models. - None : retain all features (the default). - 'first' : drop the first category in each feature. If only one category is present, the feature will be dropped entirely. - 'if_binary' : drop the first category in each feature with two categories. Features with 1 or more than 2 categories are left intact. - array : ``drop[i]`` is the category in feature ``X[:, i]`` that should be dropped. When `max_categories` or `min_frequency` is configured to group infrequent categories, the dropping behavior is handled after the grouping. .. versionadded:: 0.21 The parameter `drop` was added in 0.21. .. versionchanged:: 0.23 The option `drop='if_binary'` was added in 0.23. .. versionchanged:: 1.1 Support for dropping infrequent categories. sparse_output : bool, default=True When ``True``, it returns a :class:`scipy.sparse.csr_matrix`, i.e. a sparse matrix in "Compressed Sparse Row" (CSR) format. .. versionadded:: 1.2 `sparse` was renamed to `sparse_output` dtype : number type, default=np.float64 Desired dtype of output. handle_unknown : {'error', 'ignore', 'infrequent_if_exist', 'warn'}, default='error' Specifies the way unknown categories are handled during :meth:`transform`. - 'error' : Raise an error if an unknown category is present during transform. - 'ignore' : When an unknown category is encountered during transform, the resulting one-hot encoded columns for this feature will be all zeros. In the inverse transform, an unknown category will be denoted as None. - 'infrequent_if_exist' : When an unknown category is encountered during transform, the resulting one-hot encoded columns for this feature will map to the infrequent category if it exists. The infrequent category will be mapped to the last position in the encoding. During inverse transform, an unknown category will be mapped to the category denoted `'infrequent'` if it exists. If the `'infrequent'` category does not exist, then :meth:`transform` and :meth:`inverse_transform` will handle an unknown category as with `handle_unknown='ignore'`. Infrequent categories exist based on `min_frequency` and `max_categories`. Read more in the :ref:`User Guide `. - 'warn' : When an unknown category is encountered during transform a warning is issued, and the encoding then proceeds as described for `handle_unknown="infrequent_if_exist"`. .. versionchanged:: 1.1 `'infrequent_if_exist'` was added to automatically handle unknown categories and infrequent categories. .. versionadded:: 1.6 The option `"warn"` was added in 1.6. min_frequency : int or float, default=None Specifies the minimum frequency below which a category will be considered infrequent. - If `int`, categories with a smaller cardinality will be considered infrequent. - If `float`, categories with a smaller cardinality than `min_frequency * n_samples` will be considered infrequent. .. versionadded:: 1.1 Read more in the :ref:`User Guide `. max_categories : int, default=None Specifies an upper limit to the number of output features for each input feature when considering infrequent categories. If there are infrequent categories, `max_categories` includes the category representing the infrequent categories along with the frequent categories. If `None`, there is no limit to the number of output features. .. versionadded:: 1.1 Read more in the :ref:`User Guide `. feature_name_combiner : "concat" or callable, default="concat" Callable with signature `def callable(input_feature, category)` that returns a string. This is used to create feature names to be returned by :meth:`get_feature_names_out`. `"concat"` concatenates encoded feature name and category with `feature + "_" + str(category)`.E.g. feature X with values 1, 6, 7 create feature names `X_1, X_6, X_7`. .. versionadded:: 1.3 Attributes ---------- categories_ : list of arrays The categories of each feature determined during fitting (in order of the features in X and corresponding with the output of ``transform``). This includes the category specified in ``drop`` (if any). drop_idx_ : array of shape (n_features,) - ``drop_idx_[i]`` is the index in ``categories_[i]`` of the category to be dropped for each feature. - ``drop_idx_[i] = None`` if no category is to be dropped from the feature with index ``i``, e.g. when `drop='if_binary'` and the feature isn't binary. - ``drop_idx_ = None`` if all the transformed features will be retained. If infrequent categories are enabled by setting `min_frequency` or `max_categories` to a non-default value and `drop_idx[i]` corresponds to a infrequent category, then the entire infrequent category is dropped. .. versionchanged:: 0.23 Added the possibility to contain `None` values. infrequent_categories_ : list of ndarray Defined only if infrequent categories are enabled by setting `min_frequency` or `max_categories` to a non-default value. `infrequent_categories_[i]` are the infrequent categories for feature `i`. If the feature `i` has no infrequent categories `infrequent_categories_[i]` is None. .. versionadded:: 1.1 n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 1.0 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. .. versionadded:: 1.0 feature_name_combiner : callable or None Callable with signature `def callable(input_feature, category)` that returns a string. This is used to create feature names to be returned by :meth:`get_feature_names_out`. .. versionadded:: 1.3 See Also -------- OrdinalEncoder : Performs an ordinal (integer) encoding of the categorical features. TargetEncoder : Encodes categorical features using the target. sklearn.feature_extraction.DictVectorizer : Performs a one-hot encoding of dictionary items (also handles string-valued features). sklearn.feature_extraction.FeatureHasher : Performs an approximate one-hot encoding of dictionary items or strings. LabelBinarizer : Binarizes labels in a one-vs-all fashion. MultiLabelBinarizer : Transforms between iterable of iterables and a multilabel format, e.g. a (samples x classes) binary matrix indicating the presence of a class label. Examples -------- Given a dataset with two features, we let the encoder find the unique values per feature and transform the data to a binary one-hot encoding. >>> from sklearn.preprocessing import OneHotEncoder One can discard categories not seen during `fit`: >>> enc = OneHotEncoder(handle_unknown='ignore') >>> X = [['Male', 1], ['Female', 3], ['Female', 2]] >>> enc.fit(X) OneHotEncoder(handle_unknown='ignore') >>> enc.categories_ [array(['Female', 'Male'], dtype=object), array([1, 2, 3], dtype=object)] >>> enc.transform([['Female', 1], ['Male', 4]]).toarray() array([[1., 0., 1., 0., 0.], [0., 1., 0., 0., 0.]]) >>> enc.inverse_transform([[0, 1, 1, 0, 0], [0, 0, 0, 1, 0]]) array([['Male', 1], [None, 2]], dtype=object) >>> enc.get_feature_names_out(['gender', 'group']) array(['gender_Female', 'gender_Male', 'group_1', 'group_2', 'group_3'], ...) One can always drop the first column for each feature: >>> drop_enc = OneHotEncoder(drop='first').fit(X) >>> drop_enc.categories_ [array(['Female', 'Male'], dtype=object), array([1, 2, 3], dtype=object)] >>> drop_enc.transform([['Female', 1], ['Male', 2]]).toarray() array([[0., 0., 0.], [1., 1., 0.]]) Or drop a column for feature only having 2 categories: >>> drop_binary_enc = OneHotEncoder(drop='if_binary').fit(X) >>> drop_binary_enc.transform([['Female', 1], ['Male', 2]]).toarray() array([[0., 1., 0., 0.], [1., 0., 1., 0.]]) One can change the way feature names are created. >>> def custom_combiner(feature, category): ... return str(feature) + "_" + type(category).__name__ + "_" + str(category) >>> custom_fnames_enc = OneHotEncoder(feature_name_combiner=custom_combiner).fit(X) >>> custom_fnames_enc.get_feature_names_out() array(['x0_str_Female', 'x0_str_Male', 'x1_int_1', 'x1_int_2', 'x1_int_3'], dtype=object) Infrequent categories are enabled by setting `max_categories` or `min_frequency`. >>> import numpy as np >>> X = np.array([["a"] * 5 + ["b"] * 20 + ["c"] * 10 + ["d"] * 3], dtype=object).T >>> ohe = OneHotEncoder(max_categories=3, sparse_output=False).fit(X) >>> ohe.infrequent_categories_ [array(['a', 'd'], dtype=object)] >>> ohe.transform([["a"], ["b"]]) array([[0., 0., 1.], [1., 0., 0.]]) rAfirst if_binaryz array-likeN no_validation>r~r<ignorerr#leftclosedrneitherbooleanconcat)rKdropr!r]rr sparse_outputfeature_name_combiner_parameter_constraintsTr<)rKrrr!r]rrrcv||_||_||_||_||_||_||_||_dSr)rKrr!r]rrrr) r0rKrrr!r]rrrs r9__init__zOneHotEncoder.__init__sG%* , *,%:"""r;c|js|S|j|}||S|j|}|?||vr;|j|}t d||d|d||S)zConvert `drop_idx` into the index for infrequent categories. If there are no infrequent categories, then `drop_idx` is returned. This method is called in `_set_drop_idx` when the `drop` parameter is an array-like. NzUnable to drop category z from feature z because it is infrequent)rOrrrNrMitem)r0rldrop_idxdefault_to_infrequentrrKs r9_map_drop_idx_to_infrequentz)OneHotEncoder._map_drop_idx_to_infrequent s' O $ D[ Q (O"5kB  )h:L.L.L)+6JC:h+?+D+D+F+FCC'CCC %X..r;c|jd}nt|jtr|jdkr/tjt |jt}nq|jdkrrd|jD}|jr5t|j D] \}}|||xx|j dz zcc<!tj d|Dt}ntj |jt}t |}|t |jkr7d}t|t |j|g}g} tt!||jD]\} \} } t#| smtj| | kd } | j r0| || | d n|| | ft#| d r2| || | j dz || | ft+|rAd d d |D}t|tj | t}||_|jr||j|_dSg}t|D]L\} } |j| }| || }ntj|| kd }||Mtj |t|_dS)aCompute the drop indices associated with `self.categories_`. If `self.drop` is: - `None`, No categories have been dropped. - `'first'`, All zeros to drop the first category. - `'if_binary'`, All zeros if the category is binary and `None` otherwise. - array-like, The indices of the categories that match the categories in `self.drop`. If the dropped category is an infrequent category, then the index for the infrequent category is used. This means that the entire infrequent category is dropped. This methods defines a public `drop_idx_` and a private `_drop_idx_after_grouping`. - `drop_idx_`: Public facing API that references the drop category in `self.categories_`. - `_drop_idx_after_grouping`: Used internally to drop categories *after* the infrequent categories are grouped together. If there are no infrequent categories or drop is `None`, then `drop_idx_=_drop_idx_after_grouping`. NrrCrc,g|]}t|SrrLrcats r9rz/OneHotEncoder._set_drop_idx..As)O)O)Os#c(()O)O)Or;r#c"g|] }|dkrdnd S)rrNr)rn_features_outs r9rz/OneHotEncoder._set_drop_idx..Is6*,q00dr;zF`drop` should have length equal to the number of features ({}), got {}rrEzaThe following categories were supposed to be dropped, but were not found in the training data. {} c@g|]\}}d||S)zCategory: {}, Feature: {})rZ)rcvs r9rz/OneHotEncoder._set_drop_idx..ws<$(Aq!< B B1a H Hr;)rrQstrr)rurLrNr,rOr[rrVrPasarrayrMrZrrwherer/rrYjoin_drop_idx_after_grouping drop_idx_rr)r0drop_idx_after_groupingn_features_out_no_dropr7r drop_arraydroplenre missing_drops drop_indicesrldrop_valcat_listrrr orig_drop_idxs r9 _set_drop_idxzOneHotEncoder._set_drop_idx#s0 9 &* # #  3 ' 'B KyG##*,(3t7G3H3HPV*W*W*W''k)))O)Od>N)O)O)O&+I)243K)L)LII :%-$.q111Z_q5HH1111*,(.D! +++'DIV<<J 01166 B B1 1h%X..!xH(<==a@H}F$++ <<[(ST+VV&,,k8-DEEE!"..B ''88hmVWFWXX"((+x)@AAAA=!! & & ,9!!!oo%&(h|6&J&J&J # )@%' A+B+J!:DNNNI)23J)K)K 0 0% X(,(L)%#'<'D$,MM$&N3HH3T$U$UVW$XM  ////Z @@@DNNNr;c|j|}|jr_|j|}|P||k}d}t j||t j|gtf}|r|||}|S)zCompute the transformed categories used for column `i`. 1. If there are infrequent categories, the category is named 'infrequent_sklearn'. 2. Dropped columns are removed when remove_dropped=True. Ninfrequent_sklearnrC) rNrOrmaxr) concatenaterPr,_remove_dropped_categories)r0r7remove_droppedrb infreq_map frequent_maskinfrequent_cats r9_compute_transformed_categoriesz-OneHotEncoder._compute_transformed_categoriess"  # =a@J% *Z^^-=-= = !5~-("(N3C6*R*R*RS  <224;;D r;cn|j-|j| tj||j|S|S)zRemove dropped categories.)rr)r)r0rKr7s r9rz(OneHotEncoder._remove_dropped_categoriess;  ) 5-a0<9Z)Fq)IJJ Jr;c d|jD}|j,t|jD]\}}|||xxdzcc<|js|St|jD] \}}|||xx|jdz zcc<!|S)z2Compute the n_features_out for each input feature.c,g|]}t|Srr)rrbs r9rz:OneHotEncoder._compute_n_features_outs..s999#d))999r;Nr#)rNrr[rOrrV)r0rkr7rrs r9_compute_n_features_outsz&OneHotEncoder._compute_n_features_outss99(8999  ( 4()FGG # # 8'1IIINIII' M't'?@@ - -MAz! 1III1, ,IIII r;prefer_skip_nested_validationc|||jd|||_|S)a Fit OneHotEncoder to X. Parameters ---------- X : array-like of shape (n_samples, n_features) The data to determine the categories of each feature. y : None Ignored. This parameter exists only for compatibility with :class:`~sklearn.pipeline.Pipeline`. Returns ------- self Fitted encoder. allow-nan)r]r")rnr]rr_n_features_outs)r0r1ys r9fitzOneHotEncoder.fitsX& .)     $ = = ? ? r;ct|td|d}|dkr3|jr,|}t |d|d|d|jdkrd \}}n|jd uo|jd v}|j}|||d | \}}|j\}} |j |j } || k} t|j D]\} } | | t| | | < | dd} ||| kxxdzcc<|| z}|}t!jdg|jz}||d dz|}t!j|dzt(}d|d<t!j|d|dd |jt!j|dd |dd t!j|d}t1j|||f||df|j}|js|S|S)a Transform X using one-hot encoding. If `sparse_output=True` (default), it returns an instance of :class:`scipy.sparse._csr.csr_matrix` (CSR format). If there are infrequent categories for a feature, set by specifying `max_categories` or `min_frequency`, the infrequent categories are grouped into a single category. Parameters ---------- X : array-like of shape (n_samples, n_features) The data to encode. Returns ------- X_out : {ndarray, sparse matrix} of shape (n_samples, n_encoded_features) Transformed input. If `sparse_output=True`, a sparse matrix will be returned. transform) estimatordensedefaultzH output does not support sparse data. Set sparse_output=False to output z dataframes or disable z1 output via` ohe.set_output(transform="default").r~)TrN>rrr )r]r"rr#rErrC)r%outr!)r)r-r!)rrr capitalizerMr]rrr-rr|r[rNrLreshaperavelr)cumsumr rrvrr!rwr csr_matrixtoarray)r0r1transform_outputcapitalize_transform_outputrr]rrr4r5to_drop keep_cellsr7rbmaskfeature_indicesr$indptrdatars r9rzOneHotEncoder.transforms. -kTJJJ7S y ( (T-? (*:*E*E*G*G '.996F997999   & ( (.I +O^^"it38KP9O"0N ))+ (  v!&  :  ( 4388::G')J$T%566 + +41:%!$TGAJooa,,G %'/ " " "a ' " " " j F||~~)QC$*?$?@@?3B3//6688>)a-s333q  vA6!"":V\BBBB &*&*----wvbz"" 7F #ob12*    ! ;;== Jr;ctt|d}|j\}}tj}t jj}d}|jd|kr.t| ||jdfdtjD}t j d|D}t j ||f|} d} i} j rj} nd g|z} t|D]} || | }|jd}|dkr+j| j| | d d | f<| |z } ]|d d | | |zf}t j|d }||| d d | f<jd ksjd vr| | t j|d dk}|r=j j| || | <nĉj| j| | || f<nt j|d dk}|rNj't j|}td |dj| }|| || || f<| |z }  | rK| jt2kr| t2} | D] \}}d | ||f< | S)a Convert the data back to the original representation. When unknown categories are encountered (all zeros in the one-hot encoding), ``None`` is used to represent this category. If the feature with the unknown category has a dropped category, the dropped category will be its inverse. For a given input feature, if there is an infrequent category, 'infrequent_sklearn' will be used to represent the infrequent category. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_encoded_features) The transformed data. Returns ------- X_tr : ndarray of shape (n_samples, n_features) Inverse transformed array. csr) accept_sparseIShape of the passed X data is not correct. Expected {0} columns, got {1}.r#cDg|]\}}|dS)F)rrrr7_r0s r9rz3OneHotEncoder.inverse_transform..es@   1  0 05 0 I I   r;cg|] }|j SrrCrs r9rz3OneHotEncoder.inverse_transform..ksHHHCciHHHr;rCrN)r%r)rr~zSamples z] can not be inverted when drop=None and handle_unknown='error' because they contain all zeros)rr r-rLrNr)rr rMrZr[ result_typerrOrr.rrrargmaxflattenr]rYrr!r,r{items)r0r1r4r)r5rretransformed_featuresdtX_trj found_unknownrr7cats_wo_dropped n_categoriessublabelsunknowndroppedall_zero_samplesridxrs` r9inverse_transformzOneHotEncoder.inverse_transform?s.   / / /w 1)**  566 X  71: ' 'SZZ CCDD D    !$"233    ^HH3GHHH IxJ/r:::   # 5!%!9  "&*!4 z""3 3 A"==$Q'O+03L q  !-a01Nq1QRQQQT \!AAAq1|+++,CZ  2 233;;==F(0DAJ"h..#'FFF&q)1*SWW!W__%9::BBDD;;== 5=8;C+2 a((+/+;A+> 9!<,WaZ(*SWW!W__%9::BBDD;;== I4<+->'+B+B((='7=== $x'HD!$  AA  'zV##{{6***0022 ' ' T"&T3Y r;c~ttfdtjD}g}t t |D]-fd|D}||.tj |tS)aGet output feature names for transformation. Parameters ---------- input_features : array-like of str or None, default=None Input features. - If `input_features` is `None`, then `feature_names_in_` is used as feature names in. If `feature_names_in_` is not defined, then the following input feature names are generated: `["x0", "x1", ..., "x(n_features_in_ - 1)"]`. - If `input_features` is an array-like, then `input_features` must match `feature_names_in_` if `feature_names_in_` is defined. Returns ------- feature_names_out : ndarray of str objects Transformed feature names. c@g|]\}}|Srr'r(s r9rz7OneHotEncoder.get_feature_names_out..s;   1  0 0 3 3   r;c4g|]}|Srr)rtr7input_features name_combiners r9rz7OneHotEncoder.get_feature_names_out..s*JJJQ]]>!#4a88JJJr;rC) rrr[rN _check_get_feature_name_combinerr.rLextendr)rPr,)r0rArb feature_namesnamesr7rBs`` @@r9get_feature_names_outz#OneHotEncoder.get_feature_names_outs( 0~FF    !$"233    ==??  s4yy!! ( (AJJJJJJ$q'JJJE   ' ' ' 'x V4444r;c|jdkrdS|dd}t|ts tdt |d|jS)Nrc,|dzt|zS)Nr))r)featurerfs r9z@OneHotEncoder._check_get_feature_name_combiner..sWs]S]]-Jr;rJrfzRWhen `feature_name_combiner` is a callable, it should return a Python string. Got z instead.)rrQr TypeErrorrT)r0dry_run_combiners r9rCz.OneHotEncoder._check_get_feature_name_combiners  % 1 1JJ J#99)ZPP .44 L*./?*@*@LLL- -r;rr)rUrrrrlistrrrcallablerdict__annotations__r)float64rrrrrrr r rr<rGrCrr;r9rrsQQh"z6(++T2Wk233\4H JIII J J $8HafEEEtL HXq$v 6 6 6 HZAi 8 8 8  $",*hZ"8"8(!C$$D( j&;;;;;*///0rArArAh.*\555656UUUnuuun!5!5!5!5F . . . . .r;c `eZdZUdZedhegdeeej geddhgeeej dge eddd dge eddd e e d dd dgd Z e ed <dejddej ddddZedddZdZdZdS)ra Encode categorical features as an integer array. The input to this transformer should be an array-like of integers or strings, denoting the values taken on by categorical (discrete) features. The features are converted to ordinal integers. This results in a single column of integers (0 to n_categories - 1) per feature. Read more in the :ref:`User Guide `. For a comparison of different encoders, refer to: :ref:`sphx_glr_auto_examples_preprocessing_plot_target_encoder.py`. .. versionadded:: 0.20 Parameters ---------- categories : 'auto' or a list 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 ith column. The passed categories should not mix strings and numeric values, and should be sorted in case of numeric values. The used categories can be found in the ``categories_`` attribute. dtype : number type, default=np.float64 Desired dtype of output. handle_unknown : {'error', 'use_encoded_value'}, default='error' When set to 'error' an error will be raised in case an unknown categorical feature is present during transform. When set to 'use_encoded_value', the encoded value of unknown categories will be set to the value given for the parameter `unknown_value`. In :meth:`inverse_transform`, an unknown category will be denoted as None. .. versionadded:: 0.24 unknown_value : int or np.nan, default=None When the parameter handle_unknown is set to 'use_encoded_value', this parameter is required and will set the encoded value of unknown categories. It has to be distinct from the values used to encode any of the categories in `fit`. If set to np.nan, the `dtype` parameter must be a float dtype. .. versionadded:: 0.24 encoded_missing_value : int or np.nan, default=np.nan Encoded value of missing categories. If set to `np.nan`, then the `dtype` parameter must be a float dtype. .. versionadded:: 1.1 min_frequency : int or float, default=None Specifies the minimum frequency below which a category will be considered infrequent. - If `int`, categories with a smaller cardinality will be considered infrequent. - If `float`, categories with a smaller cardinality than `min_frequency * n_samples` will be considered infrequent. .. versionadded:: 1.3 Read more in the :ref:`User Guide `. max_categories : int, default=None Specifies an upper limit to the number of output categories for each input feature when considering infrequent categories. If there are infrequent categories, `max_categories` includes the category representing the infrequent categories along with the frequent categories. If `None`, there is no limit to the number of output features. `max_categories` do **not** take into account missing or unknown categories. Setting `unknown_value` or `encoded_missing_value` to an integer will increase the number of unique integer codes by one each. This can result in up to `max_categories + 2` integer codes. .. versionadded:: 1.3 Read more in the :ref:`User Guide `. Attributes ---------- categories_ : list of arrays The categories of each feature determined during ``fit`` (in order of the features in X and corresponding with the output of ``transform``). This does not include categories that weren't seen during ``fit``. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 1.0 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. .. versionadded:: 1.0 infrequent_categories_ : list of ndarray Defined only if infrequent categories are enabled by setting `min_frequency` or `max_categories` to a non-default value. `infrequent_categories_[i]` are the infrequent categories for feature `i`. If the feature `i` has no infrequent categories `infrequent_categories_[i]` is None. .. versionadded:: 1.3 See Also -------- OneHotEncoder : Performs a one-hot encoding of categorical features. This encoding is suitable for low to medium cardinality categorical variables, both in supervised and unsupervised settings. TargetEncoder : Encodes categorical features using supervised signal in a classification or regression pipeline. This encoding is typically suitable for high cardinality categorical variables. LabelEncoder : Encodes target labels with values between 0 and ``n_classes-1``. Notes ----- With a high proportion of `nan` values, inferring categories becomes slow with Python versions before 3.10. The handling of `nan` values was improved from Python 3.10 onwards, (c.f. `bpo-43475 `_). Examples -------- Given a dataset with two features, we let the encoder find the unique values per feature and transform the data to an ordinal encoding. >>> from sklearn.preprocessing import OrdinalEncoder >>> enc = OrdinalEncoder() >>> X = [['Male', 1], ['Female', 3], ['Female', 2]] >>> enc.fit(X) OrdinalEncoder() >>> enc.categories_ [array(['Female', 'Male'], dtype=object), array([1, 2, 3], dtype=object)] >>> enc.transform([['Female', 3], ['Male', 1]]) array([[0., 2.], [1., 0.]]) >>> enc.inverse_transform([[1, 0], [0, 1]]) array([['Male', 1], ['Female', 2]], dtype=object) By default, :class:`OrdinalEncoder` is lenient towards missing values by propagating them. >>> import numpy as np >>> X = [['Male', 1], ['Female', 3], ['Female', np.nan]] >>> enc.fit_transform(X) array([[ 1., 0.], [ 0., 1.], [ 0., nan]]) You can use the parameter `encoded_missing_value` to encode missing values. >>> enc.set_params(encoded_missing_value=-1).fit_transform(X) array([[ 1., 0.], [ 0., 1.], [ 0., -1.]]) Infrequent categories are enabled by setting `max_categories` or `min_frequency`. In the following example, "a" and "d" are considered infrequent and grouped together into a single category, "b" and "c" are their own categories, unknown values are encoded as 3 and missing values are encoded as 4. >>> X_train = np.array( ... [["a"] * 5 + ["b"] * 20 + ["c"] * 10 + ["d"] * 3 + [np.nan]], ... dtype=object).T >>> enc = OrdinalEncoder( ... handle_unknown="use_encoded_value", unknown_value=3, ... max_categories=3, encoded_missing_value=4) >>> _ = enc.fit(X_train) >>> X_test = np.array([["a"], ["b"], ["c"], ["d"], ["e"], [np.nan]], dtype=object) >>> enc.transform(X_test) array([[2.], [0.], [1.], [2.], [3.], [4.]]) rArr<use_encoded_valueNr#rrrr)rKr!encoded_missing_valuer] unknown_valuerrrrKr!r]rVrUrrch||_||_||_||_||_||_||_dSrrW)r0rKr!r]rVrUrrs r9rzOrdinalEncoder.__init__s@% ,*%:"*,r;Trcjdkrtjr;tjjjdkrt djdnWtjtj stdjdnjtdjd |jdd }|d _ d j D}jr9tjD]$\}}|||xxt#|zcc<%tj D]*\}}t|d r||xxdzcc<+jdkr2|D]/} djcxkr| krnt djd0j rtjjjdkrAtjr-t dt'j djdtjsTfdt|D} | r7t)dr j| } t djd| S)a Fit the OrdinalEncoder to X. Parameters ---------- X : array-like of shape (n_samples, n_features) The data to determine the categories of each feature. y : None Ignored. This parameter exists only for compatibility with :class:`~sklearn.pipeline.Pipeline`. Returns ------- self : object Fitted encoder. rTfzOWhen unknown_value is np.nan, the dtype parameter should be a float dtype. Got .z]unknown_value should be an integer or np.nan when handle_unknown is 'use_encoded_value', got NzQunknown_value should only be set when handle_unknown is 'use_encoded_value', got r T)r]r"r^rHc,g|]}t|Srr)rrKs r9rz&OrdinalEncoder.fit..sLLLZZLLLr;rEr#rz!The used value for unknown_value zD is one of the values already used for encoding the seen categories.z%There are missing values in features z:. For OrdinalEncoder to encode missing values with dtype: zG, set encoded_missing_value to a non-nan value, or set dtype to a floatcVg|]%\}}|jvrdjcxkr|k nn|&S)r)_missing_indicesrU)rcat_idx cardinalityr0s r9rz&OrdinalEncoder.fit..s]$$$,$"777T7EEEE+EEEEEFEEr;feature_names_in_zencoded_missing_value (z:) is already used to encode a known category in features: )r]rrVr)r!rSrMrQrrrLrnr^rNrOr[rrLrUrNr'ra) r0r1r  fit_results cardinalitiesrl infrequentr_rmr`invalid_featuress ` r9r zOrdinalEncoder.fits&  "5 5 5T/00 8DJ'',33$<.2j<<<4   2G4DEE 1 -111   +-)--- ii .)59    !,,= >LL4;KLLL  # B,5T5P+Q+Q B B' Z)!+...#j//A...,5T5E+F+F , , 'G'/344 ,g&&&!+&&&  "5 5 5,   *8888[88888$+-+++9   x ##(C//M*55/!+D122++9=+++!!;<< $$$$09-0H0H$$$ $t%899T+/+ABR+S($.$2L..+..  r;cLt|d|||jd|j\}}||jd}|jD]!\}}|dd|f|k}|j|||f<"|jdkr |j||<|S)a' Transform X to ordinal codes. Parameters ---------- X : array-like of shape (n_samples, n_features) The data to encode. Returns ------- X_out : ndarray of shape (n_samples, n_features) Transformed input. rNr )r]r"rFr|NrT) rrr]r^r{r!r.rUrV)r0r1rrX_transr_ missing_idxX_missing_masks r9rzOrdinalEncoder.transform.s m,,, .)$($9 (  v ,,tz,66$($9$?$?$A$A J J G["111g:.+=N/3/IGNG+ , ,  "5 5 5#1GVG r;ct|t|d}|j\}}t|j}d}|jd|kr.t |||jdtjd|jD}tj ||f|}i}i} t|dd} t|D]<} |dd| f} | |j vr%t| |j} |j | | | <td}|j| }| m| | et|t| | z }| |k| | <| | }tj|t"}d || | <||}|jd kr?t| |j}||| <|}t)|tjr||z}n|}| |d d }||||| f<>|s| r|t.d }|r!|D] \}}d|||f< | r!| D] \}}d |||f< |S)aP Convert the data back to the original representation. Parameters ---------- X : array-like of shape (n_samples, n_encoded_features) The transformed data. Returns ------- X_tr : ndarray of shape (n_samples, n_features) Inverse transformed array. r r@r%r#cg|] }|j SrrCrs r9rz4OrdinalEncoder.inverse_transform..jsDDDCciDDDr;rCrNFrTrrgr)rr r-rLrNrMrZr)r+rr(r.r^rrUr ones_likerxr]rVrQndarrayr{r,r.)r0r1r4r)r5rer0r1r3infrequent_masksrr7r7X_i_maskrrKinfrequent_encoding_valuefrequent_categories_maskunknown_labels known_labels labels_intr;rs r9r<z OrdinalEncoder.inverse_transformNs  [ 9 9 9w 1)**  X  71: # #SZZ AGAJ??@@ @^DD43CDDD ExJ/r::: $T+@$GGz""" =" =Aqqq!tWFD)))$VT-GHH#'#8#;x "4[[N)!,J!-2DQ2G2S,/ OOcBTUVBW>X>X,X)&,0I&I #"21"5!5,.< $+O+O+O(BG();A)>?'(@A "&999!*643E!F!F#1 a . nbj992"l2NN%1N/66wU6KKJ&0&rsVVVVVVVVVVVV////////IIIIIIIIIIII######******FFFFFFFFFF222222 , -rrrrr#]rrrj R .R .R .R .R .LR .R .R .j|||||)<|||||r;