Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Personlige anbefalinger

Lektion 19 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Mål
  2. Princippet: Lighed er lig med anbefaling
  3. Indholdsbaseret anbefaling
  4. Brugerprofil baseret på historik
  5. Anbefaling med tekstforespørgsel
  6. Diversificering af anbefalinger
  7. Vigtige pointer

Mål

  • Byg et anbefalingssystem baseret på embeddings
  • Implementér indholdsbaseret og brugerbasert anbefaling
  • Håndtér cold start-problemet og mangfoldighed

Princippet: Lighed er lig med anbefaling

En klassisk anbefalingsmotor observerer adfærd: „Folk, der læste denne artikel, læste også den.” Den kræver masser af trafik, før den kan sige noget brugbart – dette er cold start-problemet, som rammer både nye kataloger og artikler udgivet i morges.

Embedding-tilgangen springer denne ventetid over. Hvis en bruger kunne lide en artikel, anbefaler du dem med de tætteste embeddings. Dette er indholdsbaseret anbefaling: det hviler på indholdet, ikke på andre brugeres adfærd. En artikel udgivet for ti minutter siden, som ingen læser endnu har åbnet, har allerede et embedding og bliver straks anbefalelig.

Indholdsbaseret anbefaling

Kataloget nedenfor blander bevidst to verdener – maskinlæring på den ene side, softwareudvikling på den anden – så resultaterne er verificerbare. Hver artikel kodes ved at sammenkæde titel og indhold: titlen fanger emnet kort og godt, indholdet leverer ordforrådet, og brug af kun det ene uden det andet forringer kvaliteten af de fundne naboer.

Tricket ligger i linjen scores[idx] = -1. Uden den ville den artikel, der ligner en artikel mest, altid være sig selv med en score på 1,0 – og du ville anbefale en læser det, de lige har læst færdig.

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

Brugerprofil baseret på historik

At anbefale ud fra én enkelt artikel låser hurtigt læseren fast. For at tage højde for hele deres rejse bygger du en profilvektor ved at kombinere embeddings fra de artikler, de har set: dette gennemsnitlige punkt repræsenterer deres interesser i samme rum som kataloget, og du søger derefter efter de artikler, der ligger tættest på dette punkt.

Læsninger fra for seks måneder siden bør dog ikke vægte lige så meget som gårsdagens. Vægtning efter recency håndterer dette: faktoren 0.5 ** (n - 1 - i) halverer vægten for hvert skridt tilbage i historikken. En læser, der fulgte maskinlæring i lang tid, men for nylig skiftede til API’er, vil se deres anbefalinger skifte inden for få artikler i stedet for at stå fast. Den endelige normalisering bringer profilen tilbage til enhedssfæren, hvilket er en betingelse for, at prikproduktet med kataloget bliver en korrekt cosinus-lished.

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

Anbefaling med tekstforespørgsel

Den adfærdsbaserede profil ignorerer én ting, som brugeren ved bedre end dig: hvad de leder efter i dag. Da kataloget allerede er kodet, skal du blot kode en frit tekststreng for at spørge i samme rum. „Jeg vil lære at skabe API’er” finder FastAPI-artiklen frem, selvom læserens historik kun indeholder maskinlæring. Dette er også den eneste mulighed tilgængelig for en besøgende, du intet ved 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']}")

Diversificering af anbefalinger

Sortering efter ren lighed producerer en synlig fejl i produktion: de fem anbefalinger ligner hinanden. En læser af CNN-artiklen får fem varianter af computervision, når den anden eller tredje foreslåede kunne have åbnet døren til transformers.

MMR (Maximal Marginal Relevance) løser dette ved at vælge artikler én efter én: ved hvert skift vælger den den, der maksimerer relevansen for forespørgslen, minus den maksimale redundans med det, der allerede er valgt. lambda_param sætter afvejningen – ved 1,0 får du klassisk sortering, ved 0,5 favoriserer du stærkt variation, og standardværdien 0,7 giver en relevant liste, der ånder.

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

Vigtige pointer

  • Embeddings muliggør anbefaling baseret på indholdslished
  • Brugerprofilen bygges ved at gennemsnitlige viste embeddings
  • Vægtning efter recency giver nyere visninger mere vægt
  • MMR diversificerer anbefalinger ved at straffe redundans