Ki, SSKrSSKrSSKrSSKJr SSKJr SSKrSSK J r SSK J r JrJr SSKJr SSKJrJrJrJrJrJrJrJrJr SSKJrJr SSKJ r J!r! SS K"J#r#J$r$ SS K%J&r& SS K'J(r(J)r)J*r* /S Qr+"S S\\ SS9r,"SS\\ SS9r-\!"SS/S/\ "\SSSS9/\ "\SSSS9/S/S.SS9SSSS.Sj5r.S"Sjr/S"Sjr0"S S!\\ SS9r1g)#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_binarizecD^\rSrSrSrSrSrSrSrU4Sjr Sr U=r $) r(aEncode 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:[USS9n[U5UlU$)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 ^/var/www/html/dynamic-report/venv/lib/python3.13/site-packages/sklearn/preprocessing/_label.pyfitLabelEncoder.fitZs   &   c>[USS9n[USS9uUlnU$)zFit 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_transformLabelEncoder.fit_transformks(  &"1T: qr-c[U5 [U5up#[XRRSS9n[ U5S:XaUR /5$[XRS9$)zTransform 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&r4rasarrayr)r(r)xp_s r* transformLabelEncoder.transform|sW a  --"5"5D A ?a ::b> !q--00r-c [U5 [U5up#[USS9n[U5S:XaUR /5$[ R "UURURRS[U5S9US9nURS(a[S[U5-5eUR U5nURURUSS9$)zTransform 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 r7z'y contains previously unseen labels: %saxis)rrrrr6r setdiff1daranger&shaper ValueErrorstrtake)r(r)r7r8diffs r*inverse_transformLabelEncoder.inverse_transforms a   & ?a ::b> !}} IIdmm))!,VAYI ?  ::a=FTRS S JJqMwwt}}aaw00r-cv>[TU]5nSUlSURlSUR lU$)NTF)super__sklearn_tags__array_api_support input_tags two_d_array target_tags one_d_labelsr(tags __class__s r*rKLabelEncoder.__sklearn_tags__s7w')!%&+#(,% r-)r&) __name__ __module__ __qualname____firstlineno____doc__r+r1r9rGrK__static_attributes__ __classcell__rSs@r*rr(s'/b""1,1<r-r)auto_wrap_output_keysc^\rSrSr%Sr\/\/S/S.r\\S'SSSS.S jr \ "S S 9S 5r S r Sr SSjrU4SjrSrU=r$)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(XlX lX0lgNra)r(rbrcrds r*__init__LabelBinarizer.__init__s""*r-Tprefer_skip_nested_validationcURUR:a&[SURSURS35eUR(aEURS:XdURS:wa%[SURSUR35e[ U5up#U(a:UR(a)[ U5(d[SUR S35e[US S 9UlS UR;a [S 5e[U5S:Xa[S U-5e[R"U5Ul [U5UlU$)aFit 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)rbrcrCrdrr rUry_type_rspissparse sparse_input_rr&)r(r)r7 is_array_apis r*r+LabelBinarizer.fitsI >>T^^ +T^^,-!^^,A/    4>>Q#6$..A:M!^^,ODNN;KM  )+ D..7J27N7N[[M*MM  &aC8 DLL (R  ?a 2Q67 7[[^%a(  r-cBURU5RU5$)aQFit 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+r9r's r*r1LabelBinarizer.fit_transformNs(xx{$$Q''r-c[U5 [U5up#U(a:UR(a)[U5(d[ SUR S35e[ U5RS5nU(a+URRS5(d [ S5e[UURURURURS9$)aKTransform 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. rorp multilabelz0The object was not fitted with multilabel input.)classesrcrbrd) rrrdr rCrUr startswithrurr&rcrb)r(r)r7ryy_is_multilabels r*r9LabelBinarizer.transformds( (+ D..7J27N7N[[M*MM  )+66|D 4<<#:#:<#H#HOP P MMnnnn,,   r-c&[U5 [U5up4U(a:UR(a)[U5(d[ SUR S35eUcUR UR-S- nURS:Xa[XRUS9nO[XRURX#S9nUR(a[R"U5nU$[R"U5(aUR5nU$)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=)rrrxr rCrUrcrbru_inverse_binarize_multiclassr&_inverse_binarize_thresholdingrv csr_matrixrwtoarray)r(Y thresholdr7ryy_invs r*rG LabelBinarizer.inverse_transforms@ (+ D..7J27N7N''){{m3RT   $..8C?I <<< '0MMbIE2<< E   MM%(E [[  MMOE r-ch>[TU]5nSURlSURlU$NFT)rJrKrMrNrOrPrQs r*rKLabelBinarizer.__sklearn_tags__/w')&+#(,% r-)r&rbrcrxrdrurh)rUrVrWrXrYrredict__annotations__rirr+r1r9rGrKrZr[r\s@r*rrsmVrZZ#$D %&%+ 5/6/b(,) V9vr-r array-likez sparse matrixneither)closedr`)r)rrbrcrdTrkrfFrac  [U[5(d[USSSSS9nO[U5S:Xa[ SU-5eX#:a[ SR X#55eU(a&US:XdUS:wa[ S R X255eUS:HnU(aU*n[ U5nS U;a [ S 5eUS :Xa [ S 5e[U5upxn U(a0U(a)[U5(d[ SURS35eURXS9n[US5(aURSO [U5n URSn [US5(a.URUR S5(a UR n O [#U5n US:XaHU S:Xa:U(a[$R&"U S4[(S9$UR+U S4U S9nX- nU$U S:aSnUR-U5nUS:XaX[US5(aURSO [US5nU U:wa$[ SR U[/U555eUS;a[1U5n[3XUS9nUUnUR5UU5nUR7UU 5nUR9URS/U S9UR;USS945nUR=UU5n[$R&"[?UUS9[?UUS9[?UUS94X4S 9nU(dURURA5U S9nOUS:XaU(a@[$R&"U5nUS:wa#UR=URBU5nUUl!OW[$RD"U5(aURA5nURX S!S"9nUS:waX>US:g'O[ S#U-5eU(d,US:waX.US:H'U(aSXU:H'UR7XSS$9nO#URBR7[(SS$9Ul!URGX:g5(aUR5X5nUSS2U4nUS:Xa,U(a USS2S%/4nU$URIUSS2S%4S&5nU$![[4an [ SURS35U eSn A ff=f)'anBinarize 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)rq accept_sparse ensure_2dr4rrtz7neg_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}rrrsunknownz$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.r<z>`classes` contains unsupported dtype for array API namespace 'z'.rBr4integralbinaryrfr4rmultilabel-indicatorz:classes {0} mismatch with the labels {1} found in the data)rrr=r>rBT)r copyz7%s target data is not supported with label binarization)r)rrf)% isinstancelistrrrCformatrrr rUr6 TypeErrorhasattrrBlenisdtyper4rrvrintzerossortrrr searchsortedastypeconcatcumulative_sum full_liker rdatarwanyreshape)r)rrbrcrd pos_switchy_typer7rydevice_e n_samples n_classes int_dtype_r sorted_class y_n_classes y_in_classesy_seenindicesindptrrs r*rrsL a    #Ue4  ?a 2Q67 7 E L L   )q.IN vi+   aJJ A F N  ?@@ 8 ;Bg .A".E.E ++'I I  **W*5&a11 s1vI a Iq'rzz!'':>>WW #B'   >}}i^3??HHi^:H> !^!F777#L ''$+Aw$7$7aggajS1Y  #LSS]1-  )) OQB/ <//,7yyz:  A3w /!!,Q!7   ||GY/ MM!$2.!'b1!&R0  (   199;w 7A ) )  a AA~||AFFI6{{1~~IIK 14 8AA~%!q&  E N    >!a1fI  !A9n  IIa%I 0s/ vvg%&&//,8 ajM  !bT' A H 1QU8W-A HW  " }B   sRS ,SS c[R"U5(Ga[R"U5nUR 5nUR up4[R "U5n[US5Sn[R"UR5n[R"Xg5n[R"XR:H5n USS:Xa+[R"U [UR5/5n [R"XRSS5n [R"UR S/5n XU n SU [R""US:H5S'[R "U5US:UR%5S:H-n U HMnUR URUURUS-nU[R&"X_5SX'MO X$[)XS9unnnURUUS9nUR+USS9nUR-USUR SS- 5nUU$)zuInverse label binarization transformation for multiclass. Multiclass uses the maximal score instead of a threshold. rfrrNr=r<r>)rvrwnpr6tocsrrBrArrFrrepeat flatnonzerorappendrrrwhereravelr@rargmaxclip)r)rr7r n_outputsoutputsrow_maxrow_nnzy_data_repeated_maxy_i_all_argmaxindex_first_argmax y_ind_ext y_i_argmaxsamplesiindr8rrs r*rrs  {{1~~**W% GGI ww ))I&q!$Q'''!((# ii9(;vv(EF 2;! YY~AFF }EN __^XXcr]KIIaii!- .@AB 01 288GqL)!,-))I&!  18L'MNA))AHHQK!((1q5/:C#BLL$>?BJM""1!;Aw**WW*5))AA)&'''1gmmA&6&:;wr-cUS:XaGURS:Xa7URSS:a$[SRUR55e[ XS9upEnUR X&S9nUS:wa+URSURS:wa [S5e[ XS9n[US 5(a.URURS 5(a URnO [U5n[R"U5(aUS:a\URS ;aUR5n[R"UR U:["S 9UlUR%5 ODUR UR'5U:XS 9nO"UR UR XUS 9U:UUS 9nUS:Xa[R"U5(aUR'5nURS:XaURSS:Xa X SS2S4$URSS:XaUR)US[+U55$X$R-US5$US:XaU$[SRU55e)z=Inverse label binarization transformation using thresholding.rrfz'output_type='binary', but y.shape = {0}r=r<rzAThe number of class is not equal to the number of dimension of y.r4r)rcscr)r4r N)rrz{0} format is not supported)ndimrBrCrrr6r rrr4rrvrwrrarrayrreliminate_zerosrrrr) r) output_typerrr7r8rdtype_rs r*rrsh166Q;1771:>BII!''RSS-a7NB7jjj1Gh1771:q1A#A O  +1 4Fq'rzz!'':>>WW #B'  {{1~~ q=xx~-GGIXXaffy0> A 66Q;1771:?QT7# #}}Q1$yySV44zz!U344 . .6==kJKKr-c^\rSrSr%SrSS/S/S.r\\S'SSS.S jr\ "S S 9S 5r \ "S S 9S 5r Sr Sr SrSrU4SjrSrU=r$)ria<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. 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) rNr`rrdreFcXlX lgrhr)r(rrds r*riMultiLabelBinarizer.__init___s  *r-TrkcSUlURc2[[[R R U555nOL[[UR55[UR5:a [S5eURn[SU55(a[O[n[R"[U5US9UlX RSS&U$)a,Fit 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.c3B# UHn[U[5v M g7frhrr.0cs r* *MultiLabelBinarizer.fit..s?w!:a--wr) _cached_dictrsortedset itertoolschain from_iterablerrCallrobjectremptyr&)r(r)rr4s r*r+MultiLabelBinarizer.fitcs ! << S!>!>q!ABCG T\\" #c$,,&7 7/  llG?w???VWU; " a r-cpURb URU5RU5$SUl[ [ 5nUR UlURX5n[X"RS9n[SU55(a[ O[n[R"[U5US9nXBSS&[R "USS9uUln[R$"XcR&UR&R(S9UlUR*(dUR-5nU$)aFit 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. Nkeyc3B# UHn[U[5v M g7frhrrs r*r4MultiLabelBinarizer.fit_transform..s;s!:a--srrTr/)rr+r9rrr__len__default_factory _transformrgetrrrrruniquer&r6rr4rdr)r(r) class_mappingyttmpr4inverses r*r1!MultiLabelBinarizer.fit_transforms$ << #88A;((+ + $C( (5(=(= % __Q .](9(9:;s;;;S7 a!#=!N wZZ 32::;K;KL !!B r-c[U5 UR5nURX5nUR(dUR 5nU$)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_cacherrdr)r(r)class_to_indexrs r*r9MultiLabelBinarizer.transformsA **, __Q /!!B r-c URc@[[UR[ [ UR5555UlUR$rh)rrzipr&ranger)r(s r*r MultiLabelBinarizer._build_caches@    $ $Sc$-->P8Q%R SD    r-c |[R"S5n[R"SS/5n[5nUHUn[5nUHnURX(5 M UR U5 UR [ U55 MW U(a1[R"SR[U[S955 [R"[ U5[S9n [R "XU4[ U5S- [ U54S9$![a URU5 Mf=f)aTransforms 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 ignoredrrrfr)rraddKeyErrorextendrrwarningsr$rrrDronesrrvr) r(r)rrrrlabelsindexlabelrs r*rMultiLabelBinarizer._transforms$++c"S1#&%FEE'IIm23 NN5 ! MM#g, '  MM7>>vgSV?WX wws7|3/}} F #CK!OS=O+P   'KK&'sDD;:D;c [U5 URS[UR5:wa;[ SR [UR5URS55e[ R"U5(aUR5n[UR5S:wa;[[R"URSS/55S:a [ S5e[URSSURSS5VVs/sH5up#[URRUR X#55PM7 snn$[R"USS/5n[U5S:a[ SR U55eUVs/sH'n[URR#U55PM) sn$s snnfs snf)aPTransform 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_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`. rfz/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})rrBrr&rCrrvrwrrrr@r rtuplerErcompress)r(rstartend unexpected indicatorss r*rG%MultiLabelBinarizer.inverse_transforms  88A;#dmm, ,AHH &   ;;r??B277|q Sbgg1v)F%G!%K !NOO#&biinbiim"D"DJEdmm((E)>?@"D  b1a&1J:" NUU" QSSPR*E$--00<=PRS STs [TU]5nSURlSURlU$r)rJrKrMrNrO two_d_labelsrQs r*rK$MultiLabelBinarizer.__sklearn_tags__!rr-)rrr&rd)rUrVrWrXrYrerrrirr+r1r9rrrGrKrZr[r\s@r*rrs<~!$'#$D #'e+56@5)6)V4! & P'TRr-rrh)2rrr collectionsrnumbersrnumpyr scipy.sparsesparserv sklearn.baserrr sklearn.utilsrsklearn.utils._array_apir r r r r rrrrsklearn.utils._encoderrsklearn.utils._param_validationrrsklearn.utils.multiclassrrsklearn.utils.sparsefuncsrsklearn.utils.validationrrr__all__rrrrrrr-r*r2s #FF&   3EB2OO M#]$M`V%}DVrO , >xtIFGxtIFG# #' -.%W  W t, ^4LnJ*MQUJr-