Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Rekommendationer på individnivå

Lektion 19 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Mål
  2. Principen: Likheter motsvarar rekommendationer
  3. Innehållsbaserad rekommendation
  4. Användarprofil baserad på historik
  5. Rekommendation med textfråga
  6. Att diversifiera rekommendationer
  7. Viktiga punkter

Mål

  • Bygga ett rekommendationssystem baserat på inbäddningar (embeddings)
  • Implementera innehållsbaserade och användarbaserade rekommendationer
  • Hantera problemet med kall start (cold start) och mångfald

Principen: Likheter motsvarar rekommendationer

En klassisk rekommendationsmotor observerar beteende: “Personer som läste den här artikeln läste också den där.” Den behöver enorma mängder trafik innan den kan säga något användbart – detta är problemet med kall start, som drabbar både nya kataloger och artiklar som publicerats samma morgon.

Metoden med inbäddningar hoppar över denna väntan. Om en användare gillade en artikel rekommenderar du de som har de närmaste inbäddningarna. Detta är innehållsbaserad rekommendation: den förlitar sig på innehållet, inte på andra användares beteende. En artikel som publicerades för tio minuter sedan, som ingen läsare ännu har öppnat, har redan en inbäddning och blir omedelbart rekommenderbar.

Innehållsbaserad rekommendation

Katalogen nedan blandar avsiktligt två världar – maskininlärning på ena sidan, mjukvaruutveckling på den andra – så att resultaten går att verifiera. Varje artikel kodas genom att sammanfoga dess titel och innehåll: titeln fångar ämnet kortfattat, innehållet tillhandahåller ordförrådet, och att använda det ena utan det andra försämrar kvaliteten på de grannar som hittas.

Tricket ligger i raden scores[idx] = -1. Utan den skulle artikeln som är mest lik en artikel alltid vara den själv, med ett betyg på 1,0 – och du skulle rekommendera till en läsare det de just har avslutat.

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

Användarprofil baserad på historik

Att rekommendera baserat på en enda artikel låser snabbt fast läsaren. För att ta hänsyn till hela deras resa bygger du en profilvektor genom att kombinera inbäddningarna från de artiklar de har visat: denna genomsnittspunkt representerar deras intressen i samma rum som katalogen, och du söker sedan efter de artiklar som ligger närmast denna punkt.

Läsningar från för sex månader sedan bör dock inte väga lika tungt som gårdagens. Viktning baserad på aktualitet hanterar detta: faktorn 0.5 ** (n - 1 - i) halverar vikten för varje steg bakåt i historiken. En läsare som följt maskininlärning under lång tid men nyligen bytt till API:er kommer att se sina rekommendationer skifta inom några artiklar istället för att frysa fast. Den slutliga normaliseringen för profilen tillbaka till enhetssfären, vilket är ett villkor för att skalärprodukten med katalogen ska bli en korrekt cosinuslikhet.

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

Rekommendation med textfråga

Den beteendemässiga profilen ignorerar en sak som användaren vet bättre än du: vad de letar efter idag. Eftersom katalogen redan är kodad behöver du bara koda en fritextfras för att fråga samma rum. “Jag vill lära mig hur man skapar API:er” tar fram FastAPI-artikeln, även om läsarens historik endast innehåller maskininlärning. Detta är också det enda alternativet tillgängligt för en besökare du inte vet något 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']}")

Att diversifiera rekommendationer

Sortering baserad på ren likhet producerar en synlig brist i produktion: de fem rekommendationerna ser likadana ut. En läsare av CNN-artikeln får fem varianter av datorseende, när den andra eller tredje förslaget kunde ha öppnat dörren till transformers.

MMR (Maximal Marginal Relevance) fixar detta genom att välja artiklar en i taget: vid varje varv väljer den den som maximerar relevansen för frågan, minus den maximala redundansen med vad som redan är valt. lambda_param ställer in avvägningen – vid 1,0 får du klassisk sortering, vid 0,5 gynnar du mångfald starkt, och standardvärdet 0,7 ger en relevant lista som andas.

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

Viktiga punkter

  • Inbäddningar möjliggör rekommendation baserad på innehållslikhet
  • Användarprofilen byggs genom att genomsnittliga visade inbäddningar
  • Viktning baserad på aktualitet ger nyare visningar större vikt
  • MMR diversifierar rekommendationer genom att bestraffa redundans