ó ‡ˆ\c@ sdZddlmZddlmZddlZddlZddlm Z ddl m Z dd l mZdd lmZd „Zd „Zd „Zded„Zd„Zd„Zd„Zd„Zd„Zdd„Zdd„Zdd„Zed„Zd„Z dS(s’Utilities to evaluate the clustering performance of models. Functions named as *_score return a scalar value to maximize: the higher the better. iÿÿÿÿ(tdivision(tlogN(tsparsei(texpected_mutual_informationi(t check_array(tcombcC st|dddƒS(Nitexacti(R(tn((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pyt_comb2scC s±tj|ƒ}tj|ƒ}|jdkrFtd|jfƒ‚n|jdkrntd|jfƒ‚n|j|jkr§td|jd|jdfƒ‚n||fS(söCheck that the labels arrays are 1D and of same dimension. Parameters ---------- labels_true : int array, shape = [n_samples] The true labels labels_pred : int array, shape = [n_samples] The predicted labels is#labels_true must be 1D: shape is %rs#labels_pred must be 1D: shape is %rs>labels_true and labels_pred must have same size, got %d and %di(tnptasarraytndimt ValueErrortshape(t labels_truet labels_pred((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pytcheck_clusterings$s !cC s~|dkrt||ƒS|dkr6tj||ƒS|dkrUtj||gƒS|dkrnt||ƒStdƒ‚dS(s(Return a particular mean of two numbers.tmint geometrict arithmetictmaxsC'average_method' must be 'min', 'geometric', 'arithmetic', or 'max'N(RR tsqrttmeanRR (tUtVtaverage_method((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pyt_generalized_average@s      c C sù|dk r!|r!tdƒ‚ntj|dtƒ\}}tj|dtƒ\}}|jd}|jd} tjtj|jdƒ||ffd|| fdtj ƒ} |rÐ| j ƒ} | j ƒn%| j ƒ} |dk rõ| |} n| S(soBuild a contingency matrix describing the relationship between labels. Parameters ---------- labels_true : int array, shape = [n_samples] Ground truth class labels to be used as a reference labels_pred : array, shape = [n_samples] Cluster labels to evaluate eps : None or float, optional. If a float, that value is added to all values in the contingency matrix. This helps to stop NaN propagation. If ``None``, nothing is adjusted. sparse : boolean, optional. If True, return a sparse CSR continency matrix. If ``eps is not None``, and ``sparse is True``, will throw ValueError. .. versionadded:: 0.18 Returns ------- contingency : {array-like, sparse}, shape=[n_classes_true, n_classes_pred] Matrix :math:`C` such that :math:`C_{i, j}` is the number of samples in true class :math:`i` and in predicted class :math:`j`. If ``eps is None``, the dtype of this array will be integer. If ``eps`` is given, the dtype will be float. Will be a ``scipy.sparse.csr_matrix`` if ``sparse=True``. s!Cannot set 'eps' when sparse=Truetreturn_inverseiR tdtypeN( tNoneR R tuniquetTrueR tspt coo_matrixtonestintttocsrtsum_duplicatesttoarray( RRtepsRtclassest class_idxtclusterst cluster_idxt n_classest n_clusterst contingency((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pytcontingency_matrixOs"          c C s\t||ƒ\}}|jd}tj|ƒjd}tj|ƒjd}||koedkns¢||kodkns¢||ko|knr¦dSt||dtƒ}td„tj|jddƒƒDƒƒ}td„tj|jddƒƒDƒƒ}td„|jDƒƒ}||t |ƒ} ||d } || | | S( sá Rand index adjusted for chance. The Rand Index computes a similarity measure between two clusterings by considering all pairs of samples and counting pairs that are assigned in the same or different clusters in the predicted and true clusterings. The raw RI score is then "adjusted for chance" into the ARI score using the following scheme:: ARI = (RI - Expected_RI) / (max(RI) - Expected_RI) The adjusted Rand index is thus ensured to have a value close to 0.0 for random labeling independently of the number of clusters and samples and exactly 1.0 when the clusterings are identical (up to a permutation). ARI is a symmetric measure:: adjusted_rand_score(a, b) == adjusted_rand_score(b, a) Read more in the :ref:`User Guide `. Parameters ---------- labels_true : int array, shape = [n_samples] Ground truth class labels to be used as a reference labels_pred : array, shape = [n_samples] Cluster labels to evaluate Returns ------- ari : float Similarity score between -1.0 and 1.0. Random labelings have an ARI close to 0.0. 1.0 stands for perfect match. Examples -------- Perfectly matching labelings have a score of 1 even >>> from sklearn.metrics.cluster import adjusted_rand_score >>> adjusted_rand_score([0, 0, 1, 1], [0, 0, 1, 1]) 1.0 >>> adjusted_rand_score([0, 0, 1, 1], [1, 1, 0, 0]) 1.0 Labelings that assign all classes members to the same clusters are complete be not always pure, hence penalized:: >>> adjusted_rand_score([0, 0, 1, 2], [0, 0, 1, 1]) # doctest: +ELLIPSIS 0.57... ARI is symmetric, so labelings that have pure clusters with members coming from the same classes but unnecessary splits are penalized:: >>> adjusted_rand_score([0, 0, 1, 1], [0, 0, 1, 2]) # doctest: +ELLIPSIS 0.57... If classes members are completely split across different clusters, the assignment is totally incomplete, hence the ARI is very low:: >>> adjusted_rand_score([0, 0, 0, 0], [0, 1, 2, 3]) 0.0 References ---------- .. [Hubert1985] `L. Hubert and P. Arabie, Comparing Partitions, Journal of Classification 1985` http://link.springer.com/article/10.1007%2FBF01908075 .. [wk] https://en.wikipedia.org/wiki/Rand_index#Adjusted_Rand_index See also -------- adjusted_mutual_info_score: Adjusted Mutual Information iigð?Rcs s|]}t|ƒVqdS(N(R(t.0tn_c((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pys êstaxiscs s|]}t|ƒVqdS(N(R(R0tn_k((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pys ëscs s|]}t|ƒVqdS(N(R(R0tn_ij((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pys ìsg@( RR R RR/RtsumtraveltdataR( RRt n_samplesR,R-R.t sum_comb_ct sum_comb_ktsum_combt prod_combt mean_comb((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pytadjusted_rand_scoreŠsQ ++c C sÕt||ƒ\}}t|ƒdkr+dSt|ƒ}t|ƒ}t||dtƒ}tddd|ƒ}|r}||nd}|r“||nd}||dkr²d}nd||||}|||fS( sëCompute the homogeneity and completeness and V-Measure scores at once. Those metrics are based on normalized conditional entropy measures of the clustering labeling to evaluate given the knowledge of a Ground Truth class labels of the same samples. A clustering result satisfies homogeneity if all of its clusters contain only data points which are members of a single class. A clustering result satisfies completeness if all the data points that are members of a given class are elements of the same cluster. Both scores have positive values between 0.0 and 1.0, larger values being desirable. Those 3 metrics are independent of the absolute values of the labels: a permutation of the class or cluster label values won't change the score values in any way. V-Measure is furthermore symmetric: swapping ``labels_true`` and ``label_pred`` will give the same score. This does not hold for homogeneity and completeness. V-Measure is identical to :func:`normalized_mutual_info_score` with the arithmetic averaging method. Read more in the :ref:`User Guide `. Parameters ---------- labels_true : int array, shape = [n_samples] ground truth class labels to be used as a reference labels_pred : array, shape = [n_samples] cluster labels to evaluate Returns ------- homogeneity : float score between 0.0 and 1.0. 1.0 stands for perfectly homogeneous labeling completeness : float score between 0.0 and 1.0. 1.0 stands for perfectly complete labeling v_measure : float harmonic mean of the first two See also -------- homogeneity_score completeness_score v_measure_score igð?RR.gg@(gð?gð?gð?N(RtlententropyR/Rtmutual_info_scoreR( RRt entropy_Ct entropy_KR.tMIt homogeneityt completenesstv_measure_score((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pyt"homogeneity_completeness_v_measureós5     cC st||ƒdS(s Homogeneity metric of a cluster labeling given a ground truth. A clustering result satisfies homogeneity if all of its clusters contain only data points which are members of a single class. This metric is independent of the absolute values of the labels: a permutation of the class or cluster label values won't change the score value in any way. This metric is not symmetric: switching ``label_true`` with ``label_pred`` will return the :func:`completeness_score` which will be different in general. Read more in the :ref:`User Guide `. Parameters ---------- labels_true : int array, shape = [n_samples] ground truth class labels to be used as a reference labels_pred : array, shape = [n_samples] cluster labels to evaluate Returns ------- homogeneity : float score between 0.0 and 1.0. 1.0 stands for perfectly homogeneous labeling References ---------- .. [1] `Andrew Rosenberg and Julia Hirschberg, 2007. V-Measure: A conditional entropy-based external cluster evaluation measure `_ See also -------- completeness_score v_measure_score Examples -------- Perfect labelings are homogeneous:: >>> from sklearn.metrics.cluster import homogeneity_score >>> homogeneity_score([0, 0, 1, 1], [1, 1, 0, 0]) 1.0 Non-perfect labelings that further split classes into more clusters can be perfectly homogeneous:: >>> print("%.6f" % homogeneity_score([0, 0, 1, 1], [0, 0, 1, 2])) ... # doctest: +ELLIPSIS 1.000000 >>> print("%.6f" % homogeneity_score([0, 0, 1, 1], [0, 1, 2, 3])) ... # doctest: +ELLIPSIS 1.000000 Clusters that include samples from different classes do not make for an homogeneous labeling:: >>> print("%.6f" % homogeneity_score([0, 0, 1, 1], [0, 1, 0, 1])) ... # doctest: +ELLIPSIS 0.0... >>> print("%.6f" % homogeneity_score([0, 0, 1, 1], [0, 0, 0, 0])) ... # doctest: +ELLIPSIS 0.0... i(RH(RR((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pythomogeneity_score?sGcC st||ƒdS(s±Completeness metric of a cluster labeling given a ground truth. A clustering result satisfies completeness if all the data points that are members of a given class are elements of the same cluster. This metric is independent of the absolute values of the labels: a permutation of the class or cluster label values won't change the score value in any way. This metric is not symmetric: switching ``label_true`` with ``label_pred`` will return the :func:`homogeneity_score` which will be different in general. Read more in the :ref:`User Guide `. Parameters ---------- labels_true : int array, shape = [n_samples] ground truth class labels to be used as a reference labels_pred : array, shape = [n_samples] cluster labels to evaluate Returns ------- completeness : float score between 0.0 and 1.0. 1.0 stands for perfectly complete labeling References ---------- .. [1] `Andrew Rosenberg and Julia Hirschberg, 2007. V-Measure: A conditional entropy-based external cluster evaluation measure `_ See also -------- homogeneity_score v_measure_score Examples -------- Perfect labelings are complete:: >>> from sklearn.metrics.cluster import completeness_score >>> completeness_score([0, 0, 1, 1], [1, 1, 0, 0]) 1.0 Non-perfect labelings that assign all classes members to the same clusters are still complete:: >>> print(completeness_score([0, 0, 1, 1], [0, 0, 0, 0])) 1.0 >>> print(completeness_score([0, 1, 2, 3], [0, 0, 1, 1])) 0.999... If classes members are split across different clusters, the assignment cannot be complete:: >>> print(completeness_score([0, 0, 1, 1], [0, 1, 0, 1])) 0.0 >>> print(completeness_score([0, 0, 0, 0], [0, 1, 2, 3])) 0.0 i(RH(RR((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pytcompleteness_score‰sCcC st||ƒdS(sG V-measure cluster labeling given a ground truth. This score is identical to :func:`normalized_mutual_info_score` with the ``'arithmetic'`` option for averaging. The V-measure is the harmonic mean between homogeneity and completeness:: v = 2 * (homogeneity * completeness) / (homogeneity + completeness) This metric is independent of the absolute values of the labels: a permutation of the class or cluster label values won't change the score value in any way. This metric is furthermore symmetric: switching ``label_true`` with ``label_pred`` will return the same score value. This can be useful to measure the agreement of two independent label assignments strategies on the same dataset when the real ground truth is not known. Read more in the :ref:`User Guide `. Parameters ---------- labels_true : int array, shape = [n_samples] ground truth class labels to be used as a reference labels_pred : array, shape = [n_samples] cluster labels to evaluate Returns ------- v_measure : float score between 0.0 and 1.0. 1.0 stands for perfectly complete labeling References ---------- .. [1] `Andrew Rosenberg and Julia Hirschberg, 2007. V-Measure: A conditional entropy-based external cluster evaluation measure `_ See also -------- homogeneity_score completeness_score normalized_mutual_info_score Examples -------- Perfect labelings are both homogeneous and complete, hence have score 1.0:: >>> from sklearn.metrics.cluster import v_measure_score >>> v_measure_score([0, 0, 1, 1], [0, 0, 1, 1]) 1.0 >>> v_measure_score([0, 0, 1, 1], [1, 1, 0, 0]) 1.0 Labelings that assign all classes members to the same clusters are complete be not homogeneous, hence penalized:: >>> print("%.6f" % v_measure_score([0, 0, 1, 2], [0, 0, 1, 1])) ... # doctest: +ELLIPSIS 0.8... >>> print("%.6f" % v_measure_score([0, 1, 2, 3], [0, 0, 1, 1])) ... # doctest: +ELLIPSIS 0.66... Labelings that have pure clusters with members coming from the same classes are homogeneous but un-necessary splits harms completeness and thus penalize V-measure as well:: >>> print("%.6f" % v_measure_score([0, 0, 1, 1], [0, 0, 1, 2])) ... # doctest: +ELLIPSIS 0.8... >>> print("%.6f" % v_measure_score([0, 0, 1, 1], [0, 1, 2, 3])) ... # doctest: +ELLIPSIS 0.66... If classes members are completely split across different clusters, the assignment is totally incomplete, hence the V-Measure is null:: >>> print("%.6f" % v_measure_score([0, 0, 0, 0], [0, 1, 2, 3])) ... # doctest: +ELLIPSIS 0.0... Clusters that include samples from totally different classes totally destroy the homogeneity of the labeling, hence:: >>> print("%.6f" % v_measure_score([0, 0, 1, 1], [0, 0, 0, 0])) ... # doctest: +ELLIPSIS 0.0... i(RH(RR((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pyRGÏs_cC sÈ|d kr9t||ƒ\}}t||dtƒ}n0t|ddddgdttjtjgƒ}t |tj ƒr£tj |ƒ\}}|||f}n@t j |ƒrÍt j|ƒ\}}}ntdt|ƒƒ‚|jƒ}tj|jdd ƒƒ}tj|jdd ƒƒ}tj|ƒ} ||} |j|ƒjtjƒ|j|ƒjtjƒ} tj| ƒ t|jƒƒt|jƒƒ} | | t|ƒ| | } | jƒS( sEMutual Information between two clusterings. The Mutual Information is a measure of the similarity between two labels of the same data. Where :math:`|U_i|` is the number of the samples in cluster :math:`U_i` and :math:`|V_j|` is the number of the samples in cluster :math:`V_j`, the Mutual Information between clusterings :math:`U` and :math:`V` is given as: .. math:: MI(U,V)=\sum_{i=1}^{|U|} \sum_{j=1}^{|V|} \frac{|U_i\cap V_j|}{N} \log\frac{N|U_i \cap V_j|}{|U_i||V_j|} This metric is independent of the absolute values of the labels: a permutation of the class or cluster label values won't change the score value in any way. This metric is furthermore symmetric: switching ``label_true`` with ``label_pred`` will return the same score value. This can be useful to measure the agreement of two independent label assignments strategies on the same dataset when the real ground truth is not known. Read more in the :ref:`User Guide `. Parameters ---------- labels_true : int array, shape = [n_samples] A clustering of the data into disjoint subsets. labels_pred : array, shape = [n_samples] A clustering of the data into disjoint subsets. contingency : {None, array, sparse matrix}, shape = [n_classes_true, n_classes_pred] A contingency matrix given by the :func:`contingency_matrix` function. If value is ``None``, it will be computed, otherwise the given value is used, with ``labels_true`` and ``labels_pred`` ignored. Returns ------- mi : float Mutual information, a non-negative value See also -------- adjusted_mutual_info_score: Adjusted against chance Mutual Information normalized_mutual_info_score: Normalized Mutual Information Rt accept_sparsetcsrtcsctcooRs&Unsupported type for 'contingency': %sR2iiN(RRR/RRR#R tint32tint64t isinstancetndarraytnonzeroR tissparsetfindR ttypeR5R6Rttaketastype(RRR.tnzxtnzytnz_valtcontingency_sumtpitpjtlog_contingency_nmtcontingency_nmtoutert log_outertmi((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pyRA1s.1    40 twarncC s•|dkr%tjdtƒd}nt||ƒ\}}|jd}tj|ƒ}tj|ƒ}|jd|jdkoŠdkns¹|jd|jdko´dknr½dSt||dtƒ}|j tj ƒ}t ||d|ƒ}t ||ƒ}t |ƒt |ƒ} } t| | |ƒ} | |} | dkrht| tjd ƒj ƒ} nt| tjd ƒjƒ} ||| } | S( sz Adjusted Mutual Information between two clusterings. Adjusted Mutual Information (AMI) is an adjustment of the Mutual Information (MI) score to account for chance. It accounts for the fact that the MI is generally higher for two clusterings with a larger number of clusters, regardless of whether there is actually more information shared. For two clusterings :math:`U` and :math:`V`, the AMI is given as:: AMI(U, V) = [MI(U, V) - E(MI(U, V))] / [avg(H(U), H(V)) - E(MI(U, V))] This metric is independent of the absolute values of the labels: a permutation of the class or cluster label values won't change the score value in any way. This metric is furthermore symmetric: switching ``label_true`` with ``label_pred`` will return the same score value. This can be useful to measure the agreement of two independent label assignments strategies on the same dataset when the real ground truth is not known. Be mindful that this function is an order of magnitude slower than other metrics, such as the Adjusted Rand Index. Read more in the :ref:`User Guide `. Parameters ---------- labels_true : int array, shape = [n_samples] A clustering of the data into disjoint subsets. labels_pred : array, shape = [n_samples] A clustering of the data into disjoint subsets. average_method : string, optional (default: 'warn') How to compute the normalizer in the denominator. Possible options are 'min', 'geometric', 'arithmetic', and 'max'. If 'warn', 'max' will be used. The default will change to 'arithmetic' in version 0.22. .. versionadded:: 0.20 Returns ------- ami: float (upperlimited by 1.0) The AMI returns a value of 1 when the two partitions are identical (ie perfectly matched). Random partitions (independent labellings) have an expected AMI around 0 on average hence can be negative. See also -------- adjusted_rand_score: Adjusted Rand Index mutual_info_score: Mutual Information (not adjusted for chance) Examples -------- Perfect labelings are both homogeneous and complete, hence have score 1.0:: >>> from sklearn.metrics.cluster import adjusted_mutual_info_score >>> adjusted_mutual_info_score([0, 0, 1, 1], [0, 0, 1, 1]) ... # doctest: +SKIP 1.0 >>> adjusted_mutual_info_score([0, 0, 1, 1], [1, 1, 0, 0]) ... # doctest: +SKIP 1.0 If classes members are completely split across different clusters, the assignment is totally in-complete, hence the AMI is null:: >>> adjusted_mutual_info_score([0, 0, 0, 0], [0, 1, 2, 3]) ... # doctest: +SKIP 0.0 References ---------- .. [1] `Vinh, Epps, and Bailey, (2010). Information Theoretic Measures for Clusterings Comparison: Variants, Properties, Normalization and Correction for Chance, JMLR `_ .. [2] `Wikipedia entry for the Adjusted Mutual Information `_ Rds‘The behavior of AMI will change in version 0.22. To match the behavior of 'v_measure_score', AMI will use average_method='arithmetic' by default.Riigð?RR.tfloat64(twarningsRdt FutureWarningRR R RR/RRXReRARR@RRtfinfoR'R(RRRR8R(R*R.Rctemith_trueth_predt normalizert denominatortami((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pytadjusted_mutual_info_score‚s0V    **    c C s@|dkr%tjdtƒd}nt||ƒ\}}tj|ƒ}tj|ƒ}|jd|jdko}dkns¬|jd|jdko§dknr°dSt||dtƒ}|j tj ƒ}t ||d|ƒ}t |ƒt |ƒ}}t |||ƒ} t| tjd ƒjƒ} || } | S( s. Normalized Mutual Information between two clusterings. Normalized Mutual Information (NMI) is a normalization of the Mutual Information (MI) score to scale the results between 0 (no mutual information) and 1 (perfect correlation). In this function, mutual information is normalized by some generalized mean of ``H(labels_true)`` and ``H(labels_pred))``, defined by the `average_method`. This measure is not adjusted for chance. Therefore :func:`adjusted_mutual_info_score` might be preferred. This metric is independent of the absolute values of the labels: a permutation of the class or cluster label values won't change the score value in any way. This metric is furthermore symmetric: switching ``label_true`` with ``label_pred`` will return the same score value. This can be useful to measure the agreement of two independent label assignments strategies on the same dataset when the real ground truth is not known. Read more in the :ref:`User Guide `. Parameters ---------- labels_true : int array, shape = [n_samples] A clustering of the data into disjoint subsets. labels_pred : array, shape = [n_samples] A clustering of the data into disjoint subsets. average_method : string, optional (default: 'warn') How to compute the normalizer in the denominator. Possible options are 'min', 'geometric', 'arithmetic', and 'max'. If 'warn', 'geometric' will be used. The default will change to 'arithmetic' in version 0.22. .. versionadded:: 0.20 Returns ------- nmi : float score between 0.0 and 1.0. 1.0 stands for perfectly complete labeling See also -------- v_measure_score: V-Measure (NMI with arithmetic mean option.) adjusted_rand_score: Adjusted Rand Index adjusted_mutual_info_score: Adjusted Mutual Information (adjusted against chance) Examples -------- Perfect labelings are both homogeneous and complete, hence have score 1.0:: >>> from sklearn.metrics.cluster import normalized_mutual_info_score >>> normalized_mutual_info_score([0, 0, 1, 1], [0, 0, 1, 1]) ... # doctest: +SKIP 1.0 >>> normalized_mutual_info_score([0, 0, 1, 1], [1, 1, 0, 0]) ... # doctest: +SKIP 1.0 If classes members are completely split across different clusters, the assignment is totally in-complete, hence the NMI is null:: >>> normalized_mutual_info_score([0, 0, 0, 0], [0, 1, 2, 3])i ... # doctest: +SKIP 0.0 Rds‘The behavior of NMI will change in version 0.22. To match the behavior of 'v_measure_score', NMI will use average_method='arithmetic' by default.Riigð?RR.Re(RfRdRgRR RR R/RRXReRAR@RRRhR'( RRRR(R*R.RcRjRkRltnmi((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pytnormalized_mutual_info_scoreþs&J   **   cC sôt||ƒ\}}|j\}t||dtƒjtjƒ}tj|j|jƒ|}tj tj |j ddƒƒj ƒdƒ|}tj tj |j ddƒƒj ƒdƒ|}|dkrðtj ||ƒtj ||ƒSdS(sÄMeasure the similarity of two clusterings of a set of points. The Fowlkes-Mallows index (FMI) is defined as the geometric mean between of the precision and recall:: FMI = TP / sqrt((TP + FP) * (TP + FN)) Where ``TP`` is the number of **True Positive** (i.e. the number of pair of points that belongs in the same clusters in both ``labels_true`` and ``labels_pred``), ``FP`` is the number of **False Positive** (i.e. the number of pair of points that belongs in the same clusters in ``labels_true`` and not in ``labels_pred``) and ``FN`` is the number of **False Negative** (i.e the number of pair of points that belongs in the same clusters in ``labels_pred`` and not in ``labels_True``). The score ranges from 0 to 1. A high value indicates a good similarity between two clusters. Read more in the :ref:`User Guide `. Parameters ---------- labels_true : int array, shape = (``n_samples``,) A clustering of the data into disjoint subsets. labels_pred : array, shape = (``n_samples``, ) A clustering of the data into disjoint subsets. sparse : bool Compute contingency matrix internally with sparse matrix. Returns ------- score : float The resulting Fowlkes-Mallows score. Examples -------- Perfect labelings are both homogeneous and complete, hence have score 1.0:: >>> from sklearn.metrics.cluster import fowlkes_mallows_score >>> fowlkes_mallows_score([0, 0, 1, 1], [0, 0, 1, 1]) 1.0 >>> fowlkes_mallows_score([0, 0, 1, 1], [1, 1, 0, 0]) 1.0 If classes members are completely split across different clusters, the assignment is totally random, hence the FMI is null:: >>> fowlkes_mallows_score([0, 0, 0, 0], [0, 1, 2, 3]) 0.0 References ---------- .. [1] `E. B. Fowkles and C. L. Mallows, 1983. "A method for comparing two hierarchical clusterings". Journal of the American Statistical Association `_ .. [2] `Wikipedia entry for the Fowlkes-Mallows Index `_ RR2iiig( RR R/RRXR RPtdotR7R5R R6R(RRRR8tcttktpktqk((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pytfowlkes_mallows_scoreesA  22cC s’t|ƒdkrdStj|dtƒd}tj|ƒjtjƒ}||dk}tj|ƒ}tj||tj|ƒt|ƒƒ S(s‰Calculates the entropy for a labeling. Parameters ---------- labels : int array, shape = [n_samples] The labels igð?Ri( R?R RRtbincountRXReR5R(tlabelst label_idxR]tpi_sum((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pyR@±s(!t__doc__t __future__RtmathRRftnumpyR tscipyRR texpected_mutual_info_fastRtutils.validationRt utils.fixesRRRRRtFalseR/R>RHRIRJRGRARoRqRwR@(((sAlib/python2.7/site-packages/sklearn/metrics/cluster/supervised.pyts,      ; i L J F b R | f L