Classification de nœuds avec les GNN
Jeu de données Cora, GCN à deux couches, boucle d’entraînement, perte masquée, précision sur les tests, visualisation des plongements.
Classification de nœuds avec les GNN est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.
La tâche de classification des nœuds
La classification des nœuds consiste à prédire une étiquette pour chaque nœud à partir de ses caractéristiques et de la structure du graphe. Exemple classique : attribuer à chaque article d’un réseau de citations une étiquette correspondant à son sujet de recherche, en utilisant à la fois les mots de l’article et les articles qu’il cite.
Le jeu de données Cora
Cora est le MNIST de l’apprentissage sur les graphes. Il s’agit d’un graphe de citations contenant 2 708 articles d’apprentissage automatique. Les arêtes représentent les citations ; chaque article possède un vecteur de caractéristiques basé sur un sac de mots, de longueur 1433 ; l’objectif est de classer chaque article dans l’un des 7 sujets.
# Cora:
# nodes = 2708 papers
# edges = citations
# features per node = 1433
# classes = 7Chargement avec Planetoid
PyTorch Geometric fournit Cora via le chargeur Planetoid, qui télécharge les données et les met en forme dans un objet représentant un graphe unique.
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’objet de données
L’objet graphe contient tout : data.x (caractéristiques 2708 x 1433), data.edge_index (connectivité), data.y (étiquettes réelles) et des masques booléens indiquant quels nœuds sont destinés à l’entraînement, à la validation et à l’évaluation.
Un GCN pour 7 classes
Nous construisons un GCN à deux couches qui fait passer les 1433 caractéristiques d’entrée par une couche cachée de 64 dimensions, puis les réduit à 7 scores de 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)Apprentissage transductif
Cora est transductif : le graphe entier, y compris les nœuds réservés à l’évaluation et leurs caractéristiques, est visible pendant l’entraînement ; seules les étiquettes de ces nœuds sont masquées. Le modèle utilise toutes les connexions des nœuds, mais apprend uniquement à partir des nœuds d’entraînement étiquetés.
Le masque train_mask
Le train_mask est un vecteur booléen qui sélectionne les nœuds contribuant à la fonction de perte. Nous exécutons le modèle sur le graphe entier, mais calculons l’entropie croisée uniquement sur les nœuds d’entraînement sélectionnés par le masque.
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()Intuition sur la perte masquée
Bien que la propagation avant produise des scores pour les 2708 nœuds, l’indexation avec train_mask limite la perte aux nœuds d’entraînement étiquetés. Les nœuds non étiquetés continuent à transmettre des messages, ce qui aide le modèle, mais n’influencent pas directement le gradient.
Évaluation avec test_mask
Après l’entraînement, nous évaluons la précision sur les nœuds réservés à l’évaluation sélectionnés par test_mask, que la fonction de perte n’a jamais pris en compte. Cette mesure évalue la généralisation à des articles dont le modèle n’a jamais vu les étiquettes.
@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())Visualiser les représentations vectorielles avec t-SNE
Pour voir ce que le GCN a appris, prenez les représentations vectorielles des nœuds de la couche cachée et projetez-les en 2D avec t-SNE. Un GCN bien entraîné produit des groupes dans lesquels les nœuds de même classe se retrouvent ensemble.
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)Interpréter le graphique t-SNE
Des groupes colorés bien séparés signifient que les représentations vectorielles permettent de distinguer les classes, ce qui indique que le GCN a appris une structure utile. Des amas qui se chevauchent suggèrent un entraînement insuffisant ou un lissage excessif. t-SNE est une vérification qualitative, pas une mesure.
Vérification rapide
Vérifiez vos connaissances sur la classification des nœuds.
Récapitulatif
Vous avez appris la classification des nœuds avec un GNN :
- Planetoid charge le graphe de citations Cora
- Un GCN à deux couches transforme 1433 en 64 puis en 7 classes
- train_mask limite la perte ; test_mask mesure la généralisation
- t-SNE visualise les représentations vectorielles des nœuds afin d’examiner la séparation des classes
Questions Fréquemment Posées
La leçon « Classification de nœuds avec les GNN » est-elle gratuite ?
Oui — le texte complet de « Classification de nœuds avec les GNN » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Classification de nœuds avec les GNN » ?
Jeu de données Cora, GCN à deux couches, boucle d’entraînement, perte masquée, précision sur les tests, visualisation des plongements. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn AI with Python ?
Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Classification de nœuds avec les GNN » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?
Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Théorie des graphes pour l’apprentissage automatique
- Réseaux convolutifs de graphes (GCN)
- Classification de nœuds avec les GNN
- Prédiction de liens et classification de graphes