def test_check_clustering_error():
# Test warning message for continuous values
rng = np.random.RandomState(42)
noise = rng.rand(500)
wavelength = np.linspace(0.01, 1, 500) * 1e-6
msg = 'Clustering metrics expects discrete values but received ' \
'continuous values for label, and continuous values for ' \
'target'
with pytest.warns(UserWarning, match=msg):
check_clusterings(wavelength, noise)
def rand_index_score(labels_true, labels_pred):
# check clusterings
labels_true, labels_pred = check_clusterings(labels_true, labels_pred)
# initial statistics calculations
n_samples = labels_true.shape[0]
n_samples_comb = comb(n_samples,2)
n_classes = np.unique(labels_true).shape[0]
n_clusters = np.unique(labels_pred).shape[0]
class_freq = np.bincount(labels_true)
cluster_freq = np.bincount(labels_pred)
# Special limit cases: no clustering since the data is not split;
# or trivial clustering where each document is assigned a unique cluster.
# These are perfect matches hence return 1.0.
if (n_classes == n_clusters == 1 or
n_classes == n_clusters == 0 or
n_classes == n_clusters == n_samples):
return 1.0
# Compute the RI using the contingency data
contingency = contingency_matrix(labels_true, labels_pred, sparse=True)
sum_comb_c = sum((n_c**2) for n_c in cluster_freq)
sum_comb_k = sum((n_k**2) for n_k in class_freq)
sum_comb = sum((n_ij**2) for n_ij in contingency.data)
return (1 + (sum_comb - 0.5 * sum_comb_k - 0.5 * sum_comb_c)/n_samples_comb)
def pair_confusion_matrix(labels_true, labels_pred):
labels_true, labels_pred = check_clusterings(labels_true, labels_pred)
n_samples = np.int64(labels_true.shape[0])
# Computation using the contingency data
contingency = contingency_matrix(
labels_true, labels_pred, sparse=True, dtype=np.int64
)
n_c = np.ravel(contingency.sum(axis=1))
n_k = np.ravel(contingency.sum(axis=0))
sum_squares = (contingency.data ** 2).sum()
C = np.empty((2, 2), dtype=np.int64)
C[1, 1] = sum_squares - n_samples
C[0, 1] = contingency.dot(n_k).sum() - sum_squares
C[1, 0] = contingency.transpose().dot(n_c).sum() - sum_squares
C[0, 0] = n_samples ** 2 - C[0, 1] - C[1, 0] - sum_squares
return C
def clustering_accuracy(labels_true, labels_pred):
"""Clustering Accuracy between two clusterings.
Clustering Accuracy is a measure of the similarity between two labels of
the same data. Assume that both labels_true and labels_pred contain n
distinct labels. Clustering Accuracy is the maximum accuracy over all
possible permutations of the labels, i.e.
\max_{\sigma} \sum_i labels_true[i] == \sigma(labels_pred[i])
where \sigma is a mapping from the set of unique labels of labels_pred to
the set of unique labels of labels_true. Clustering accuracy is one if
and only if there is a permutation of the labels such that there is an
exact match
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.
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.
Returns
-------
accuracy : float
return clustering accuracy in the range of [0, 1]
"""
labels_true, labels_pred = _supervised.check_clusterings(
labels_true, labels_pred)
# value = _supervised.contingency_matrix(labels_true, labels_pred, sparse=False)
value = _supervised.contingency_matrix(labels_true, labels_pred)
[r, c] = linear_sum_assignment(-value)
return value[r, c].sum() / len(labels_true)
