Clasificación de nodos con GNN
Dataset Cora, GCN de 2 capas, bucle de entrenamiento, pérdida con máscara, precisión de prueba y visualización de embeddings.
Clasificación de nodos con GNN es una lección gratuita de Learn AI with Python en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn AI with Python, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn AI with Python incluye 4 lecciones en total.
La tarea de clasificación de nodos
La clasificación de nodos predice una etiqueta para cada nodo usando sus características y la estructura del grafo. Un ejemplo clásico es etiquetar cada artículo de una red de citas según su tema de investigación, usando tanto las palabras del artículo como los artículos que cita.
El conjunto de datos Cora
Cora es el MNIST del aprendizaje sobre grafos. Es un grafo de citas formado por 2708 artículos de aprendizaje automático. Las aristas son citas; cada artículo tiene un vector de características de bolsa de palabras de longitud 1433; el objetivo es clasificar cada artículo en uno de 7 temas.
# Cora:
# nodes = 2708 papers
# edges = citations
# features per node = 1433
# classes = 7Carga mediante Planetoid
PyTorch Geometric incluye Cora mediante el cargador Planetoid, que descarga y da formato a los datos en un ú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_maskEl objeto Data
El objeto de grafo contiene todo: data.x (características de 2708 x 1433), data.edge_index (conectividad), data.y (etiquetas verdaderas) y máscaras booleanas que indican qué nodos se destinan al entrenamiento, la validación y las pruebas.
Una GCN para 7 clases
Construimos una GCN de 2 capas que transforma las 1433 características de entrada mediante una capa oculta de 64 dimensiones hasta obtener los logits de 7 clases.
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)Aprendizaje transductivo
Cora es transductivo: durante el entrenamiento se puede ver el grafo completo (incluidos los nodos de prueba y sus características); solo ocultamos las etiquetas de prueba. El modelo utiliza todas las conexiones entre nodos, pero aprende únicamente de los nodos de entrenamiento etiquetados.
La train_mask
train_mask es un vector booleano que selecciona qué nodos contribuyen a la pérdida. Ejecutamos el modelo sobre el grafo completo, pero calculamos la entropía cruzada únicamente sobre los nodos de entrenamiento indicados por la 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()Intuición de la pérdida con máscara
Aunque el paso hacia delante produce logits para los 2708 nodos, la indexación con train_mask restringe la pérdida a los nodos de entrenamiento etiquetados. Los nodos sin etiqueta siguen transmitiendo mensajes, lo que ayuda al modelo, pero no impulsan directamente el gradiente.
Evaluación con test_mask
Después del entrenamiento, evaluamos la precisión en los nodos indicados por test_mask, que nunca participaron en el cálculo de la pérdida. Esto mide la generalización a artículos cuyas etiquetas el modelo nunca vio.
@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())Visualización de representaciones vectoriales con t-SNE
Para observar lo que ha aprendido la GCN, tome las representaciones vectoriales de los nodos de la capa oculta y proyéctelas en 2D con t-SNE. Una GCN bien entrenada produce agrupaciones en las que los nodos de la misma clase aparecen 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)Interpretación del gráfico t-SNE
Las agrupaciones de colores bien separadas indican que las representaciones vectoriales distinguen las clases, una señal de que la GCN ha aprendido una estructura útil. Las masas superpuestas sugieren un entrenamiento insuficiente o sobre-suavizado. t-SNE es una comprobación cualitativa, no una métrica.
Comprobación rápida
Ponga a prueba sus conocimientos sobre clasificación de nodos.
Resumen
Ha aprendido sobre la clasificación de nodos con una GNN:
- Planetoid carga el grafo de citas Cora
- Una GCN de 2 capas transforma 1433 en 64 y después en 7 clases
- train_mask restringe la pérdida; test_mask mide la generalización
- t-SNE visualiza las representaciones vectoriales de los nodos para examinar la separación entre clases
Preguntas frecuentes
¿La lección «Clasificación de nodos con GNN» es gratis?
Sí — el texto completo de «Clasificación de nodos con GNN» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn AI with Python, actualiza a CoddyKit PRO. El curso de Learn AI with Python incluye 4 lecciones en total.
¿Qué aprenderé en «Clasificación de nodos con GNN»?
Dataset Cora, GCN de 2 capas, bucle de entrenamiento, pérdida con máscara, precisión de prueba y visualización de embeddings. Practicas Learn AI with Python con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Learn AI with Python?
No se requiere experiencia previa. Learn AI with Python en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Clasificación de nodos con GNN»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Learn AI with Python?
Sí. Cada lección de Learn AI with Python incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Teoría de grafos para aprendizaje automático
- Redes convolucionales de grafos (GCN)
- Clasificación de nodos con GNN
- Predicción de enlaces y clasificación de grafos