Recomandări personalizate
Pe această pagină
Obiective
- Construirea unui sistem de recomandare bazat pe embedding-uri
- Implementarea recomandărilor bazate pe conținut și pe utilizator
- Gestionarea problemei de start la rece (cold start) și a diversității
Principiul: Similaritatea înseamnă Recomandare
Un motor de recomandare clasic observă comportamentul: „Persoanele care au citit acest articol au citit și pe acela.“ Are nevoie de mult trafic înainte de a putea spune ceva util—aceasta este problema de start la rece (cold start), care afectează atât cataloagele noi, cât și articolele publicate chiar în dimineața respectivă.
Abordarea bazată pe embedding-uri sare peste această așteptare. Dacă unui utilizator i-a plăcut un articol, îi recomandați pe cele cu embedding-urile cele mai apropiate. Aceasta este recomandarea bazată pe conținut: se bazează pe conținut, nu pe comportamentul altor utilizatori. Un articol publicat acum zece minute, pe care niciun cititor nu l-a deschis încă, are deja un embedding și devine recomandabil imediat.
Recomandare bazată pe conținut
Catalogul de mai jos amestecă intenționat două lumi—machine learning pe de o parte, inginerie software pe de altă parte—astfel încât rezultatele să fie verificabile. Fiecare articol este codificat prin concatenarea titlului și a conținutului său: titlul surprinde subiectul în esență, conținutul oferă vocabularul, iar utilizarea unuia fără celălalt degradează calitatea vecinilor găsiți.
Trucul stă în linia scores[idx] = -1. Fără ea, articolul cel mai similar cu un articol ar fi întotdeauna el însuși, cu un scor de 1.0—și ați recomanda cititorului chiar ceea ce tocmai a terminat de citit.
from openai import OpenAI
import numpy as np
client = OpenAI()
# Catalog de articole
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..."},
]
# Indexarea catalogului
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]:
"""Recomandă cele mai similare k articole."""
idx = next(i for i, a in enumerate(articles) if a["id"] == article_id)
article_emb = catalogue_embs[idx]
# Similaritate cu toate celelalte articole
scores = catalogue_embs @ article_emb
scores[idx] = -1 # Excluderea articolului însuși
top_k = np.argsort(scores)[-k:][::-1]
return [
{"article": articles[i], "score": float(scores[i])}
for i in top_k
]
# Un utilizator citește „Introduction to ML“
recos = recommander_similaires("a1", k=3)
print("Ați citit: Introduction au machine learning")
print("Recomandări:")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Profilul utilizatorului din istoric
Recomandarea bazată pe un singur articol blochează rapid cititorul. Pentru a ține cont de întregul său parcurs, construiți un vector de profil combinând embedding-urile articolelor pe care le-a vizualizat: acest punct mediu reprezintă interesele sale în același spațiu ca și catalogul, iar apoi căutați articolele cele mai apropiate de acest punct.
Totuși, citirile de acum șase luni nu ar trebui să cântărească la fel de mult ca cele de ieri. Ponderarea în funcție de recentitate gestionează acest aspect: factorul 0.5 ** (n - 1 - i) înjumătățește greutatea la fiecare pas înapoi în istoric. Un cititor care a urmărit machine learning mult timp, dar a trecut recent la API-uri, își va vedea recomandările schimbându-se în câteva articole, în loc să rămână înghețate. Normalizarea finală readuce profilul pe sfera unitară, o condiție pentru ca produsul scalar cu catalogul să fie o similaritate cosinus corectă.
def creer_profil_utilisateur(
articles_consultes: list[str],
poids_recency: bool = True
) -> np.ndarray:
"""Creează un vector de profil din istoric."""
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:
# Articolele recente contează mai mult
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)
# Normalizare
profil /= np.linalg.norm(profil)
return profil
def recommander_pour_utilisateur(
articles_consultes: list[str],
k: int = 3
) -> list[dict]:
"""Recomandă articole pe baza profilului utilizatorului."""
profil = creer_profil_utilisateur(articles_consultes)
scores = catalogue_embs @ profil
# Excluderea articolelor deja vizualizate
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
]
# Utilizator care a citit ML și deep learning
recos = recommander_pour_utilisateur(["a1", "a2"], k=3)
print("Istoric: ML + PyTorch")
print("Recomandări:")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Recomandare cu interogare text
Profilul comportamental ignoră un lucru pe care utilizatorul îl știe mai bine decât dumneavoastră: ce caută astăzi. Deoarece catalogul este deja codificat, trebuie doar să codificați o frază în text liber pentru a interoga același spațiu. „Vreau să învăț cum să creez API-uri“ va afișa articolul despre FastAPI, chiar dacă istoricul cititorului conține doar machine learning. Aceasta este, de asemenea, singura opțiune disponibilă pentru un vizitator despre care nu știți nimic.
def recommander_par_interet(
description: str,
k: int = 3
) -> list[dict]:
"""Recomandă articole pe baza unei descrieri a intereselor."""
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
]
# „Vreau să învăț cum să creez API-uri“
recos = recommander_par_interet("créer des APIs web en Python")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Diversificarea recomandărilor
Sortarea prin similaritate pură produce un defect vizibil în producție: cele cinci recomandări seamănă între ele. Un cititor al articolului despre CNN primește cinci variante de computer vision, când a doua sau a treia sugestie ar fi putut deschide ușa către transformers.
MMR (Maximal Marginal Relevance) remediază acest lucru selectând articolele unul câte unul: la fiecare tur, îl alege pe cel care maximizează relevanța față de interogare, minus redundanța maximă cu ceea ce este deja selectat. Parametrul lambda_param stabilește compromisul—la 1.0 obțineți sortarea clasică, la 0.5 favorizați puternic varietatea, iar valoarea implicită de 0.7 oferă o listă relevantă care „respiră“.
def recommander_divers(
query_emb: np.ndarray,
k: int = 5,
lambda_param: float = 0.7
) -> list[int]:
"""MMR: echilibrează relevanța și diversitatea."""
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:
# Relevanță
pertinence = scores[idx]
# Redundanță maximă cu cele deja selectate
if selectionnes:
sims_selectionnes = [
float(np.dot(catalogue_embs[idx], catalogue_embs[s]))
for s in selectionnes
]
redondance = max(sims_selectionnes)
else:
redondance = 0
# Scor 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
Puncte cheie
- Embedding-urile permit recomandarea prin similaritate de conținut
- Profilul utilizatorului este construit prin medierea embedding-urilor vizualizate
- Ponderarea în funcție de recentitate acordă mai multă greutate vizualizărilor recente
- MMR diversifică recomandările prin penalizarea redundanței