metrics.davies_bouldin_score

.. _davies-bouldin_index:

Davies-Bouldin Index

If the ground truth labels are not known, the Davies-Bouldin index

(:func:`sklearn.metrics.davies_bouldin_score`) can be used to evaluate the

model, where a lower Davies-Bouldin index relates to a model with better

separation between the clusters.

The index is defined as the average similarity between each cluster :math:`C_i`

for :math:`i=1, ..., k` and its most similar one :math:`C_j`. In the context of

this index, similarity is defined as a measure :math:`R_{ij}` that trades off:

- :math:`s_i`, the average distance between each point of cluster :math:`i` and

the centroid of that cluster -- also know as cluster diameter.

- :math:`d_{ij}`, the distance between cluster centroids :math:`i` and :math:`j`.

A simple choice to construct :math:`R_ij` so that it is nonnegative and

symmetric is:

Then the Davies-Bouldin index is defined as:

Zero is the lowest possible score. Values closer to zero indicate a better

partition.

In normal usage, the Davies-Bouldin index is applied to the results of a

cluster analysis as follows:

>>> from sklearn import datasets

>>> iris = datasets.load_iris()

>>> X = iris.data

>>> from sklearn.cluster import KMeans

>>> from sklearn.metrics import davies_bouldin_score

>>> kmeans = KMeans(n_clusters=3, random_state=1).fit(X)

>>> labels = kmeans.labels_

>>> davies_bouldin_score(X, labels) # doctest: +ELLIPSIS

0.6623...

Advantages

- The computation of Davies-Bouldin is simpler than that of Silhouette scores.

- The index is computed only quantities and features inherent to the dataset.

Drawbacks

- The Davies-Boulding index is generally higher for convex clusters than other

concepts of clusters, such as density based clusters like those obtained from

DBSCAN.

- The usage of centroid distance limits the distance metric to Euclidean space.

- A good value reported by this method does not imply the best information retrieval.

.. topic:: References

* Davies, David L.; Bouldin, Donald W. (1979).

"A Cluster Separation Measure"

IEEE Transactions on Pattern Analysis and Machine Intelligence.

PAMI-1 (2): 224-227.

`doi:10.1109/TPAMI.1979.4766909 <http://dx.doi.org/10.1109/TPAMI.1979.4766909>`_.

* Halkidi, Maria; Batistakis, Yannis; Vazirgiannis, Michalis (2001).

"On Clustering Validation Techniques"

Journal of Intelligent Information Systems, 17(2-3), 107-145.

`doi:10.1023/A:1012801612483 <http://dx.doi.org/10.1023/A:1012801612483>`_.

* `Wikipedia entry for Davies-Bouldin index

<https://en.wikipedia.org/wiki/Davies–Bouldin_index>`_.

- Added the :func:`metrics.cluster.davies_bouldin_index` metric for unsupervised

evaluation of clustering models. :issue:`10827` by :user:`Luis Osa <logc>`.

from .cluster import davies_bouldin_score

'davies_bouldin_score',

from .unsupervised import davies_bouldin_score

"silhouette_score", "calinski_harabaz_score",

"davies_bouldin_score", "consensus_score"]

from sklearn.metrics.cluster import davies_bouldin_score

"calinski_harabaz_score": calinski_harabaz_score,

"davies_bouldin_score": davies_bouldin_score

import pytest

from sklearn.metrics.cluster import davies_bouldin_score

pytest.approx(score_precomputed, score_euclidean)

pytest.approx(score_euclidean,

score_dense_without_sampling)

pytest.approx(score_euclidean, score_precomputed)

pytest.approx(score_euclidean, score_dense_with_sampling)

pytest.approx(expected,

silhouette_samples(D, np.array(labels),

metric='precomputed'),

abs=1e-2)

pytest.approx(score,

silhouette_score(D, np.array(labels),

metric='precomputed'),

abs=1e-2)

def assert_raises_on_only_one_label(func):

"""Assert message when there is only one label"""

func,

def assert_raises_on_all_points_same_cluster(func):

"""Assert message when all point are in different clusters"""

rng = np.random.RandomState(seed=0)

func,

def test_calinski_harabaz_score():

assert_raises_on_only_one_label(calinski_harabaz_score)

assert_raises_on_all_points_same_cluster(calinski_harabaz_score)

pytest.approx(calinski_harabaz_score(X, labels),

def test_davies_bouldin_score():

assert_raises_on_only_one_label(davies_bouldin_score)

assert_raises_on_all_points_same_cluster(davies_bouldin_score)

# Assert the value is 0. when all samples are equals

assert davies_bouldin_score(np.ones((10, 2)),

[0] * 5 + [1] * 5) == pytest.approx(0.0)

# Assert the value is 0. when all the mean cluster are equal

assert davies_bouldin_score([[-1, -1], [1, 1]] * 10,

[0] * 10 + [1] * 10) == pytest.approx(0.0)

# General case (with non numpy arrays)

X = ([[0, 0], [1, 1]] * 5 + [[3, 3], [4, 4]] * 5 +

[[0, 4], [1, 3]] * 5 + [[3, 1], [4, 0]] * 5)

labels = [0] * 10 + [1] * 10 + [2] * 10 + [3] * 10

pytest.approx(davies_bouldin_score(X, labels), 2 * np.sqrt(0.5) / 3)

# General case - cluster have one sample

X = ([[0, 0], [2, 2], [3, 3], [5, 5]])

labels = [0, 0, 1, 2]

pytest.approx(davies_bouldin_score(X, labels), (5. / 4) / 3)

from ...utils import safe_indexing

def davies_bouldin_score(X, labels):

"""Computes the Davies-Bouldin score.

X, labels = check_X_y(X, labels)

le = LabelEncoder()

labels = le.fit_transform(labels)

n_samples, _ = X.shape

n_labels = len(le.classes_)

check_number_of_labels(n_labels, n_samples)

intra_dists = np.zeros(n_labels)

centroids = np.zeros((n_labels, len(X[0])), dtype=np.float)

for k in range(n_labels):

cluster_k = safe_indexing(X, labels == k)

centroid = cluster_k.mean(axis=0)

centroids[k] = centroid

intra_dists[k] = np.average(pairwise_distances(

cluster_k, [centroid]))

centroid_distances = pairwise_distances(centroids)

if np.allclose(intra_dists, 0) or np.allclose(centroid_distances, 0):

return 0.0

score = (intra_dists[:, None] + intra_dists) / centroid_distances

score[score == np.inf] = np.nan

return np.mean(np.nanmax(score, axis=1))