Salt la conținutul principal
Română— Alege o limbă
Meniu

Recomandări personalizate

Lecția 19 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Obiective
  2. Principiul: Similaritatea înseamnă Recomandare
  3. Recomandare bazată pe conținut
  4. Profilul utilizatorului din istoric
  5. Recomandare cu interogare text
  6. Diversificarea recomandărilor
  7. Puncte cheie

Obiective

  • Construirea unui sistem de recomandare bazat pe embedding-uri
  • Implementarea recomandărilor bazate pe conținut și pe utilizator
  • Gestionarea problemei de start la rece (cold start) și a diversității

Principiul: Similaritatea înseamnă Recomandare

Un motor de recomandare clasic observă comportamentul: „Persoanele care au citit acest articol au citit și pe acela.“ Are nevoie de mult trafic înainte de a putea spune ceva util—aceasta este problema de start la rece (cold start), care afectează atât cataloagele noi, cât și articolele publicate chiar în dimineața respectivă.

Abordarea bazată pe embedding-uri sare peste această așteptare. Dacă unui utilizator i-a plăcut un articol, îi recomandați pe cele cu embedding-urile cele mai apropiate. Aceasta este recomandarea bazată pe conținut: se bazează pe conținut, nu pe comportamentul altor utilizatori. Un articol publicat acum zece minute, pe care niciun cititor nu l-a deschis încă, are deja un embedding și devine recomandabil imediat.

Recomandare bazată pe conținut

Catalogul de mai jos amestecă intenționat două lumi—machine learning pe de o parte, inginerie software pe de altă parte—astfel încât rezultatele să fie verificabile. Fiecare articol este codificat prin concatenarea titlului și a conținutului său: titlul surprinde subiectul în esență, conținutul oferă vocabularul, iar utilizarea unuia fără celălalt degradează calitatea vecinilor găsiți.

Trucul stă în linia scores[idx] = -1. Fără ea, articolul cel mai similar cu un articol ar fi întotdeauna el însuși, cu un scor de 1.0—și ați recomanda cititorului chiar ceea ce tocmai a terminat de citit.

from openai import OpenAI
import numpy as np

client = OpenAI()

# Catalog de articole
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..."},
]

# Indexarea catalogului
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]:
    """Recomandă cele mai similare k articole."""
    idx = next(i for i, a in enumerate(articles) if a["id"] == article_id)
    article_emb = catalogue_embs[idx]

    # Similaritate cu toate celelalte articole
    scores = catalogue_embs @ article_emb
    scores[idx] = -1  # Excluderea articolului însuși

    top_k = np.argsort(scores)[-k:][::-1]
    return [
        {"article": articles[i], "score": float(scores[i])}
        for i in top_k
    ]

# Un utilizator citește „Introduction to ML“
recos = recommander_similaires("a1", k=3)
print("Ați citit: Introduction au machine learning")
print("Recomandări:")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Profilul utilizatorului din istoric

Recomandarea bazată pe un singur articol blochează rapid cititorul. Pentru a ține cont de întregul său parcurs, construiți un vector de profil combinând embedding-urile articolelor pe care le-a vizualizat: acest punct mediu reprezintă interesele sale în același spațiu ca și catalogul, iar apoi căutați articolele cele mai apropiate de acest punct.

Totuși, citirile de acum șase luni nu ar trebui să cântărească la fel de mult ca cele de ieri. Ponderarea în funcție de recentitate gestionează acest aspect: factorul 0.5 ** (n - 1 - i) înjumătățește greutatea la fiecare pas înapoi în istoric. Un cititor care a urmărit machine learning mult timp, dar a trecut recent la API-uri, își va vedea recomandările schimbându-se în câteva articole, în loc să rămână înghețate. Normalizarea finală readuce profilul pe sfera unitară, o condiție pentru ca produsul scalar cu catalogul să fie o similaritate cosinus corectă.

def creer_profil_utilisateur(
    articles_consultes: list[str],
    poids_recency: bool = True
) -> np.ndarray:
    """Creează un vector de profil din istoric."""
    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:
        # Articolele recente contează mai mult
        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)

    # Normalizare
    profil /= np.linalg.norm(profil)
    return profil

def recommander_pour_utilisateur(
    articles_consultes: list[str],
    k: int = 3
) -> list[dict]:
    """Recomandă articole pe baza profilului utilizatorului."""
    profil = creer_profil_utilisateur(articles_consultes)

    scores = catalogue_embs @ profil
    # Excluderea articolelor deja vizualizate
    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
    ]

# Utilizator care a citit ML și deep learning
recos = recommander_pour_utilisateur(["a1", "a2"], k=3)
print("Istoric: ML + PyTorch")
print("Recomandări:")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Recomandare cu interogare text

Profilul comportamental ignoră un lucru pe care utilizatorul îl știe mai bine decât dumneavoastră: ce caută astăzi. Deoarece catalogul este deja codificat, trebuie doar să codificați o frază în text liber pentru a interoga același spațiu. „Vreau să învăț cum să creez API-uri“ va afișa articolul despre FastAPI, chiar dacă istoricul cititorului conține doar machine learning. Aceasta este, de asemenea, singura opțiune disponibilă pentru un vizitator despre care nu știți nimic.

def recommander_par_interet(
    description: str,
    k: int = 3
) -> list[dict]:
    """Recomandă articole pe baza unei descrieri a intereselor."""
    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
    ]

# „Vreau să învăț cum să creez API-uri“
recos = recommander_par_interet("créer des APIs web en Python")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Diversificarea recomandărilor

Sortarea prin similaritate pură produce un defect vizibil în producție: cele cinci recomandări seamănă între ele. Un cititor al articolului despre CNN primește cinci variante de computer vision, când a doua sau a treia sugestie ar fi putut deschide ușa către transformers.

MMR (Maximal Marginal Relevance) remediază acest lucru selectând articolele unul câte unul: la fiecare tur, îl alege pe cel care maximizează relevanța față de interogare, minus redundanța maximă cu ceea ce este deja selectat. Parametrul lambda_param stabilește compromisul—la 1.0 obțineți sortarea clasică, la 0.5 favorizați puternic varietatea, iar valoarea implicită de 0.7 oferă o listă relevantă care „respiră“.

def recommander_divers(
    query_emb: np.ndarray,
    k: int = 5,
    lambda_param: float = 0.7
) -> list[int]:
    """MMR: echilibrează relevanța și diversitatea."""
    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:
            # Relevanță
            pertinence = scores[idx]

            # Redundanță maximă cu cele deja selectate
            if selectionnes:
                sims_selectionnes = [
                    float(np.dot(catalogue_embs[idx], catalogue_embs[s]))
                    for s in selectionnes
                ]
                redondance = max(sims_selectionnes)
            else:
                redondance = 0

            # Scor 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

Puncte cheie

  • Embedding-urile permit recomandarea prin similaritate de conținut
  • Profilul utilizatorului este construit prin medierea embedding-urilor vizualizate
  • Ponderarea în funcție de recentitate acordă mai multă greutate vizualizărilor recente
  • MMR diversifică recomandările prin penalizarea redundanței