U 2d*v@sddlmZddlmZddlZddlZddlZddlZddl m Z ddl m Z mZddlmZddlmZddlmZmZmZdd lmZdd lmZdd lmZmZd d ddgZGdddee ZGdd d ee Zdddddd Z ddZ!ddZ"Gdddee Z#dS)) defaultdict)IntegralN) BaseEstimatorTransformerMixin) min_max_axis) column_or_1d) _num_samples check_arraycheck_is_fitted) unique_labels)type_of_target)_encode_uniquelabel_binarizeLabelBinarizer LabelEncoderMultiLabelBinarizerc@s8eZdZdZddZddZddZdd Zd d Zd 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 import preprocessing >>> le = preprocessing.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 = preprocessing.LabelEncoder() >>> le.fit(["paris", "paris", "tokyo", "amsterdam"]) LabelEncoder() >>> list(le.classes_) ['amsterdam', 'paris', 'tokyo'] >>> le.transform(["tokyo", "tokyo", "paris"]) array([2, 2, 1]...) >>> list(le.inverse_transform([2, 2, 1])) ['tokyo', 'tokyo', '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. Twarnrrclasses_selfyr@/tmp/pip-unpacked-wheel-zrfo1fqw/sklearn/preprocessing/_label.pyfitVs  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_inverserrrrr fit_transformgs zLabelEncoder.fit_transformcCs>t|t||jjdd}t|dkr0tgSt||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)r rrr r nparrayrrrrr transformxs   zLabelEncoder.transformcCsnt|t|dd}t|dkr*tgSt|tt|j}t|rZt dt |t |}|j|S)a Transform labels back to original encoding. Parameters ---------- y : ndarray of shape (n_samples,) Target values. Returns ------- y : ndarray of shape (n_samples,) Original encoding. Trrz'y contains previously unseen labels: %s) r rr r!r" setdiff1darangelenr ValueErrorstrasarray)rrdiffrrrinverse_transforms     zLabelEncoder.inverse_transformcCs ddgiSNX_typesZ1dlabelsrrrrr _more_tagsszLabelEncoder._more_tagsN) __name__ __module__ __qualname____doc__rrr#r+r/rrrrr$s 1c@sheZdZUdZegegdgdZeed<dddddd Zd d Z d d Z ddZ dddZ ddZ dS)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 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 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 import preprocessing >>> lb = preprocessing.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 = preprocessing.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||_||_||_dSNr5)rr6r7r8rrr__init__ szLabelBinarizer.__init__cCs||j|jkr.td|jd|jd|jr`|jdksH|jdkr`td|jd|jt|dd|_d |jkrtd 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) _validate_paramsr6r7r'r8r y_type_r spissparse sparse_input_r rrrrrrs&      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. )rr#rrrrr: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.)classesr7r6r8) r r startswithrCr'rrr7r6r8)rrZy_is_multilabelrrrr#PszLabelBinarizer.transformNcCsrt||dkr |j|jd}|jdkr8t||j}nt||j|j|}|jr\t |}nt |rn| }|S)atTransform 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 decision_function (classifier). Use 0.5 when ``Y`` contains the output of 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), inverse_transform chooses the class with the greatest value. Typically, this allows to use the output of a linear model's decision_function method directly as the input of inverse_transform. Ng@ multiclass) r r7r6rC_inverse_binarize_multiclassr_inverse_binarize_thresholdingrFrD csr_matrixrEtoarray)rY thresholdZy_invrrrr+rs    z LabelBinarizer.inverse_transformcCs ddgiSr,rr.rrrr/szLabelBinarizer._more_tags)N)r0r1r2r3rr9dict__annotations__r<rrr#r+r/rrrrrs Y+" 3r:Fr5cCst|tst|ddddd}nt|dkr6td|||krNtd|||rr|dksb|dkrrtd |||dk}|r| }t|}d |krtd |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]]) rcsrFN)r>Z accept_sparseZ ensure_2dr rrAz7neg_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}r?r@unknownz$The type of target data is not knownbinaryr:r rImultilabel-indicatorshapez:classes {0} mismatch with the labels {1} found in the data)rTrIrXz7%s target data is not supported with label binarization)copy)r[r:)! isinstancelistr r r'formatr rDrErXr&r!r)rLintzerossorthasattrsizer rZin1d searchsortedZhstackZcumsumZ empty_likefilldatarMZastypeanyZgetcolZreshape)rrGr6r7r8Z pos_switchZy_type n_samplesZ n_classesrNZ sorted_classZ y_n_classesZ y_in_classesZy_seenindicesindptrrfrrrrs<        "                cCsPt|}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. r:r[rN)ZaxisZclip)mode)r!r)rDrEtocsrrXr%rr*rjrepeatZ flatnonzerorfappendr&rdriwhereravelr$takeZargmax)rrGrhZ n_outputsoutputsZrow_maxZrow_nnzZy_data_repeated_maxZy_i_all_argmaxZindex_first_argmaxZ y_ind_extZ y_i_argmaxZsamplesiindrrrrJTs*        rJcCsf|dkr0|jdkr0|jddkr0td|j|dkrR|jdt|krRtdt|}t|r|dkr|jdkr| }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.rTrr:z'output_type='binary', but y.shape = {0}zAThe number of class is not equal to the number of dimension of y.r)rRZcscrUNrWz{0} format is not supported)ndimrXr'r^r&r!r)rDrErlr"rfr_Zeliminate_zerosrMrmrp)r output_typerGrOrrrrKs4        rKc@sreZdZUdZddgdgdZeed<ddddd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZdS)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) z array-likeNr4rGr8r9FcCs||_||_dSr;rw)rrGr8rrrr<szMultiLabelBinarizer.__init__cCs|d|_|jdkr.tttj|}n(tt|jt|jkrPt dn|j}t dd|Drlt nt }t jt||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|tVqdSr;r\r_.0crrr sz*MultiLabelBinarizer.fit..rU)rB _cached_dictrGsortedset itertoolschain from_iterabler&r'allr_objectr!emptyr)rrrGr rrrrs zMultiLabelBinarizer.fitcCs|jdk r|||S|d|_tt}|j|_| ||}t ||j d}t dd|Drhtnt }tjt||d}||dd<tj|dd\|_}tj||j|jjdd |_|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|tVqdSr;rxryrrrr|4sz4MultiLabelBinarizer.fit_transform..rUTrF)r rZ)rGrr#rBr}rr___len__default_factory _transformr~getrrr!rr&uniquerr"rir r8rM)rr class_mappingyttmpr Zinverserrrrs    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_cacherr8rM)rrZclass_to_indexrrrrr#@s  zMultiLabelBinarizer.transformcCs,|jdkr&tt|jtt|j|_|jSr;)r}rPziprranger&r.rrrrZs z MultiLabelBinarizer._build_cachec Cstd}tddg}t}|D]^}t}|D]6}z|||Wq0tk rd||Yq0Xq0|||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. rsrz%unknown class(es) {0} will be ignoredrrUr:rY)r"raddKeyErrorextendrnr&warningsrr^r~r(r!Zonesr_rDrL) rrrrirjrSlabelsindexlabelrfrrrr`s*  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`. r:z/Expected indicator for {0} classes, but got {1}rz+Expected only 0s and 1s in label indicator.cs*g|]"\}}tjj||qSr)tuplerrqri)rzstartendrrrr sz9MultiLabelBinarizer.inverse_transform..Nr[z8Expected only 0s and 1s in label indicator. Also got {0}csg|]}tj|qSr)rrcompress)rzZ indicatorsr.rrrs)r rXr&rr'r^rDrErlrfr!r$rrj)rrZ unexpectedrrrr+s. (  z%MultiLabelBinarizer.inverse_transformcCs ddgiS)Nr-Z2dlabelsrr.rrrr/szMultiLabelBinarizer._more_tags)r0r1r2r3r9rPrQr<rrr#rrr+r/rrrrrs ?!,())$ collectionsrZnumbersrrr"rZnumpyr!Z scipy.sparsesparserDbaserrZutils.sparsefuncsrutilsrZutils.validationr r r Zutils.multiclassr r Z utils._encoderr__all__rrrrJrKrrrrr s8       ,+,