U
    9%eZx                  
   @   sb  d dl Z d dlZd dlZd dlmZ d dlmZ d dlZd dl	m
Z ddlmZmZmZ ddlmZ ddlmZmZ ddlmZmZ dd	lmZmZ dd
lmZ ddlmZmZm Z  ddddgZ!G dd deeddZ"G dd deeddZ#edgdgeeddddgeeddddgdgdddd dddddZ$dd Z%d d! Z&G d"d deeddZ'dS )#    N)defaultdict)Integral   )BaseEstimatorTransformerMixin_fit_context)column_or_1d)_encode_unique)Intervalvalidate_params)type_of_targetunique_labels)min_max_axis)_num_samplescheck_arraycheck_is_fittedlabel_binarizeLabelBinarizerLabelEncoderMultiLabelBinarizerc                   @   s8   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d ZdS )r   au  Encode 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 <preprocessing_targets>`.

    .. 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_)
    ['amsterdam', 'paris', 'tokyo']
    >>> le.transform(["tokyo", "tokyo", "paris"])
    array([2, 2, 1]...)
    >>> list(le.inverse_transform([2, 2, 1]))
    ['tokyo', 'tokyo', 'paris']
    c                 C   s   t |d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.
        Twarnr   r
   classes_selfy r   [/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/sklearn/preprocessing/_label.pyfitT   s    
zLabelEncoder.fitc                 C   s"   t |dd}t|dd\| _}|S )a  Fit 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   Zreturn_inverser   r   r   r   r   fit_transforme   s    zLabelEncoder.fit_transformc                 C   s>   t |  t|| jjdd}t|dkr0tg S t|| jdS )a  Transform 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   )Zuniques)r   r   r   r#   r   nparrayr	   r   r   r   r   	transformv   s
    
zLabelEncoder.transformc                 C   sn   t |  t|dd}t|dkr*tg S t|tt| j}t|rZt	dt
| 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.
        Tr   r   z'y contains previously unseen labels: %s)r   r   r   r$   r%   	setdiff1darangelenr   
ValueErrorstrasarray)r   r   diffr   r   r   inverse_transform   s    

zLabelEncoder.inverse_transformc                 C   s
   ddgiS NX_typesZ1dlabelsr   r   r   r   r   
_more_tags   s    zLabelEncoder._more_tagsN)	__name__
__module____qualname____doc__r    r"   r&   r.   r2   r   r   r   r   r   "   s   1)Zauto_wrap_output_keysc                   @   sr   e Zd ZU dZegegdgdZeed< dddddd	Ze	d
ddd Z
dd Zdd ZdddZdd ZdS )r   a
  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 <preprocessing_targets>`.

    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_constraintsr      Fc                C   s   || _ || _|| _d S Nr8   )r   r9   r:   r;   r   r   r   __init__  s    zLabelBinarizer.__init__TZprefer_skip_nested_validationc                 C   s   | j | jkr&td| j  d| j d| jrX| jdks@| j dkrXtd| j d| j  t|dd| _d	| jkrxtd
t|dkrtd| t|| _	t
|| _| S )aa  Fit 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=.r   z`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 binarizationy has 0 samples: %r)r9   r:   r*   r;   r   y_type_r   spissparsesparse_input_r   r   r   r   r   r   r      s$    

zLabelBinarizer.fitc                 C   s   |  ||S )a  Fit 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&   r   r   r   r   r"   5  s    zLabelBinarizer.fit_transformc                 C   sH   t |  t|d}|r.| jds.tdt|| j| j| j| j	dS )a  Transform 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.)classesr:   r9   r;   )
r   r   
startswithrF   r*   r   r   r:   r9   r;   )r   r   Zy_is_multilabelr   r   r   r&   K  s    zLabelBinarizer.transformNc                 C   sr   t |  |dkr | j| j d }| jdkr8t|| j}nt|| j| j|}| jr\t	|}nt
|rn| }|S )a  Transform 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)r   r:   r9   rF   _inverse_binarize_multiclassr   _inverse_binarize_thresholdingrI   rG   
csr_matrixrH   toarray)r   Y	thresholdZy_invr   r   r   r.   m  s      
   
z LabelBinarizer.inverse_transformc                 C   s
   ddgiS r/   r   r1   r   r   r   r2     s    zLabelBinarizer._more_tags)N)r3   r4   r5   r6   r   r<   dict__annotations__r?   r   r    r"   r&   r.   r2   r   r   r   r   r      s   
Y
("
3
array-likeZneither)closedr7   )r   rJ   r9   r:   r;   Tr@   r=   Fr8   c                C   s  t | tst| ddddd} nt| dkr6td|  ||krNtd|||rr|dksb|dkrrtd	|||dk}|r| }t| }d
|krtd|dkrtdt| r| j	d nt
| }t
|}t|}|dkr<|dkr*|rtj|dftdS tjt
| dftd}	|	|7 }	|	S nt
|dkr<d}t|}
|dkrt| drf| j	d n
t
| d }|j|krtd|t| |dkrt| } t| |}| | }t|
|}tdt|f}t|}|| tj|||f||fd}	nH|dkrBt| }	|dkrNt|	j}|| ||	_ntd| |s|	 }	|	jtdd}	|dkr||	|	dk< |rd|	|	|k< n|	jjtdd|	_t||
krt|
|}|	dd|f }	|dkr|r|	d}	n|	dddf  d}	|	S )a  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.

    This function makes it possible to compute this transformation for a
    fixed set of class labels known ahead of time.

    Parameters
    ----------
    y : array-like
        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)rB   Zaccept_sparseZ	ensure_2dr#   r   rE   z7neg_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}rC   rD   unknownz$The type of target data is not knownbinaryr=   r#      rL   multilabel-indicatorshapez:classes {0} mismatch with the labels {1} found in the data)rY   rL   r]   z7%s target data is not supported with label binarization)copy)r`   r=   )!
isinstancelistr   r   r*   formatr   rG   rH   r]   r)   r$   r,   rO   intZzerossorthasattrsizer   r   isinsearchsortedZhstackZcumsumZ
empty_likefilldatarP   ZastypeanyZgetcolZreshape)r   rJ   r9   r:   r;   Z
pos_switchZy_type	n_samplesZ	n_classesrQ   Zsorted_classZy_n_classesZy_in_classesZy_seenindicesindptrrk   r   r   r   r     s    F
      




" 








c                 C   sP  t |}t| r6|  } | j\}}t |}t| dd }t | j	}t 
||}t || jk}|d dkrt |t| jg}t || j	dd }	t | jdg}
|
||	  }d|t |dkd < t ||dk| dk@  }|D ]:}| j| j	| | j	|d   }|t || d ||< q|| S |j| jddddS dS )z}Inverse label binarization transformation for multiclass.

    Multiclass uses the maximal score instead of a threshold.
    r=   r`   r   N)ZaxisZclip)mode)r$   r,   rG   rH   tocsrr]   r(   r   r-   ro   repeatZflatnonzerork   appendr)   ri   rn   whereravelr'   takeZargmax)r   rJ   rm   Z	n_outputsoutputsZrow_maxZrow_nnzZy_data_repeated_maxZy_i_all_argmaxZindex_first_argmaxZ	y_ind_extZ
y_i_argmaxZsamplesiindr   r   r   rM   Y  s*    


rM   c                 C   sf  |dkr0| j dkr0| jd dkr0td| j|dkrR| jd t|krRtdt|}t| r|dkr| jdkr| 	 } tj
| j|ktd| _|   qtj
|  |ktd} ntj
| |ktd} |dkrFt| r|  } | j dkr| jd dkr|| d	d	df  S t|dkr8t|d t| S ||   S n|d
krT| S td|d	S )z=Inverse label binarization transformation using thresholding.rY   r   r=   z'output_type='binary', but y.shape = {0}zAThe number of class is not equal to the number of dimension of y.r   )rW   ZcscrZ   Nr\   z{0} format is not supported)ndimr]   r*   rc   r)   r$   r,   rG   rH   rq   r%   rk   rd   Zeliminate_zerosrP   rr   ru   )r   output_typerJ   rR   r   r   r   rN     s4     






rN   c                   @   s   e Zd ZU dZddgdgdZeed< ddddd	Zed
ddd Z	ed
ddd Z
dd Zdd Zdd Zdd Zdd ZdS )r   a   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)
    rU   Nr7   rJ   r;   r<   Fc                C   s   || _ || _d S r>   r|   )r   rJ   r;   r   r   r   r?     s    zMultiLabelBinarizer.__init__Tr@   c                 C   s   d| _ | jdkr&tttj|}n(tt| jt| jk rHtdn| j}t	dd |D rdt
nt}tjt||d| _|| jdd< | S )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.c                 s   s   | ]}t |tV  qd S r>   ra   rd   .0cr   r   r   	<genexpr>  s     z*MultiLabelBinarizer.fit.<locals>.<genexpr>rZ   )_cached_dictrJ   sortedset	itertoolschainfrom_iterabler)   r*   allrd   objectr$   emptyr   )r   r   rJ   r#   r   r   r   r      s    
zMultiLabelBinarizer.fitc                 C   s   | j dk	r| ||S d| _tt}|j|_| ||}t	||j
d}tdd |D r`tnt}tjt||d}||dd< tj|dd\| _}tj||j |jjdd	|_| js| }|S )
aM  Fit 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.
        Nkeyc                 s   s   | ]}t |tV  qd S r>   r}   r~   r   r   r   r   9  s     z4MultiLabelBinarizer.fit_transform.<locals>.<genexpr>rZ   Tr!   F)r#   r_   )rJ   r    r&   r   r   rd   __len__default_factory
_transformr   getr   r   r$   r   r)   uniquer   r%   rn   r#   r;   rP   )r   r   class_mappingyttmpr#   Zinverser   r   r   r"     s    
z!MultiLabelBinarizer.fit_transformc                 C   s.   t |  |  }| ||}| js*| }|S )a  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 : 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_cacher   r;   rP   )r   r   Zclass_to_indexr   r   r   r   r&   E  s    zMultiLabelBinarizer.transformc                 C   s,   | j d kr&tt| jtt| j| _ | j S r>   )r   rS   zipr   ranger)   r1   r   r   r   r   _  s    
z MultiLabelBinarizer._build_cachec           
   
   C   s   t  d}t  ddg}t }|D ]^}t }|D ]6}z|||  W q0 tk
rd   || Y q0X q0|| |t| q"|rtd	t
|td tjt|td}	tj|	||ft|d t|fdS )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.
        rx   r   z%unknown class(es) {0} will be ignoredr   rZ   r=   r^   )r%   r   addKeyErrorextendrs   r)   warningsr   rc   r   r+   r$   Zonesrd   rG   rO   )
r   r   r   rn   ro   rX   labelsindexlabelrk   r   r   r   r   e  s*    

 zMultiLabelBinarizer._transformc                    s   t   jd t jkr8tdt jjd tr tj	dkrztt
j	ddgdkrztd fddtjdd jdd D S t
ddg}t|dkrtd	| fd
dD S dS )a  Transform 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}r   z+Expected only 0s and 1s in label indicator.c                    s*   g | ]"\}}t  jj|| qS r   )tupler   rv   rn   )r   startendr   r   r   r   
<listcomp>  s   z9MultiLabelBinarizer.inverse_transform.<locals>.<listcomp>Nr`   z8Expected only 0s and 1s in label indicator. Also got {0}c                    s   g | ]}t  j|qS r   )r   r   compress)r   Z
indicatorsr1   r   r   r     s     )r   r]   r)   r   r*   rc   rG   rH   rq   rk   r$   r'   r   ro   )r   r   Z
unexpectedr   r   r   r.     s.     
(z%MultiLabelBinarizer.inverse_transformc                 C   s
   ddgiS )Nr0   Z2dlabelsr   r1   r   r   r   r2     s    zMultiLabelBinarizer._more_tags)r3   r4   r5   r6   r<   rS   rT   r?   r   r    r"   r&   r   r   r.   r2   r   r   r   r   r     s   
?
 
+())(r%   r   r   collectionsr   numbersr   numpyr$   Zscipy.sparsesparserG   baser   r   r   utilsr   Zutils._encoder	   r
   Zutils._param_validationr   r   Zutils.multiclassr   r   Zutils.sparsefuncsr   Zutils.validationr   r   r   __all__r   r   r   rM   rN   r   r   r   r   r   <module>	   sH     }
 ,+,