Aanbevelingen op maat
Op deze pagina
Doelstellingen
- Een aanbevelingssysteem bouwen op basis van embeddings
- Content-based en user-based aanbevelingen implementeren
- Omgaan met het cold start-probleem en diversiteit
Het principe: gelijkenis is aanbeveling
Een klassieke aanbevelingsengine observeert gedrag: “Mensen die dit artikel lazen, lazen ook dat.” Er is veel verkeer nodig voordat er iets zinnigs gezegd kan worden—dit is het cold start-probleem, dat zowel nieuwe catalogi treft als artikelen die vanochtend zijn gepubliceerd.
De embeddings-aanpak slaat dit wachten over. Als een gebruiker een artikel leuk vond, beveelt u de artikelen aan met de dichtstbijzijnde embeddings. Dit is content-based aanbeveling: het vertrouwt op de inhoud, niet op het gedrag van andere gebruikers. Een artikel dat tien minuten geleden is gepubliceerd en dat nog door geen enkele lezer is geopend, heeft al een embedding en wordt direct aanbevolen.
Content-based aanbeveling
De onderstaande catalogus mengt bewust twee werelden—machine learning aan de ene kant, software engineering aan de andere—zodat de resultaten verifieerbaar zijn. Elk artikel wordt gecodeerd door de titel en de inhoud samen te voegen: de titel vat het onderwerp kort samen, de inhoud levert de vocabulaire, en het gebruik van het een zonder het ander verslechtert de kwaliteit van de gevonden buren.
De truc zit in de regel scores[idx] = -1. Zonder deze regel zou het artikel dat het meest lijkt op een artikel altijd het artikel zelf zijn, met een score van 1,0—en u zou een lezer aanbevelen wat hij zojuist heeft gelezen.
from openai import OpenAI
import numpy as np
client = OpenAI()
# Article catalog
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..."},
]
# Index the catalog
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]:
"""Recommends the k most similar articles."""
idx = next(i for i, a in enumerate(articles) if a["id"] == article_id)
article_emb = catalogue_embs[idx]
# Similarity with all other articles
scores = catalogue_embs @ article_emb
scores[idx] = -1 # Exclude the article itself
top_k = np.argsort(scores)[-k:][::-1]
return [
{"article": articles[i], "score": float(scores[i])}
for i in top_k
]
# A user reads "Introduction to ML"
recos = recommander_similaires("a1", k=3)
print("You read: Introduction au machine learning")
print("Recommendations:")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Gebruikersprofiel op basis van geschiedenis
Aanbevelen op basis van één enkel artikel sluit de lezer snel op. Om rekening te houden met hun volledige reis, bouwt u een profielvector door de embeddings van de bekeken artikelen te combineren: dit gemiddelde punt vertegenwoordigt hun interesses in dezelfde ruimte als de catalogus, en u zoekt vervolgens naar de artikelen die het dichtst bij dit punt liggen.
Lezingen van zes maanden geleden moeten echter niet even zwaar wegen als die van gisteren. Recency weighting lost dit op: de factor 0.5 ** (n - 1 - i) halveert het gewicht bij elke stap terug in de geschiedenis. Een lezer die lang machine learning heeft gevolgd maar onlangs is overgestapt op API’s, zal zien dat zijn aanbevelingen binnen een paar artikelen verschuiven in plaats van bevroren te blijven. De uiteindelijke normalisatie brengt het profiel terug naar de eenheidsbol, een voorwaarde zodat het dot-product met de catalogus een juiste cosinusgelijkenis is.
def creer_profil_utilisateur(
articles_consultes: list[str],
poids_recency: bool = True
) -> np.ndarray:
"""Creates a profile vector from history."""
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:
# Recent articles count more
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)
# Normalize
profil /= np.linalg.norm(profil)
return profil
def recommander_pour_utilisateur(
articles_consultes: list[str],
k: int = 3
) -> list[dict]:
"""Recommends articles based on the user profile."""
profil = creer_profil_utilisateur(articles_consultes)
scores = catalogue_embs @ profil
# Exclude already viewed articles
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
]
# User who read ML and deep learning
recos = recommander_pour_utilisateur(["a1", "a2"], k=3)
print("History: ML + PyTorch")
print("Recommendations:")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Aanbeveling met tekstquery
Het gedragsprofiel negeert één ding dat de gebruiker beter weet dan u: wat hij vandaag zoekt. Omdat de catalogus al is gecodeerd, hoeft u alleen een vrije tekstzin te coderen om dezelfde ruimte te bevragen. “Ik wil leren hoe ik API’s moet maken” haalt het FastAPI-artikel naar boven, zelfs als de geschiedenis van de lezer alleen machine learning bevat. Dit is ook de enige optie beschikbaar voor een bezoeker waarvan u niets weet.
def recommander_par_interet(
description: str,
k: int = 3
) -> list[dict]:
"""Recommends articles based on an interest description."""
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
]
# "I want to learn how to create APIs"
recos = recommander_par_interet("créer des APIs web en Python")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Aanbevelingen diversifiëren
Sorteren op pure gelijkenis produceert een zichtbaar gebrek in productie: de vijf aanbevelingen lijken op elkaar. Een lezer van het CNN-artikel krijgt vijf varianten van computer vision, terwijl de tweede of derde suggestie de deur naar transformers had kunnen openen.
MMR (Maximal Marginal Relevance) lost dit op door artikelen één voor één te selecteren: bij elke beurt kiest het degene die de relevantie voor de query maximaliseert, minus de maximale redundantie met wat al is geselecteerd. De lambda_param stelt de afweging in—bij 1,0 krijgt u klassieke sortering, bij 0,5 begunstigt u variatie sterk, en de standaardwaarde van 0,7 geeft een relevante lijst die ademt.
def recommander_divers(
query_emb: np.ndarray,
k: int = 5,
lambda_param: float = 0.7
) -> list[int]:
"""MMR: balances relevance and diversity."""
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:
# Relevance
pertinence = scores[idx]
# Max redundancy with already selected
if selectionnes:
sims_selectionnes = [
float(np.dot(catalogue_embs[idx], catalogue_embs[s]))
for s in selectionnes
]
redondance = max(sims_selectionnes)
else:
redondance = 0
# MMR Score
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
Belangrijkste punten
- Embeddings maken aanbeveling mogelijk op basis van inhoudelijke gelijkenis
- Het gebruikersprofiel wordt opgebouwd door het gemiddelde van bekeken embeddings
- Recency weighting geeft meer gewicht aan recente views
- MMR diversifieert aanbevelingen door redundantie te bestraffen