Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Asmeninės rekomendacijos

Paskaita 19 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Tikslai
  2. Principas: panašumas lygus rekomendacijai
  3. Turiniu pagrįstos rekomendacijos
  4. Vartotojo profilis iš istorijos
  5. Rekomendacija pagal teksto užklausą
  6. Rekomendacijų įvairovė
  7. Svarbiausi punktai

Tikslai

  • Sukurti rekomendacijų sistemą, pagrįstą įterpiniais (embeddings)
  • Įgyvendinti turiniu ir vartotoju pagrįstas rekomendacijas
  • Spręsti „šalto starto“ ir įvairovės problemas

Principas: panašumas lygus rekomendacijai

Klasikinė rekomendacijų sistema stebi elgseną: „Žmonės, kurie skaitė šį straipsnį, taip pat skaitė tą.“ Jai reikia daug srauto, kad ji galėtų pasakyti ką nors naudingo – tai yra „šalto starto“ problema, kuri ištinka tiek naujus katalogus, tiek ryte paskelbtus straipsnius.

Įterpinių (embeddings) metodas leidžia praleisti šį laukimą. Jei vartotojui patiko straipsnis, rekomenduoji tuos, kurių įterpiniai yra artimiausi. Tai yra turiniu pagrįsta rekomendacija: ji remiasi turiniu, o ne kitų vartotojų elgsena. Straipsnis, paskelbtas prieš dešimt minučių, kurio dar neatidarė nė vienas skaitytojas, jau turi įterpinį ir tampa rekomenduojamas iškart.

Turiniu pagrįstos rekomendacijos

Toliau pateiktame kataloge sąmoningai sumaišyti du pasauliai – viena vertus, mašininis mokymasis, kita vertus, programinės įrangos inžinerija, kad rezultatai būtų patikrinami. Kiekvienas straipsnis koduojamas sujungiant jo pavadinimą ir turinį: pavadinimas trumpai apibūdina temą, turinys suteikia žodyną, o naudojant tik vieną iš jų, pablogėja rastų kaimynų kokybė.

Gudrybė slypi eilutėje scores[idx] = -1. Be jos, straipsnis, labiausiai panašus į straipsnį, visada būtų jis pats, turintis 1,0 balą – ir tu rekomenduotum skaitytojui tai, ką jis tik ką baigė skaityti.

from openai import OpenAI
import numpy as np

client = OpenAI()

# Straipsnių katalogas
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..."},
]

# Katalogo indeksavimas
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]:
    """Rekomenduoja k panašiausių straipsnių."""
    idx = next(i for i, a in enumerate(articles) if a["id"] == article_id)
    article_emb = catalogue_embs[idx]

    # Panašumas su visais kitais straipsniais
    scores = catalogue_embs @ article_emb
    scores[idx] = -1  # Neįtraukti paties straipsnio

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

# Vartotojas perskaitė „Įvadas į ML“
recos = recommander_similaires("a1", k=3)
print("Perskaitei: Introduction au machine learning")
print("Rekomendacijos:")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Vartotojo profilis iš istorijos

Rekomendavimas remiantis vienu straipsniu greitai įklampina skaitytoją. Norint atsižvelgti į visą jo kelionę, sukuriamas profilio vektorius, sujungiant peržiūrėtų straipsnių įterpinius: šis vidurkio taškas reprezentuoja jo interesus toje pačioje erdvėje kaip ir katalogas, o tada ieškoma straipsnių, esančių arčiausiai šio taško.

Tačiau prieš šešis mėnesius skaityti straipsniai neturėtų sverti tiek pat, kiek vakarykščiai. Naujumo svorio koeficientas tai ir išsprendžia: faktorius 0.5 ** (n - 1 - i) perpus sumažina svorį kiekvienam žingsniui atgal istorijoje. Skaitytojas, kuris ilgai domėjosi mašininiu mokymusi, bet neseniai perėjo prie API, matys, kaip jo rekomendacijos pasislenka po kelių straipsnių, užuot likusios sustingusios. Galutinis normalizavimas grąžina profilį į vienetinę sferą, o tai yra būtina sąlyga, kad skaliarinė sandauga su katalogu būtų tinkama kosinusinis panašumas.

def creer_profil_utilisateur(
    articles_consultes: list[str],
    poids_recency: bool = True
) -> np.ndarray:
    """Sukuria profilio vektorių iš istorijos."""
    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:
        # Naujesni straipsniai svarbesni
        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)

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

def recommander_pour_utilisateur(
    articles_consultes: list[str],
    k: int = 3
) -> list[dict]:
    """Rekomenduoja straipsnius pagal vartotojo profilį."""
    profil = creer_profil_utilisateur(articles_consultes)

    scores = catalogue_embs @ profil
    # Neįtraukti jau peržiūrėtų straipsnių
    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
    ]

# Vartotojas, skaitęs apie ML ir giluminį mokymąsi
recos = recommander_pour_utilisateur(["a1", "a2"], k=3)
print("Istorija: ML + PyTorch")
print("Rekomendacijos:")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Rekomendacija pagal teksto užklausą

Elgsenos profilis ignoruoja vieną dalyką, kurį vartotojas žino geriau už tave: ko jis ieško šiandien. Kadangi katalogas jau užkoduotas, tereikia užkoduoti laisvos formos teksto frazę, kad būtų galima užklausti tą pačią erdvę. „Noriu išmokti kurti API“ iškelia „FastAPI“ straipsnį, net jei skaitytojo istorijoje yra tik mašininis mokymasis. Tai taip pat yra vienintelė galimybė lankytojui, apie kurį nieko nežinai.

def recommander_par_interet(
    description: str,
    k: int = 3
) -> list[dict]:
    """Rekomenduoja straipsnius pagal interesų aprašymą."""
    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
    ]

# „Noriu išmokti kurti žiniatinklio API naudojant Python“
recos = recommander_par_interet("créer des APIs web en Python")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Rekomendacijų įvairovė

Rikiavimas pagal gryną panašumą sukuria matomą trūkumą gamyboje: penkios rekomendacijos atrodo vienodos. CNN straipsnio skaitytojas gauna penkias kompiuterinės regos variacijas, nors antras ar trečias pasiūlymas galėjo atverti duris į transformatorius.

MMR (Maximal Marginal Relevance) tai ištaiso, atrinkdamas straipsnius po vieną: kiekviename žingsnyje jis pasirenka tą, kuris maksimaliai padidina aktualumą užklausai, atėmus maksimalų perteklinumą su jau atrinktais. lambda_param nustato pusiausvyrą – esant 1,0 gauni klasikinį rikiavimą, esant 0,5 – stipriai favorizuoji įvairovę, o numatytoji 0,7 reikšmė suteikia aktualų ir „kvėpuojantį“ sąrašą.

def recommander_divers(
    query_emb: np.ndarray,
    k: int = 5,
    lambda_param: float = 0.7
) -> list[int]:
    """MMR: subalansuoja aktualumą ir įvairovę."""
    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:
            # Aktualumas
            pertinence = scores[idx]

            # Maksimalus perteklinumas su jau atrinktais
            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 balas
            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

Svarbiausi punktai

  • Įterpiniai leidžia rekomenduoti pagal turinio panašumą
  • Vartotojo profilis kuriamas vidurkinant peržiūrėtų straipsnių įterpinius
  • Naujumo svorio koeficientas suteikia daugiau svarbos naujausiems peržiūrėjimams
  • MMR įvairina rekomendacijas, baudžiant už perteklinumą