]ji SSKrSSKrSSKJr SSKrSSKJr SSKJrJ r J r J r SSK J r Jr SSKJrJrJrJr SSKJr SSKJr SS KJrJrJr SS KJr SS KJrJ r J!r! S S /r""SS\ \5r#"SS \#5r$"SS \ \#5r%g)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_incheck_is_fitted validate_data OneHotEncoderOrdinalEncoderc^\rSrSrSrS SjrSSjrSSjr\S5r Sr Sr S r S r U4S jrS rU=r$) _BaseEncoder za Base class for encoders that includes the code to categorize and transform the input features. c[US5(a[USS5S:Xde[USUS9n[US5(dD[R"UR [R 5(a[U[US9nOUnSnOUnURupV/n[U5H*n[XS S 9n [U SSUS 9n URU 5 M, XuU4$) a Perform custom check_array: - convert list of strings to object dtype - check for missing values for object dtype data (check_array does not do that) - return list of features (arrays): this list of features is constructed feature by feature to preserve the data types of pandas DataFrame columns, as otherwise information is lost and cannot be used, e.g. for the `categories_` attribute. ilocndimrN)dtypeensure_all_finiter!F)indicesaxis) ensure_2dr!r") hasattrgetattrr np issubdtyper!str_objectshaperanger append) selfXr"X_tempneeds_validation n_samples n_features X_columnsiXis \/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sklearn/preprocessing/_encoders.py_check_X_BaseEncoder._check_X's6""wq&!'<'A $BSTF1g&&2==rww+O+OCTU$  1  !  z"A15Be4CSB   R #Z//c UR5 [XSSS9 URXS9upgnXlURS:wa$[ UR5U:wa [ S5e/Ul/n U=(d URn [U5GHpn Xkn URS:Xa+[XS9n U (aU upU RU5 GOU nGO[R"U R[R5(a[ nO U Rn[R""URU US9nUR[ :Xa\[%US[&5(aDU RR(S :wa*S U S [+U S5R,S 3n[ U5eUSS H$n[/U5(dM[ SUSU 35e UR0[ [U55:waS U S3n[ U5eU RR(S;ai[R2"U5nSn[R4"US 5(aS OSn[R6"USUUSU:g5(a [ U5eUS:Xa/[9X5nU(aSR;UU 5n[ U5eU (aU R[=X55 URRU5 GMs SU0nU(aU US'0nU(aK[?UR5H-unn[/US 5(dMUR0S- UU'M/ UUS'UR(aURAUU U5 U$)NTr1resetskip_check_arrayr"autozOShape mismatch: if categories is an array, it has to be of shape (n_features,).) return_countsr!rSz In column zY, the predefined categories have type 'bytes' which is incompatible with values of type 'z'.zKNan should be the last element in user provided categories, see categories z in column #z7, the predefined categories contain duplicate elements.OUSz>Unsorted categories are not supported for numerical categorieserrorz5Found unknown categories {0} in column {1} during fitr4category_countsr#missing_indices)!_check_infrequent_enabledrr: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"rC(return_and_ignore_missing_for_infrequentX_listr4r5rIcompute_countsr7r8resultcatscountsXi_dtypemsgcategory sorted_cats error_msgstop_idxdiffoutputrJ feature_idxcategories_for_idxs r9_fit_BaseEncoder._fitLs_ &&(dtdC(, )6) %:) ??f $4??#z1 < &B$*B*Bz"AB&( B!#)LD#**62!D==27733 &H!xxHxx 2(CJJ&("47E22 ,%QC(!"Q%[112"6 %S/)!%Sb H$X..(DDH6*1#/!*99GDM 22$QC(77%S/)88==-"$''$-KX&(XXk"o%>%>rDHvvk)84YhGHH(33!W,)"3D**0&q/)o-!#**;r+@A    # #D )K#Ny) (7F$ % 33rD) return_maskrHz;Found unknown categories {0} in column {1} during transform)UrEOrtr)uniques check_unknowninfrequent_if_existz$Found unknown categories in columns zW during transform. These unknown categories will be encoded as the infrequent category.zH during transform. These unknown categories will be encoded as all zeros)r:rr)zerosintonesboolr.r rPallr\rOr/r!rUitemsizeastypecopyr warningswarn UserWarning_map_infrequent_categories)r0r1r_r"warn_on_unknownignore_category_indicesrar4r5X_intX_maskcolumns_with_unknownr7r8rl valid_maskrgs r9 _transform_BaseEncoder._transforms,)- )6) %: dutD)0<)0=!z"AB-b2B2B12ESWX D66*%%!W,,,2F4O%S/)&,33A6$.1a4L((+1166*D ,,Q/882;;FYYt'7'7':'@'@A))!,22773>288==TWCW YYs^WWY&*&6&6q&9!&.>q.AQVWE!Q$KI#J !66:+,-++;+,-FF MM#{ + ''7NO}r<cURn[URU5VVs/sHup#UcSOX#PM snn$s snnf)z'Infrequent categories for each feature.N)_infrequent_indicesziprP)r0infrequent_indicesrhr$s r9infrequent_categories_#_BaseEncoder.infrequent_categories_ sT"55&))9)9;M%N %N!OD): :%N   s?cx[USS5n[USS5nUSL=(a US:=(d USLUlg)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(rQ)r0rrs r9rK&_BaseEncoder._check_infrequent_enabledsH !'7>ot< $ & >>Q+>$' $ &  r<ct[UR[R5(aXR:nOb[UR[R5(aX R-nX:nO&[ R "URS[S9nURUR5- S-nURbHURU:a8URS- nUS:XaSUSS&O[ R"USS9SU*nSXH'[ R"U5n U RS:aU $S$)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. rrDr#NT mergesort)rU)rSrnumbersrRealr)ryr-r|rXsumrargsort flatnonzero) r0category_countr4col_idxinfrequent_maskmin_frequency_absn_current_featuresfrequent_category_countsmallest_levelsrms r9_identify_infrequent!_BaseEncoder._identify_infrequents( d(('*:*: ; ;,/A/AAO **GLL 9 9 ),>,> > ,@O hh~';';A'>dKO+00?3F3F3HH1L    *t/B/BEW/W&*&9&9A&= #&!+%)"#%**^+"N---#4800qv2d2r<c 6U(aW/n[U5HEupVXS;a*UR[R"XcU55 M4URU5 MG OUn[U5VVs/sHupxUR XU5PM snnUl/Ul[UR 5HupYURUn U cUR RS5 M4[U 5n XS;aU S-n [R"U [RS9n U Rn X- nXU '[R"[R"U 5U 5n[R"U5X'UR RU 5 M gs snnf)aFit 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. Nr#rD)r]r/r)deleterr_default_to_infrequent_mappingsrPrNemptyint64rX setdiff1darange)r0r4rIrJcategory_counts_rncountrr infreq_idxrdn_catsmappingn_infrequent_catsn_frequent_catsfrequent_indicess r9r^-_BaseEncoder._fit_infrequent_category_mappingLsvF ! &/&@" 1$++ %)EF%++E2 'A / ,55E+F$ +F'  % %n I+F$  02,'01I1I'J #K##K0D!44;;DAYF-! hhvRXX6G * %8O"1J !||BIIf,=zJ (* /(BG %  0 0 7 7 @3(K$ s/FcUR(dgU=(d 0n[URS5HCnURUnUcMUSXSS2U4)U4'URS;dM:SUSS2U4'ME [ UR 5HGupgUcM Xc;aUSS2U4X6:gnO [S5n[R"XqX45XU4'MI g)auMap 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#rrxrT) rQr.r-rr_r]rslicer)take) r0rrrrinfrequent_idxr7rrows_to_updates r9r'_BaseEncoder._map_infrequent_categoriess('' "9"?RU[[^,G!55g>N%2@2CE!W*%%w. /""&EE &*q'z"-$D$H$HIJA+!&q!t0G0J!J!&t')wwwn>O8P'QE!# $Jr<ch>[TU]5nSURlSURlU$)NT)super__sklearn_tags__ input_tags categorical allow_nan)r0tags __class__s r9r_BaseEncoder.__sklearn_tags__s-w')&*#$(! r<)rrQrrPrLT)rHTFF)rHTFN)rW __module__ __qualname____firstlineno____doc__r:rprpropertyrrKrr^rr__static_attributes__ __classcell__)rs@r9rr sp #0P16 sp $ GR   '+3ZPAd2Rhr<rc F\rSrSr%Sr\"S15\/\"SS15SS/S\"1S k5/\"\S SS S 9S/\"\S SS S 9\"\ S S SS 9S/S/\"S15\ /S.r \ \ S'SSS\RSSSSS.SjrSrSrS#SjrSrSr\"SS9S$Sj5rSrSrS$S jrS!rS"rg)%rias+ 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 an 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.]]) rBfirst if_binaryz array-likeN no_validation>rrHignorerxr#leftclosedrneitherbooleanconcat)rMdropr!r_rr sparse_outputfeature_name_combiner_parameter_constraintsTrH)rMrrr!r_rrrcdXlX0lX@lXPlX lX`lXplXlgN)rMrr!r_rrrr) r0rMrrr!r_rrrs r9__init__OneHotEncoder.__init__s1%* , *,%:"r<cUR(dU$URUnUcU$URUnUb7X$;a2URUn[ SXRR 5<SUS35eX2$)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. zUnable to drop category z from feature z because it is infrequent)rQrrrPrOitem)r0rndrop_idxdefault_to_infrequentrrMs r9_map_drop_idx_to_infrequent)OneHotEncoder._map_drop_idx_to_infrequents''O $ D D[ Q (O"55kB  )h.L))+6J*:+?+D+D+F*IJ'=(AC %..r<c URcSnGO[UR[5(aURS:Xa.[R"[ UR 5[S9nGOURS:XaUR Vs/sHn[ U5PM nnUR(a<[UR5H#upEUcM X4==URS- -ss'M% [R"UVs/sH nUS:XaSOSPM sn[S9nGO[R"UR[S9n[ U5nU[ UR 5:wa0Sn [U R[ UR 5U55e/n /n [[!XpR 55Hun up[#U 5(dd[R$"X:H5SnUR(a$U R'UR)XS55 OU R'X45 M|[#US 5(a/U R'UR)XRS- 55 MU R'X45 M [+U 5(aQS RS R-U VVs/sHunnS RUU5PM snn55n [U 5e[R"U [S9nWUlUR(aUcUR.Ulg/n[U5HJupUR2U nUbUcUnO[R4"UU:H5SnUR'U5 ML [R"U[S9Ulgs snfs snfs snnf) 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`. NrrDrr#r rzF`drop` should have length equal to the number of features ({}), got {}rFzaThe following categories were supposed to be dropped, but were not found in the training data. {} zCategory: {}, Feature: {})rrSstrr)ryrNrPr,rQr]rrXrRasarrayrOr\rrwherer/rr[join_drop_idx_after_grouping drop_idx_rr)r0drop_idx_after_groupingcatn_features_out_no_dropr7rn_features_out drop_arraydroplenrg missing_drops drop_indicesrndrop_valcat_listrcvrr orig_drop_idxs r9 _set_drop_idxOneHotEncoder._set_drop_idx+sc0 99 &* #  3 ' 'yyG#*,((3t7G7G3HPV*W'k)>B>N>N)O>Ns#c(>N&)O++)243K3K)L %-$.1Z__q5HH1*M +-((/E.DN,q0d:.D! +'DIIVJ 0 0161 1h%X..!xx(<=a@H}}$++ <<[ST+V&,,k-DE!".. ''88mmVWFWX"((+)@A'6*=!! & -:,9DAq!< B B1a H,9!!o%&(hh|6&J # )@%''+B+J!::DNI)23J)K% (,(L(L)%#'<'D$,M$&NN3HH3T$UVW$XM  /*L ZZ @DNi*P\s N3N8=N=c&URUnUR(aXURUnUbFXDR5:nSn[R "X5[R "U/[S945nU(aURX15nU$)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. infrequent_sklearnrD) rPrQrmaxr) concatenaterRr,_remove_dropped_categories)r0r7remove_droppedrd infreq_map frequent_maskinfrequent_cats r9_compute_transformed_categories-OneHotEncoder._compute_transformed_categoriess"  # #==a@J% *^^-= = !5~~("((N3C6*RS 224;D r<cURb3URUb#[R"XRU5$U$)zRemove dropped categories.)rr)r)r0rMr7s r9r(OneHotEncoder._remove_dropped_categoriessA  ) ) 5--a0<99Z)F)Fq)IJ Jr<cpURVs/sHn[U5PM nnURb/[UR5Hup4UcM X#==S-ss'M UR(dU$[UR 5H#up5UcM X#==UR S- -ss'M% U$s snf)z2Compute the n_features_out for each input feature.r#)rPrNrr]rQrrX)r0rdrmr7rrs r9_compute_n_features_outs&OneHotEncoder._compute_n_features_outss(,(8(89(8#d)(89  ( ( 4()F)FG 'INI H''M't'?'?@MA! I1, ,IA  #:sB3prefer_skip_nested_validationcURUURSS9 UR5 UR5UlU$)a6 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")rpr_rr _n_features_outs)r0r1ys r9fitOneHotEncoder.fitsH& ..)   $ = = ? r<c[U5 [SUS9SnUS:wa5UR(a$UR5n[ USUSUS35eUR S:XaS upEO0UR S L=(a UR S ;nUR nURUUS US 9upgURupURbuURR5n Xj:gn [UR5HupXbM [U 5X'M U RSS5n XfU :==S-ss'X{-nUR5n[ R""S/UR$-5nXoS S-R5Un[ R&"US-[(S9nSUS'[ R*"USUSS UR,S9 [ R""USS USS S9 [ R."US5n[0R2"UUU4XS4UR,S9nUR(dUR55$U$)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)TrxN>rrxr)r_r"rr#rFrrD)r%outr!)r)r-r!)rrr capitalizerOr_rrr-rrr]rPrNreshaperavelr)cumsumrrrzrr!r{r csr_matrixtoarray)r0r1transform_outputcapitalize_transform_outputrr_rrr4r5to_drop keep_cellsr7rdmaskfeature_indicesr$indptrdatars r9rOneHotEncoder.transforms]. -kTJ7S y (T-?-?*:*E*E*G './066F5GH78999    & (.I +O^"iit38K8KP9O"00N ))+ ( !&   ( ( 43388:G)J$T%5%56:%!$TGJ 7 ooa,G '/ "a ' "  F||~))QC$*?*?$?@3B//668>)a-s3q  vA6!":V\\B &*&*-wwvbz" 7F #b12**  !!;;= Jr<c 2[U5 [USS9nURup#[UR5n[ R "UR5nSnURSU:wa'[URXQRS55e[UR5VVs/sHupsURUSS9PM nnn[ R"UV s/sHoRPM sn 6n [ R"X$4U S9n Sn 0n UR(a UR nOS /U-n[#U5GHnUR%XU5nURSnUS:Xa-URUUR&UU S S 2U4'U U- n MZUS S 2XU-24n[ R("UR+SS 95R-5nUUU S S 2U4'UR.S :XdUR.S ;aXc[ R("UR SS 9S:H5R-5nUR15(aFUR&bUR&UcUX'OURUUR&UU UU4'O[ R("UR SS 9S:H5R-5nUR15(aMUR&c%[ R2"U5n[S US35eUR&UnXUU UU4'U U- n GM U (aJU R[4:waU R7[45n U R95H unnS U UU4'M U $s snnfs sn f)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_original : 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#F)rrDrN)r%rrzSamples z] can not be inverted when drop=None and handle_unknown='error' because they contain all zeros)rr r-rNrPr)rrrOr\r]r result_typer!rrQrr.rrrargmaxflattenr_r[rr,ritems)r0r1r4_r5rrgr7transformed_featuresrdtX_trj found_unknownrcats_wo_dropped n_categoriessublabelsunknowndroppedall_zero_samplesridxr's r9inverse_transformOneHotEncoder.inverse_transformGs.   /ww ))*  5 56 X  771: 'SZZ CD D"$"2"23 3  0 05 0 I3  ^^3GH3GCii3GH Ixx/r:   # #!%!9!9 "&*!4 z"A"==$'O+003L q !--a01N1Nq1QRQT \!Aq|+++,CZZ  23;;=F(0DAJ""h.##'FF&)1**SWW!W_%9:BBD;;==55=88;C+2 (+/+;+;A+> 99!<,WaZ(**SWW!W_%9:BBD;;==44<+->>'+B((&'7&89== $<x'HD!$  Ag#n zzV#{{6**002 T"&T3Y3 _ Is -N Nc[U5 [X5n[UR5VVs/sHup#UR U5PM nnnUR 5n/n[ [U55H0nXBVs/sH ou"XU5PM nnURU5 M2 [R"U[S9$s snnfs snf)aoGet 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. rD) rrr]rPr _check_get_feature_name_combinerr.rNextendr)rRr,) r0input_featuresr7r4rd name_combiner feature_namestnamess r9get_feature_names_out#OneHotEncoder.get_feature_names_outs( 0F"$"2"23 3  0 0 33  ==?  s4y!ABF'J'Q]>#4a8'EJ   '"xx V44 Ks C>CcURS:XaS$URSS5n[U[5(d[S[ U5S35eUR$)Nrc$US-[U5-$)Nr4)r)featurerhs r9@OneHotEncoder._check_get_feature_name_combiner..sWs]S]-Jr<rPrhzRWhen `feature_name_combiner` is a callable, it should return a Python string. Got z instead.)rrSr TypeErrorrV)r0dry_run_combiners r9rE.OneHotEncoder._check_get_feature_name_combinersk  % % 1J J#99)ZP .44**./?*@)AL-- -r<) rrrMrrr!rr_rrrrr)rWrrrrrlistrrrcallablerdict__annotations__r)float64rrrrrr rrrrBrLrErr<r9rrsQh"6(+T2Wk23\4H I J $HafEtL Xq$v 6 ZAi 8  $",hZ"8(!C$D( jj&;*/0rAh.*566Unun!5F .r<cD\rSrSr%Sr\"S15\/S\\"\ R5/\"SS15/\\"\ R5S/\ "\SSS S 9S/\ "\SSS S 9\ "\ S SS S 9S/S .r \\S'S\ R SS\ RSSS.Sjr\"SS9SSj5rSrSrSrg)ria 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``. 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.]]) rBrrHuse_encoded_valueNr#rrrr)rMr!encoded_missing_valuer_ unknown_valuerrrrMr!r_r_r^rrcXXlX lX0lX@lXPlX`lXplgrr`)r0rMr!r_r_r^rrs r9rOrdinalEncoder.__init__s,% ,*%:"*,r<TrcvURS:Xa[UR5(aH[R"UR5R S:wa[ SURS35eOi[UR[R5(d[SURS35eO&URb[SURS35eURUURSSS 9nUS Ul URVs/sHn[U5PM nnUR(a8[!UR"5HupgUcM XV==[U5-ss'M! [!UR5H&up[U S 5(dMXX==S -ss'M( URS:Xa=UH7n S URs=::aU :dMO M [ SURS35e UR(Ga [R"UR5R S:waI[UR$5(a/[ S['UR5SURS35e[UR$5(d[!U5VV s/sH5upXR;dMS UR$s=::aU :dM/O M3UPM7 n nn U (a;[)US5(aUR*U n [ SUR$SU 35eU$s snfs sn nf)aD 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. r]fzOWhen 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 zQunknown_value should only be set when handle_unknown is 'use_encoded_value', got rT)r_r"r`rJrFr#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 floatfeature_names_in_zencoded_missing_value (z:) is already used to encode a known category in features: )r_rr_r)r!rUrOrSrrrSrp_missing_indicesrPrNrQr]rr^rVr'rf) r0r1r fit_resultsrM cardinalitiesrn infrequentcat_idxro cardinalityinvalid_featuress r9rOrdinalEncoder.fitsS&   "5 5T//0088DJJ',,3$..2jj\<4   2 2G4D4DEE --.a1F   +))*!- ii ..)59   !,,= >;?;K;KL;KZZ;K L  # #,5T5P5P+Q' )!.#j/A.,R ,5T5E5E+F 'G/344&!+&,G   "5 5, **8[88$;--./++ -  xx #((C/M**55!;D1123499= E++!!;!;<< 1:-0H$0H,"7"77T77E+EF0H!$$t%899+/+A+ABR+S($1$2L2L1MNS+,.  sMP$sL0-L5L5L5#L5c^[US5 URUURSURS9up#UR UR SS9nURR 5H!upVUSS2U4U:HnURXGU4'M# URS:XaURXC)'U$)z 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. rPr)r_r"rFrNr]) rrr_rgrr!r3r^r_)r0r1rrX_transrk missing_idxX_missing_masks r9rOrdinalEncoder.transform/s m, ..)$($9$9 (  ,,tzz,6$($9$9$?$?$A G"1g:.+=N/3/I/IGG+ ,%B   "5 5#11GG r<c[U5 [USS9nURup#[UR5nSnURSU:wa'[ UR XARS55e[R"URVs/sHofRPM sn6n[R"X$4US9n0n 0n [USS5n [U5GHn USS2U 4n XR;a&[XR5nURU X'[!S5nURU nU bOXbJ[U5[X5- nU U:HX'X)n[R""U[$S9nSUX'UUnUR&S :XaC[XR(5nUX'U)n[+U[R,5(aUU-nOUnXR/S SS 9nUUXU 4'GM U (dU (aUR/[0SS 9nU (a!U R35H unnSUUU4'M U (a!U R35H unnS UUU4'M U$s snf) a Convert the data back to the original representation. Parameters ---------- X : array-like of shape (n_samples, n_encoded_features) The transformed data. Returns ------- X_original : ndarray of shape (n_samples, n_features) Inverse transformed array. rrAr/r#rDrNFr]rrpr)rr r-rNrPrOr\r)r0r!rr(r.rgrr^r ones_liker|r_r_rSndarrayrr,r3)r0r1r4r4r5rgrr6r7r9infrequent_masksrr7r=X_i_maskrrMinfrequent_encoding_valuefrequent_categories_maskunknown_labels known_labels labels_intrAr's r9rB OrdinalEncoder.inverse_transformOs  [ 9ww ))*  X  771: #SZZ GGAJ?@ @^^43C3CD3CCii3CD Exx/r: $T+@$Gz"Aq!tWF)))$V-G-GH#'#8#8#; "4[N))!,J!-2D2G2S,/ OcBTBW>X,X)&,0I&I #"2"5!5,.<< $+O(BG();)>?'(@A ""&99!*63E3E!F#1  . nbjj99"l2N%1N/66wU6KJ&0&rs 6OO)0LL8 , -v#]vr R .LR .ju)<ur<