U
    3dE                     @   s   d 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 ddlm	Z	 ddl
Zdd	lmZmZ d
dlmZ dd Zdd ZeeedZdd Zdd Zdd Zdd Zd"ddZd#ddZd$ddZd d! ZdS )%zX
Multi-class / multi-label utility function
==========================================

    )Sequence)chainN)issparse)
dok_matrix)
lil_matrix   )check_array_assert_all_finite   )get_namespacec                 C   s6   t | \}}t| ds|r*||| S t| S d S )N	__array__)r   hasattrunique_valuesasarrayset)yxpis_array_api r   </tmp/pip-unpacked-wheel-zrfo1fqw/sklearn/utils/multiclass.py_unique_multiclass   s    r   c                 C   s    t t| ddddgdjd S )Nr   csrcsccoo)
input_nameaccept_sparser   )npZaranger   shaper   r   r   r   _unique_indicator   s    r   )binary
multiclassmultilabel-indicatorc                     s  t |  \}}| stdtdd | D }|ddhkr<dh}t|dkrTtd| | }|dkrttd	d | D dkrtd
t|d  stdt|  |r| fdd| D }|	|S tt
 fdd| D }ttdd |D dkrtd|t|S )a  Extract an ordered array of unique labels.

    We don't allow:
        - mix of multilabel and multiclass (single label) targets
        - mix of label indicator matrix and anything else,
          because there are no explicit labels)
        - mix of label indicator matrices of different sizes
        - mix of string and integer labels

    At the moment, we also don't allow "multiclass-multioutput" input type.

    Parameters
    ----------
    *ys : array-likes
        Label values.

    Returns
    -------
    out : ndarray of shape (n_unique_labels,)
        An ordered array of unique labels.

    Examples
    --------
    >>> from sklearn.utils.multiclass import unique_labels
    >>> unique_labels([3, 5, 5, 5, 7, 7])
    array([3, 5, 7])
    >>> unique_labels([1, 2, 3, 4], [2, 2, 3, 4])
    array([1, 2, 3, 4])
    >>> unique_labels([1, 2, 10], [5, 11])
    array([ 1,  2,  5, 10, 11])
    zNo argument has been passed.c                 s   s   | ]}t |V  qd S N)type_of_target).0xr   r   r   	<genexpr>Q   s     z unique_labels.<locals>.<genexpr>r    r!   r   z'Mix type of y not allowed, got types %sr"   c                 s   s&   | ]}t |d ddgdjd V  qdS )r   r   r   )r   r   N)r   r   r%   r   r   r   r   r'   ^   s    zCMulti-label binary indicator input with different numbers of labelsNzUnknown label type: %sc                    s   g | ]} |qS r   r   r(   Z_unique_labelsr   r   
<listcomp>o   s     z!unique_labels.<locals>.<listcomp>c                 3   s    | ]}d d  |D V  qdS )c                 s   s   | ]
}|V  qd S r#   r   )r%   ir   r   r   r'   r   s     z*unique_labels.<locals>.<genexpr>.<genexpr>Nr   r(   r)   r   r   r'   r   s     c                 s   s   | ]}t |tV  qd S r#   )
isinstancestr)r%   labelr   r   r   r'   t   s     z,Mix of label input types (string and number))r   
ValueErrorr   lenpop_FN_UNIQUE_LABELSgetreprconcatr   r   from_iterabler   sorted)Zysr   r   Zys_typesZ
label_typeZ	unique_ysZ	ys_labelsr   r)   r   unique_labels,   s@     	
r8   c                 C   s    | j jdkot| t| kS )Nf)dtypekindr   allastypeintr   r   r   r   _is_integral_floatz   s    r?   c              
   C   sF  t | \}}t| ds$t| ts$|r~t L tdtj z|	| } W n( tjt
fk
rr   |j	| td} Y nX W 5 Q R X t| dr| jdkr| jd dksdS t| rt| ttfr|  } || j}t| jdkp|jdks|jdkod|ko| jjd	kpt|S || }t|d
k o@| jjd	kp@t|S dS )a~  Check if ``y`` is in a multilabel format.

    Parameters
    ----------
    y : ndarray of shape (n_samples,)
        Target values.

    Returns
    -------
    out : bool
        Return ``True``, if ``y`` is in a multilabel format, else ```False``.

    Examples
    --------
    >>> import numpy as np
    >>> from sklearn.utils.multiclass import is_multilabel
    >>> is_multilabel([0, 1, 0, 1])
    False
    >>> is_multilabel([[1], [0, 2], []])
    False
    >>> is_multilabel(np.array([[1, 0], [0, 0]]))
    True
    >>> is_multilabel(np.array([[1], [0], [0]]))
    False
    >>> is_multilabel(np.array([[1, 0, 0]]))
    True
    r   errorr:   r   r
   r   Fr   Zbiu   N)r   r   r,   r   warningscatch_warningssimplefilterr   VisibleDeprecationWarningr   r/   objectndimr   r   r   r   Ztocsrr   datar0   sizer:   r;   r?   )r   r   r   labelsr   r   r   is_multilabel~   s,    
"

rL   c                 C   s$   t | dd}|dkr td| dS )aA  Ensure that target y is of a non-regression type.

    Only the following target types (as defined in type_of_target) are allowed:
        'binary', 'multiclass', 'multiclass-multioutput',
        'multilabel-indicator', 'multilabel-sequences'

    Parameters
    ----------
    y : array-like
        Target values.
    r   r   )r    r!   zmulticlass-multioutputr"   zmultilabel-sequenceszUnknown label type: %rN)r$   r/   )r   Zy_typer   r   r   check_classification_targets   s    rN    c           	   
   C   sN  t | \}}t| ts(t| s(t| dr4t| t p6|}|sHtd|  | jjdk}|r`tdt	| rldS t
 T t
dtj t| sz|| } W n( tjtfk
r   |j| td} Y nX W 5 Q R X z<t| d dst| d trt| d tstd	W n tk
r    Y nX | jd
kr2dS t| jsR| jdkrNdS dS t| s~| jtkr~t| jd ts~dS | jdkr| jd dkrd}nd}| jjdkrt| r| jn| }|||tkrt||d d| S t| s| d n
| dj}|| jd dks>| jdkrFt|dkrFd| S dS dS )a
  Determine the type of data indicated by the target.

    Note that this type is the most specific type that can be inferred.
    For example:

        * ``binary`` is more specific but compatible with ``multiclass``.
        * ``multiclass`` of integers is more specific but compatible with
          ``continuous``.
        * ``multilabel-indicator`` is more specific but compatible with
          ``multiclass-multioutput``.

    Parameters
    ----------
    y : {array-like, sparse matrix}
        Target values. If a sparse matrix, `y` is expected to be a
        CSR/CSC matrix.

    input_name : str, default=""
        The data name used to construct the error message.

        .. versionadded:: 1.1.0

    Returns
    -------
    target_type : str
        One of:

        * 'continuous': `y` is an array-like of floats that are not all
          integers, and is 1d or a column vector.
        * 'continuous-multioutput': `y` is a 2d array of floats that are
          not all integers, and both dimensions are of size > 1.
        * 'binary': `y` contains <= 2 discrete values and is 1d or a column
          vector.
        * 'multiclass': `y` contains more than two discrete values, is not a
          sequence of sequences, and is 1d or a column vector.
        * 'multiclass-multioutput': `y` is a 2d array that contains more
          than two discrete values, is not a sequence of sequences, and both
          dimensions are of size > 1.
        * 'multilabel-indicator': `y` is a label indicator matrix, an array
          of two dimensions with at least two columns, and at most 2 unique
          values.
        * 'unknown': `y` is array-like but none of the above, such as a 3d
          array, sequence of sequences, or an array of non-sequence objects.

    Examples
    --------
    >>> from sklearn.utils.multiclass import type_of_target
    >>> import numpy as np
    >>> type_of_target([0.1, 0.6])
    'continuous'
    >>> type_of_target([1, -1, -1, 1])
    'binary'
    >>> type_of_target(['a', 'b', 'a'])
    'binary'
    >>> type_of_target([1.0, 2.0])
    'binary'
    >>> type_of_target([1, 0, 2])
    'multiclass'
    >>> type_of_target([1.0, 0.0, 3.0])
    'multiclass'
    >>> type_of_target(['a', 'b', 'c'])
    'multiclass'
    >>> type_of_target(np.array([[1, 2], [3, 1]]))
    'multiclass-multioutput'
    >>> type_of_target([[1, 2]])
    'multilabel-indicator'
    >>> type_of_target(np.array([[1.5, 2.0], [3.0, 1.6]]))
    'continuous-multioutput'
    >>> type_of_target(np.array([[0, 1], [1, 1]]))
    'multilabel-indicator'
    r   z:Expected array-like (array or non-string sequence), got %r)ZSparseSeriesZSparseArrayz1y cannot be class 'SparseSeries' or 'SparseArray'r"   r@   rA   r   zYou appear to be using a legacy multi-label data representation. Sequence of sequences are no longer supported; use a binary array or sparse matrix instead - the MultiLabelBinarizer transformer can convert to this format.)r   r
   unknownr   r    r
   z-multioutputrO   r9   rM   Z
continuousr!   N) r   r,   r   r   r   r-   r/   	__class____name__rL   rC   rD   rE   r   rF   r   rG   
IndexErrorrH   minr   r:   Zflatr;   rI   anyr=   r>   r	   Zgetrowr   r0   )	r   r   r   r   ZvalidZsparse_pandassuffixrI   Z	first_rowr   r   r   r$      sl    H

(0r$   c                 C   sr   t | dddkr"|dkr"tdnL|dk	rnt | dddk	r`t| jt|sntd|| jf nt|| _dS dS )a"  Private helper function for factorizing common classes param logic.

    Estimators that implement the ``partial_fit`` API need to be provided with
    the list of possible classes at the first call to partial_fit.

    Subsequent calls to partial_fit should check that ``classes`` is still
    consistent with a previous value of ``clf.classes_`` when provided.

    This function returns True if it detects that this was the first call to
    ``partial_fit`` on ``clf``. In that case the ``classes_`` attribute is also
    set on ``clf``.

    classes_Nz8classes must be passed on the first call to partial_fit.zD`classes=%r` is not the same as on last call to partial_fit, was: %rTF)getattrr/   r   Zarray_equalrW   r8   )Zclfclassesr   r   r   _check_partial_fit_first_callr  s    

rZ   c                 C   s  g }g }g }| j \}}|dk	r(t|}t| rp|  } t| j}t|D ]}| j| j| | j|d   }	|dk	r||	 }
t	|t	|
 }nd}
| j d ||  }tj
| j| j| | j|d   dd\}}tj||
d}d|kr||dk  |7  < d|kr@|| | j d k r@t|dd}t|d|}|| ||j d  |||	   qNnht|D ]^}tj
| dd|f dd\}}|| ||j d  tj||d}|||	   qx|||fS )az  Compute class priors from multioutput-multiclass target data.

    Parameters
    ----------
    y : {array-like, sparse matrix} of size (n_samples, n_outputs)
        The labels for each example.

    sample_weight : array-like of shape (n_samples,), default=None
        Sample weights.

    Returns
    -------
    classes : list of size n_outputs of ndarray of size (n_classes,)
        List of classes for each column.

    n_classes : list of int of size n_outputs
        Number of classes in each column.

    class_prior : list of size n_outputs of ndarray of size (n_classes,)
        Class distribution of each column.
    Nr   r   T)Zreturn_inverse)weights)r   r   r   r   ZtocscZdiffZindptrrangeindicessumuniquerI   Zbincountinsertappend)r   Zsample_weightrY   	n_classesZclass_prior	n_samplesZ	n_outputsZy_nnzkZcol_nonzeroZnz_samp_weightZzeros_samp_weight_sumZ	classes_kZy_kZclass_prior_kr   r   r   class_distribution  sH    


 



re   c           
      C   s  | j d }t||f}t||f}d}t|D ]}t|d |D ]}|dd|f  |dd|f 8  < |dd|f  |dd|f 7  < || dd|f dk|f  d7  < || dd|f dk|f  d7  < |d7 }qDq2|dt|d   }	||	 S )ay  Compute a continuous, tie-breaking OvR decision function from OvO.

    It is important to include a continuous value, not only votes,
    to make computing AUC or calibration meaningful.

    Parameters
    ----------
    predictions : array-like of shape (n_samples, n_classifiers)
        Predicted classes for each binary classifier.

    confidences : array-like of shape (n_samples, n_classifiers)
        Decision functions or predicted probabilities for positive class
        for each binary classifier.

    n_classes : int
        Number of classes. n_classifiers must be
        ``n_classes * (n_classes - 1 ) / 2``.
    r   r   NrB   )r   r   zerosr\   abs)
ZpredictionsZconfidencesrb   rc   ZvotesZsum_of_confidencesrd   r+   jZtransformed_confidencesr   r   r   _ovr_decision_function  s    
$$$$	ri   )rO   )N)N)__doc__collections.abcr   	itertoolsr   rC   Zscipy.sparser   r   r   Znumpyr   Z
validationr   r	   Zutils._array_apir   r   r   r2   r8   r?   rL   rN   r$   rZ   re   ri   r   r   r   r   <module>   s0   N=
 !
#
J