Recomendaciones personalizadas
En esta página
Objetivos
- Construir un sistema de recomendación basado en embeddings
- Implementar recomendaciones basadas en contenido y en usuario
- Gestionar el arranque en frío y la diversidad
El principio: similitud equivale a recomendación
Un motor de recomendación clásico observa el comportamiento: «Las personas que leyeron este artículo también leyeron aquel». Necesita mucho tráfico antes de poder decir algo útil; este es el problema del arranque en frío, que afecta tanto a catálogos nuevos como a artículos publicados esta misma mañana.
El enfoque basado en embeddings evita esta espera. Si a un usuario le gustó un artículo, recomiendas los que tengan los embeddings más cercanos. Esto es una recomendación basada en contenido: se apoya en el contenido, no en el comportamiento de otros usuarios. Un artículo publicado hace diez minutos, que ningún lector ha abierto aún, ya tiene un embedding y se vuelve recomendable de inmediato.
Recomendación basada en contenido
El catálogo de abajo mezcla intencionadamente dos mundos: aprendizaje automático por un lado e ingeniería de software por el otro, para que los resultados sean verificables. Cada artículo se codifica concatenando su título y su contenido: el título captura el asunto en pocas palabras, el contenido aporta el vocabulario, y usar uno sin el otro degrada la calidad de los vecinos encontrados.
El truco está en la línea scores[idx] = -1. Sin ella, el artículo más similar a un artículo sería siempre él mismo, con una puntuación de 1,0, y estarías recomendando al lector justo lo que acaba de terminar.
from openai import OpenAI
import numpy as np
client = OpenAI()
# Catálogo de artículos
articles = [
{"id": "a1", "titre": "Introduction au machine learning",
"contenu": "Le ML permet aux machines d'apprendre à partir de données..."},
{"id": "a2", "titre": "Deep learning avec PyTorch",
"contenu": "PyTorch est un framework de deep learning flexible..."},
{"id": "a3", "titre": "Déployer une API REST avec FastAPI",
"contenu": "FastAPI est un framework Python pour créer des APIs..."},
{"id": "a4", "titre": "Les bases de PostgreSQL",
"contenu": "PostgreSQL est un SGBD relationnel open source..."},
{"id": "a5", "titre": "Réseaux de neurones convolutifs",
"contenu": "Les CNN sont utilisés pour la vision par ordinateur..."},
{"id": "a6", "titre": "NLP avec les transformers",
"contenu": "Les transformers ont révolutionné le traitement du langage..."},
]
# Indexar el catálogo
textes = [f"{a['titre']}. {a['contenu']}" for a in articles]
response = client.embeddings.create(
input=textes, model="text-embedding-3-large"
)
catalogue_embs = np.array(
[d.embedding for d in sorted(response.data, key=lambda x: x.index)]
)
def recommander_similaires(
article_id: str,
k: int = 3
) -> list[dict]:
"""Recomienda los k artículos más similares."""
idx = next(i for i, a in enumerate(articles) if a["id"] == article_id)
article_emb = catalogue_embs[idx]
# Similitud con todos los demás artículos
scores = catalogue_embs @ article_emb
scores[idx] = -1 # Excluir el propio artículo
top_k = np.argsort(scores)[-k:][::-1]
return [
{"article": articles[i], "score": float(scores[i])}
for i in top_k
]
# Un usuario lee "Introducción al ML"
recos = recommander_similaires("a1", k=3)
print("Has leído: Introduction au machine learning")
print("Recomendaciones:")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Perfil de usuario a partir del historial
Recomendar basándose en un solo artículo atrapa rápidamente al lector. Para tener en cuenta todo su recorrido, construyes un vector de perfil combinando los embeddings de los artículos que ha visto: este punto medio representa sus intereses en el mismo espacio que el catálogo, y luego buscas los artículos más cercanos a ese punto.
Sin embargo, las lecturas de hace seis meses no deberían pesar lo mismo que las de ayer. La ponderación por antigüedad soluciona esto: el factor 0.5 ** (n - 1 - i) reduce a la mitad el peso en cada paso hacia atrás en el historial. Un lector que siguió aprendizaje automático durante mucho tiempo pero que recientemente cambió a APIs verá cómo sus recomendaciones se desplazan en pocos artículos en lugar de quedarse congeladas. La normalización final devuelve el perfil a la esfera unidad, condición necesaria para que el producto escalar con el catálogo sea una similitud del coseno correcta.
def creer_profil_utilisateur(
articles_consultes: list[str],
poids_recency: bool = True
) -> np.ndarray:
"""Crea un vector de perfil a partir del historial."""
indices = [
i for i, a in enumerate(articles)
if a["id"] in articles_consultes
]
if not indices:
return np.zeros(catalogue_embs.shape[1])
embs = catalogue_embs[indices]
if poids_recency:
# Los artículos recientes cuentan más
n = len(indices)
poids = np.array([0.5 ** (n - 1 - i) for i in range(n)])
poids /= poids.sum()
profil = np.average(embs, axis=0, weights=poids)
else:
profil = np.mean(embs, axis=0)
# Normalizar
profil /= np.linalg.norm(profil)
return profil
def recommander_pour_utilisateur(
articles_consultes: list[str],
k: int = 3
) -> list[dict]:
"""Recomienda artículos basándose en el perfil del usuario."""
profil = creer_profil_utilisateur(articles_consultes)
scores = catalogue_embs @ profil
# Excluir artículos ya vistos
for i, a in enumerate(articles):
if a["id"] in articles_consultes:
scores[i] = -1
top_k = np.argsort(scores)[-k:][::-1]
return [
{"article": articles[i], "score": float(scores[i])}
for i in top_k
]
# Usuario que leyó ML y deep learning
recos = recommander_pour_utilisateur(["a1", "a2"], k=3)
print("Historial: ML + PyTorch")
print("Recomendaciones:")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Recomendación con consulta de texto
El perfil conductual ignora algo que el usuario conoce mejor que tú: qué busca hoy. Como el catálogo ya está codificado, solo necesitas codificar una frase en texto libre para consultar el mismo espacio. «Quiero aprender a crear APIs» hace aparecer el artículo de FastAPI, aunque el historial del lector contenga solo aprendizaje automático. Esta es también la única opción disponible para un visitante del que no sabes nada.
def recommander_par_interet(
description: str,
k: int = 3
) -> list[dict]:
"""Recomienda artículos basándose en una descripción de interés."""
query_emb = client.embeddings.create(
input=description,
model="text-embedding-3-large"
).data[0].embedding
scores = catalogue_embs @ np.array(query_emb)
top_k = np.argsort(scores)[-k:][::-1]
return [
{"article": articles[i], "score": float(scores[i])}
for i in top_k
]
# «Quiero aprender a crear APIs»
recos = recommander_par_interet("créer des APIs web en Python")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Diversificar las recomendaciones
Ordenar por similitud pura produce un defecto visible en producción: las cinco recomendaciones se parecen entre sí. Un lector del artículo sobre CNN recibe cinco variantes de visión por ordenador, cuando la segunda o tercera sugerencia podrían haber abierto la puerta a los transformers.
MMR (Maximal Marginal Relevance) soluciona esto seleccionando artículos uno a uno: en cada turno, elige el que maximiza la relevancia respecto a la consulta, menos la máxima redundancia con lo ya seleccionado. El parámetro lambda_param establece el equilibrio: en 1,0 obtienes la ordenación clásica; en 0,5 favoreces fuertemente la variedad; y el valor predeterminado de 0,7 ofrece una lista relevante que respira.
def recommander_divers(
query_emb: np.ndarray,
k: int = 5,
lambda_param: float = 0.7
) -> list[int]:
"""MMR: equilibra relevancia y diversidad."""
scores = catalogue_embs @ query_emb
candidats = list(range(len(articles)))
selectionnes = []
for _ in range(k):
if not candidats:
break
meilleur_score = -float("inf")
meilleur_idx = -1
for idx in candidats:
# Relevancia
pertinence = scores[idx]
# Máxima redundancia con los ya seleccionados
if selectionnes:
sims_selectionnes = [
float(np.dot(catalogue_embs[idx], catalogue_embs[s]))
for s in selectionnes
]
redondance = max(sims_selectionnes)
else:
redondance = 0
# Puntuación MMR
mmr_score = (
lambda_param * pertinence
- (1 - lambda_param) * redondance
)
if mmr_score > meilleur_score:
meilleur_score = mmr_score
meilleur_idx = idx
selectionnes.append(meilleur_idx)
candidats.remove(meilleur_idx)
return selectionnes
Resumen
- Los embeddings permiten recomendar por similitud de contenido
- El perfil de usuario se construye promediando los embeddings de lo visto
- La ponderación por antigüedad da más peso a las vistas recientes
- MMR diversifica las recomendaciones penalizando la redundancia