Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Priporočila po meri

Lekcija 19 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Cilji
  2. Načelo: Podobnost enaka priporočilu
  3. Priporočila na osnovi vsebine
  4. Uporabniški profil iz zgodovine
  5. Priporočila z besedilnim poizvedbo
  6. Raznolikost priporočil
  7. Ključne ugotovitve

Cilji

  • Izgradi sistem priporočil na osnovi vdelav (embeddings)
  • Implementiraj priporočila na osnovi vsebine in uporabnika
  • Obvladaj problem hladnega zagona in zagotovi raznolikost

Načelo: Podobnost enaka priporočilu

Klasičen pogon za priporočila opazuje vedenje: „Ljudje, ki so brali ta članek, so brali tudi tistega.” Preden lahko reče kaj uporabnega, potrebuje veliko prometa – to je problem hladnega zagona, ki prizadene tako nove kataloge kot članke, objavljene danes zjutraj.

Pristop z vdelavami to čakanje preskoči. Če je uporabniku bil članek všeč, mu priporoči tiste z najbližjimi vdelavami. To je priporočilo na osnovi vsebine: zanaša se na vsebino, ne na vedenje drugih uporabnikov. Članek, objavljen pred desetimi minutami, ki ga še noben bralec ni odprl, že ima vdelavo in takoj postane priporočljiv.

Priporočila na osnovi vsebine

Spodnji katalog namerno meša dva svetova – strojno učenje na eni strani in programsko inženirstvo na drugi – tako da so rezultati preverljivi. Vsak članek je kodiran z združitvijo naslova in vsebine: naslov zajame bistvo teme, vsebina pa zagotavlja besedišče; uporaba samo enega od njiju poslabša kakovost najdenih sosedov.

Trik je v vrstici scores[idx] = -1. Brez nje bi bil članek, najbolj podoben članku, vedno sam sebi z oceno 1,0 – in bralcu bi priporočal tisto, kar je pravkar prebral.

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']}")

Uporabniški profil iz zgodovine

Priporočanje na osnovi enega samega članka bralca hitro ujame v past. Da bi upošteval celotno pot, zgradiš profilni vektor z združitvijo vdelav ogledanih člankov: ta povprečna točka predstavlja njegova zanimanja v istem prostoru kot katalog, nato pa iščeš članke, ki so najbližje tej točki.

Vendar branja pred šestimi meseci ne bi smela tehtati toliko kot včerajšnja. Tehtanje glede na svežino to ureja: faktor 0.5 ** (n - 1 - i) na vsakem koraku nazaj v zgodovini prepolovi težo. Bralec, ki je dolgo sledil strojnemu učenju, a se nedavno preklopil na API-je, bo videl premik priporočil v nekaj člankih, namesto da bi ostala zamrznjena. Končna normalizacija vrne profil na enotsko sfero, kar je pogoj, da je skalarni produkt s katalogom pravilna kosinusna podobnost.

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']}")

Priporočila z besedilnim poizvedbo

Vedenjski profil prezre eno stvar, ki jo uporabnik ve bolje kot ti: kaj išče danes. Ker je katalog že kodiran, moraš le kodirati frazo v prostem besedilu, da poizveduješ v istem prostoru. „Želim se naučiti ustvarjati API-je” prikliče članek o FastAPI, tudi če zgodovina bralca vsebuje samo strojno učenje. To je tudi edina možnost za obiskovalca, o katerem ne veš ničesar.

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']}")

Raznolikost priporočil

Razvrščanje po čisti podobnosti povzroči vidno napako v produkciji: pet priporočil je si podobnih. Bralec članka o CNN dobi pet različic računalniškega vida, čeprav bi lahko drugo ali tretje predlog odprlo vrata transformerjem.

MMR (Maximal Marginal Relevance) to popravi z izbiro člankov enega za drugim: ob vsakem koraku izbere tistega, ki maksimira ustreznost poizvedbi, minus največjo redundanco s tistimi, ki so že izbrani. Parameter lambda_param določa kompromis – pri 1,0 dobiš klasično razvrščanje, pri 0,5 močno favoriziraš raznolikost, privzeta vrednost 0,7 pa da ustrezen seznam, ki diha.

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

Ključne ugotovitve

  • Vdelave omogočajo priporočanje na osnovi podobnosti vsebine
  • Uporabniški profil se gradi s povprečenjem vdelav ogledanih člankov
  • Tehtanje glede na svežino daje večjo težo nedavnim ogledom
  • MMR raznoliki priporočila s kaznovanjem redundance