Classificação de nós com GNN
Conjunto de dados Cora, GCN de 2 camadas, ciclo de treinamento, perda mascarada, precisão no teste e visualização de embeddings.
Classificação de nós com GNN é uma aula grátis de Learn AI with Python no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn AI with Python, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn AI with Python inclui 4 aulas no total.
A tarefa de classificação de nós
A classificação de nós prevê um rótulo para cada nó usando seus atributos e a estrutura do grafo. Um exemplo clássico é rotular cada artigo em uma rede de citações de acordo com seu tema de pesquisa, usando tanto as palavras do artigo quanto os artigos que ele cita.
O conjunto de dados Cora
Cora é o MNIST do aprendizado em grafos. Trata-se de um grafo de citações com 2.708 artigos de aprendizado de máquina. As arestas são citações; cada artigo tem um vetor de atributos de saco de palavras com comprimento 1433; o objetivo é classificar cada artigo em um dos 7 temas.
# Cora:
# nodes = 2708 papers
# edges = citations
# features per node = 1433
# classes = 7Carregamento por meio do Planetoid
O PyTorch Geometric fornece o Cora por meio do carregador Planetoid, que baixa e formata os dados em um único objeto de grafo.
from torch_geometric.datasets import Planetoid
dataset = Planetoid(root="data/Cora", name="Cora")
data = dataset[0]
print(data) # x, edge_index, y, train_mask, test_maskO objeto de dados
O objeto de grafo contém tudo: data.x (atributos 2708 x 1433), data.edge_index (conectividade), data.y (rótulos verdadeiros) e máscaras booleanas que indicam quais nós são usados para treinamento, validação e teste.
Uma GCN para 7 classes
Construímos uma GCN de 2 camadas que mapeia os 1433 atributos de entrada por meio de uma camada oculta de 64 dimensões até os logits de 7 classes.
import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
class GCN(torch.nn.Module):
def __init__(self):
super().__init__()
self.conv1 = GCNConv(1433, 64)
self.conv2 = GCNConv(64, 7)
def forward(self, x, edge_index):
x = F.relu(self.conv1(x, edge_index))
x = F.dropout(x, training=self.training)
return self.conv2(x, edge_index)Aprendizado transdutivo
O Cora é transdutivo: o grafo inteiro (incluindo os nós de teste e seus atributos) fica visível durante o treinamento; ocultamos apenas os rótulos dos nós de teste. O modelo usa todas as conexões dos nós, mas aprende somente com os nós de treinamento rotulados.
A train_mask
A train_mask é um vetor booleano que seleciona quais nós contribuem para a perda. Executamos o modelo no grafo inteiro, mas calculamos a entropia cruzada apenas nos nós de treinamento selecionados pela máscara.
model = GCN()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
def train():
model.train()
optimizer.zero_grad()
out = model(data.x, data.edge_index)
loss = F.cross_entropy(out[data.train_mask], data.y[data.train_mask])
loss.backward()
optimizer.step()
return loss.item()Intuição sobre a perda mascarada
Embora a passagem forward produza logits para todos os 2708 nós, o uso de train_mask como índice restringe a perda aos nós de treinamento rotulados. Os nós não rotulados ainda propagam mensagens, ajudando o modelo, mas não determinam diretamente o gradiente.
Avaliação com test_mask
Após o treinamento, avaliamos a precisão nos nós selecionados por test_mask, que nunca foram considerados pela perda. Isso mede a capacidade de generalização para artigos cujos rótulos o modelo nunca viu.
@torch.no_grad()
def test():
model.eval()
pred = model(data.x, data.edge_index).argmax(dim=1)
correct = (pred[data.test_mask] == data.y[data.test_mask]).sum()
return int(correct) / int(data.test_mask.sum())Visualizando representações vetoriais com t-SNE
Para ver o que a GCN aprendeu, extraia as representações vetoriais dos nós da camada oculta e projete-as em 2D com t-SNE. Uma GCN bem treinada produz agrupamentos nos quais os nós da mesma classe ficam juntos.
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
emb = model.conv1(data.x, data.edge_index).detach().numpy()
z = TSNE(n_components=2).fit_transform(emb)
plt.scatter(z[:, 0], z[:, 1], c=data.y, cmap="tab10", s=8)Interpretando o gráfico t-SNE
Agrupamentos coloridos bem separados indicam que as representações vetoriais distinguem as classes, um sinal de que a GCN aprendeu uma estrutura útil. Blocos sobrepostos sugerem treinamento insuficiente ou suavização excessiva. t-SNE é uma verificação qualitativa, não uma métrica.
Verificação rápida
Teste seus conhecimentos sobre classificação de nós.
Revisão
Você aprendeu classificação de nós com uma GNN:
- O Planetoid carrega o grafo de citações Cora
- Uma GCN de 2 camadas mapeia 1433 para 64 e depois para 7 classes
- train_mask restringe a perda; test_mask mede a generalização
- t-SNE visualiza as representações vetoriais dos nós para examinar a separação entre classes
Perguntas Frequentes
A aula “Classificação de nós com GNN” é grátis?
Sim — o texto completo de “Classificação de nós com GNN” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn AI with Python, atualize para CoddyKit PRO. O curso de Learn AI with Python inclui 4 aulas no total.
O que vou aprender em “Classificação de nós com GNN”?
Conjunto de dados Cora, GCN de 2 camadas, ciclo de treinamento, perda mascarada, precisão no teste e visualização de embeddings. Você pratica Learn AI with Python com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Learn AI with Python?
Nenhuma experiência prévia é necessária. Learn AI with Python no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Classificação de nós com GNN”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Learn AI with Python?
Sim. Cada aula de Learn AI with Python inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Teoria dos grafos para aprendizado de máquina
- Redes convolucionais de grafos (GCN)
- Classificação de nós com GNN
- Previsão de links e classificação de grafos