Algoritmo de Biclustering Espectral

Introdução

Neste laboratório, utilizaremos o algoritmo de Biclustering Espectral para agrupar dados considerando simultaneamente as linhas (amostras) e colunas (características) de uma matriz. O objetivo é identificar padrões não só entre as amostras, mas também dentro de subconjuntos de amostras, permitindo a deteção de estrutura localizada nos dados. Isto torna o biclustering espectral particularmente adequado para conjuntos de dados onde a ordem ou disposição das características é fixa, como em imagens, séries temporais ou genomas. Utilizaremos a biblioteca scikit-learn para gerar um conjunto de dados em tabuleiro de xadrez e realizar o biclustering utilizando o algoritmo de Biclustering Espectral.

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 a prática.

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 o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Gerar dados de amostra

Geramos os dados de amostra utilizando a função make_checkerboard. Cada pixel dentro de shape=(300, 300) representa, com sua cor, um valor de uma distribuição uniforme. O ruído é adicionado a partir de uma distribuição normal, onde o valor escolhido para noise é o desvio padrão.

from sklearn.datasets import make_checkerboard
from matplotlib import pyplot as plt

n_clusters = (4, 3)
data, rows, columns = make_checkerboard(
    shape=(300, 300), n_clusters=n_clusters, noise=10, shuffle=False, random_state=42
)

plt.matshow(data, cmap=plt.cm.Blues)
plt.title("Conjunto de dados original")
_ = plt.show()

Embaralhar os dados

Embaralhamos os dados e o objetivo é reconstruí-los posteriormente usando SpectralBiclustering.

import numpy as np

## Criando listas de índices de linha e coluna embaralhados
rng = np.random.RandomState(0)
row_idx_shuffled = rng.permutation(data.shape[0])
col_idx_shuffled = rng.permutation(data.shape[1])

## Redefinindo os dados embaralhados e plotando-os.
data = data[row_idx_shuffled][:, col_idx_shuffled]

plt.matshow(data, cmap=plt.cm.Blues)
plt.title("Conjunto de dados embaralhado")
_ = plt.show()

Ajustar SpectralBiclustering

Ajustamos o modelo e comparamos os clusters obtidos com a verdade fundamental. Note que, ao criar o modelo, especificamos o mesmo número de clusters que usamos para criar o conjunto de dados (n_clusters = (4, 3)), o que contribuirá para obter um bom resultado.

from sklearn.cluster import SpectralBiclustering
from sklearn.metrics import consensus_score

model = SpectralBiclustering(n_clusters=n_clusters, method="log", random_state=0)
model.fit(data)

## Calcular a similaridade de dois conjuntos de biclusters
score = consensus_score(
    model.biclusters_, (rows[:, row_idx_shuffled], columns[:, col_idx_shuffled])
)
print(f"score de consenso: {score:.1f}")

Plotando resultados

Agora, reorganizamos os dados com base nas etiquetas de linha e coluna atribuídas pelo modelo SpectralBiclustering em ordem crescente e plotamos novamente. Os row_labels_ variam de 0 a 3, enquanto os column_labels_ variam de 0 a 2, representando um total de 4 clusters por linha e 3 clusters por coluna.

## Reordenando primeiro as linhas e depois as colunas.
reordered_rows = data[np.argsort(model.row_labels_)]
reordered_data = reordered_rows[:, np.argsort(model.column_labels_)]

plt.matshow(reordered_data, cmap=plt.cm.Blues)
plt.title("Após o biclustering; reorganizado para mostrar os biclusters")
_ = plt.show()

Como último passo, queremos demonstrar as relações entre as etiquetas de linha e coluna atribuídas pelo modelo. Portanto, criamos uma grade com numpy.outer, que recebe os row_labels_ e column_labels_ ordenados e adiciona 1 a cada um para garantir que as etiquetas comecem em 1 em vez de 0, para uma melhor visualização.

plt.matshow(
    np.outer(np.sort(model.row_labels_) + 1, np.sort(model.column_labels_) + 1),
    cmap=plt.cm.Blues,
)
plt.title("Estrutura de xadrez dos dados reorganizados")
plt.show()

Resumo

Neste laboratório, aprendemos a utilizar o algoritmo Spectral Biclustering para agrupar dados considerando simultaneamente as linhas (amostras) e colunas (características) de uma matriz. Gerámos um conjunto de dados em xadrez e agrupámos-no em biclusters utilizando o algoritmo Spectral Biclustering. Também visualizámos os resultados para demonstrar as relações entre as etiquetas de linha e coluna atribuídas pelo modelo.