a j} @stddlZddlZddlZddlmZddlmZddlZddl m Z ddl m Z mZmZddlmZddlmZmZmZddlmZmZdd lmZmZdd lmZmZdd lm Z dd l!m"Z"m#Z#m$Z$gd Z%Gdddee ddZ&Gdddee ddZ'eddgdgeeddddgeeddddgdgdddddddddZ(d d!Z)d"d#Z*Gd$d%d%ee ddZ+dS)&N) defaultdict)Integral) BaseEstimatorTransformerMixin _fit_context) column_or_1d) _setdiff1ddevice get_namespace)_encode_unique)Intervalvalidate_params)type_of_target unique_labels) min_max_axis) _num_samples check_arraycheck_is_fitted)label_binarizeLabelBinarizer LabelEncoderMultiLabelBinarizercs@eZdZdZddZddZddZdd Zfd d ZZ S) raEncode target labels with value between 0 and n_classes-1. This transformer should be used to encode target values, *i.e.* `y`, and not the input `X`. Read more in the :ref:`User Guide `. .. versionadded:: 0.12 Attributes ---------- classes_ : ndarray of shape (n_classes,) Holds the label for each class. See Also -------- OrdinalEncoder : Encode categorical features using an ordinal encoding scheme. OneHotEncoder : Encode categorical features as a one-hot numeric array. Examples -------- `LabelEncoder` can be used to normalize labels. >>> from sklearn.preprocessing import LabelEncoder >>> le = LabelEncoder() >>> le.fit([1, 2, 2, 6]) LabelEncoder() >>> le.classes_ array([1, 2, 6]) >>> le.transform([1, 1, 2, 6]) array([0, 0, 1, 2]...) >>> le.inverse_transform([0, 0, 1, 2]) array([1, 1, 2, 6]) It can also be used to transform non-numerical labels (as long as they are hashable and comparable) to numerical labels. >>> le = LabelEncoder() >>> le.fit(["paris", "paris", "tokyo", "amsterdam"]) LabelEncoder() >>> list(le.classes_) [np.str_('amsterdam'), np.str_('paris'), np.str_('tokyo')] >>> le.transform(["tokyo", "tokyo", "paris"]) array([2, 2, 1]...) >>> list(le.inverse_transform([2, 2, 1])) [np.str_('tokyo'), np.str_('tokyo'), np.str_('paris')] cCst|dd}t||_|S)zFit label encoder. Parameters ---------- y : array-like of shape (n_samples,) Target values. Returns ------- self : returns an instance of self. Fitted label encoder. Twarnrr classes_selfyr!BE:\soccer\ml_env\Lib\site-packages\sklearn/preprocessing/_label.pyfitPs  zLabelEncoder.fitcCs"t|dd}t|dd\|_}|S)aFit label encoder and return encoded labels. Parameters ---------- y : array-like of shape (n_samples,) Target values. Returns ------- y : array-like of shape (n_samples,) Encoded labels. TrZreturn_inverserrr!r!r" fit_transformas zLabelEncoder.fit_transformcCsJt|t|\}}t||jjdd}t|dkr<|gSt||jdS)aTransform labels to normalized encoding. Parameters ---------- y : array-like of shape (n_samples,) Target values. Returns ------- y : array-like of shape (n_samples,) Labels as normalized encodings. T)dtyperr)Zuniques)rr rrr&rasarrayr )rr xp_r!r!r" transformrs    zLabelEncoder.transformcCst|t|\}}t|dd}t|dkr6|gSt||j|jjdt |d|d}|jdrtt dt |||}|j |j|ddS)a Transform labels back to original encoding. Parameters ---------- y : array-like of shape (n_samples,) Target values. Returns ------- y : ndarray of shape (n_samples,) Original encoding. Trr)r )Zar1Zar2r(z'y contains previously unseen labels: %sZaxis) rr rrr'r arangershaper ValueErrorstrtake)rr r(r)diffr!r!r"inverse_transforms       zLabelEncoder.inverse_transformcs$t}d|_d|j_d|j_|S)NTF)super__sklearn_tags__Zarray_api_support input_tags two_d_array target_tags one_d_labelsrtags __class__r!r"r4s  zLabelEncoder.__sklearn_tags__) __name__ __module__ __qualname____doc__r#r%r*r2r4 __classcell__r!r!r;r"rs 1r)Zauto_wrap_output_keyscszeZdZUdZegegdgdZeed<dddddd Ze d d d d Z ddZ ddZ dddZ fddZZS)ra Binarize labels in a one-vs-all fashion. Several regression and binary classification algorithms are available in scikit-learn. A simple way to extend these algorithms to the multi-class classification case is to use the so-called one-vs-all scheme. At learning time, this simply consists in learning one regressor or binary classifier per class. In doing so, one needs to convert multi-class labels to binary labels (belong or does not belong to the class). `LabelBinarizer` makes this process easy with the transform method. At prediction time, one assigns the class for which the corresponding model gave the greatest confidence. `LabelBinarizer` makes this easy with the :meth:`inverse_transform` method. Read more in the :ref:`User Guide `. Parameters ---------- neg_label : int, default=0 Value with which negative labels must be encoded. pos_label : int, default=1 Value with which positive labels must be encoded. sparse_output : bool, default=False True if the returned array from transform is desired to be in sparse CSR format. Attributes ---------- classes_ : ndarray of shape (n_classes,) Holds the label for each class. y_type_ : str Represents the type of the target data as evaluated by :func:`~sklearn.utils.multiclass.type_of_target`. Possible type are 'continuous', 'continuous-multioutput', 'binary', 'multiclass', 'multiclass-multioutput', 'multilabel-indicator', and 'unknown'. sparse_input_ : bool `True` if the input data to transform is given as a sparse matrix, `False` otherwise. See Also -------- label_binarize : Function to perform the transform operation of LabelBinarizer with fixed classes. OneHotEncoder : Encode categorical features using a one-hot aka one-of-K scheme. Examples -------- >>> from sklearn.preprocessing import LabelBinarizer >>> lb = LabelBinarizer() >>> lb.fit([1, 2, 6, 4, 2]) LabelBinarizer() >>> lb.classes_ array([1, 2, 4, 6]) >>> lb.transform([1, 6]) array([[1, 0, 0, 0], [0, 0, 0, 1]]) Binary targets transform to a column vector >>> lb = LabelBinarizer() >>> lb.fit_transform(['yes', 'no', 'no', 'yes']) array([[1], [0], [0], [1]]) Passing a 2D matrix for multilabel classification >>> import numpy as np >>> lb.fit(np.array([[0, 1, 1], [1, 0, 0]])) LabelBinarizer() >>> lb.classes_ array([0, 1, 2]) >>> lb.transform([0, 1, 2, 1]) array([[1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 1, 0]]) boolean neg_label pos_label sparse_output_parameter_constraintsrFcCs||_||_||_dSNrC)rrDrErFr!r!r"__init__ szLabelBinarizer.__init__TZprefer_skip_nested_validationcCs|j|jkr&td|jd|jd|jrX|jdks@|jdkrXtd|jd|jt|dd|_d |jvrxtd t|dkrtd |t||_ t ||_ |S) aaFit label binarizer. Parameters ---------- y : ndarray of shape (n_samples,) or (n_samples, n_classes) Target values. The 2-d matrix should only contain 0 and 1, represents multilabel classification. Returns ------- self : object Returns the instance itself. z neg_label=z& must be strictly less than pos_label=.rz`Sparse binarization is only supported with non zero pos_label and zero neg_label, got pos_label=z and neg_label=r ) input_name multioutput@Multioutput target data is not supported with label binarizationy has 0 samples: %r) rDrEr.rFry_type_rspissparse sparse_input_rrrr!r!r"r#s0       zLabelBinarizer.fitcCs|||S)aFit label binarizer/transform multi-class labels to binary labels. The output of transform is sometimes referred to as the 1-of-K coding scheme. Parameters ---------- y : {ndarray, sparse matrix} of shape (n_samples,) or (n_samples, n_classes) Target values. The 2-d matrix should only contain 0 and 1, represents multilabel classification. Sparse matrix can be CSR, CSC, COO, DOK, or LIL. Returns ------- Y : {ndarray, sparse matrix} of shape (n_samples, n_classes) Shape will be (n_samples, 1) for binary problems. Sparse matrix will be of CSR format. )r#r*rr!r!r"r%;szLabelBinarizer.fit_transformcCsHt|t|d}|r.|jds.tdt||j|j|j|j dS)aTransform multi-class labels to binary labels. The output of transform is sometimes referred to by some authors as the 1-of-K coding scheme. Parameters ---------- y : {array, sparse matrix} of shape (n_samples,) or (n_samples, n_classes) Target values. The 2-d matrix should only contain 0 and 1, represents multilabel classification. Sparse matrix can be CSR, CSC, COO, DOK, or LIL. Returns ------- Y : {ndarray, sparse matrix} of shape (n_samples, n_classes) Shape will be (n_samples, 1) for binary problems. Sparse matrix will be of CSR format. Z multilabelz0The object was not fitted with multilabel input.)classesrErDrF) rr startswithrQr.rrrErDrF)rr Zy_is_multilabelr!r!r"r*QszLabelBinarizer.transformNcCsrt||dur |j|jd}|jdkr8t||j}nt||j|j|}|jr\t |}nt |rn| }|S)aTransform binary labels back to multi-class labels. Parameters ---------- Y : {ndarray, sparse matrix} of shape (n_samples, n_classes) Target values. All sparse matrices are converted to CSR before inverse transformation. threshold : float, default=None Threshold used in the binary and multi-label cases. Use 0 when ``Y`` contains the output of :term:`decision_function` (classifier). Use 0.5 when ``Y`` contains the output of :term:`predict_proba`. If None, the threshold is assumed to be half way between neg_label and pos_label. Returns ------- y : {ndarray, sparse matrix} of shape (n_samples,) Target values. Sparse matrix will be of CSR format. Notes ----- In the case when the binary labels are fractional (probabilistic), :meth:`inverse_transform` chooses the class with the greatest value. Typically, this allows to use the output of a linear model's :term:`decision_function` method directly as the input of :meth:`inverse_transform`. Ng@ multiclass) rrErDrQ_inverse_binarize_multiclassr_inverse_binarize_thresholdingrTrR csr_matrixrStoarray)rY thresholdZy_invr!r!r"r2ss     z LabelBinarizer.inverse_transformcst}d|j_d|j_|SNFT)r3r4r5r6r7r8r9r;r!r"r4s zLabelBinarizer.__sklearn_tags__)N)r=r>r?r@rrGdict__annotations__rJrr#r%r*r2r4rAr!r!r;r"rs Y (" 3r array-likez sparse matrixZneither)closedrB)r rUrDrErFTrKrHFrCcCst|tst|ddddd}nt|dkr6td|||krNtd|||rr|dksb|dkrrtd |||dk}|r| }t|}d |vrtd |d krtd t|r|j dnt |}t |}t |}|dkr<|dkr*|rtj |dftdSt jt |dftd} | |7} | Snt |dkr>> from sklearn.preprocessing import label_binarize >>> label_binarize([1, 6], classes=[1, 2, 4, 6]) array([[1, 0, 0, 0], [0, 0, 0, 1]]) The class ordering is preserved: >>> label_binarize([1, 6], classes=[1, 6, 4, 2]) array([[1, 0, 0, 0], [0, 1, 0, 0]]) Binary targets transform to a column vector >>> label_binarize(['yes', 'no', 'no', 'yes'], classes=['no', 'yes']) array([[1], [0], [0], [1]]) r csrFN)rMZ accept_sparseZ ensure_2dr&rrPz7neg_label={0} must be strictly less than pos_label={1}.zuSparse binarization is only supported with non zero pos_label and zero neg_label, got pos_label={0} and neg_label={1}rNrOunknownz$The type of target data is not knownbinaryrHr&rWmultilabel-indicatorr-z:classes {0} mismatch with the labels {1} found in the data)rerWr-z7%s target data is not supported with label binarization)copy)rkrH)! isinstancelistrrr.formatrrRrSr-lennpr'rZintZzerossorthasattrsizerrisin searchsortedZhstackZcumsumZ empty_likefilldatar[ZastypeanyZgetcolZreshape)r rUrDrErFZ pos_switchZy_type n_samplesZ n_classesr\Z sorted_classZ y_n_classesZ y_in_classesZy_seenindicesindptrrxr!r!r"rsF         "                rcCsPt|}t|r6|}|j\}}t|}t|dd}t|j }t ||}t ||j k}|ddkrt |t|j g}t||j dd} t |jdg} | || } d| t|dkd<t||dk|dk@} | D]:} |j|j | |j | d}|t||d| | <q|| S|j|jddddSdS)z}Inverse label binarization transformation for multiclass. Multiclass uses the maximal score instead of a threshold. rHrkrNr+Zclip)mode)rpr'rRrStocsrr-r,rr1r|repeatZ flatnonzerorxappendrorvr{whereravel setdiff1dr0Zargmax)r rUrzZ n_outputsoutputsZrow_maxZrow_nnzZy_data_repeated_maxZy_i_all_argmaxZindex_first_argmaxZ y_ind_extZ y_i_argmaxZsamplesiindr!r!r"rXbs*        rXcCsf|dkr0|jdkr0|jddkr0td|j|dkrR|jdt|krRtdt|}t|r|dkr|jdvr| }tj |j |kt d|_ | qtj ||kt d}ntj ||kt d}|dkrFt|r|}|jdkr|jddkr||d d dfSt|dkr8t|dt|S||Sn|d krT|Std |d S) z=Inverse label binarization transformation using thresholding.rerrHz'output_type='binary', but y.shape = {0}zAThe number of class is not equal to the number of dimension of y.r)rcZcscrfNrhz{0} format is not supported)ndimr-r.rnrorpr'rRrSr~arrayrxrqZeliminate_zerosr[rr)r output_typerUr]r!r!r"rYs4        rYcseZdZUdZddgdgdZeed<ddddd Zed d d d Z ed d ddZ ddZ ddZ ddZ ddZfddZZS)raTransform between iterable of iterables and a multilabel format. Although a list of sets or tuples is a very intuitive format for multilabel data, it is unwieldy to process. This transformer converts between this intuitive format and the supported multilabel format: a (samples x classes) binary matrix indicating the presence of a class label. Parameters ---------- classes : array-like of shape (n_classes,), default=None Indicates an ordering for the class labels. All entries should be unique (cannot contain duplicate classes). sparse_output : bool, default=False Set to True if output binary array is desired in CSR sparse format. Attributes ---------- classes_ : ndarray of shape (n_classes,) A copy of the `classes` parameter when provided. Otherwise it corresponds to the sorted set of classes found when fitting. See Also -------- OneHotEncoder : Encode categorical features using a one-hot aka one-of-K scheme. Examples -------- >>> from sklearn.preprocessing import MultiLabelBinarizer >>> mlb = MultiLabelBinarizer() >>> mlb.fit_transform([(1, 2), (3,)]) array([[1, 1, 0], [0, 0, 1]]) >>> mlb.classes_ array([1, 2, 3]) >>> mlb.fit_transform([{'sci-fi', 'thriller'}, {'comedy'}]) array([[0, 1, 1], [1, 0, 0]]) >>> list(mlb.classes_) ['comedy', 'sci-fi', 'thriller'] A common mistake is to pass in a list, which leads to the following issue: >>> mlb = MultiLabelBinarizer() >>> mlb.fit(['sci-fi', 'thriller', 'comedy']) MultiLabelBinarizer() >>> mlb.classes_ array(['-', 'c', 'd', 'e', 'f', 'h', 'i', 'l', 'm', 'o', 'r', 's', 't', 'y'], dtype=object) To correct this, the list of labels should be passed in as: >>> mlb = MultiLabelBinarizer() >>> mlb.fit([['sci-fi', 'thriller', 'comedy']]) MultiLabelBinarizer() >>> mlb.classes_ array(['comedy', 'sci-fi', 'thriller'], dtype=object) raNrBrUrFrGFcCs||_||_dSrIr)rrUrFr!r!r"rJszMultiLabelBinarizer.__init__TrKcCsd|_|jdur&tttj|}n(tt|jt|jkrHtdn|j}t dd|Drdt nt }t j t||d|_||jdd<|S)aFit the label sets binarizer, storing :term:`classes_`. Parameters ---------- y : iterable of iterables A set of labels (any orderable and hashable object) for each sample. If the `classes` parameter is set, `y` will not be iterated. Returns ------- self : object Fitted estimator. NztThe classes argument contains duplicate classes. Remove these duplicates before passing them to MultiLabelBinarizer.css|]}t|tVqdSrIrlrq.0cr!r!r" z*MultiLabelBinarizer.fit..rf) _cached_dictrUsortedset itertoolschain from_iterableror.allrqobjectrpemptyr)rr rUr&r!r!r"r#s zMultiLabelBinarizer.fitcCs|jdur|||Sd|_tt}|j|_|||}t ||j d}t dd|Dr`tnt }t jt||d}||dd<t j|dd\|_}t j||j|jjd|_|js|}|S)aMFit the label sets binarizer and transform the given label sets. Parameters ---------- y : iterable of iterables A set of labels (any orderable and hashable object) for each sample. If the `classes` parameter is set, `y` will not be iterated. Returns ------- y_indicator : {ndarray, sparse matrix} of shape (n_samples, n_classes) A matrix such that `y_indicator[i, j] = 1` iff `classes_[j]` is in `y[i]`, and 0 otherwise. Sparse matrix will be of CSR format. Nkeycss|]}t|tVqdSrIrrr!r!r"rBrz4MultiLabelBinarizer.fit_transform..rfTr$)rUr#r*rrrq__len__default_factory _transformrgetrrrprrouniquerr'r{r&rFr[)rr class_mappingyttmpr&Zinverser!r!r"r%"s   z!MultiLabelBinarizer.fit_transformcCs.t||}|||}|js*|}|S)aTransform the given label sets. Parameters ---------- y : iterable of iterables A set of labels (any orderable and hashable object) for each sample. If the `classes` parameter is set, `y` will not be iterated. Returns ------- y_indicator : array or CSR matrix, shape (n_samples, n_classes) A matrix such that `y_indicator[i, j] = 1` iff `classes_[j]` is in `y[i]`, and 0 otherwise. )r _build_cacherrFr[)rr Zclass_to_indexrr!r!r"r*Ns  zMultiLabelBinarizer.transformcCs,|jdur&tt|jtt|j|_|jSrI)rr_ziprrangerorr!r!r"rhs z MultiLabelBinarizer._build_cachec Cstd}tddg}t}|D]\}t}|D]4}z|||Wq0tyb||Yq00q0|||t|q"|rtd t |t dt j t|td} tj| ||ft|dt|fdS)a/Transforms the label sets with a given mapping. Parameters ---------- y : iterable of iterables A set of labels (any orderable and hashable object) for each sample. If the `classes` parameter is set, `y` will not be iterated. class_mapping : Mapping Maps from label to column index in label indicator matrix. Returns ------- y_indicator : sparse matrix of shape (n_samples, n_classes) Label indicator matrix. Will be of CSR format. rrz%unknown class(es) {0} will be ignoredrrfrHri)rraddKeyErrorextendrrowarningsrrnrr/rpZonesrqrRrZ) rr rr{r|rdlabelsindexlabelrxr!r!r"rns(   zMultiLabelBinarizer._transformcstjdtjkr8tdtjjdtrtj dkrztt j ddgdkrztdfddt j ddj ddDSt ddg}t|dkrtd |fd dDSdS) aTransform the given indicator matrix into label sets. Parameters ---------- yt : {ndarray, sparse matrix} of shape (n_samples, n_classes) A matrix containing only 1s ands 0s. Returns ------- y : list of tuples The set of labels for each sample such that `y[i]` consists of `classes_[j]` for each `yt[i, j] == 1`. rHz/Expected indicator for {0} classes, but got {1}rz+Expected only 0s and 1s in label indicator.cs*g|]"\}}tjj||qSr!)tuplerr0r{)rstartendrrr!r" sz9MultiLabelBinarizer.inverse_transform..Nrkz8Expected only 0s and 1s in label indicator. Also got {0}csg|]}tj|qSr!)rrcompress)rZ indicatorsrr!r"rr)rr-rorr.rnrRrSr~rxrprrr|)rrZ unexpectedr!rr"r2s, (  z%MultiLabelBinarizer.inverse_transformcst}d|j_d|j_|Sr^)r3r4r5r6r7Z two_d_labelsr9r;r!r"r4s z$MultiLabelBinarizer.__sklearn_tags__)r=r>r?r@rGr_r`rJrr#r%r*rrr2r4rAr!r!r;r"rs ?  +()r),rrr collectionsrnumbersrnumpyrpZ scipy.sparsesparserRbaserrrutilsrZutils._array_apir r r Z utils._encoder r Zutils._param_validationrrZutils.multiclassrrZutils.sparsefuncsrZutils.validationrrr__all__rrrrXrYrr!r!r!r"sD      ,+,