Q3j ddlZddlZddlZddlmZddlmZddlZddl m Z ddl m Z mZmZddlmZmZddlmZmZmZmZmZmZmZmZmZddlmZmZddl m!Z!m"Z"dd l#m$Z$m%Z%dd l&m'Z'dd l(m)Z)m*Z*m+Z+gd Z,Gd dee dZ-Gddee dZ.e"ddgdge!edddge!edddgdgdddddddZ/d"dZ0d"dZ1Gd d!ee dZ2y)#N) defaultdict)Integral) BaseEstimatorTransformerMixin _fit_context)_align_api_if_sparse column_or_1d) _find_matching_floating_dtype_is_numpy_namespace_isindevice get_namespaceget_namespace_and_deviceindexing_dtypemove_toxpx)_encode_unique)Intervalvalidate_params)type_of_target unique_labels) min_max_axis) _num_samples check_arraycheck_is_fitted)LabelBinarizer LabelEncoderMultiLabelBinarizerlabel_binarizec:eZdZdZdZdZdZdZfdZxZ 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')] c@t|d}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. Twarnr rclasses_selfys I/DATA/.local/lib/python3.12/site-packages/sklearn/preprocessing/_label.pyfitzLabelEncoder.fitZs   &   cJt|d}t|d\|_}|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. Tr#return_inverser%r's r* fit_transformzLabelEncoder.fit_transformks(  &"1T: qr,ct|t|\}}t||jjd}t |dk(r|j gSt||jS)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)dtyper$r)uniques)rrr r&r2rasarrayr)r(r)xp_s r* transformzLabelEncoder.transform|s] a A $--"5"5D A ?a ::b> !q$--00r,c t|t|\}}t|d}t|dk(r|j gSt j ||j|jjdt||}|jdrtdt|z|j |}|j|j|dS)aTransform labels back to original encoding. Parameters ---------- y : array-like of shape (n_samples,) Target values. Returns ------- y_original : ndarray of shape (n_samples,) Original encoding. Tr#rr r5z'y contains previously unseen labels: %saxis)rrr rr4r setdiff1daranger&shaper ValueErrorstrtake)r(r)r5r6diffs r*inverse_transformzLabelEncoder.inverse_transforms a A  & ?a ::b> !}} IIdmm))!,VAYI ?  ::a=FTRS S JJqMwwt}}aaw00r,cvt|}d|_d|j_d|j _|S)NTF)super__sklearn_tags__array_api_support input_tags two_d_array target_tags one_d_labelsr(tags __class__s r*rGzLabelEncoder.__sklearn_tags__s7w')!%&+#(,% r,) __name__ __module__ __qualname____doc__r+r0r7rDrG __classcell__rOs@r*rr(s'/b""1,1<r,r)auto_wrap_output_keysceZdZUdZegegdgdZeed<dddddZe d d Z d Z d Z ddZ fdZxZS)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_constraintsrFc.||_||_||_yNrY)r(rZr[r\s r*__init__zLabelBinarizer.__init__s""*r,Tprefer_skip_nested_validationc|j|jk\r&td|jd|jd|jrC|jdk(s|jdk7r%td|jd|jt |\}}|r0|jr$t |std|j dt|d |_d |jvr td t|dk(rtd |ztj||_ 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=>`sparse_output=True` is not supported for array API namespace <. Use `sparse_output=False` to return a dense array instead.r)) input_name multioutput@Multioutput target data is not supported with label binarizationy has 0 samples: %r)rZr[r@r\rr rPry_type_rspissparse sparse_input_rr&)r(r)r5 is_array_apis r*r+zLabelBinarizer.fitsH >>T^^ +T^^,-!^^,A/    4>>Q#6$..A:M!^^,ODNN;KM  )+L D..7J27N[[M*MM  &aC8 DLL (R  ?a 2Q67 7[[^%a(  r,cB|j|j|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+r7r's r*r0zLabelBinarizer.fit_transformNs(xx{$$Q''r,ct|t|\}}|r0|jr$t|st d|j dt |jd}|r&|jjds t dt||j|j|j|jS)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. rfrg multilabelz0The object was not fitted with multilabel input.)classesr[rZr\) rrr\r r@rPr startswithrlr r&r[rZ)r(r)r5rpy_is_multilabels r*r7zLabelBinarizer.transformds( (+L D..7J27N[[M*MM  )+66|D 4<<#:#:<#HOP P MMnnnn,,   r,ct|t|\}}|r0|jr$t|st d|j d||j |jzdz }|jdk(rt||j|}n$t||j|j||}|jr ttj|}|Stj|r|j!}|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_original : {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`. zY`LabelBinarizer` was fitted on a sparse matrix, and therefore cannot inverse transform a z array back to a sparse matrix.g@ multiclassr:)rrror r@rPr[rZrl_inverse_binarize_multiclassr&_inverse_binarize_thresholdingrrm csr_arrayrntoarray)r(Y thresholdr5rpy_invs r*rDz LabelBinarizer.inverse_transforms@ (+L D..7J27N''){{m3RT   $..8C?I <<< '0DMMbIE24<< bE   (e)<=E [[ MMOE r,cht|}d|j_d|j_|SNFT)rFrGrIrJrKrLrMs r*rGzLabelBinarizer.__sklearn_tags__/w')&+#(,% r,r`)rPrQrRrSrr]dict__annotations__rarr+r0r7rDrGrTrUs@r*rrsmVrZZ#$D %&%+ 5/6/b(,) V9vr,r array-likez sparse matrixneither)closedrX)r)rtrZr[r\Trbr^FrYc  t|tst|dddd}nt|dk(rt d|z||k\rt dj |||r%|dk(s|dk7rt d j |||dk(}|r| }t |}d |vr t d |d k(r t d t|\}}} |r&|r$t|st d|jd |j|| }t|dr|jdn t|} |jd} t|d} | r)|j|j dr |j }n t#|}| r:|j|j dr|j%||j d}|dk(rP| dk(rD|r&t't)j*| dft,S|j/| df|}||z }|S| dk\rd}|j1|}|dk(rRt|dr|jdn t|d}| |k7r$t dj |t3||dvrt5|}t7||| }||}|j9||}|j%||}|j;|jdg| |j=|d!f}|j?||}t)j*tA|tBd"#tA|tBd"#tA|tBd"#f| | f$}|s|j|jE| }n|dk(r|r>t)j*|}|dk7ry|j?|jF|}||_#nUt)jH|r|jE}|j|| d%&}|dk7r|||dk7<nt d'|z|s,|dk7r|||dk(<|rd|||k(<|j%||d}n&|jFj%t,d|_#|jK||k7r|j9||}|dd|f}|dk(r0|r|ddd(gf}t'|S|jM|ddd(fd)}t'|S#ttf$r} t d|jd| d} ~ wwxYw)*aBinarize 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. This function makes it possible to compute this transformation for a fixed set of class labels known ahead of time. Parameters ---------- y : array-like or sparse matrix Sequence of integer labels or multilabel data to encode. classes : array-like of shape (n_classes,) Uniquely holds the label for each class. 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, Set to true if output binary array is desired in CSR sparse format. 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. See Also -------- LabelBinarizer : Class used to wrap the functionality of label_binarize and allow for fitting to classes independently of the transform operation. Examples -------- >>> 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)rh accept_sparse ensure_2dr2rrkz7neg_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}rirjunknownz$The type of target data is not knownz?`sparse_output=True` is not supported for array API 'namespace z='. Use `sparse_output=False` to return a dense array instead.r9z>`classes` contains unsupported dtype for array API namespace 'z'.r?r2signed integerintegral)copybinaryr^r2rxmultilabel-indicatorz:classes {0} mismatch with the labels {1} found in the data)rrxr:r;cpu)r5r r?T)r rz7%s target data is not supported with label binarization)rr^)' isinstancelistrrr@formatrrr rPr4 TypeErrorhasattrr?lenisdtyper2rastyperrmr{intzerossortrr r searchsortedconcatcumulative_sum full_likernpr|datarnanyreshape)r)rtrZr[r\ pos_switchy_typer5rpdevice_e n_samples n_classes y_has_dtype int_dtype_r} sorted_class y_n_classes y_in_classesy_seenindicesindptrrs r*r r s/L a   #Ue4  ?a 2Q67 7I E L L9   )q.IN vi+   aJJ A F N  ?@@ 8 ;B g .A".E ++'I I  **WW*5&a1 s1vI a I!W%Krzz!''+;<WW #B' rzz!'':6))GQWW5)9  >+BLL)Qs,STTHHi^:H>Y !^!F777#L ''$+Aw$7aggajS1Y  #LSS]1-  )) OQB/ <//,7yyz:  A3w /!!,Q!7   ||GY/ LLE2Bu52e4  i(   199;w 7A ) )  QAA~||AFFI6{{1~IIK 1W4 8AA~%!q&  E N    >!Aa1fI  !Aa9n  IIa%I 0s/ vvg%&//,8 ajM  !bT' A  "" 1QU8W-A  ""e  " }B   s1SS=S88S=ctj|rtj|}|j }|j \}}tj |}t|dd}tj|j}tj||}tj||jk(} |ddk(r*tj| t|jg} tj| |jdd} tj|j dg} | | | } d| tj"|dk(d<tj ||dkD|j%dk(z} | D]M}|j |j||j|dz}|tj&||d| |<O|| St)||\}}}|j||}|j+|d}|j-|d|j ddz }||S)z}Inverse label binarization transformation for multiclass. Multiclass uses the maximal score instead of a threshold. r^rrNr:r9r;)rmrnrr4tocsrr?r>rrCrrepeat flatnonzerorappendrrrwhereravelr=rargmaxclip)r)rtr5r n_outputsoutputsrow_maxrow_nnzy_data_repeated_maxy_i_all_argmaxindex_first_argmax y_ind_ext y_i_argmaxsamplesiindr6rrs r*ryrys  {{1~**W% GGI ww 9))I&q!$Q'''!((# ii9(;qvv(EF 2;! YY~AFF }EN __^QXXcr]KIIaii!- ~.@AB 01 288GqL)!,-))I&!  18L'MNA))AHHQK!((1q5/:C#BLL#$>?BJqMz""1!;Aw**WW*5))AA)&'''1gmmA&6&:;wr,c|dk(rE|jdk(r6|jddkDr$tdj|jt ||\}}}|j ||}|dk7r*|jd|jdk7r tdt ||}t|d r)|j|jd r |j}n t|}tj|r|dkDr\|jd vr|j}tj|j |kDt" |_|j%nO|j |j'|kD|| }n)|j |j ||| |kD|| }|dk(rtj|r|j'}|jdk(r|jddk(r ||dddfS|jddk(r|j)|dt+|S||j-|dS|dk(r|Stdj|)z=Inverse label binarization transformation using thresholding.rr^z'output_type='binary', but y.shape = {0}r:r9rzAThe number of class is not equal to the number of dimension of y.r2r)rcscr)r2r N)rrz{0} format is not supported)ndimr?r@rrr4r rrr2rrmrnrrarrayrreliminate_zerosr|rrr) r) output_typertr~r5r6rdtype_rs r*rzrzs$h166Q;1771:>BII!''RSS-aB7NB7jjj1Gh1771:q1A#A O  +1 4Fq'rzz!''3CDWW #B'  {{1~ q=xx~-GGIXXaffy0 A 66Q;1771:?1QT7# #}}Q1$yySV44rzz!U344 . .6==kJKKr,ceZdZUdZddgdgdZeed<ddddZed d Z ed d Z d Z dZ dZ dZfdZxZS)ra?Transform 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. Read more in the :ref:`User Guide `. 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) rNrXrtr\r]Fc ||_||_yr`r)r(rtr\s r*razMultiLabelBinarizer.__init__hs *r,Trbcd|_|j2tttj j |}nKtt|jt|jkr td|j}td|Drtnt}tjt|||_||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.c3<K|]}t|tywr`rr.0cs r* z*MultiLabelBinarizer.fit..s?w!:a-wr) _cached_dictrtsortedset itertoolschain from_iterablerr@allrobjectremptyr&)r(r)rtr2s r*r+zMultiLabelBinarizer.fitls ! << S!>!>q!ABCG T\\" #c$,,&7 7/  llG?w??VWU; " a r,ct|j |j|j|Sd|_t t }|j |_|j||}t||j}td|Drt nt}tjt||}||ddtj |d\|_}tj$||j&|j&j(|_|j*s|j-}|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. Nkeyc3<K|]}t|tywr`rrs r*rz4MultiLabelBinarizer.fit_transform..s;s!:a-srrTr.)rtr+r7rrr__len__default_factory _transformrgetrrrrruniquer&r4rr2r\r|)r(r) class_mappingyttmpr2inverses r*r0z!MultiLabelBinarizer.fit_transforms$ << #88A;((+ + $C( (5(=(= % __Q .] (9(9:;s;;S7  a!#=!N wZZ 32::;K;KL !!B r,ct||j}|j||}|js|j }|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_cacherr\r|)r(r)class_to_indexrs r*r7zMultiLabelBinarizer.transformsC **, __Q /!!B r,c |j@tt|jt t |j|_|jSr`)rrzipr&ranger)r(s r*rz MultiLabelBinarizer._build_caches@    $ $Sc$-->P8Q%R SD    r,c tjd}tjddg}t}|D]S}t}|D]} |j|||j ||j t |U|r3tjdjt|ttjt |t} tt!j"| ||ft |dz t |fS#t$r|j|YwxYw)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 ignoredrrr^r)rraddKeyErrorextendrrwarningsr$rrrAronesrrrmr{) r(r)rrrrlabelsindexlabelrs r*rzMultiLabelBinarizer._transforms $++c"S1#&%FEE'IImE23 NN5 ! MM#g, '  MM7>>vgSV?WX wws7|3/# LLw'F a]AS/T    'KK&'s D""D?>D?c t||jdt|jk7r;t dj t|j|jdt j|r|j}t|jdk7r9ttj|jddgdkDr t dt|jdd|jddDcgc]6\}}t|jj|j ||8c}}Stj|ddg}t|dkDrt dj ||Dcgc]&}t|jj#|(c}Scc}}wcc}w)aTransform the given indicator matrix into label sets. Parameters ---------- yt : {ndarray, sparse matrix} of shape (n_samples, n_classes) A matrix containing only 1s and 0s. Returns ------- y_original : 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.Nrz8Expected only 0s and 1s in label indicator. Also got {0})rr?rr&r@rrmrnrrrr=rrtuplerBrcompress)r(rstartend unexpected indicatorss r*rDz%MultiLabelBinarizer.inverse_transforms  88A;#dmm, ,AHH &   ;;r?B277|q Sbgg1v)F%G!%K !NOO#&biinbiim"D"DJE3dmm((E#)>?@"D  b1a&1J:" NUU" QSSPR*E$--00<=PRS STs ;F<+Gcht|}d|j_d|j_|Sr)rFrGrIrJrK two_d_labelsrMs r*rGz$MultiLabelBinarizer.__sklearn_tags__,rr,)rPrQrRrSr]rrrarr+r0r7rrrDrGrTrUs@r*rr"s>B!$'#$D #'e+56@5)6)V4! ( T'TRr,rr`)3rrr collectionsrnumbersrnumpyr scipy.sparsesparserm sklearn.baserrr sklearn.utilsrr sklearn.utils._array_apir r r r rrrrrsklearn.utils._encoderrsklearn.utils._param_validationrrsklearn.utils.multiclassrrsklearn.utils.sparsefuncsrsklearn.utils.validationrrr__all__rrr ryrzrr,r*rs #FF<   3EB2OO M#]$M`V%}DVrO , >xtIFGxtIFG# #' -.%^# ^#B, ^4LnN*MQUNr,