Personlige anbefalinger
På denne side
Mål
- Byg et anbefalingssystem baseret på embeddings
- Implementér indholdsbaseret og brugerbasert anbefaling
- Håndtér cold start-problemet og mangfoldighed
Princippet: Lighed er lig med anbefaling
En klassisk anbefalingsmotor observerer adfærd: „Folk, der læste denne artikel, læste også den.” Den kræver masser af trafik, før den kan sige noget brugbart – dette er cold start-problemet, som rammer både nye kataloger og artikler udgivet i morges.
Embedding-tilgangen springer denne ventetid over. Hvis en bruger kunne lide en artikel, anbefaler du dem med de tætteste embeddings. Dette er indholdsbaseret anbefaling: det hviler på indholdet, ikke på andre brugeres adfærd. En artikel udgivet for ti minutter siden, som ingen læser endnu har åbnet, har allerede et embedding og bliver straks anbefalelig.
Indholdsbaseret anbefaling
Kataloget nedenfor blander bevidst to verdener – maskinlæring på den ene side, softwareudvikling på den anden – så resultaterne er verificerbare. Hver artikel kodes ved at sammenkæde titel og indhold: titlen fanger emnet kort og godt, indholdet leverer ordforrådet, og brug af kun det ene uden det andet forringer kvaliteten af de fundne naboer.
Tricket ligger i linjen scores[idx] = -1. Uden den ville den artikel, der ligner en artikel mest, altid være sig selv med en score på 1,0 – og du ville anbefale en læser det, de lige har læst færdig.
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']}")
Brugerprofil baseret på historik
At anbefale ud fra én enkelt artikel låser hurtigt læseren fast. For at tage højde for hele deres rejse bygger du en profilvektor ved at kombinere embeddings fra de artikler, de har set: dette gennemsnitlige punkt repræsenterer deres interesser i samme rum som kataloget, og du søger derefter efter de artikler, der ligger tættest på dette punkt.
Læsninger fra for seks måneder siden bør dog ikke vægte lige så meget som gårsdagens. Vægtning efter recency håndterer dette: faktoren 0.5 ** (n - 1 - i) halverer vægten for hvert skridt tilbage i historikken. En læser, der fulgte maskinlæring i lang tid, men for nylig skiftede til API’er, vil se deres anbefalinger skifte inden for få artikler i stedet for at stå fast. Den endelige normalisering bringer profilen tilbage til enhedssfæren, hvilket er en betingelse for, at prikproduktet med kataloget bliver en korrekt cosinus-lished.
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']}")
Anbefaling med tekstforespørgsel
Den adfærdsbaserede profil ignorerer én ting, som brugeren ved bedre end dig: hvad de leder efter i dag. Da kataloget allerede er kodet, skal du blot kode en frit tekststreng for at spørge i samme rum. „Jeg vil lære at skabe API’er” finder FastAPI-artiklen frem, selvom læserens historik kun indeholder maskinlæring. Dette er også den eneste mulighed tilgængelig for en besøgende, du intet ved om.
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']}")
Diversificering af anbefalinger
Sortering efter ren lighed producerer en synlig fejl i produktion: de fem anbefalinger ligner hinanden. En læser af CNN-artiklen får fem varianter af computervision, når den anden eller tredje foreslåede kunne have åbnet døren til transformers.
MMR (Maximal Marginal Relevance) løser dette ved at vælge artikler én efter én: ved hvert skift vælger den den, der maksimerer relevansen for forespørgslen, minus den maksimale redundans med det, der allerede er valgt. lambda_param sætter afvejningen – ved 1,0 får du klassisk sortering, ved 0,5 favoriserer du stærkt variation, og standardværdien 0,7 giver en relevant liste, der ånder.
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
Vigtige pointer
- Embeddings muliggør anbefaling baseret på indholdslished
- Brugerprofilen bygges ved at gennemsnitlige viste embeddings
- Vægtning efter recency giver nyere visninger mere vægt
- MMR diversificerer anbefalinger ved at straffe redundans