Métricas de Agrupamento Hierárquico Agglomerativo

Introdução

O agrupamento aglomerativo é um método de agrupamento hierárquico usado para agrupar objetos semelhantes. Ele começa com cada objeto como seu próprio cluster e, em seguida, funde iterativamente os clusters mais semelhantes até que um critério de parada seja atingido. Neste laboratório, demonstraremos o efeito de diferentes métricas no agrupamento hierárquico usando o algoritmo de agrupamento aglomerativo.

Dicas da Máquina Virtual

Após o término da inicialização da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação de operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você encontrar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para você.

Importar bibliotecas e gerar dados de forma de onda

Primeiro, importamos as bibliotecas necessárias e geramos dados de forma de onda que serão usados neste laboratório.

import matplotlib.pyplot as plt
import matplotlib.patheffects as PathEffects
import numpy as np
from sklearn.cluster import AgglomerativeClustering
from sklearn.metrics import pairwise_distances

np.random.seed(0)

## Gerar dados de forma de onda
n_features = 2000
t = np.pi * np.linspace(0, 1, n_features)

def sqr(x):
    return np.sign(np.cos(x))

X = list()
y = list()
for i, (phi, a) in enumerate([(0.5, 0.15), (0.5, 0.6), (0.3, 0.2)]):
    for _ in range(30):
        phase_noise = 0.01 * np.random.normal()
        amplitude_noise = 0.04 * np.random.normal()
        additional_noise = 1 - 2 * np.random.rand(n_features)
        ## Tornar o ruído esparso
        additional_noise[np.abs(additional_noise) < 0.997] = 0

        X.append(
            12
            * (
                (a + amplitude_noise) * (sqr(6 * (t + phi + phase_noise)))
                + additional_noise
            )
        )
        y.append(i)

X = np.array(X)
y = np.array(y)

Plotar a rotulagem real

Plotamos a rotulagem real dos dados da forma de onda.

n_clusters = 3

labels = ("Forma de Onda 1", "Forma de Onda 2", "Forma de Onda 3")

colors = ["#f7bd01", "#377eb8", "#f781bf"]

## Plotar a rotulagem real
plt.figure()
plt.axes([0, 0, 1, 1])
for l, color, n in zip(range(n_clusters), colors, labels):
    lines = plt.plot(X[y == l].T, c=color, alpha=0.5)
    lines[0].set_label(n)

plt.legend(loc="best")

plt.axis("tight")
plt.axis("off")
plt.suptitle("Verdade real", size=20, y=1)

Plotar as distâncias

Plotamos as distâncias interclasses para diferentes métricas.

for index, metric in enumerate(["cosine", "euclidean", "cityblock"]):
    avg_dist = np.zeros((n_clusters, n_clusters))
    plt.figure(figsize=(5, 4.5))
    for i in range(n_clusters):
        for j in range(n_clusters):
            avg_dist[i, j] = pairwise_distances(
                X[y == i], X[y == j], metric=metric
            ).mean()
    avg_dist /= avg_dist.max()
    for i in range(n_clusters):
        for j in range(n_clusters):
            t = plt.text(
                i,
                j,
                "%5.3f" % avg_dist[i, j],
                verticalalignment="center",
                horizontalalignment="center",
            )
            t.set_path_effects(
                [PathEffects.withStroke(linewidth=5, foreground="w", alpha=0.5)]
            )

    plt.imshow(avg_dist, interpolation="nearest", cmap="cividis", vmin=0)
    plt.xticks(range(n_clusters), labels, rotation=45)
    plt.yticks(range(n_clusters), labels)
    plt.colorbar()
    plt.suptitle("Distâncias interclasses %s" % metric, size=18, y=1)
    plt.tight_layout()

Plotar resultados de agrupamento

Plotamos os resultados do agrupamento para diferentes métricas.

for index, metric in enumerate(["cosine", "euclidean", "cityblock"]):
    model = AgglomerativeClustering(
        n_clusters=n_clusters, linkage="average", metric=metric
    )
    model.fit(X)
    plt.figure()
    plt.axes([0, 0, 1, 1])
    for l, color in zip(np.arange(model.n_clusters), colors):
        plt.plot(X[model.labels_ == l].T, c=color, alpha=0.5)
    plt.axis("tight")
    plt.axis("off")
    plt.suptitle("AgglomerativeClustering(métrica=%s)" % metric, size=20, y=1)

Resumo

Neste laboratório, demonstramos o efeito de diferentes métricas no agrupamento hierárquico utilizando o algoritmo de agrupamento aglomerativo. Geramos dados de forma de onda e plotamos a rotulagem real, as distâncias interclasses e os resultados de agrupamento para diferentes métricas. Observamos que os resultados de agrupamento variaram com a escolha da métrica e que a distância cityblock apresentou o melhor desempenho na separação das formas de onda.