Image for post Redes Neuronales Gráficas (GNNs) para Sistemas de Recomendación: Implementación Práctica con PyTorch Geometric

Redes Neuronales Gráficas (GNNs) para Sistemas de Recomendación: Implementación Práctica con PyTorch Geometric

Escrito por Sergio Márquez

Contexto del Problema: Más Allá de las Recomendaciones Tradicionales

Los sistemas de recomendación son el motor invisible de gran parte de nuestra experiencia digital, desde sugerencias de películas en Netflix hasta productos en Amazon o conexiones en LinkedIn. Tradicionalmente, estos sistemas se han basado en métodos como el filtrado colaborativo (analizando el comportamiento de usuarios similares) o el filtrado basado en contenido (recomendando ítems con atributos similares). Si bien son efectivos, estos enfoques a menudo luchan con la complejidad inherente de las interacciones del mundo real, que son inherentemente relacionales y a menudo no lineales. [6]

Imagina una red donde los usuarios y los ítems son nodos, y sus interacciones (compras, valoraciones, clics) son aristas. Esta estructura es, por definición, un grafo. Los métodos tradicionales a menudo simplifican esta estructura o la aplanan, perdiendo información valiosa sobre las relaciones de alto orden y las dependencias complejas. Aquí es donde las Redes Neuronales Gráficas (GNNs) entran en juego. [6]

Las GNNs están diseñadas para operar directamente sobre datos estructurados como grafos, permitiendo capturar y explotar las relaciones explícitas e implícitas entre entidades. Al modelar usuarios, ítems y sus interacciones como un grafo, las GNNs pueden aprender representaciones (embeddings) ricas que codifican tanto las características de los nodos individuales como la estructura de la red en la que están inmersos. Esto conduce a recomendaciones más precisas, personalizadas y, en muchos casos, más diversas, aliviando problemas como la escasez de datos (sparsity) y el problema del 'cold-start' para nuevos usuarios o ítems. [13, 14, 16]

Fundamento Teórico: Entendiendo los Grafos y las GNNs

¿Qué es un Grafo?

Un grafo es una estructura de datos no lineal que consiste en un conjunto de nodos (o vértices) y un conjunto de aristas (o enlaces) que conectan pares de nodos. Los grafos pueden ser:

  • Dirigidos o No Dirigidos: Las aristas pueden tener una dirección (A a B) o ser bidireccionales (A y B están conectados).
  • Ponderados o No Ponderados: Las aristas pueden tener un valor asociado (ej. la fuerza de una amistad, la valoración de un producto).
  • Homogéneos o Heterogéneos: Todos los nodos y aristas son del mismo tipo (ej. solo productos y relaciones de co-compra) o de diferentes tipos (ej. usuarios, productos, categorías, y diferentes tipos de interacciones). [1, 3]

En el contexto de los sistemas de recomendación, un grafo común es el grafo bipartito usuario-ítem, donde un conjunto de nodos representa a los usuarios y otro conjunto representa a los ítems, y las aristas conectan a un usuario con un ítem con el que ha interactuado. [17, 18]

El Concepto de las Redes Neuronales Gráficas (GNNs)

Las GNNs son una clase de redes neuronales que operan directamente sobre la estructura de un grafo. A diferencia de las CNNs (para datos de cuadrícula como imágenes) o las RNNs (para datos secuenciales como texto), las GNNs están diseñadas para manejar la topología arbitraria de los grafos. [18]

El principio fundamental de las GNNs es el paso de mensajes (message passing) o agregación de información. En cada capa de una GNN, cada nodo agrega información de sus vecinos y de sí mismo para actualizar su propia representación (embedding). Este proceso se repite en múltiples capas, permitiendo que la información se propague a través de todo el grafo, capturando dependencias locales y globales. [6, 13]

Las GNNs aprenden a generar embeddings para los nodos (y opcionalmente para las aristas o el grafo completo) que capturan su posición en la red y las características de sus vecinos. Estos embeddings pueden luego ser utilizados para diversas tareas, como:

  • Clasificación de Nodos: Predecir la categoría de un nodo.
  • Predicción de Enlaces (Link Prediction): Predecir si una arista debería existir entre dos nodos (fundamental para recomendación). [1, 2, 3, 9]
  • Clasificación de Grafos: Predecir la categoría de un grafo completo.

Arquitecturas Comunes de GNNs para Recomendación

Existen varias arquitecturas de GNNs, cada una con sus particularidades en cómo agregan y transforman los mensajes. Algunas de las más relevantes para sistemas de recomendación incluyen:

  • Graph Convolutional Networks (GCNs): Una de las arquitecturas pioneras, que generaliza las convoluciones a los grafos. Agregan las características de los vecinos y las transforman linealmente. [1, 5, 6]
  • GraphSAGE: Permite el muestreo de vecinos para escalar a grafos grandes y utiliza diferentes funciones de agregación (media, suma, LSTM, max-pooling). [6, 13]
  • Graph Attention Networks (GATs): Introducen un mecanismo de atención que permite a los nodos asignar diferentes pesos a sus vecinos durante la agregación, capturando la importancia relativa de cada conexión. [6, 11]
  • LightGCN: Una simplificación de GCNs específicamente diseñada para sistemas de recomendación, que elimina transformaciones no lineales y utiliza solo la propagación de embeddings para aprender representaciones de usuario e ítem. [5, 15]

Implementación Práctica: Construyendo un Recomendador con PyTorch Geometric

Vamos a implementar un sistema de recomendación básico utilizando PyTorch Geometric (PyG), una extensión de PyTorch para GNNs. Nos centraremos en la tarea de predicción de enlaces en un grafo bipartito usuario-ítem, donde el objetivo es predecir si un usuario interactuará con un ítem que aún no ha visto. [2, 3]

Configuración del Entorno

Primero, necesitamos instalar las librerías necesarias:

pip install torch torch_geometric

Preparación de Datos: Grafo Usuario-Ítem

Para este ejemplo, simularemos un pequeño dataset de interacciones usuario-ítem. En un escenario real, usarías datasets como MovieLens. [5, 8]

import torch
from torch_geometric.data import Data
from torch_geometric.nn import GCNConv
from torch_geometric.utils import train_test_split_edges
import torch.nn.functional as F

# Datos de ejemplo: Usuario-Ítem interacciones (aristas)
# (usuario_id, item_id)
# Suponemos 5 usuarios y 4 ítems
edges = torch.tensor([
    [0, 5], [0, 6], [0, 7], # Usuario 0 interactúa con ítems 5, 6, 7
    [1, 5], [1, 6],         # Usuario 1 interactúa con ítems 5, 6
    [2, 6], [2, 7], [2, 8], # Usuario 2 interactúa con ítems 6, 7, 8
    [3, 5], [3, 8],         # Usuario 3 interactúa con ítems 5, 8
    [4, 7], [4, 8]          # Usuario 4 interactúa con ítems 7, 8
], dtype=torch.long).t().contiguous()

# Mapeo de IDs para que los ítems comiencen después de los usuarios
# Usuarios: 0, 1, 2, 3, 4
# Ítems: 5, 6, 7, 8
num_users = 5
num_items = 4
num_nodes = num_users + num_items # Total de nodos en el grafo

# Características de los nodos (embeddings iniciales o features)
# Para simplicidad, usaremos embeddings aleatorios. En la realidad, podrían ser one-hot, atributos, etc.
x = torch.randn(num_nodes, 16) # 16 es la dimensión del embedding

# Crear el objeto Data de PyTorch Geometric
data = Data(x=x, edge_index=edges)

print(f"Número de nodos: {data.num_nodes}")
print(f"Número de aristas: {data.num_edges}")
print(f"Características de los nodos: {data.x.shape}")
print(f"Índices de las aristas: {data.edge_index.shape}")

# Dividir el grafo en conjuntos de entrenamiento, validación y prueba para la predicción de enlaces
# Esto crea 'positive' y 'negative' edges para cada conjunto.
# PyG tiene una utilidad para esto: train_test_split_edges
# Nota: Esto es para la tarea de link prediction, no para node classification.
data = train_test_split_edges(data, val_ratio=0.1, test_ratio=0.2)

print(f"Aristas de entrenamiento (positivas): {data.train_pos_edge_index.shape}")
print(f"Aristas de validación (positivas): {data.val_pos_edge_index.shape}")
print(f"Aristas de validación (negativas): {data.val_neg_edge_index.shape}")
print(f"Aristas de prueba (positivas): {data.test_pos_edge_index.shape}")
print(f"Aristas de prueba (negativas): {data.test_neg_edge_index.shape}")

Definición del Modelo GNN para Predicción de Enlaces

Usaremos una GCN simple y un decodificador para predecir la probabilidad de un enlace. El decodificador tomará los embeddings de los nodos y calculará una similitud (ej. producto punto) para predecir la existencia de un enlace. [1, 9]

class GCNLinkPredictor(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super(GCNLinkPredictor, self).__init__()
        self.conv1 = GCNConv(in_channels, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, out_channels)

    def encode(self, x, edge_index):
        # Propagación de mensajes para obtener embeddings de nodos
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.conv2(x, edge_index)
        return x

    def decode(self, z, edge_label_index):
        # Decodificador para predecir la existencia de un enlace
        # z: embeddings de los nodos
        # edge_label_index: pares de nodos para los que queremos predecir un enlace
        return (z[edge_label_index[0]] * z[edge_label_index[1]]).sum(dim=-1)

# Inicializar el modelo
model = GCNLinkPredictor(in_channels=data.num_node_features, hidden_channels=32, out_channels=16)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

print(model)

Proceso de Entrenamiento y Evaluación

El entrenamiento de un modelo de predicción de enlaces implica alimentar el modelo con aristas positivas (existentes) y aristas negativas (no existentes) y optimizar una función de pérdida binaria (ej. BCEWithLogitsLoss). [1]

def train():
    model.train()
    optimizer.zero_grad()

    # Codificar los nodos usando solo las aristas de entrenamiento positivas
    z = model.encode(data.x, data.train_pos_edge_index)

    # Combinar aristas positivas y negativas para el entrenamiento
    # PyG ya generó aristas negativas en data.train_neg_edge_index
    # Para el entrenamiento, necesitamos un conjunto balanceado de positivas y negativas.
    # train_test_split_edges ya maneja esto internamente para el 'edge_label_index' y 'edge_label'
    # que se usan en el 'decode'.
    # Sin embargo, para este ejemplo simple, vamos a construirlo manualmente para claridad.
    
    # Aristas positivas de entrenamiento
    pos_train_edge_label_index = data.train_pos_edge_index
    pos_train_edge_label = torch.ones(pos_train_edge_label_index.shape[1])

    # Generar aristas negativas para el entrenamiento (si no están ya en data.train_neg_edge_index)
    # Para este ejemplo, usaremos las que PyG ya generó para el conjunto de validación/prueba
    # En un escenario real, generarías negativas dinámicamente o usarías las pre-generadas para entrenamiento.
    # Aquí, para simplificar, usaremos un subconjunto de las negativas de validación/prueba como ejemplo.
    # NOTA: En un caso real, data.train_neg_edge_index sería el apropiado si train_test_split_edges lo generara.
    # Para este ejemplo, asumiremos que train_test_split_edges solo genera neg_edges para val/test.
    # Si no, deberíamos generar nuestras propias negativas para entrenamiento o usar un DataLoader específico.
    
    # Para este ejemplo, vamos a simular la generación de negativas para el entrenamiento
    # Esto es una simplificación; PyG tiene utilidades más robustas para esto.
    num_train_edges = data.train_pos_edge_index.shape[1]
    neg_train_edge_label_index = torch.randint(0, num_nodes, (2, num_train_edges), dtype=torch.long)
    neg_train_edge_label = torch.zeros(num_train_edges)

    # Concatenar positivas y negativas
    edge_label_index = torch.cat([pos_train_edge_label_index, neg_train_edge_label_index], dim=-1)
    edge_label = torch.cat([pos_train_edge_label, neg_train_edge_label], dim=0)

    # Decodificar y calcular la pérdida
    out = model.decode(z, edge_label_index)
    loss = F.binary_cross_entropy_with_logits(out, edge_label)

    loss.backward()
    optimizer.step()
    return loss

@torch.no_grad()
def test(edge_label_index, edge_label):
    model.eval()
    z = model.encode(data.x, data.train_pos_edge_index) # Usar aristas de entrenamiento para codificar
    out = model.decode(z, edge_label_index)
    return F.binary_cross_entropy_with_logits(out, edge_label)

# Bucle de entrenamiento
for epoch in range(1, 101):
    loss = train()
    val_loss = test(torch.cat([data.val_pos_edge_index, data.val_neg_edge_index], dim=-1),
                    torch.cat([torch.ones(data.val_pos_edge_index.shape[1]), torch.zeros(data.val_neg_edge_index.shape[1])], dim=0))
    
    if epoch % 10 == 0:
        print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}, Val Loss: {val_loss:.4f}')

# Evaluación final en el conjunto de prueba
# Para una evaluación más robusta, se usarían métricas como AUC, Precision@K, Recall@K
# Aquí, solo la pérdida BCE para simplicidad.

test_loss = test(torch.cat([data.test_pos_edge_index, data.test_neg_edge_index], dim=-1),
                 torch.cat([torch.ones(data.test_pos_edge_index.shape[1]), torch.zeros(data.test_neg_edge_index.shape[1])], dim=0))
print(f'Test Loss: {test_loss:.4f}')

# Generar recomendaciones para un usuario específico (ej. Usuario 0)
user_id = 0
# Obtener el embedding del usuario 0
user_embedding = model.encode(data.x, data.train_pos_edge_index)[user_id]

# Generar pares de usuario 0 con todos los ítems posibles
all_item_ids = torch.arange(num_users, num_nodes) # IDs de los ítems
user_item_pairs = torch.stack([torch.full_like(all_item_ids, user_id), all_item_ids], dim=0)

# Predecir puntuaciones para estos pares
with torch.no_grad():
    scores = model.decode(model.encode(data.x, data.train_pos_edge_index), user_item_pairs)

# Ordenar ítems por puntuación y obtener los top-N
top_n = 2
recommended_item_indices = torch.topk(scores, top_n).indices
recommended_item_ids = all_item_ids[recommended_item_indices]

print(f"\nTop {top_n} ítems recomendados para el Usuario {user_id}: {recommended_item_ids.tolist()}")

Aplicaciones Reales: Dónde y Cómo Usar GNNs en Recomendación

Las GNNs están siendo adoptadas en la industria para potenciar sistemas de recomendación en diversos dominios:

  • E-commerce: Amazon utiliza GNNs para recomendar productos relacionados, manejando la asimetría de las relaciones (ej. recomendar una funda para un teléfono, pero no un teléfono para una funda). [10]
  • Streaming de Contenido: Netflix, YouTube y Spotify emplean GNNs para sugerir películas, videos y música, modelando las interacciones usuario-contenido y las relaciones entre contenidos. [2, 5]
  • Redes Sociales: Para sugerir nuevas conexiones de amistad o contenido relevante en plataformas como Facebook o LinkedIn. [9]
  • Noticias y Artículos: Personalización de feeds de noticias basada en los intereses del usuario y las relaciones entre artículos.
  • Detección de Fraude: Aunque no es directamente recomendación, la predicción de enlaces en grafos de transacciones o usuarios puede identificar patrones anómalos que sugieren fraude.
  • Recomendación de Puntos de Interés (POI): Sugerir lugares o actividades basadas en la ubicación y el comportamiento de otros usuarios. [16]

La capacidad de las GNNs para capturar dependencias complejas y propagar información a través de múltiples saltos en el grafo las hace ideales para escenarios donde las relaciones son tan importantes como los atributos individuales. [14, 16]

Mejores Prácticas y Consideraciones en Producción

Desplegar GNNs en producción presenta desafíos únicos, especialmente con grafos a gran escala. [4, 12]

  • Escalabilidad: Los grafos del mundo real pueden tener miles de millones de nodos y aristas. Técnicas como el muestreo de grafos (graph sampling) (ej. Neighbor Sampling en GraphSAGE), el entrenamiento distribuido y el uso de bases de datos de grafos distribuidas son cruciales para manejar la memoria y la computación. [4, 12, 18]
  • Manejo del Cold-Start: Las GNNs pueden mitigar el problema del cold-start al incorporar características de nodos (atributos de nuevos usuarios/ítems) y aprovechar las conexiones existentes, incluso si son pocas. La inicialización inteligente de embeddings para nuevos nodos es clave. [10, 13, 14]
  • Representación de Características de Nodos y Aristas: La calidad de los embeddings iniciales de los nodos (x en nuestro ejemplo) es vital. Pueden ser características de texto (con LLMs), imágenes (con CNNs), o atributos categóricos/numéricos. Las aristas también pueden tener características (ej. tipo de interacción, rating) que pueden ser incorporadas en el proceso de paso de mensajes. [1, 3, 13]
  • Elección de la Arquitectura GNN: La mejor arquitectura depende del problema. LightGCN es popular para recomendación por su simplicidad y eficiencia, mientras que GATs pueden ser mejores si la importancia de las conexiones varía. [5, 6, 11]
  • Generación de Negativos: Para la predicción de enlaces, la generación de muestras negativas (aristas que no existen) es fundamental. Esto puede hacerse de forma aleatoria o más sofisticada (ej. muestreo negativo basado en popularidad). [1]
  • Métricas de Evaluación: Más allá de la pérdida binaria, métricas como AUC (Area Under the Curve), Precision@K, Recall@K, y MRR (Mean Reciprocal Rank) son esenciales para evaluar la calidad de las recomendaciones. [10, 5]
  • Inferencias en Tiempo Real: Para inferencia en producción, a menudo se precomputan los embeddings de los nodos o se utilizan sistemas de recuperación eficientes que pueden consultar los embeddings y realizar la predicción de enlaces rápidamente. [4]

Aprendizaje Futuro y Próximos Pasos

El campo de las GNNs para sistemas de recomendación está en constante evolución. Algunos temas avanzados a explorar incluyen:

  • GNNs Temporales y Dinámicas: Modelar cómo los grafos y las interacciones cambian con el tiempo para capturar preferencias dinámicas del usuario. [14, 17]
  • GNNs Heterogéneas: Trabajar con grafos que tienen múltiples tipos de nodos y aristas, lo que es común en sistemas de recomendación complejos (ej. usuarios, ítems, categorías, marcas, etc.). [1, 3, 11]
  • GNNs con Knowledge Graphs: Integrar grafos de conocimiento para enriquecer las representaciones de ítems y usuarios con información semántica. [11, 14]
  • Autoencoders Gráficos y Variacionales (GAE/VGAE): Utilizar autoencoders para aprender embeddings de grafos y reconstruir la estructura del grafo, lo que puede ser útil para la predicción de enlaces. [15]
  • GNNs y LLMs: La combinación de GNNs con Large Language Models para enriquecer las características de los nodos con información textual o para generar recomendaciones explicables. [12]

Para profundizar, se recomienda explorar los datasets de referencia como MovieLens, implementar arquitecturas GNN más complejas como LightGCN o GraphSAGE, y experimentar con diferentes estrategias de muestreo y optimización. Las librerías como PyTorch Geometric y DGL ofrecen excelentes recursos y ejemplos para continuar este viaje.

Volver al blog