Rekomendacje spersonalizowane
Na tej stronie
Cele
- Zbuduj system rekomendacji oparty na osadzeniach (embeddings)
- Wdróż rekomendacje oparte na treści i na użytkowniku
- Rozwiąż problem zimnego startu i zadbaj o różnorodność
Zasada: Podobieństwo równa się rekomendacji
Klasyczny silnik rekomendacji obserwuje zachowania: „Osoby, które przeczytały ten artykuł, przeczytały również tamten“. Potrzebuje on ogromnego ruchu, aby móc cokolwiek sensownego zasugerować – to właśnie problem zimnego startu, który dotyka zarówno nowe katalogi, jak i artykuły opublikowane dziś rano.
Podejście oparte na osadzeniach pomija to oczekiwanie. Jeśli użytkownik polubił jakiś artykuł, rekomendujesz mu te o najbliższych osadzeniach. Jest to rekomendacja oparta na treści: polega ona na zawartości, a nie na zachowaniach innych użytkowników. Artykuł opublikowany dziesięć minut temu, którego żaden czytelnik jeszcze nie otworzył, posiada już swoje osadzenie i natychmiast nadaje się do rekomendacji.
Rekomendacje oparte na treści
Poniższy katalog celowo miesza dwa światy – uczenie maszynowe po jednej stronie i inżynierię oprogramowania po drugiej – aby wyniki były weryfikowalne. Każdy artykuł jest kodowany przez połączenie jego tytułu i treści: tytuł ujmuje temat w pigułce, treść dostarcza słownictwa, a użycie tylko jednego z tych elementów pogarsza jakość znajdowanych sąsiadów.
Sztuczka tkwi w linii scores[idx] = -1. Bez niej artykuł najbardziej podobny do danego artykułu byłby zawsze on sam, z wynikiem 1,0 – co oznaczałoby rekomendowanie czytelnikowi tego, co właśnie skończył czytać.
from openai import OpenAI
import numpy as np
client = OpenAI()
# Katalog artykułów
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..."},
]
# Indeksowanie katalogu
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]:
"""Rekomenduje k najbardziej podobnych artykułów."""
idx = next(i for i, a in enumerate(articles) if a["id"] == article_id)
article_emb = catalogue_embs[idx]
# Podobieństwo do wszystkich innych artykułów
scores = catalogue_embs @ article_emb
scores[idx] = -1 # Wyklucz sam artykuł
top_k = np.argsort(scores)[-k:][::-1]
return [
{"article": articles[i], "score": float(scores[i])}
for i in top_k
]
# Użytkownik czyta "Wstęp do ML"
recos = recommander_similaires("a1", k=3)
print("Przeczytałeś: Introduction au machine learning")
print("Rekomendacje:")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Profil użytkownika na podstawie historii
Rekomendowanie w oparciu o pojedynczy artykuł szybko wpędza czytelnika w pułapkę. Aby uwzględnić całą jego ścieżkę, budujesz wektor profilu, łącząc osadzenia artykułów, które wyświetlił: ten uśredniony punkt reprezentuje jego zainteresowania w tej samej przestrzeni co katalog, a następnie szukasz artykułów najbliższych temu punktowi.
Jednakże odczyty sprzed sześciu miesięcy nie powinny ważyć tyle co te z wczoraj. Ważenie ze względu na świeżość (recency weighting) rozwiązuje ten problem: czynnik 0.5 ** (n - 1 - i) zmniejsza wagę o połowę przy każdym kroku wstecz w historii. Czytelnik, który od dawna śledził tematy związane z uczeniem maszynowym, ale niedawno przestawił się na API, zobaczy zmianę w rekomendacjach już po kilku artykułach, zamiast pozostawać w zawieszeniu. Końcowa normalizacja przywraca profil do sfery jednostkowej, co jest warunkiem koniecznym, aby iloczyn skalarny z katalogiem stanowił właściwe podobieństwo kosinusowe.
def creer_profil_utilisateur(
articles_consultes: list[str],
poids_recency: bool = True
) -> np.ndarray:
"""Tworzy wektor profilu na podstawie historii."""
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:
# Nowsze artykuły liczą się bardziej
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)
# Normalizacja
profil /= np.linalg.norm(profil)
return profil
def recommander_pour_utilisateur(
articles_consultes: list[str],
k: int = 3
) -> list[dict]:
"""Rekomenduje artykuły na podstawie profilu użytkownika."""
profil = creer_profil_utilisateur(articles_consultes)
scores = catalogue_embs @ profil
# Wyklucz już wyświetlone artykuły
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
]
# Użytkownik, który czytał o ML i deep learningu
recos = recommander_pour_utilisateur(["a1", "a2"], k=3)
print("Historia: ML + PyTorch")
print("Rekomendacje:")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Rekomendacje na podstawie zapytania tekstowego
Profil behawioralny ignoruje jedną rzecz, którą użytkownik zna lepiej niż ty: czego szuka dzisiaj. Ponieważ katalog jest już zakodowany, wystarczy zakodować frazę w języku naturalnym, aby odpytać tę samą przestrzeń. Zapytanie „Chcę nauczyć się tworzyć API“ wyświetli artykuł o FastAPI, nawet jeśli historia czytelnika zawiera wyłącznie tematy związane z uczeniem maszynowym. Jest to również jedyna dostępna opcja dla odwiedzającego, o którym nic nie wiesz.
def recommander_par_interet(
description: str,
k: int = 3
) -> list[dict]:
"""Rekomenduje artykuły na podstawie opisu zainteresowań."""
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
]
# „Chcę nauczyć się tworzyć API webowe w Pythonie“
recos = recommander_par_interet("créer des APIs web en Python")
for r in recos:
print(f" [{r['score']:.3f}] {r['article']['titre']}")
Dywersyfikacja rekomendacji
Sortowanie wyłącznie według podobieństwa ujawnia widoczny błąd w środowisku produkcyjnym: pięć rekomendacji wygląda tak samo. Czytelnik artykułu o CNN otrzymuje pięć wariantów widzenia komputerowego, podczas gdy druga lub trzecia sugestia mogłyby otworzyć drzwi do transformerów.
MMR (Maximal Marginal Relevance) naprawia to, wybierając artykuły jeden po drugim: w każdym kroku wybiera ten, który maksymalizuje trafność względem zapytania, pomniejszoną o maksymalną redundancję z tym, co już wybrano. Parametr lambda_param ustala kompromis – przy wartości 1,0 otrzymujesz klasyczne sortowanie, przy 0,5 mocno faworyzujesz różnorodność, a domyślna wartość 0,7 daje trafną listę, która „oddycha“.
def recommander_divers(
query_emb: np.ndarray,
k: int = 5,
lambda_param: float = 0.7
) -> list[int]:
"""MMR: balansuje między trafnością a różnorodnością."""
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:
# Trafność
pertinence = scores[idx]
# Maksymalna redundancja z już wybranymi
if selectionnes:
sims_selectionnes = [
float(np.dot(catalogue_embs[idx], catalogue_embs[s]))
for s in selectionnes
]
redondance = max(sims_selectionnes)
else:
redondance = 0
# Wynik 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
Kluczowe wnioski
- Osadzenia pozwalają na rekomendacje oparte na podobieństwie treści
- Profil użytkownika buduje się poprzez uśrednianie osadzeń wyświetlonych artykułów
- Ważenie ze względu na świeżość nadaje większą wagę niedawnym wyświetleniom
- MMR dywersyfikuje rekomendacje, karząc redundancję