Classificazione dei nodi con le GNN
Dataset Cora, GCN a 2 layer, ciclo di addestramento, loss con maschera, accuratezza sul test, visualizzazione degli embedding
Classificazione dei nodi con le GNN è una lezione Learn AI with Python gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn AI with Python, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn AI with Python include 4 lezioni in totale.
Il compito di classificazione dei nodi
La classificazione dei nodi predice un'etichetta per ogni nodo usando le sue caratteristiche e la struttura del grafo. Un esempio classico consiste nell'assegnare a ogni articolo di una rete di citazioni l'argomento di ricerca, usando sia le parole dell'articolo sia gli articoli citati.
Il dataset Cora
Cora è l'MNIST dell'apprendimento sui grafi. È un grafo di citazioni composto da 2.708 articoli di machine learning. Gli archi sono citazioni; ogni articolo ha un vettore di caratteristiche bag-of-words di lunghezza 1433; l'obiettivo è classificare ogni articolo in uno dei 7 argomenti.
# Cora:
# nodes = 2708 papers
# edges = citations
# features per node = 1433
# classes = 7Caricamento tramite Planetoid
PyTorch Geometric include Cora tramite il loader Planetoid, che scarica e formatta i dati in un singolo oggetto 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_maskL'oggetto Data
L'oggetto grafo contiene tutto: data.x (caratteristiche 2708 x 1433), data.edge_index (connettività), data.y (etichette vere) e maschere booleane che indicano quali nodi sono destinati all'addestramento, alla validazione e al test.
Una GCN per 7 classi
Costruiamo una GCN a 2 livelli che trasforma le 1433 caratteristiche di input in un livello nascosto di 64 dimensioni e infine in 7 logit di classe.
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)Apprendimento transduttivo
Cora è transduttivo: durante l'addestramento è visibile l'intero grafo (compresi i nodi di test e le relative caratteristiche); nascondiamo solo le etichette dei nodi di test. Il modello usa tutte le connessioni dei nodi, ma apprende solo dai nodi di addestramento dotati di etichetta.
La train_mask
La train_mask è un vettore booleano che seleziona i nodi che contribuiscono alla loss. Eseguiamo il modello sull'intero grafo, ma calcoliamo la cross-entropy solo sui nodi di addestramento selezionati dalla maschera.
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()Intuizione sulla loss mascherata
Anche se il forward pass produce logit per tutti i 2708 nodi, l'indicizzazione con train_mask limita la loss ai nodi di addestramento dotati di etichetta. I nodi privi di etichetta continuano a trasmettere messaggi, aiutando il modello, ma non determinano direttamente il gradiente.
Valutazione con test_mask
Dopo l'addestramento, valutiamo l'accuratezza sui nodi di test_mask tenuti da parte, che non sono mai stati considerati dalla loss. Questa misura indica la capacità di generalizzazione agli articoli le cui etichette il modello non ha mai visto.
@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())Visualizzare gli embedding con t-SNE
Per vedere che cosa ha appreso la GCN, prenda gli embedding dei nodi del livello nascosto e li proietti in 2D con t-SNE. Una GCN ben addestrata produce gruppi in cui i nodi della stessa classe si trovano vicini.
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)Interpretare il grafico t-SNE
Gruppi colorati ben separati indicano che gli embedding distinguono le classi, segno che la GCN ha appreso una struttura utile. Nuvole sovrapposte suggeriscono un addestramento insufficiente o over-smoothing. t-SNE è una verifica qualitativa, non una metrica.
Verifica rapida
Verifichi le Sue conoscenze sulla classificazione dei nodi.
Riepilogo
Ha appreso la classificazione dei nodi con una GNN:
- Planetoid carica il grafo di citazioni Cora
- Una GCN a 2 livelli trasforma 1433 in 64 e poi in 7 classi
- train_mask limita la loss; test_mask misura la generalizzazione
- t-SNE visualizza gli embedding dei nodi per esaminare la separazione delle classi
Domande Frequenti
La lezione «Classificazione dei nodi con le GNN» è gratuita?
Sì — il testo completo di «Classificazione dei nodi con le GNN» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn AI with Python, passa a CoddyKit PRO. Il corso Learn AI with Python include 4 lezioni in totale.
Cosa imparerò in «Classificazione dei nodi con le GNN»?
Dataset Cora, GCN a 2 layer, ciclo di addestramento, loss con maschera, accuratezza sul test, visualizzazione degli embedding Eserciti Learn AI with Python con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn AI with Python?
Non è richiesta alcuna esperienza precedente. Learn AI with Python su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Classificazione dei nodi con le GNN»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn AI with Python?
Sì. Ogni lezione Learn AI with Python include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Teoria dei grafi per il machine learning
- Graph Convolutional Network (GCN)
- Classificazione dei nodi con le GNN
- Predizione dei link e classificazione dei grafi