Rekommendationer på individnivå
På denna sida
Mål
- Bygga ett rekommendationssystem baserat på inbäddningar (embeddings)
- Implementera innehållsbaserade och användarbaserade rekommendationer
- Hantera problemet med kall start (cold start) och mångfald
Principen: Likheter motsvarar rekommendationer
En klassisk rekommendationsmotor observerar beteende: “Personer som läste den här artikeln läste också den där.” Den behöver enorma mängder trafik innan den kan säga något användbart – detta är problemet med kall start, som drabbar både nya kataloger och artiklar som publicerats samma morgon.
Metoden med inbäddningar hoppar över denna väntan. Om en användare gillade en artikel rekommenderar du de som har de närmaste inbäddningarna. Detta är innehållsbaserad rekommendation: den förlitar sig på innehållet, inte på andra användares beteende. En artikel som publicerades för tio minuter sedan, som ingen läsare ännu har öppnat, har redan en inbäddning och blir omedelbart rekommenderbar.
Innehållsbaserad rekommendation
Katalogen nedan blandar avsiktligt två världar – maskininlärning på ena sidan, mjukvaruutveckling på den andra – så att resultaten går att verifiera. Varje artikel kodas genom att sammanfoga dess titel och innehåll: titeln fångar ämnet kortfattat, innehållet tillhandahåller ordförrådet, och att använda det ena utan det andra försämrar kvaliteten på de grannar som hittas.
Tricket ligger i raden scores[idx] = -1. Utan den skulle artikeln som är mest lik en artikel alltid vara den själv, med ett betyg på 1,0 – och du skulle rekommendera till en läsare det de just har avslutat.
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']}")
Användarprofil baserad på historik
Att rekommendera baserat på en enda artikel låser snabbt fast läsaren. För att ta hänsyn till hela deras resa bygger du en profilvektor genom att kombinera inbäddningarna från de artiklar de har visat: denna genomsnittspunkt representerar deras intressen i samma rum som katalogen, och du söker sedan efter de artiklar som ligger närmast denna punkt.
Läsningar från för sex månader sedan bör dock inte väga lika tungt som gårdagens. Viktning baserad på aktualitet hanterar detta: faktorn 0.5 ** (n - 1 - i) halverar vikten för varje steg bakåt i historiken. En läsare som följt maskininlärning under lång tid men nyligen bytt till API:er kommer att se sina rekommendationer skifta inom några artiklar istället för att frysa fast. Den slutliga normaliseringen för profilen tillbaka till enhetssfären, vilket är ett villkor för att skalärprodukten med katalogen ska bli en korrekt cosinuslikhet.
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']}")
Rekommendation med textfråga
Den beteendemässiga profilen ignorerar en sak som användaren vet bättre än du: vad de letar efter idag. Eftersom katalogen redan är kodad behöver du bara koda en fritextfras för att fråga samma rum. “Jag vill lära mig hur man skapar API:er” tar fram FastAPI-artikeln, även om läsarens historik endast innehåller maskininlärning. Detta är också det enda alternativet tillgängligt för en besökare du inte vet något 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']}")
Att diversifiera rekommendationer
Sortering baserad på ren likhet producerar en synlig brist i produktion: de fem rekommendationerna ser likadana ut. En läsare av CNN-artikeln får fem varianter av datorseende, när den andra eller tredje förslaget kunde ha öppnat dörren till transformers.
MMR (Maximal Marginal Relevance) fixar detta genom att välja artiklar en i taget: vid varje varv väljer den den som maximerar relevansen för frågan, minus den maximala redundansen med vad som redan är valt. lambda_param ställer in avvägningen – vid 1,0 får du klassisk sortering, vid 0,5 gynnar du mångfald starkt, och standardvärdet 0,7 ger en relevant lista som andas.
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
Viktiga punkter
- Inbäddningar möjliggör rekommendation baserad på innehållslikhet
- Användarprofilen byggs genom att genomsnittliga visade inbäddningar
- Viktning baserad på aktualitet ger nyare visningar större vikt
- MMR diversifierar rekommendationer genom att bestraffa redundans