Ir al contenido principal
Español— Elegir un idioma
Menú

Recomendaciones personalizadas

Lección 19 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Objetivos
  2. El principio: similitud equivale a recomendación
  3. Recomendación basada en contenido
  4. Perfil de usuario a partir del historial
  5. Recomendación con consulta de texto
  6. Diversificar las recomendaciones
  7. Resumen

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