Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Suositukset henkilökohtaistettuna

Oppitunti 19 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Tavoitteet
  2. Periaate: Samankaltaisuus vastaa suositusta
  3. Sisältöön perustuva suosittelu
  4. Käyttäjäprofiili historian perusteella
  5. Suosittelu tekstikyselyn perusteella
  6. Suositusten monimuotoistaminen
  7. Keskeiset asiat

Tavoitteet

  • Rakenna upotuksiin perustuva suositusjärjestelmä
  • Toteuta sisältöön ja käyttäjään perustuva suosittelu
  • Hallitse kylmä käynnistys ja monimuotoisuus

Periaate: Samankaltaisuus vastaa suositusta

Klassinen suositusmoottori tarkkailee käyttäytymistä: “Ihmiset, jotka lukivat tämän artikkelin, lukivat myös tuon.” Se tarvitsee paljon liikennettä ennen kuin se pystyy sanomaan mitään hyödyllistä – tämä on kylmän käynnistyksen ongelma, joka koskee sekä uusia luetteloita että tänä aamuna julkaistuja artikkeleita.

Upotuksiin perustuva lähestymistapa ohittaa tämän odotuksen. Jos käyttäjä piti tietystä artikkelista, suosittelet niitä, joiden upotukset ovat lähimpänä. Tämä on sisältöön perustuvaa suosittelemista: se nojaa sisältöön, ei muiden käyttäjien käyttäytymiseen. Kymmenen minuuttia sitten julkaistulla artikkelilla, jota yksikään lukija ei ole vielä avannut, on jo upotus, ja se voidaan suositella välittömästi.

Sisältöön perustuva suosittelu

Alla oleva luettelo sekoittaa tarkoituksellisesti kahta maailmaa – koneoppimisen toisella puolella ja ohjelmistotekniikan toisella – jotta tulokset ovat varmennettavissa. Jokainen artikkeli koodataan yhdistämällä sen otsikko ja sisältö: otsikko tiivistää aiheen ytimekkäästi, sisältö tarjoaa sanaston, ja toisen käyttäminen ilman toista heikentää löydettyjen naapureiden laatua.

Temppu piilee rivissä scores[idx] = -1. Ilman sitä artikkeli, joka on samankaltaisin itsensä kanssa, olisi aina itse artikkeli pistemäärällä 1,0 – ja suosittelisit lukijalle juuri sitä, jonka hän vasta lopetti.

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

Käyttäjäprofiili historian perusteella

Yhden artikkelin perusteella suosittelu lukitsee lukijan nopeasti. Koko polun huomioon ottamiseksi rakennat profiilivektorin yhdistämällä katsottujen artikkelien upotukset: tämä keskiarvopiste edustaa heidän kiinnostuksen kohteitaan samassa avaruudessa kuin luettelo, ja etsit sen jälkeen artikkeleita, jotka ovat lähimpänä tätä pistettä.

Kuusi kuukautta sitten tehdyt lukukerrat eivät kuitenkaan saisi painaa yhtä paljon kuin eiliset. Tuoreuspainotus hoitaa tämän: kerroin 0.5 ** (n - 1 - i) puolittaa painon jokaista askelta taaksepäin historiassa. Lukija, joka on seurannut koneoppimista pitkään mutta siirtynyt äskettäin API-rajapintoihin, näkee suositustensa siirtyvän muutaman artikkelin kuluessa sen sijaan, että ne pysyisivät jäätyneinä. Lopullinen normalisointi palauttaa profiilin yksikköpallolle, mikä on edellytys sille, että pistetulo luettelon kanssa on oikea kosinussamankaltaisuus.

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

Suosittelu tekstikyselyn perusteella

Käyttäytymisprofiili jättää huomiotta yhden asian, jonka käyttäjä tietää paremmin kuin sinä: mitä hän etsii juuri tänään. Koska luettelo on jo koodattu, sinun tarvitsee vain koodata vapaan tekstin lause kysyäksesi samasta avaruudesta. “Haluan oppia luomaan API-rajapintoja” nostaa esiin FastAPI-artikkelin, vaikka lukijan historia sisältäisi vain koneoppimista. Tämä on myös ainoa vaihtoehto vierailijalle, josta et tiedä mitään.

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

Suositusten monimuotoistaminen

Pelkän samankaltaisuuden perusteella lajittelu tuottaa näkyvän virheen tuotannossa: viisi suositusta näyttävät samanlaisilta. CNN-artikkelin lukija saa viisi variaatiota tietokonenäöstä, kun toinen tai kolmas ehdotus olisi voinut avata oven transformereille.

MMR (Maximal Marginal Relevance) korjaa tämän valitsemalla artikkeleita yksi kerrallaan: jokaisella kierroksella se valitsee sen, joka maksimoi merkityksellisyyden kyselyyn nähden vähennettynä jo valittujen suurimmalla päällekkäisyydellä. lambda_param asettaa kompromissin – arvolla 1,0 saat klassisen lajittelun, arvolla 0,5 suositt voimakkaasti vaihtelua, ja oletusarvo 0,7 antaa merkityksellisen listan, joka hengittää.

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

Keskeiset asiat

  • Upotukset mahdollistavat suosittelun sisältösamankaltaisuuden perusteella
  • Käyttäjäprofiili rakennetaan keskiarvoimalla katsottujen artikkelien upotukset
  • Tuoreuspainotus antaa enemmän painoa viimeaikaisille katselukerroille
  • MMR monimuotoistaa suosituksia rankaisemalla päällekkäisyydestä