Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Preporuke prilagođene korisniku

Lekcija 19 od 22 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Ciljevi
  2. Načelo: Sličnost jednaka preporuci
  3. Preporuke temeljene na sadržaju
  4. Korisnički profil iz povijesti
  5. Preporuke s tekstualnim upitom
  6. Raznolikost preporuka
  7. Ključne točke

Ciljevi

  • Izgradi sustav preporuka temeljen na ugradnjama (embeddings)
  • Implementiraj preporuke temeljene na sadržaju i na korisniku
  • Riješi problem hladnog starta i osiguraj raznolikost

Načelo: Sličnost jednaka preporuci

Klasičan pogon za preporuke promatra ponašanje: „Ljudi koji su čitali ovaj članak, čitali su i onaj.“ Potrebno je mnogo prometa prije nego što može reći išta korisno – to je problem hladnog starta, koji pogađa i nove kataloge i članke objavljene jutros.

Pristup s ugradnjama preskače to čekanje. Ako je korisniku se svidio članak, preporučuješ one s najbližim ugradnjama. Ovo je preporuka temeljena na sadržaju: oslanja se na sadržaj, a ne na ponašanje drugih korisnika. Članak objavljen prije deset minuta, koji još nijedan čitatelj nije otvorio, već ima ugradnju i odmah postaje preporučljiv.

Preporuke temeljene na sadržaju

Katalog u nastavku namjerno miješa dva svijeta – strojno učenje s jedne strane i softversko inženjerstvo s druge – kako bi rezultati bili provjerljivi. Svaki članak kodiran je spajanjem naslova i sadržaja: naslov sažima temu, sadržaj osigurava rječnik, a korištenje samo jednog od njih umanjuje kvalitetu pronađenih susjeda.

Trik leži u retku scores[idx] = -1. Bez njega, članak najsličniji nekom članku uvijek bi bio on sam, s rezultatom 1.0 – pa bi čitatelju preporučivao ono što je upravo pročitao.

from openai import OpenAI
import numpy as np

client = OpenAI()

# Katalog članaka
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..."},
]

# Indeksiraj katalog
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]:
    """Preporučuje k najsličnijih članaka."""
    idx = next(i for i, a in enumerate(articles) if a["id"] == article_id)
    article_emb = catalogue_embs[idx]

    # Sličnost sa svim ostalim člancima
    scores = catalogue_embs @ article_emb
    scores[idx] = -1  # Isključi sam članak

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

# Korisnik čita "Uvod u strojno učenje"
recos = recommander_similaires("a1", k=3)
print("Pročitao/la si: Introduction au machine learning")
print("Preporuke:")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Korisnički profil iz povijesti

Preporučivanje na temelju jednog članka brzo zarobljava čitatelja. Da bi uzeo u obzir cijelo njegovo putovanje, gradiš vektor profila kombiniranjem ugradnji članaka koje je pregledao: ta prosječna točka predstavlja njegove interese u istom prostoru kao i katalog, a zatim tražiš članke najbliže toj točki.

Međutim, čitanja od prije šest mjeseci ne bi trebala težiti isto kao jučerašnja. Vaganje po novosti to rješava: faktor 0.5 ** (n - 1 - i) prepolovljuje težinu pri svakom koraku unatrag u povijesti. Čitatelj koji je dugo pratio strojno učenje, ali se nedavno prebacio na API-je, vidjet će kako se njegove preporuke pomiču unutar nekoliko članaka umjesto da ostanu zamrznute. Konačna normalizacija vraća profil na jediničnu sferu, što je uvjet da točkasti umnožak s katalogom bude ispravna kosinusna sličnost.

def creer_profil_utilisateur(
    articles_consultes: list[str],
    poids_recency: bool = True
) -> np.ndarray:
    """Stvara vektor profila iz povijesti."""
    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:
        # Nedavni članci više vrijede
        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)

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

def recommander_pour_utilisateur(
    articles_consultes: list[str],
    k: int = 3
) -> list[dict]:
    """Preporučuje članke na temelju korisničkog profila."""
    profil = creer_profil_utilisateur(articles_consultes)

    scores = catalogue_embs @ profil
    # Isključi već pregledane članke
    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
    ]

# Korisnik koji je čitao ML i duboko učenje
recos = recommander_pour_utilisateur(["a1", "a2"], k=3)
print("Povijest: ML + PyTorch")
print("Preporuke:")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Preporuke s tekstualnim upitom

Bihevioralni profil ignorira jednu stvar koju korisnik zna bolje od tebe: što danas traži. Budući da je katalog već kodiran, trebaš samo kodirati frazu slobodnog teksta kako bi upitao isti prostor. „Želim naučiti kako stvoriti API-je“ izvlači članak o FastAPI-ju, čak i ako povijest čitatelja sadrži samo strojno učenje. Ovo je također jedina opcija dostupna za posjetitelja o kojem ne znaš ništa.

def recommander_par_interet(
    description: str,
    k: int = 3
) -> list[dict]:
    """Preporučuje članke na temelju opisa interesa."""
    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
    ]

# "Želim naučiti kako stvoriti API-je"
recos = recommander_par_interet("créer des APIs web en Python")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Raznolikost preporuka

Sortiranje po čistoj sličnosti proizvodi vidljiv nedostatak u produkciji: pet preporuka izgleda isto. Čitatelj članka o CNN-u dobiva pet varijanti računalnog vida, dok bi druga ili treća sugestija mogle otvoriti vrata transformerima.

MMR (Maximal Marginal Relevance) to popravlja odabirom članaka jedan po jedan: u svakom krugu bira onaj koji maksimizira relevantnost za upit, umanjenu za maksimalnu redundanciju s već odabranima. Parametar lambda_param postavlja kompromis – na 1.0 dobivaš klasično sortiranje, na 0.5 snažno favoriziraš raznolikost, a zadana vrijednost 0.7 daje relevantan popis koji „diše“.

def recommander_divers(
    query_emb: np.ndarray,
    k: int = 5,
    lambda_param: float = 0.7
) -> list[int]:
    """MMR: balansira relevantnost i raznolikost."""
    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:
            # Relevantnost
            pertinence = scores[idx]

            # Maksimalna redundancija s već odabranima
            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 rezultat
            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 točke

  • Ugradnje omogućuju preporuke po sličnosti sadržaja
  • Korisnički profil gradi se prosječnim vrijednostima pregledanih ugradnji
  • Vaganje po novosti daje veću težinu nedavnim pregledima
  • MMR raznolikuje preporuke kažnjavanjem redundancije