Raccomandazioni personalizzate
In questa pagina
Obiettivi
- Costruire un sistema di raccomandazione basato sugli embedding
- Implementare raccomandazioni basate sui contenuti e sugli utenti
- Gestire il problema dell’avvio a freddo (cold start) e la diversità
Il principio: similarità uguale raccomandazione
Un motore di raccomandazione classico osserva il comportamento: «Le persone che hanno letto questo articolo hanno letto anche quello». Ha bisogno di molto traffico prima di poter dire qualcosa di utile: è il problema dell’avvio a freddo, che colpisce sia i nuovi cataloghi sia gli articoli pubblicati stamattina.
L’approccio basato sugli embedding salta questa attesa. Se un utente ha apprezzato un articolo, gli consigli quelli con gli embedding più vicini. Questa è una raccomandazione basata sui contenuti: si fonda sul contenuto, non sul comportamento degli altri utenti. Un articolo pubblicato dieci minuti fa, che nessun lettore ha ancora aperto, ha già un embedding e diventa immediatamente raccomandabile.
Raccomandazione basata sui contenuti
Il catalogo qui sotto mescola volutamente due mondi: machine learning da una parte, ingegneria del software dall’altra, così i risultati sono verificabili. Ogni articolo viene codificato concatenando titolo e contenuto: il titolo cattura l’argomento in sintesi, il contenuto fornisce il vocabolario, e usare solo uno dei due degrada la qualità dei vicini trovati.
Il trucco sta nella riga scores[idx] = -1. Senza di essa, l’articolo più simile a un articolo sarebbe sempre se stesso, con punteggio 1.0: finiresti per consigliare al lettore proprio ciò che ha appena finito di leggere.
from openai import OpenAI
import numpy as np
client = OpenAI()
# Catalogo articoli
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..."},
]
# Indicizzazione del catalogo
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]:
"""Consiglia i k articoli più simili."""
idx = next(i for i, a in enumerate(articles) if a["id"] == article_id)
article_emb = catalogue_embs[idx]
# Similarità con tutti gli altri articoli
scores = catalogue_embs @ article_emb
scores[idx] = -1 # Esclude l'articolo stesso
top_k = np.argsort(scores)[-k:][::-1]
return [
{"article": articles[i], "score": float(scores[i])}
for i in top_k
]
# Un utente legge "Introduction to ML"
recos = recommander_similaires("a1", k=3)
print("Hai letto: Introduction au machine learning")
print("Raccomandazioni:")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Profilo utente dalla cronologia
Raccomandare sulla base di un singolo articolo intrappola rapidamente il lettore. Per tenere conto dell’intero percorso, costruisci un vettore profilo combinando gli embedding degli articoli visualizzati: questo punto medio rappresenta i suoi interessi nello stesso spazio del catalogo, e poi cerchi gli articoli più vicini a questo punto.
Tuttavia, le letture di sei mesi fa non dovrebbero pesare quanto quelle di ieri. La ponderazione per recentezza gestisce questo aspetto: il fattore 0.5 ** (n - 1 - i) dimezza il peso a ogni passo indietro nella cronologia. Un lettore che ha seguito il machine learning a lungo ma di recente è passato alle API vedrà le proprie raccomandazioni spostarsi nel giro di pochi articoli, invece di rimanere bloccate. La normalizzazione finale riporta il profilo sulla sfera unitaria, condizione necessaria affinché il prodotto scalare con il catalogo sia una corretta similarità del coseno.
def creer_profil_utilisateur(
articles_consultes: list[str],
poids_recency: bool = True
) -> np.ndarray:
"""Crea un vettore profilo dalla cronologia."""
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:
# Gli articoli recenti contano di più
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)
# Normalizzazione
profil /= np.linalg.norm(profil)
return profil
def recommander_pour_utilisateur(
articles_consultes: list[str],
k: int = 3
) -> list[dict]:
"""Consiglia articoli in base al profilo utente."""
profil = creer_profil_utilisateur(articles_consultes)
scores = catalogue_embs @ profil
# Esclude gli articoli già visualizzati
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
]
# Utente che ha letto ML e deep learning
recos = recommander_pour_utilisateur(["a1", "a2"], k=3)
print("Cronologia: ML + PyTorch")
print("Raccomandazioni:")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Raccomandazione con query testuale
Il profilo comportamentale ignora una cosa che l’utente conosce meglio di te: cosa sta cercando oggi. Dato che il catalogo è già codificato, ti basta codificare una frase in testo libero per interrogare lo stesso spazio. «Voglio imparare a creare API» fa emergere l’articolo su FastAPI, anche se la cronologia del lettore contiene solo machine learning. Questa è anche l’unica opzione disponibile per un visitatore di cui non sai nulla.
def recommander_par_interet(
description: str,
k: int = 3
) -> list[dict]:
"""Consiglia articoli in base a una descrizione di interesse."""
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
]
# "Voglio imparare a creare API"
recos = recommander_par_interet("créer des APIs web en Python")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Diversificare le raccomandazioni
Ordinare per pura similarità produce un difetto visibile in produzione: le cinque raccomandazioni si assomigliano troppo. Un lettore dell’articolo sui CNN riceve cinque varianti di computer vision, quando la seconda o la terza suggerimento avrebbero potuto aprire la porta ai transformer.
MMR (Maximal Marginal Relevance) risolve il problema selezionando gli articoli uno per uno: a ogni turno, sceglie quello che massimizza la rilevanza rispetto alla query, meno la massima ridondanza con quanto già selezionato. Il parametro lambda_param imposta il compromesso: a 1.0 ottieni l’ordinamento classico, a 0.5 favorisci fortemente la varietà, e il valore predefinito 0.7 produce un elenco rilevante ma vario.
def recommander_divers(
query_emb: np.ndarray,
k: int = 5,
lambda_param: float = 0.7
) -> list[int]:
"""MMR: bilancia rilevanza e diversità."""
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:
# Rilevanza
pertinence = scores[idx]
# Massima ridondanza con i già selezionati
if selectionnes:
sims_selectionnes = [
float(np.dot(catalogue_embs[idx], catalogue_embs[s]))
for s in selectionnes
]
redondance = max(sims_selectionnes)
else:
redondance = 0
# Punteggio 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
Punti chiave
- Gli embedding permettono raccomandazioni basate sulla similarità dei contenuti
- Il profilo utente si costruisce facendo la media degli embedding visualizzati
- La ponderazione per recentezza dà più peso alle visualizzazioni recenti
- MMR diversifica le raccomandazioni penalizzando la ridondanza