3;ji, ddlZddlZddlZddlmZddlmZddlZddl m Z ddl m Z mZmZddlmZddlmZmZmZmZmZmZmZmZmZddlmZmZddlm 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"dZ/d"dZ0Gd d!ee dZ1dS)#N) defaultdict)Integral) BaseEstimatorTransformerMixin _fit_context) column_or_1d) _convert_to_numpy_find_matching_floating_dtype_is_numpy_namespace_isindevice get_namespaceget_namespace_and_deviceindexing_dtypexpx)_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')] cPt|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. Twarnrrclasses_selfys V/root/voice-cloning/.venv/lib/python3.11/site-packages/sklearn/preprocessing/_label.pyfitzLabelEncoder.fitZs(  & & &   cZt|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_transformks4  & & &"1T::: qr+ct|t|\}}t||jjd}t |dkr|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)rrrr%r1rasarrayr)r'r(xp_s r) transformzLabelEncoder.transform|sr a  A $-"5D A A A ??a  ::b>> !q$-0000r+c t|t|\}}t|d}t|dkr|gSt j|||jj dt||}|j drtdt|z||}| |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 r4z'y contains previously unseen labels: %saxis)rrrrr3r setdiff1daranger%shaper ValueErrorstrtake)r'r(r4r5diffs r)inverse_transformzLabelEncoder.inverse_transforms a  A  & & & ??a  ::b>> !} IIdm)!,VAYYI ? ?    :a= TFTRSS S JJqMMwwt}aaw000r+ct}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)rFzLabelEncoder.__sklearn_tags__s:ww''))!%&+#(,% r+) __name__ __module__ __qualname____doc__r*r/r6rCrF __classcell__rNs@r)rr(s//b""111,111<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_constraintsrFc0||_||_||_dSNrX)r'rYrZr[s r)__init__zLabelBinarizer.__init__s""*r+Tprefer_skip_nested_validationcb|j|jkr td|jd|jd|jr5|jdks |jdkrtd|jd|jt |\}}|r.|jr't |std|jdt|d |_d |jvrtd t|dkrtd |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)rYrZr?r[rr rOry_type_rspissparse sparse_input_rr%)r'r(r4 is_array_apis r)r*zLabelBinarizer.fits >T^ + +/T^//!^///    4>Q#6#6$.A:M:MM!^MM<@NMM  )++L  D. 7J27N7N M[MMM  &aC888 DL ( (R  ??a  2Q677 7[^^%a((  r+cR|||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*r6r&s r)r/zLabelBinarizer.fit_transformNs"(xx{{$$Q'''r+ct|t|\}}|r.|jr't|st d|jdt |d}|r)|jdst 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. rerf multilabelz0The object was not fitted with multilabel input.)classesrZrYr[) rrr[r r?rOr startswithrkrr%rZrY)r'r(r4roy_is_multilabels r)r6zLabelBinarizer.transformds( (++L  D. 7J27N7N M[MMM  )++66|DD  Q4<#:#:<#H#H QOPP P Mnn,     r+Nct|t|\}}|r.|jr't|st d|jd||j|jzdz }|jdkrt||j |}nt||j|j ||}|jrtj |}n(tj|r|}|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.Ng@ multiclassr9)rrrnr r?rOrZrYrk_inverse_binarize_multiclassr%_inverse_binarize_thresholdingrl csr_matrixrmtoarray)r'Y thresholdr4roy_invs r)rCz LabelBinarizer.inverse_transforms@ (++L  D. 7J27N7N T'){TTT   $.8C?I << ' '0DMbIIIEE24< bE   $M%((EE [   $MMOOE r+cxt}d|j_d|j_|SNFT)rErFrHrIrJrKrLs r)rFzLabelBinarizer.__sklearn_tags__2ww''))&+#(,% r+r_)rOrPrQrRrr\dict__annotations__r`rr*r/r6rCrFrSrTs@r)rrsVVrZZ#$$D %&%+++++ \555//65/b(((,) ) ) V9999vr+r array-likez sparse matrixneither)closedrW)r(rsrYrZr[Trar]FrXc t|tst|dddd}n%t|dkrt d|z||kr#t d|||r/|dks|dkr#t d |||dk}|r| }t |}d |vrt d |d krt d t|\}}} |r)|r't|st d|j d | || }n2#ttf$r} t d|j d| d} ~ wwxYwt|dr |j dnt|} |j d} t|dr#||jdr|j} nt#|} |dkrM| dkr?|rt%j| dft(S|| df| }||z }|S| dkrd}||}|dkrht|dr |j dnt|d}| |kr0t d|t/||dvr!t1|}t3|||}||}|||}||| }|| dg| ||df}|||}t%jt?||t?||t?||f| | f }|s)| | | }n|dkr|r=t%j|}|dkr"||j!|}||_!nbt%j"|r| }| || d!"}|dkr |||dk<nt d#|z|s3|dkr |||dk<|r d|||k<||| d$}n&|j!t(d$|_!|#||kr"|||}|dd|f}|dkr0|r|ddd%gf}n |$|ddd%fd&}|S)'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)rg accept_sparse ensure_2dr1rrjz7neg_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}rhriunknownz$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.r8z>`classes` contains unsupported dtype for array API namespace 'z'.r>r1integralbinaryr]r1rwmultilabel-indicatorz:classes {0} mismatch with the labels {1} found in the data)rrwr9r:r>T)r copyz7%s target data is not supported with label binarization)r)rr])% isinstancelistrrr?formatrrr rOr3 TypeErrorhasattrr>lenisdtyper1rrlrzintzerossortrrr searchsortedastypeconcatcumulative_sum full_liker r{datarmanyreshape)r(rsrYrZr[ pos_switchy_typer4rodevice_e n_samples n_classes int_dtype_r| sorted_class y_n_classes y_in_classesy_seenindicesindptrrs r)rrsDL a  8  #Ue4    ??a  2Q677 7I E L L9      )q..INN vi++    aJJ A  F N   ?@@@ 8 ; ;B g  .A".E.E  I+ I I I   **WW*55  "        &a11= s1vvI a Iq'(rzz!':>>(W #B''   >> }i^3????HHi^:H>>Y !^^!F777##L '''$+Aw$7$7FagajjS1YY  # #LSS]1--  ))) OOQB/// <//,77yyz::  A3w //!!,Q!77    ||GY// M!$2...!'b111!&R000  i(     8 199;;w 77A ) ) )  & a  AA~~||AFI66{1~~ IIKK 1W4 88AA~~%!q&  E N     0 >>!Aa1fI  " !Aa9n  IIa%I 0 0s// vvg%&&//,88 aaajM   .!!!bT' AA 1QQQU8W--A Hs+EE2E--E2ctj|rtj|}|}|j\}}tj|}t|dd}tj|j }tj ||}tj ||j k} |ddkr(tj | t|j g} tj| |j dd} tj |jdg} | | | } d| tj|dkd<tj||dk|dkz} | D]N}|j|j ||j |dz}|tj||d| |<O|| St)||\}}}|||}||d}||d|jddz }||S)z}Inverse label binarization transformation for multiclass. Multiclass uses the maximal score instead of a threshold. r]rrNr9r8r:)rlrmnpr3tocsrr>r=rrBrrepeat flatnonzerorappendrrrwhereravelr<rargmaxclip)r(rsr4r n_outputsoutputsrow_maxrow_nnzy_data_repeated_maxy_i_all_argmaxindex_first_argmax y_ind_ext y_i_argmaxsamplesiindr5rrs r)rxrxs  {1~~' *W%% GGII w 9)I&&q!$$Q''!(## i99(;qv(EFF 2;!  Y~AF }EEN _^QXcrc]KKIai!-- ~.@AB 01 28GqL))!,-)I&&!  18L'MN C CA)AHQK!(1q5/9:C#BL#$>$>?BJqMMz""1!;;;Aw**WW*55))AA)&&'''1gmA&6&:;;wr+cX|dkrC|jdkr8|jddkr'td|jt ||\}}}|||}|dkr+|jd|jdkrtdt ||}t|d r#||j d r|j }nt|}tj |r|dkr[|jd vr| }tj|j|kt" |_|na|||k|| }n2||||| |k|| }|dkrtj |r|}|jdkr#|jddkr||dddfS|jddkr)||dt+|S|||dS|dkr|Std|)z=Inverse label binarization transformation using thresholding.rr]z'output_type='binary', but y.shape = {0}r9r8rzAThe number of class is not equal to the number of dimension of y.r1r)rcscr)r1r N)rrz{0} format is not supported)ndimr>r?rrr3r rrr1rrlrmrrarrayrreliminate_zerosr{rrr) r( output_typersr}r4r5rdtype_rs r)ryrysh16Q;;171:>>BII!'RRSSS-aB777NB7jjj11Gh171:q1A#A#A O   +1 4 4 4Fq'(rzz!':>>(W #B''  {1~~  q==x~--GGIIXafy0<<>  A 6Q;;171:??1QQQT7# #}Q1$$yySVV444rzz!U3344 . . .6==kJJKKKr+ceZdZUdZddgdgdZeed<ddddZed d Z ed d Z d Z dZ dZ dZfdZxZS)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) rNrWrsr[r\Fc"||_||_dSr_r)r'rsr[s r)r`zMultiLabelBinarizer.__init___s *r+Tracd|_|j:tttj|}nMtt|jt|jkrtd|j}td|Drtnt}tj t|||_||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|tVdSr_rr.0cs r) z*MultiLabelBinarizer.fit..s,??!:a--??????r+r) _cached_dictrssortedset itertoolschain from_iterablerr?allrobjectremptyr%)r'r(rsr1s r)r*zMultiLabelBinarizer.fitcs ! < S!>!>q!A!ABBCCGG T\"" # #c$,&7&7 7 7/  lG??w?????KVWU;;; " aaa r+c~|j(|||Sd|_t t }|j|_|||}t||j }td|Drt nt}tjt||}||dd<tj|d\|_}tj||j|jj|_|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. Nkeyc3@K|]}t|tVdSr_rrs r)rz4MultiLabelBinarizer.fit_transform..s,;;!:a--;;;;;;r+rTr-)rsr*r6rrr__len__default_factory _transformrgetrrrrruniquer%r3rr1r[r{)r'r( class_mappingyttmpr1inverses r)r/z!MultiLabelBinarizer.fit_transforms$ < #88A;;((++ + $C(( (5(= % __Q . .] (9:::;;s;;;;;GS777  aaa!#=!N!N!N wZ 32:;KLLL ! B r+ct||}|||}|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_cacherr[r{)r'r(class_to_indexrs r)r6zMultiLabelBinarizer.transformsS **,, __Q / /! B r+c |jFtt|jt t |j|_|jSr_)rrzipr%ranger)r's r)rz MultiLabelBinarizer._build_cachesB   $ $Sc$->P>P8Q8Q%R%R S SD   r+ctjd}tjddg}t}|D]}t}|D]C} |||#t$r||Y@wxYw|||t ||r;tjd t|ttj t |t} tj| ||ft |dz t |fS)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#rrr@ronesrrlrz) r'r(rrrrlabelsindexlabelrs r)rzMultiLabelBinarizer._transformsh$+c""S1#&&%% ( (FEEE ' ''IImE23333'''KK&&&&&' NN5 ! ! ! MM#g,, ' ' ' '   M7>>vgSV?W?W?WXX   ws7||3///} 7F #CKK!OS=O=O+P    sA,,B Bctjdtjkr@t dtjjdt jrtj dkrz9MultiLabelBinarizer.inverse_transform..sPE3dm((E#I)>??@@r+Nrz8Expected only 0s and 1s in label indicator. Also got {0}c^g|])}tj|*Sr)rr%compress)r indicatorsr's r)rz9MultiLabelBinarizer.inverse_transform..s1SSS*E$-00<<==SSSr+)rr>rr%r?rrlrmrrrr<rr)r'r unexpecteds`` r)rCz%MultiLabelBinarizer.inverse_transforms  8A;#dm,, , ,AHH &&   ;r?? TB27||q  Sbg1v)F)F%G%G!%K%K !NOOO"%binbim"D"D  b1a&11J:"" NUU" TSSSPRSSS Sr+cxt}d|j_d|j_|Sr)rErFrHrIrJ two_d_labelsrLs r)rFz$MultiLabelBinarizer.__sklearn_tags__!rr+)rOrPrQrRr\rrr`rr*r/r6rrrCrFrSrTs@r)rrs'<<~!$'#$$D #'e+++++\55565@\555))65)V4!!! & & & P'T'T'TRr+rr_)2rrr collectionsrnumbersrnumpyr scipy.sparsesparserl sklearn.baserrr sklearn.utilsrsklearn.utils._array_apir r r r r rrrrsklearn.utils._encoderrsklearn.utils._param_validationrrsklearn.utils.multiclassrrsklearn.utils.sparsefuncsrsklearn.utils.validationrrr__all__rrrrxryrrr+r)rs ######FFFFFFFFFF&&&&&&                      32222222EEEEEEEEBBBBBBBB222222OOOOOOOOOO   MMMMM#]$MMMM`VVVVV%}DVVVVrO , >hxtIFFFGhxtIFFFG# #'   -.%W W W W   W t, , , , ^4L4L4L4LnJJJJJ*MQUJJJJJJr+