ó ‡ˆ\c@s»ddlmZddlZddlZddlZddlZddljZ ddl m Z m Z ddl mZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZejjZejjZd dddgZded„Z ded„Z!ded„Z"ed„Z#de e fd„ƒYZ$de e fd„ƒYZ%dded„Z&d„Z'd„Z(de e fd„ƒYZ)dS(iÿÿÿÿ(t defaultdictNi(t BaseEstimatortTransformerMixin(t min_max_axis(t column_or_1d(t check_array(tcheck_is_fitted(t _num_samples(t unique_labels(ttype_of_target(tsixtlabel_binarizetLabelBinarizert LabelEncodertMultiLabelBinarizercCsŸ|dkrG|r7tj|dtƒ\}}||fStj|ƒSn|r—t||ƒ}|r{tdt|ƒƒ‚ntj||ƒ}||fS|SdS(Ntreturn_inverses'y contains previously unseen labels: %s(tNonetnptuniquetTruet_encode_check_unknownt ValueErrortstrt searchsorted(tvaluestuniquestencodetencodedtdiff((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyt _encode_numpy(s   cCs½|dkr9tt|ƒƒ}tj|d|jƒ}n|rµd„t|ƒDƒ}y*tjg|D]}||^qeƒ}Wn)tk rª}tdt |ƒƒ‚nX||fS|SdS(NtdtypecSsi|]\}}||“qS(((t.0titval((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pys Bs s'y contains previously unseen labels: %s( RtsortedtsetRtarrayRt enumeratetKeyErrorRR(RRRttabletvRte((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyt_encode_python<s * cCs3|jtkrt|||ƒSt|||ƒSdS(sHelper function to factorize (find uniques) and encode values. Uses pure python method for object dtype, and numpy method for all other dtypes. The numpy method has the limitation that the `uniques` need to be sorted. Importantly, this is not checked but assumed to already be the case. The calling method needs to ensure this for all non-object values. Parameters ---------- values : array Values to factorize or encode. uniques : array, optional If passed, uniques are not determined from passed values (this can be because the user specified categories, or because they already have been determined in fit). encode : bool, default False If True, also encode the values into integer codes based on `uniques`. Returns ------- uniques If ``encode=False``. The unique values are sorted if the `uniques` parameter was None (and thus inferred from the data). (uniques, encoded) If ``encode=True``. N(RtobjectR*R(RRR((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyt_encodeMscCs|jtkr”t|ƒ}tt|ƒ|ƒ}|r|rhtjg|D]}||k^qJƒ}ntjt|ƒdtƒ}||fS|Snwtj |ƒ}ttj ||dt ƒƒ}|r|râtj ||ƒ}ntjt|ƒdtƒ}||fS|SdS(s— Helper function to check for unknowns in values to be encoded. Uses pure python method for object dtype, and numpy method for all other dtypes. Parameters ---------- values : array Values to check for unknowns. uniques : array Allowed uniques values. return_mask : bool, default False If True, return a mask of the same shape as `values` indicating the valid values. Returns ------- diff : list The unique values present in `values` and not in `uniques` (the unknown values). valid_mask : boolean array Additionally returned if ``return_mask=True``. Rt assume_uniqueN( RR+R#tlistRR$tonestlentboolRt setdiff1dRtin1d(RRt return_maskt uniques_setRR!t valid_maskt unique_values((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyRqs" +  cBs2eZdZd„Zd„Zd„Zd„ZRS(sôEncode labels with value between 0 and n_classes-1. Read more in the :ref:`User Guide `. Attributes ---------- classes_ : array of shape (n_class,) Holds the label for each class. Examples -------- `LabelEncoder` can be used to normalize labels. >>> from sklearn import preprocessing >>> le = preprocessing.LabelEncoder() >>> le.fit([1, 2, 2, 6]) LabelEncoder() >>> le.classes_ array([1, 2, 6]) >>> le.transform([1, 1, 2, 6]) #doctest: +ELLIPSIS 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 = preprocessing.LabelEncoder() >>> le.fit(["paris", "paris", "tokyo", "amsterdam"]) LabelEncoder() >>> list(le.classes_) ['amsterdam', 'paris', 'tokyo'] >>> le.transform(["tokyo", "tokyo", "paris"]) #doctest: +ELLIPSIS array([2, 2, 1]...) >>> list(le.inverse_transform([2, 2, 1])) ['tokyo', 'tokyo', 'paris'] See also -------- sklearn.preprocessing.OrdinalEncoder : encode categorical features using a one-hot or ordinal encoding scheme. cCs%t|dtƒ}t|ƒ|_|S(sÖFit label encoder Parameters ---------- y : array-like of shape (n_samples,) Target values. Returns ------- self : returns an instance of self. twarn(RRR,tclasses_(tselfty((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pytfitÏs cCs1t|dtƒ}t|dtƒ\|_}|S(sï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] R8R(RRR,R9(R:R;((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyt fit_transformßs cCsct|dƒt|dtƒ}t|ƒdkr>tjgƒSt|d|jdtƒ\}}|S(sìTransform labels to normalized encoding. Parameters ---------- y : array-like of shape [n_samples] Target values. Returns ------- y : array-like of shape [n_samples] R9R8iRR(RRRRRR$R,R9(R:R;t_((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyt transformïs  !cCs¡t|dƒt|dtƒ}t|ƒdkr>tjgƒStj|tjt|j ƒƒƒ}t|ƒr‡t dt |ƒƒ‚ntj |ƒ}|j |S(sñTransform labels back to original encoding. Parameters ---------- y : numpy array of shape [n_samples] Target values. Returns ------- y : numpy array of shape [n_samples] R9R8is'y contains previously unseen labels: %s( RRRRRR$R2tarangeR0R9RRtasarray(R:R;R((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pytinverse_transforms  $ (t__name__t __module__t__doc__R<R=R?RB(((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyR £s *   cBsGeZdZdded„Zd„Zd„Zd„Zdd„Z RS( s0 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 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 : boolean (default: False) True if the returned array from transform is desired to be in sparse CSR format. Attributes ---------- classes_ : array of shape [n_class] Holds the label for each class. y_type_ : str, Represents the type of the target data as evaluated by utils.multiclass.type_of_target. Possible type are 'continuous', 'continuous-multioutput', 'binary', 'multiclass', 'multiclass-multioutput', 'multilabel-indicator', and 'unknown'. sparse_input_ : boolean, True if the input data to transform is given as a sparse matrix, False otherwise. Examples -------- >>> from sklearn import preprocessing >>> lb = preprocessing.LabelBinarizer() >>> lb.fit([1, 2, 6, 4, 2]) LabelBinarizer(neg_label=0, pos_label=1, sparse_output=False) >>> 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 = preprocessing.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(neg_label=0, pos_label=1, sparse_output=False) >>> 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]]) See also -------- label_binarize : function to perform the transform operation of LabelBinarizer with fixed classes. sklearn.preprocessing.OneHotEncoder : encode categorical features using a one-hot aka one-of-K scheme. iicCs||kr'tdj||ƒƒ‚n|r`|dksE|dkr`tdj||ƒƒ‚n||_||_||_dS(Ns7neg_label={0} must be strictly less than pos_label={1}.isuSparse binarization is only supported with non zero pos_label and zero neg_label, got pos_label={0} and neg_label={1}(Rtformatt neg_labelt pos_labelt sparse_output(R:RGRHRI((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyt__init__ys     cCswt|ƒ|_d|jkr-tdƒ‚nt|ƒdkrRtd|ƒ‚ntj|ƒ|_t|ƒ|_|S(sKFit label binarizer Parameters ---------- y : array 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 : returns an instance of self. t multioutputs@Multioutput target data is not supported with label binarizationisy has 0 samples: %r( R ty_type_RRtsptissparset sparse_input_RR9(R:R;((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyR<ˆs cCs|j|ƒj|ƒS(s”Fit label binarizer and transform multi-class labels to binary labels. The output of transform is sometimes referred to as the 1-of-K coding scheme. Parameters ---------- y : array or 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 : array or CSR matrix of shape [n_samples, n_classes] Shape will be [n_samples, 1] for binary problems. (R<R?(R:R;((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyR= sc Csut|dƒt|ƒjdƒ}|rJ|jjdƒ rJtdƒ‚nt||jd|jd|jd|j ƒS(s†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 or 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 : numpy array or CSR matrix of shape [n_samples, n_classes] Shape will be [n_samples, 1] for binary problems. R9t multilabels0The object was not fitted with multilabel input.RHRGRI( RR t startswithRLRR R9RHRGRI(R:R;ty_is_multilabel((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyR?¶s   cCs¬t|dƒ|dkr0|j|jd}n|jdkrTt||jƒ}nt||j|j|ƒ}|jrŠt j |ƒ}nt j |ƒr¨|j ƒ}n|S(sBTransform binary labels back to multi-class labels Parameters ---------- Y : numpy array or sparse matrix with shape [n_samples, n_classes] Target values. All sparse matrices are converted to CSR before inverse transformation. threshold : float or None Threshold used in the binary and multi-label cases. Use 0 when ``Y`` contains the output of decision_function (classifier). Use 0.5 when ``Y`` contains the output of predict_proba. If None, the threshold is assumed to be half way between neg_label and pos_label. Returns ------- y : numpy array or CSR matrix of shape [n_samples] Target values. Notes ----- In the case when the binary labels are fractional (probabilistic), inverse_transform chooses the class with the greatest value. Typically, this allows to use the output of a linear model's decision_function method directly as the input of inverse_transform. R9g@t multiclassN( RRRHRGRLt_inverse_binarize_multiclassR9t_inverse_binarize_thresholdingRORMt csr_matrixRNttoarray(R:tYt thresholdty_inv((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyRBÕs    N( RCRDREtFalseRJR<R=R?RRB(((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyR s Y   iicCsEt|tƒs0t|dddtddƒ}n%t|ƒdkrUtd|ƒ‚n||kr|tdj||ƒƒ‚n|rµ|dksš|dkrµtdj||ƒƒ‚n|dk}|rÑ| }nt|ƒ}d |krøtd ƒ‚n|d krtd ƒ‚nt j |ƒr/|j dn t |ƒ}t |ƒ}t j|ƒ}|d krà|dkrÂ|rt j|dfdtƒSt jt |ƒdfdt jƒ} | |7} | Sqàt |ƒdkràd}qànt j|ƒ} |dkr2|j|j dkr2tdj|t|ƒƒƒ‚n|dkrÙt|ƒ}t j||ƒ} || } t j| | ƒ} t jdt j| ƒfƒ}t j| ƒ}|j|ƒt j|| |fd||fƒ} ne|dkr.t j|ƒ} |dkr>t j| jƒ}|j|ƒ|| _q>ntd|ƒ‚|s | jƒ} | jtdtƒ} |dkr„|| | dk>> 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]]) See also -------- LabelBinarizer : class used to wrap the functionality of label_binarize and allow for fitting to classes independently of the transform operation t accept_sparsetcsrt ensure_2dRisy has 0 samples: %rs7neg_label={0} must be strictly less than pos_label={1}.suSparse binarization is only supported with non zero pos_label and zero neg_label, got pos_label={0} and neg_label={1}RKs@Multioutput target data is not supported with label binarizationtunknowns$The type of target data is not knowntbinaryiiRSsmultilabel-indicators:classes {0} missmatch with the labels {1}found in the datatshapes7%s target data is not supported with label binarizationtcopyNiÿÿÿÿ(R`RS(iÿÿÿÿi("t isinstanceR.RR[RRRRFR RMRNRaR0RRARVtinttzerostsorttsizeRRR3Rthstacktcumsumt empty_liketfilltdataRWtastypetanytgetcoltreshape(R;tclassesRGRHRIt pos_switchty_typet n_samplest n_classesRXt sorted_classt y_in_classesty_seentindicestindptrRl((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyR sˆ;!        (   $  "            "cCsÉtj|ƒ}tj|ƒr¦|jƒ}|j\}}tj|ƒ}t|dƒd}tj|j ƒ}tj ||ƒ}tj ||j kƒ}|ddkrÈtj |t|j ƒgƒ}ntj||j d ƒ} tj |jdgƒ} | || } d| tj|dkƒd>> 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([set(['sci-fi', 'thriller']), set(['comedy'])]) array([[0, 1, 1], [1, 0, 0]]) >>> list(mlb.classes_) ['comedy', 'sci-fi', 'thriller'] See also -------- sklearn.preprocessing.OneHotEncoder : encode categorical features using a one-hot aka one-of-K scheme. cCs||_||_dS(N(RqRI(R:RqRI((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyRJ)s cCs½|jdkr0tttjj|ƒƒƒ}n<tt|jƒƒt|jƒkrctdƒ‚n |j}t d„|Dƒƒr‹t j nt }t j t|ƒd|ƒ|_||j(|S(s‚Fit the label sets binarizer, storing `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 : returns this MultiLabelBinarizer instance stThe classes argument contains duplicate classes. Remove these duplicates before passing them to MultiLabelBinarizer.css|]}t|tƒVqdS(N(RcRd(Rtc((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pys CsRN(RqRR"R#t itertoolstchaint from_iterableR0RtallRRdR+temptyR9(R:R;RqR((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyR<-s!$ % cCs|jdk r%|j|ƒj|ƒSttƒ}|j|_|j||ƒ}t |d|j ƒ}t d„|Dƒƒrƒt jnt }t jt|ƒd|ƒ}||(t j|dtƒ\|_}t j||jd|jjdtƒ|_|js |jƒ}n|S(sFit 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 : 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. tkeycss|]}t|tƒVqdS(N(RcRd(RR•((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pys dsRRRbN(RqRR<R?RRdt__len__tdefault_factoryt _transformR"tgetR™RR+RšR0RRR9R$RyRR[RIRW(R:R;t class_mappingtytttmpRtinverse((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyR=Hs  %  cCsbt|dƒtt|jtt|jƒƒƒƒ}|j||ƒ}|js^|jƒ}n|S(só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. R9( RtdicttzipR9trangeR0RžRIRW(R:R;tclass_to_indexR¡((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyR?qs  ' c Cs&tjdƒ}tjddgƒ}tƒ}x~|D]v}tƒ}xD|D]<}y|j||ƒWqJtk r…|j|ƒqJXqJW|j|ƒ|jt|ƒƒq4W|rÙtjdj t |dt ƒƒƒnt j t|ƒdtƒ} tj| ||fdt|ƒdt|ƒfƒS(spTransforms the label sets with a given mapping Parameters ---------- y : iterable of iterables class_mapping : Mapping Maps from label to column index in label indicator matrix Returns ------- y_indicator : sparse CSR matrix, shape (n_samples, n_classes) Label indicator matrix R is%unknown class(es) {0} will be ignoredR›RRai(R$R#taddR&textendRR0twarningsR8RFR"RRR/RdRMRV( R:R;R RyRzR_tlabelstindextlabelRl((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyRž‹s$       cCsyt|dƒ|jdt|jƒkrTtdjt|jƒ|jdƒƒ‚ntj|ƒr |jƒ}t|j ƒdkrºtt j |j ddgƒƒdkrºtdƒ‚ngt |j d |j dƒD].\}}t|jj|j||!ƒƒ^qØSt j |ddgƒ}t|ƒdkrLtdj|ƒƒ‚ng|D]}t|jj|ƒƒ^qSSdS( s”Transform the given indicator matrix into label sets Parameters ---------- yt : array or 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`. R9is/Expected indicator for {0} classes, but got {1}is+Expected only 0s and 1s in label indicator.iÿÿÿÿs8Expected only 0s and 1s in label indicator. Also got {0}N(RRaR0R9RRFRMRNR~RlRR2R¥RzttupleR„Rytcompress(R:R¡tstarttendt unexpectedt indicators((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyRB­s   " <M N( RCRDRERR[RJR<R=R?RžRB(((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyRüs+  )  "(*t collectionsRR–R$RªtnumpyRt scipy.sparsetsparseRMtbaseRRtutils.sparsefuncsRtutilsRtutils.validationRRRtutils.multiclassRR t externalsR tmovesR¥tmapt__all__RR[RR*R,RR R R RTRUR(((s:lib/python2.7/site-packages/sklearn/preprocessing/label.pyt s<       $ 2{é , ,