Ajustando para o Acaso na Avaliação de Desempenho de Agrupamento

Introdução

Este laboratório explora o impacto da rotulagem aleatória uniformemente distribuída no comportamento de algumas métricas de avaliação de agrupamento. Os algoritmos de agrupamento são fundamentalmente métodos de aprendizagem não supervisionada, e as métricas de avaliação que utilizam informações de "verdade fundamental" supervisionada para quantificar a qualidade dos clusters resultantes. No entanto, as métricas de avaliação de agrupamento não ajustadas podem ser enganosas, pois produzem valores elevados para rotulações detalhadas, que podem ser totalmente aleatórias. Portanto, apenas as medidas ajustadas podem ser usadas com segurança como um índice de consenso para avaliar a estabilidade média dos algoritmos de agrupamento para um determinado valor de k em vários subconjuntos sobrepostos do conjunto de dados.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para praticar.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Definindo a Lista de Métricas para Avaliação

Primeiro, definimos uma lista de métricas a serem usadas para avaliar algoritmos de agrupamento. Exemplos de tais métricas são a medida V, o índice Rand, o índice Rand Ajustado (ARI), a Informação Mútua (MI), a Informação Mútua Normalizada (NMI) e a Informação Mútua Ajustada (AMI).

from sklearn import metrics

score_funcs = [
    ("Medida V", metrics.v_measure_score),
    ("Índice Rand", metrics.rand_score),
    ("ARI", metrics.adjusted_rand_score),
    ("MI", metrics.mutual_info_score),
    ("NMI", metrics.normalized_mutual_info_score),
    ("AMI", metrics.adjusted_mutual_info_score),
]

Experimento 1 - Rótulos de Verdade Fundamentais Fixos e Número Crescente de Clusters

Criamos rotulagem aleatória uniformemente distribuída e usamos a função random_labels para criar um conjunto fixo de rótulos de verdade fundamentais (labels_a) distribuídos em n_classes e, em seguida, avaliamos vários conjuntos de rótulos aleatoriamente "previstos" (labels_b) para avaliar a variabilidade de uma determinada métrica para um determinado n_clusters.

rng = np.random.RandomState(0)

def random_labels(n_samples, n_classes):
    return rng.randint(low=0, high=n_classes, size=n_samples)

def fixed_classes_uniform_labelings_scores(
    score_func, n_samples, n_clusters_range, n_classes, n_runs=5
):
    scores = np.zeros((len(n_clusters_range), n_runs))
    labels_a = random_labels(n_samples=n_samples, n_classes=n_classes)

    for i, n_clusters in enumerate(n_clusters_range):
        for j in range(n_runs):
            labels_b = random_labels(n_samples=n_samples, n_classes=n_clusters)
            scores[i, j] = score_func(labels_a, labels_b)
    return scores

Plotando os Resultados do Experimento 1

Plotamos os resultados do primeiro experimento usando as bibliotecas matplotlib e seaborn. O índice Rand satura para n_clusters > n_classes. Outras medidas não ajustadas, como a Medida V, mostram uma dependência linear entre o número de clusters e o número de amostras. Medidas ajustadas para o acaso, como ARI e AMI, exibem algumas variações aleatórias centradas em uma pontuação média de 0,0, independentemente do número de amostras e clusters.

import matplotlib.pyplot as plt
import seaborn as sns

n_samples = 1000
n_classes = 10
n_clusters_range = np.linspace(2, 100, 10).astype(int)
plots = []
names = []

sns.color_palette("colorblind")
plt.figure(1)

for marker, (score_name, score_func) in zip("d^vx.,", score_funcs):
    scores = fixed_classes_uniform_labelings_scores(
        score_func, n_samples, n_clusters_range, n_classes=n_classes
    )
    plots.append(
        plt.errorbar(
            n_clusters_range,
            scores.mean(axis=1),
            scores.std(axis=1),
            alpha=0.8,
            linewidth=1,
            marker=marker,
        )[0]
    )
    names.append(score_name)

plt.title(
    "Medidas de agrupamento para rotulagem aleatória uniforme\n"
    f"contra atribuição de referência com {n_classes} classes"
)
plt.xlabel(f"Número de clusters (Número de amostras fixo em {n_samples})")
plt.ylabel("Valor da pontuação")
plt.ylim(bottom=-0.05, top=1.05)
plt.legend(plots, names, bbox_to_anchor=(0.5, 0.5))
plt.show()

Experimento 2 - Número Variável de Classes e Clusters

Nesta seção, definimos uma função semelhante que utiliza várias métricas para avaliar duas rotulações aleatórias uniformemente distribuídas. Neste caso, o número de classes e o número de clusters atribuídos são correspondentes para cada valor possível em n_clusters_range.

def uniform_labelings_scores(score_func, n_samples, n_clusters_range, n_runs=5):
    scores = np.zeros((len(n_clusters_range), n_runs))

    for i, n_clusters in enumerate(n_clusters_range):
        for j in range(n_runs):
            labels_a = random_labels(n_samples=n_samples, n_classes=n_clusters)
            labels_b = random_labels(n_samples=n_samples, n_classes=n_clusters)
            scores[i, j] = score_func(labels_a, labels_b)
    return scores

Plotando os Resultados do Experimento 2

Plotamos os resultados do segundo experimento utilizando a biblioteca matplotlib. Observamos resultados semelhantes aos do primeiro experimento: as métricas ajustadas para o acaso permanecem constantemente próximas de zero, enquanto outras métricas tendem a aumentar com rotulações mais detalhadas. A medida média V-measure de rotulação aleatória aumenta significativamente à medida que o número de clusters se aproxima do número total de amostras usadas para calcular a medida.

n_samples = 100
n_clusters_range = np.linspace(2, n_samples, 10).astype(int)

plt.figure(2)

plots = []
names = []

for marker, (score_name, score_func) in zip("d^vx.,", score_funcs):
    scores = uniform_labelings_scores(score_func, n_samples, n_clusters_range)
    plots.append(
        plt.errorbar(
            n_clusters_range,
            np.median(scores, axis=1),
            scores.std(axis=1),
            alpha=0.8,
            linewidth=2,
            marker=marker,
        )[0]
    )
    names.append(score_name)

plt.title(
    "Medidas de agrupamento para 2 rotulações aleatórias uniformes\ncom número igual de clusters"
)
plt.xlabel(f"Número de clusters (Número de amostras fixo em {n_samples})")
plt.ylabel("Valor da pontuação")
plt.legend(plots, names)
plt.ylim(bottom=-0.05, top=1.05)
plt.show()

Resumo

Este laboratório explorou o impacto de rotulação aleatória uniformemente distribuída no comportamento de algumas métricas de avaliação de agrupamento. Os resultados indicaram que métricas de avaliação de agrupamento não ajustadas podem ser enganosas, e apenas as medidas ajustadas podem ser usadas com segurança como um índice de consenso para avaliar a estabilidade média de algoritmos de agrupamento para um determinado valor de k em vários subconjuntos sobrepostos do conjunto de dados.