val get_py : string -> Py.Object.tGet an attribute of this module as a Py.Object.t. This is useful to pass a Python function to another function.
val adjusted_mutual_info_score :
?average_method:string ->
labels_true:[> `ArrayLike ] Np.Obj.t ->
labels_pred:[> `ArrayLike ] Np.Obj.t ->
unit ->
floatAdjusted 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 <mutual_info_score>`.
Parameters ---------- labels_true : int array, shape = n_samples A clustering of the data into disjoint subsets.
labels_pred : int array-like of shape (n_samples,) A clustering of the data into disjoint subsets.
average_method : string, optional (default: 'arithmetic') How to compute the normalizer in the denominator. Possible options are 'min', 'geometric', 'arithmetic', and 'max'.
.. versionadded:: 0.20
.. versionchanged:: 0.22 The default value of ``average_method`` changed from 'max' to 'arithmetic'.
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 <http://jmlr.csail.mit.edu/papers/volume11/vinh10a/vinh10a.pdf>`_
.. 2 `Wikipedia entry for the Adjusted Mutual Information <https://en.wikipedia.org/wiki/Adjusted_Mutual_Information>`_
val adjusted_rand_score :
labels_true:[> `ArrayLike ] Np.Obj.t ->
labels_pred:[> `ArrayLike ] Np.Obj.t ->
unit ->
floatRand 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 <adjusted_rand_score>`.
Parameters ---------- labels_true : int array, shape = n_samples Ground truth class labels to be used as a reference
labels_pred : array-like of 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) 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) 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 https://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
val calinski_harabasz_score :
x:[> `ArrayLike ] Np.Obj.t ->
labels:[> `ArrayLike ] Np.Obj.t ->
unit ->
floatCompute the Calinski and Harabasz score.
It is also known as the Variance Ratio Criterion.
The score is defined as ratio between the within-cluster dispersion and the between-cluster dispersion.
Read more in the :ref:`User Guide <calinski_harabasz_index>`.
Parameters ---------- X : array-like, shape (``n_samples``, ``n_features``) List of ``n_features``-dimensional data points. Each row corresponds to a single data point.
labels : array-like, shape (``n_samples``,) Predicted labels for each sample.
Returns ------- score : float The resulting Calinski-Harabasz score.
References ---------- .. 1 `T. Calinski and J. Harabasz, 1974. 'A dendrite method for cluster analysis'. Communications in Statistics <https://www.tandfonline.com/doi/abs/10.1080/03610927408827101>`_
val completeness_score :
labels_true:[> `ArrayLike ] Np.Obj.t ->
labels_pred:[> `ArrayLike ] Np.Obj.t ->
unit ->
floatCompleteness 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 <homogeneity_completeness>`.
Parameters ---------- labels_true : int array, shape = n_samples ground truth class labels to be used as a reference
labels_pred : array-like of 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 <https://aclweb.org/anthology/D/D07/D07-1043.pdf>`_
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
val consensus_score :
?similarity:[ `S of string | `Callable of Py.Object.t ] ->
a:Py.Object.t ->
b:Py.Object.t ->
unit ->
Py.Object.tThe similarity of two sets of biclusters.
Similarity between individual biclusters is computed. Then the best matching between sets is found using the Hungarian algorithm. The final score is the sum of similarities divided by the size of the larger set.
Read more in the :ref:`User Guide <biclustering>`.
Parameters ---------- a : (rows, columns) Tuple of row and column indicators for a set of biclusters.
b : (rows, columns) Another set of biclusters like ``a``.
similarity : string or function, optional, default: 'jaccard' May be the string 'jaccard' to use the Jaccard coefficient, or any function that takes four arguments, each of which is a 1d indicator vector: (a_rows, a_columns, b_rows, b_columns).
References ----------
* Hochreiter, Bodenhofer, et. al., 2010. `FABIA: factor analysis for bicluster acquisition <https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2881408/>`__.
val contingency_matrix :
?eps:float ->
?sparse:bool ->
labels_true:[> `ArrayLike ] Np.Obj.t ->
labels_pred:[> `ArrayLike ] Np.Obj.t ->
unit ->
Py.Object.tBuild 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-like of 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_, 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``.
val davies_bouldin_score :
x:[> `ArrayLike ] Np.Obj.t ->
labels:[> `ArrayLike ] Np.Obj.t ->
unit ->
floatComputes the Davies-Bouldin score.
The score is defined as the average similarity measure of each cluster with its most similar cluster, where similarity is the ratio of within-cluster distances to between-cluster distances. Thus, clusters which are farther apart and less dispersed will result in a better score.
The minimum score is zero, with lower values indicating better clustering.
Read more in the :ref:`User Guide <davies-bouldin_index>`.
.. versionadded:: 0.20
Parameters ---------- X : array-like, shape (``n_samples``, ``n_features``) List of ``n_features``-dimensional data points. Each row corresponds to a single data point.
labels : array-like, shape (``n_samples``,) Predicted labels for each sample.
Returns ------- score: float The resulting Davies-Bouldin score.
References ---------- .. 1 Davies, David L.; Bouldin, Donald W. (1979). `'A Cluster Separation Measure' <https://ieeexplore.ieee.org/document/4766909>`__. IEEE Transactions on Pattern Analysis and Machine Intelligence. PAMI-1 (2): 224-227
val entropy : [> `ArrayLike ] Np.Obj.t -> Py.Object.tCalculates the entropy for a labeling.
Parameters ---------- labels : int array, shape = n_samples The labels
Notes ----- The logarithm used is the natural logarithm (base-e).
val fowlkes_mallows_score :
?sparse:bool ->
labels_true:[> `ArrayLike ] Np.Obj.t ->
labels_pred:[> `ArrayLike ] Np.Obj.t ->
unit ->
floatMeasure the similarity of two clusterings of a set of points.
.. versionadded:: 0.18
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 <fowlkes_mallows_scores>`.
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 <http://wildfire.stat.ucla.edu/pdflibrary/fowlkes.pdf>`_
.. 2 `Wikipedia entry for the Fowlkes-Mallows Index <https://en.wikipedia.org/wiki/Fowlkes-Mallows_index>`_
val homogeneity_completeness_v_measure :
?beta:float ->
labels_true:[> `ArrayLike ] Np.Obj.t ->
labels_pred:[> `ArrayLike ] Np.Obj.t ->
unit ->
float * float * floatCompute 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 <homogeneity_completeness>`.
Parameters ---------- labels_true : int array, shape = n_samples ground truth class labels to be used as a reference
labels_pred : array-like of shape (n_samples,) cluster labels to evaluate
beta : float Ratio of weight attributed to ``homogeneity`` vs ``completeness``. If ``beta`` is greater than 1, ``completeness`` is weighted more strongly in the calculation. If ``beta`` is less than 1, ``homogeneity`` is weighted more strongly.
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
val homogeneity_score :
labels_true:[> `ArrayLike ] Np.Obj.t ->
labels_pred:[> `ArrayLike ] Np.Obj.t ->
unit ->
floatHomogeneity 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 <homogeneity_completeness>`.
Parameters ---------- labels_true : int array, shape = n_samples ground truth class labels to be used as a reference
labels_pred : array-like of 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 <https://aclweb.org/anthology/D/D07/D07-1043.pdf>`_
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)) 1.000000 >>> print('%.6f' % homogeneity_score(0, 0, 1, 1, 0, 1, 2, 3)) 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)) 0.0... >>> print('%.6f' % homogeneity_score(0, 0, 1, 1, 0, 0, 0, 0)) 0.0...
val mutual_info_score :
?contingency:[> `ArrayLike ] Np.Obj.t ->
labels_true:[> `ArrayLike ] Np.Obj.t ->
labels_pred:[> `ArrayLike ] Np.Obj.t ->
unit ->
floatMutual 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_=1^ |U| \sum_j=1^ |V| \frac |U_i\cap V_j| N \log\fracN|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 <mutual_info_score>`.
Parameters ---------- labels_true : int array, shape = n_samples A clustering of the data into disjoint subsets.
labels_pred : int array-like of 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
Notes ----- The logarithm used is the natural logarithm (base-e).
See also -------- adjusted_mutual_info_score: Adjusted against chance Mutual Information normalized_mutual_info_score: Normalized Mutual Information
val normalized_mutual_info_score :
?average_method:string ->
labels_true:[> `ArrayLike ] Np.Obj.t ->
labels_pred:[> `ArrayLike ] Np.Obj.t ->
unit ->
floatNormalized 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 <mutual_info_score>`.
Parameters ---------- labels_true : int array, shape = n_samples A clustering of the data into disjoint subsets.
labels_pred : int array-like of shape (n_samples,) A clustering of the data into disjoint subsets.
average_method : string, optional (default: 'arithmetic') How to compute the normalizer in the denominator. Possible options are 'min', 'geometric', 'arithmetic', and 'max'.
.. versionadded:: 0.20
.. versionchanged:: 0.22 The default value of ``average_method`` changed from 'geometric' to 'arithmetic'.
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) ... # doctest: +SKIP 0.0
val silhouette_samples :
?metric:[ `S of string | `Callable of Py.Object.t ] ->
?kwds:(string * Py.Object.t) list ->
x:[ `Otherwise of Py.Object.t | `Arr of [> `ArrayLike ] Np.Obj.t ] ->
labels:[> `ArrayLike ] Np.Obj.t ->
unit ->
[> `ArrayLike ] Np.Obj.tCompute the Silhouette Coefficient for each sample.
The Silhouette Coefficient is a measure of how well samples are clustered with samples that are similar to themselves. Clustering models with a high Silhouette Coefficient are said to be dense, where samples in the same cluster are similar to each other, and well separated, where samples in different clusters are not very similar to each other.
The Silhouette Coefficient is calculated using the mean intra-cluster distance (``a``) and the mean nearest-cluster distance (``b``) for each sample. The Silhouette Coefficient for a sample is ``(b - a) / max(a, b)``. Note that Silhouette Coefficient is only defined if number of labels is 2 <= n_labels <= n_samples - 1.
This function returns the Silhouette Coefficient for each sample.
The best value is 1 and the worst value is -1. Values near 0 indicate overlapping clusters.
Read more in the :ref:`User Guide <silhouette_coefficient>`.
Parameters ---------- X : array n_samples_a, n_samples_a if metric == 'precomputed', or, n_samples_a, n_features otherwise Array of pairwise distances between samples, or a feature array.
labels : array, shape = n_samples label values for each sample
metric : string, or callable The metric to use when calculating distance between instances in a feature array. If metric is a string, it must be one of the options allowed by :func:`sklearn.metrics.pairwise.pairwise_distances`. If X is the distance array itself, use 'precomputed' as the metric. Precomputed distance matrices must have 0 along the diagonal.
`**kwds` : optional keyword parameters Any further parameters are passed directly to the distance function. If using a ``scipy.spatial.distance`` metric, the parameters are still metric dependent. See the scipy docs for usage examples.
Returns ------- silhouette : array, shape = n_samples Silhouette Coefficient for each samples.
References ----------
.. 1 `Peter J. Rousseeuw (1987). 'Silhouettes: a Graphical Aid to the Interpretation and Validation of Cluster Analysis'. Computational and Applied Mathematics 20: 53-65. <https://www.sciencedirect.com/science/article/pii/0377042787901257>`_
.. 2 `Wikipedia entry on the Silhouette Coefficient <https://en.wikipedia.org/wiki/Silhouette_(clustering)>`_
val silhouette_score :
?metric:[ `S of string | `Callable of Py.Object.t ] ->
?sample_size:int ->
?random_state:int ->
?kwds:(string * Py.Object.t) list ->
x:[ `Otherwise of Py.Object.t | `Arr of [> `ArrayLike ] Np.Obj.t ] ->
labels:[> `ArrayLike ] Np.Obj.t ->
unit ->
floatCompute the mean Silhouette Coefficient of all samples.
The Silhouette Coefficient is calculated using the mean intra-cluster distance (``a``) and the mean nearest-cluster distance (``b``) for each sample. The Silhouette Coefficient for a sample is ``(b - a) / max(a, b)``. To clarify, ``b`` is the distance between a sample and the nearest cluster that the sample is not a part of. Note that Silhouette Coefficient is only defined if number of labels is 2 <= n_labels <= n_samples - 1.
This function returns the mean Silhouette Coefficient over all samples. To obtain the values for each sample, use :func:`silhouette_samples`.
The best value is 1 and the worst value is -1. Values near 0 indicate overlapping clusters. Negative values generally indicate that a sample has been assigned to the wrong cluster, as a different cluster is more similar.
Read more in the :ref:`User Guide <silhouette_coefficient>`.
Parameters ---------- X : array n_samples_a, n_samples_a if metric == 'precomputed', or, n_samples_a, n_features otherwise Array of pairwise distances between samples, or a feature array.
labels : array, shape = n_samples Predicted labels for each sample.
metric : string, or callable The metric to use when calculating distance between instances in a feature array. If metric is a string, it must be one of the options allowed by :func:`metrics.pairwise.pairwise_distances <sklearn.metrics.pairwise.pairwise_distances>`. If X is the distance array itself, use ``metric='precomputed'``.
sample_size : int or None The size of the sample to use when computing the Silhouette Coefficient on a random subset of the data. If ``sample_size is None``, no sampling is used.
random_state : int, RandomState instance or None, optional (default=None) Determines random number generation for selecting a subset of samples. Used when ``sample_size is not None``. Pass an int for reproducible results across multiple function calls. See :term:`Glossary <random_state>`.
**kwds : optional keyword parameters Any further parameters are passed directly to the distance function. If using a scipy.spatial.distance metric, the parameters are still metric dependent. See the scipy docs for usage examples.
Returns ------- silhouette : float Mean Silhouette Coefficient for all samples.
References ----------
.. 1 `Peter J. Rousseeuw (1987). 'Silhouettes: a Graphical Aid to the Interpretation and Validation of Cluster Analysis'. Computational and Applied Mathematics 20: 53-65. <https://www.sciencedirect.com/science/article/pii/0377042787901257>`_
.. 2 `Wikipedia entry on the Silhouette Coefficient <https://en.wikipedia.org/wiki/Silhouette_(clustering)>`_
val v_measure_score :
?beta:float ->
labels_true:[> `ArrayLike ] Np.Obj.t ->
labels_pred:[> `ArrayLike ] Np.Obj.t ->
unit ->
floatV-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 = (1 + beta) * homogeneity * completeness / (beta * 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 <homogeneity_completeness>`.
Parameters ---------- labels_true : int array, shape = n_samples ground truth class labels to be used as a reference
labels_pred : array-like of shape (n_samples,) cluster labels to evaluate
beta : float Ratio of weight attributed to ``homogeneity`` vs ``completeness``. If ``beta`` is greater than 1, ``completeness`` is weighted more strongly in the calculation. If ``beta`` is less than 1, ``homogeneity`` is weighted more strongly.
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 <https://aclweb.org/anthology/D/D07/D07-1043.pdf>`_
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)) 0.8... >>> print('%.6f' % v_measure_score(0, 1, 2, 3, 0, 0, 1, 1)) 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)) 0.8... >>> print('%.6f' % v_measure_score(0, 0, 1, 1, 0, 1, 2, 3)) 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)) 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)) 0.0...