Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Doporučení na míru

Lekce 19 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Princip: Podobnost se rovná doporučení
  3. Doporučení založená na obsahu
  4. Profil uživatele z historie
  5. Doporučení na základě textového dotazu
  6. Diverzifikace doporučení
  7. Klíčové poznatky

Cíle

  • Vytvořit doporučovací systém založený na vnořeních (embeddings)
  • Implementovat doporučení založená na obsahu i na chování uživatele
  • Zvládnout problém studeného startu a zajistit rozmanitost výsledků

Princip: Podobnost se rovná doporučení

Klasický doporučovací engine sleduje chování: „Lidé, kteří četli tento článek, četli také tenhle.“ Aby mohl říct něco smysluplného, potřebuje obrovský provoz – to je problém studeného startu, který postihuje jak nové katalogy, tak články publikované dnes ráno.

Přístup pomocí vnoření toto čekání přeskočí. Pokud se uživateli líbil nějaký článek, doporučíš mu ty s nejbližšími vnořeními. Jedná se o doporučení založená na obsahu: spoléhají na samotný obsah, nikoliv na chování ostatních uživatelů. Článek publikovaný před deseti minutami, který ještě žádný čtenář neotevřel, již má své vnoření a může být okamžitě doporučován.

Doporučení založená na obsahu

Níže uvedený katalog záměrně mísí dva světy – na jedné straně strojové učení, na druhé softwarové inženýrství – aby byly výsledky ověřitelné. Každý článek je zakódován spojením jeho názvu a obsahu: název zachycuje podstatu tématu, obsah poskytuje slovní zásobu a použití pouze jednoho z nich snižuje kvalitu nalezených sousedů.

Fígl spočívá v řádku scores[idx] = -1. Bez něj by byl článek nejpodobnější sám sobě se skóre 1,0 – a čtenáři bys doporučoval přesně to, co právě dočetl.

from openai import OpenAI
import numpy as np

client = OpenAI()

# Katalog článků
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..."},
]

# Indexace katalogu
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]:
    """Doporučí k nejpodobnějších článků."""
    idx = next(i for i, a in enumerate(articles) if a["id"] == article_id)
    article_emb = catalogue_embs[idx]

    # Podobnost se všemi ostatními články
    scores = catalogue_embs @ article_emb
    scores[idx] = -1  # Vyloučí samotný článek

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

# Uživatel četl „Úvod do strojového učení“
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']}")

Profil uživatele z historie

Doporučování na základě jediného článku čtenáře rychle uvězní v bublině. Abychom zohlednili celou jeho cestu, vytvoříme profilový vektor kombinací vnoření článků, které si prohlédl: tento průměrný bod reprezentuje jeho zájmy ve stejném prostoru jako katalog a následně hledáme články nejblíže tomuto bodu.

Čtení před šesti měsíci by však neměla vážit stejně jako ta ze včerejška. Váhování podle aktuálnosti (recency weighting) toto řeší: faktor 0.5 ** (n - 1 - i) půlí váhu s každým krokem zpět v historii. Čtenář, který se dlouho věnoval strojovému učení, ale nedávno přešel na API, uvidí, jak se mu doporučení během několika článků posunou, místo aby zůstala zmražená. Konečná normalizace vrátí profil na jednotkovou sféru, což je podmínka pro to, aby byl skalární součin s katalogem správnou kosinovou podobností.

def creer_profil_utilisateur(
    articles_consultes: list[str],
    poids_recency: bool = True
) -> np.ndarray:
    """Vytvoří profilový vektor z historie."""
    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:
        # Nedávné články mají větší váhu
        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)

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

def recommander_pour_utilisateur(
    articles_consultes: list[str],
    k: int = 3
) -> list[dict]:
    """Doporučí články na základě uživatelského profilu."""
    profil = creer_profil_utilisateur(articles_consultes)

    scores = catalogue_embs @ profil
    # Vyloučí již přečtené články
    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
    ]

# Uživatel, který četl ML a 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']}")

Doporučení na základě textového dotazu

Behaviorální profil ignoruje jednu věc, kterou uživatel ví lépe než ty: co hledá právě dnes. Protože je katalog již zakódován, stačí zakódovat frázi v přirozeném jazyce a dotazovat se stejného prostoru. Dotaz „Chci se naučit vytvářet API“ vytáhne článek o FastAPI, i když historie čtenáře obsahuje pouze strojové učení. Je to také jediná možnost dostupná pro návštěvníka, o kterém nic nevíš.

def recommander_par_interet(
    description: str,
    k: int = 3
) -> list[dict]:
    """Doporučí články na základě popisu zájmu."""
    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
    ]

# „Chci se naučit vytvářet webové API v Pythonu“
recos = recommander_par_interet("créer des APIs web en Python")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Diverzifikace doporučení

Řazení podle čisté podobnosti produkuje ve výrobě viditelnou chybu: pět doporučení vypadá stejně. Čtenář článku o CNN dostane pět variant počítačového vidění, přitom by druhé nebo třetí doporučení mohlo otevřít dveře transformerům.

MMR (Maximal Marginal Relevance) toto opravuje výběrem článků jeden po druhém: v každém kroku vybere ten, který maximalizuje relevanci k dotazu, minus maximální redundanci s tím, co již bylo vybráno. Parametr lambda_param nastavuje kompromis – při hodnotě 1,0 získáš klasické řazení, při 0,5 silně upřednostňuješ rozmanitost a výchozí hodnota 0,7 poskytuje relevantní seznam, který dýchá.

def recommander_divers(
    query_emb: np.ndarray,
    k: int = 5,
    lambda_param: float = 0.7
) -> list[int]:
    """MMR: vyvažuje relevanci a rozmanitost."""
    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]

            # Maximální redundance s již vybranými
            if selectionnes:
                sims_selectionnes = [
                    float(np.dot(catalogue_embs[idx], catalogue_embs[s]))
                    for s in selectionnes
                ]
                redondance = max(sims_selectionnes)
            else:
                redondance = 0

            # Skóre MMR
            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

Klíčové poznatky

  • Vnoření umožňují doporučení na základě podobnosti obsahu
  • Profil uživatele se vytváří průměrováním vnoření zhlédnutých článků
  • Váhování podle aktuálnosti přidává větší váhu nedávným zhlédnutím
  • MMR diverzifikuje doporučení penalizací redundance