0 dní v řadě · 0 bodů

Neuronové sítě a moderní AI · 30 min

Embeddingy a podobnost

Jak se ze slov stanou čísla, která nesou význam. Měříš podobnost, učíš vektory z textu a stavíš malé sémantické vyhledávání.

Hloubka
Úkoly
Lidsky řečeno

Každé město má na mapě dvě souřadnice. Nikdo si je nepamatuje, ale z čísel hned poznáš, že Brno je blíž k Vídni než k Lisabonu. Embedding je taková mapa pro slova, filmy nebo zákazníky. Místo dvou souřadnic jich má třeba stovky a blízko sebe leží věci, které si jsou v něčem podobné.

Proč nestačí očíslovat slova

Síť počítá s čísly. Když slovu pes přidělíš 1, kočka 2 a traktor 3, vznikne nesmysl: kočka je pak „průměr“ psa a traktoru. Lepší je one-hot: vektor samých nul s jedinou jedničkou na místě daného slova. Tím zmizí falešné pořadí, ale tipni si, jak daleko od sebe slova jsou.

import numpy as np

slova = ["pes", "kočka", "traktor"]
one_hot = np.eye(3)

print(one_hot[0])
print(one_hot[0] @ one_hot[1])
print(one_hot[0] @ one_hot[2])
print(round(float(np.linalg.norm(one_hot[0] - one_hot[1])), 3))
print(round(float(np.linalg.norm(one_hot[0] - one_hot[2])), 3))
Výstup
[1. 0. 0.]
0.0
0.0
1.414
1.414

Všechna slova jsou od sebe stejně daleko. Pes má ke kočce stejně blízko jako k traktoru. Navíc při slovníku o sto tisících slovech má každý vektor sto tisíc čísel.

Embedding přiřadí každému slovu krátký vektor desetinných čísel, například o 64 hodnotách. Ty se nenastavují ručně, síť se je naučí. Technicky je to obyčejná tabulka: řádek je slovo, sloupec jedna souřadnice.

import numpy as np

E = np.array([
    [0.9, 0.1],     # pes
    [0.8, 0.2],     # kočka
    [0.0, 1.0],     # traktor
])

ids = np.array([2, 0, 0])
print(E[ids])
print(E[ids].shape)

one_hot = np.eye(3)[1]
print(one_hot @ E)
Výstup
[[0.  1. ]
 [0.9 0.1]
 [0.9 0.1]]
(3, 2)
[0.8 0.2]

Poslední řádek ukazuje podstatu: vyhledání v tabulce je totéž jako násobení one-hot vektorem. Embedding je tedy lineární vrstva bez posunu, jen uložená úsporně. V PyTorch se jmenuje nn.Embedding a její váhy se učí jako všechny ostatní.

python
import torch
from torch import nn

emb = nn.Embedding(num_embeddings=10_000, embedding_dim=64, padding_idx=0)

ids = torch.tensor([[5, 42, 7, 0], [9, 1, 0, 0]])  # (batch, tokens), 0 = padding
vectors = emb(ids)
print(vectors.shape)                               # torch.Size([2, 4, 64])
print(emb.weight.shape)                            # torch.Size([10000, 64])

Jak měřit podobnost

Máš dva vektory a chceš číslo, které řekne, jak moc si jsou podobné. Běžné jsou tři míry:

MíraVzorecNa co reaguje
skalární součina @ bsměr i délku
kosinová podobnost`a @ b / (a*b)`jen směr, rozsah -1 až 1
eukleidovská vzdálenost`a - b`polohu, menší znamená bližší

Kosinus je kosinus úhlu mezi vektory. Hodnota 1 znamená stejný směr, 0 kolmý a -1 opačný. Délka vektoru ho nezajímá, a to bývá žádoucí.

import numpy as np

def cosine(a, b):
    return float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b)))

a = np.array([1.0, 2.0, 0.5])
long_a = a * 10
other = np.array([-2.0, 0.5, 1.0])

print("skalární součin a, a:", float(a @ a))
print("skalární součin a, 10a:", float(a @ long_a))
print("kosinus a, 10a:", round(cosine(a, long_a), 3))
print("kosinus a, jiný:", round(cosine(a, other), 3))
Výstup
skalární součin a, a: 5.25
skalární součin a, 10a: 52.5
kosinus a, 10a: 1.0
kosinus a, jiný: -0.095
Úkol

Kosinová podobnost

Napiš funkci kosinus(a, b), která vrátí kosinovou podobnost dvou vektorů NumPy. Když má některý vektor nulovou délku, vrať 0.0, aby se nedělilo nulou.

import numpy as np

def kosinus(a, b):
    return a @ b
Výstup

Když všechny vektory předem znormalizuješ na délku 1, všechny tři míry se propojí: skalární součin je rovnou kosinus a vzdálenost dá stejné pořadí. Proto se v praxi ukládají normalizované vektory a počítá se levný skalární součin.

import numpy as np

rng = np.random.RandomState(0)
a, b = rng.randn(2, 8)
a = a / np.linalg.norm(a)
b = b / np.linalg.norm(b)

cos = a @ b
dist2 = np.sum((a - b) ** 2)
print(round(float(cos), 4))
print(round(float(dist2), 4))
print(round(float(2 - 2 * cos), 4))
Výstup
0.7372
0.5257
0.5257
Kvíz

Dva normalizované vektory mají kosinovou podobnost 1. Jaká je jejich eukleidovská vzdálenost?

Význam z okolí

Odkud se význam vezme, když slovník nikomu nevysvětluje, co je pes? Z pozorování, které se nazývá distribuční hypotéza: slova v podobném okolí mají podobný význam. Když o něčem čteš „spí na dvoře“ a „žere z misky“, je to nejspíš zvíře.

Vyzkoušej si to na malém umělém korpusu. Spočítáš, která slova se potkávají, převedeš počty na míru překvapení a zhustíš je rozkladem SVD.

Ta míra je PPMI. Říká, kolikrát častěji se dvě slova potkala, než by odpovídalo náhodě. Záporné hodnoty se nahradí nulou. Časté výplňové slovo jako „na“ tak nepřehluší všechno ostatní.

import numpy as np

groups = {
    "zvíře": ("pes kočka kůň kráva", ["{} spí na dvoře", "{} běží po louce", "{} žere z misky"]),
    "jídlo": ("polévka guláš knedlík bramborák", ["{} voní v kuchyni", "{} leží na talíři", "{} chutná skvěle"]),
    "stroj": ("auto vlak autobus traktor", ["{} jede po silnici", "{} stojí v garáži", "{} veze náklad"]),
}
sentences = [
    template.format(word).split()
    for words, templates in groups.values()
    for word in words.split()
    for template in templates
]
vocab = sorted({w for s in sentences for w in s})
index = {w: i for i, w in enumerate(vocab)}

counts = np.zeros((len(vocab), len(vocab)))
for s in sentences:
    for i, word in enumerate(s):
        for j in range(max(0, i - 2), min(len(s), i + 3)):
            if i != j:
                counts[index[word], index[s[j]]] += 1

total = counts.sum()
p_word = counts.sum(axis=1, keepdims=True) / total
p_context = counts.sum(axis=0, keepdims=True) / total
with np.errstate(divide="ignore"):
    pmi = np.log((counts / total) / (p_word * p_context))
ppmi = np.maximum(pmi, 0)

U, S, _ = np.linalg.svd(ppmi)
E = U[:, :4] * S[:4]
E = E / np.linalg.norm(E, axis=1, keepdims=True)

def similar(word, k=3):
    scores = E @ E[index[word]]
    scores[index[word]] = -2
    return sorted(vocab[i] for i in np.argsort(-scores)[:k])

print("slov:", len(vocab), " vět:", len(sentences))
for word in ["pes", "polévka", "vlak"]:
    print(word, "->", similar(word))

for a, b in [("pes", "kůň"), ("pes", "guláš"), ("vlak", "traktor")]:
    print(a, b, round(float(E[index[a]] @ E[index[b]]), 1) + 0.0)
Výstup
slov: 34  vět: 36
pes -> ['kočka', 'kráva', 'kůň']
polévka -> ['bramborák', 'guláš', 'knedlík']
vlak -> ['auto', 'autobus', 'traktor']
pes kůň 1.0
pes guláš 0.2
vlak traktor 1.0

Program nikde nedostal informaci, že pes je zvíře. Stačilo mu, že pes a kůň se objevují ve stejných větách. Ve skutečném textu je to mnohem zašuměnější, ale princip platí.

Učení gradientním sestupem

Druhá cesta je skip-gram s negativním vzorkováním, jádro známého word2vec. Pro každý pár (slovo, soused) chceme vysoký skalární součin. Pro pár se slovem vylosovaným náhodně nízký. Každé slovo má dva vektory: jeden v roli středu a jeden v roli souseda.

text
ztráta = -log σ(střed · soused) - Σ log σ(-střed · náhodné)

σ je sigmoida. Celé to je vlastně logistická regrese nad páry slov, jen se místo vah učí samotné vektory.

import numpy as np

groups = [
    ("pes kočka kůň kráva", ["{} spí na dvoře", "{} běží po louce", "{} žere z misky"]),
    ("polévka guláš knedlík bramborák", ["{} voní v kuchyni", "{} leží na talíři", "{} chutná skvěle"]),
    ("auto vlak autobus traktor", ["{} jede po silnici", "{} stojí v garáži", "{} veze náklad"]),
]
sentences = [t.format(w).split() for words, ts in groups for w in words.split() for t in ts]
vocab = sorted({w for s in sentences for w in s})
index = {w: i for i, w in enumerate(vocab)}
V, DIM, NEG = len(vocab), 8, 3

pairs = np.array([
    (index[w], index[s[j]])
    for s in sentences
    for i, w in enumerate(s)
    for j in range(max(0, i - 2), min(len(s), i + 3)) if i != j
])

rng = np.random.RandomState(0)
W = rng.normal(0, 0.1, (V, DIM))      # word vectors
C = rng.normal(0, 0.1, (V, DIM))      # context vectors

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

for epoch in range(300):
    center, context = pairs.T
    negative = rng.randint(V, size=(len(pairs), NEG))

    pos = sigmoid(np.sum(W[center] * C[context], axis=1))
    neg = sigmoid(np.sum(W[center][:, None] * C[negative], axis=2))

    grad_W = np.zeros_like(W)
    grad_C = np.zeros_like(C)
    np.add.at(grad_W, center, (pos - 1)[:, None] * C[context])
    np.add.at(grad_W, center, np.sum(neg[..., None] * C[negative], axis=1))
    np.add.at(grad_C, context, (pos - 1)[:, None] * W[center])
    np.add.at(grad_C, negative.ravel(), (neg[..., None] * W[center][:, None]).reshape(-1, DIM))

    W -= 0.02 * grad_W
    C -= 0.02 * grad_C

E = W / np.linalg.norm(W, axis=1, keepdims=True)

for word in ["pes", "knedlík", "autobus"]:
    scores = E @ E[index[word]]
    scores[index[word]] = -2
    print(word, "->", sorted(vocab[i] for i in np.argsort(-scores)[:3]))
Výstup
pes -> ['kočka', 'kráva', 'kůň']
knedlík -> ['bramborák', 'guláš', 'polévka']
autobus -> ['auto', 'traktor', 'vlak']
Spoj dvojice

Spoj pojmy

Spoj pojem s jeho popisem.

Sémantické vyhledávání

Když máš vektory, je vyhledávání prosté: dotaz převedeš na vektor a najdeš nejbližší. Normalizovaná matice to zvládne jediným násobením. Vektory v ukázce jsou ručně vymyšlené a jejich osy znamenají přibližně zvíře, jídlo a dopravu.

import numpy as np

items = ["jak vycvičit štěně", "recept na guláš", "jízdní řád vlaků", "krmení koček", "levné jízdenky"]
M = np.array([
    [0.9, 0.1, 0.0],
    [0.1, 1.0, 0.0],
    [0.0, 0.0, 1.0],
    [0.8, 0.4, 0.0],
    [0.0, 0.1, 0.9],
])
M = M / np.linalg.norm(M, axis=1, keepdims=True)

query = np.array([0.7, 0.6, 0.0])       # "what should my dog eat"
query = query / np.linalg.norm(query)

scores = M @ query
for i in np.argsort(-scores)[:3]:
    print(f"{scores[i]:.2f}  {items[i]}")
Výstup
0.97  krmení koček
0.83  jak vycvičit štěně
0.72  recept na guláš
Úkol

Nejbližší sousedé

Napiš funkci nejblizsi(M, slova, slovo, k). M je matice s normalizovanými řádky a slova je seznam názvů řádků. Funkce vrátí seznam k nejpodobnějších slov od nejbližšího, bez hledaného slova.

import numpy as np

def nejblizsi(M, slova, slovo, k):
    return slova[:k]
Výstup
Najdi chybu

Dlouhý dokument vždycky vyhraje

Dotaz se týká prvního tématu, takže má vyhrát dokument 0. Vyhrává ale dlouhý dokument 1, který je o něčem jiném.

Vektor celé věty se nejjednodušeji získá průměrem vektorů slov. Je to levné a často použitelné, má to ale tvrdou mez.

import numpy as np

E = {
    "dvě": np.array([0.2, 0.9, 0.1]),
    "tři": np.array([0.3, 0.8, 0.2]),
    "mínus": np.array([0.9, 0.1, 0.4]),
}

def sentence(text):
    return np.mean([E[w] for w in text.split()], axis=0)

a = sentence("dvě mínus tři")
b = sentence("tři mínus dvě")
cos = a @ b / (np.linalg.norm(a) * np.linalg.norm(b))
print(round(float(cos), 3))
Výstup
1.0

Výrazy s opačným výsledkem mají stejný vektor, protože průměr nezná pořadí. Slovo má navíc jediný vektor bez ohledu na větu, takže „zámek“ na dveřích a „zámek“ na kopci splývají. Oba problémy řeší až attention.

Pod kapotou · embeddingy v produkci

Hledání ve velkém. Přesné hledání stojí O(N·d) na dotaz. Od určitého objemu se přechází na přibližné metody (ANN): HNSW prochází vícevrstvý graf sousedů, IVF hledá jen v několika shlucích, PQ vektory komprimuje. Vyměňuješ přesnost za rychlost a paměť, takže měř recall@k proti přesnému hledání na vlastních datech. Princip ukazuje jednoduché hashování náhodnými rovinami (LSH): vektory na stejné straně náhodných rovin spadnou do stejného koše a porovnáš jen ty.

import numpy as np

rng = np.random.RandomState(0)
centers = rng.randn(50, 32)
data = centers[rng.randint(50, size=5000)] + 0.35 * rng.randn(5000, 32)
data /= np.linalg.norm(data, axis=1, keepdims=True)
queries = data[:100] + 0.02 * rng.randn(100, 32)
queries /= np.linalg.norm(queries, axis=1, keepdims=True)
base = data[100:]

TABLES, BITS = 6, 8
planes = rng.randn(TABLES, BITS, 32)
powers = 2 ** np.arange(BITS)

def buckets(x, table):
    return ((x @ planes[table].T > 0) * powers).sum(axis=-1)

stored = [buckets(base, t) for t in range(TABLES)]
hits, looked_at = 0, 0
for q in queries:
    mask = np.zeros(len(base), dtype=bool)
    for t in range(TABLES):
        mask |= stored[t] == buckets(q, t)
    candidates = np.flatnonzero(mask)
    looked_at += len(candidates)
    exact = int(np.argmax(base @ q))
    if len(candidates) and candidates[np.argmax(base[candidates] @ q)] == exact:
        hits += 1

print(f"recall@1: {hits / len(queries):.2f}")
print(f"prohlédnuto: {looked_at / len(queries) / len(base):.0%} databáze")
Výstup
recall@1: 0.92
prohlédnuto: 5% databáze

Vektory různých modelů nejsou porovnatelné. I nová verze téhož modelu znamená přepočítat celý index. Ukládej k vektorům identifikátor modelu a verzi a migraci plánuj jako změnu schématu.

Asymetrie. Krátký dotaz a dlouhý dokument jsou jiné rozdělení dat. Některé modely proto rozlišují kódování dotazu a dokumentu a smíchání obou režimů tiše zhorší výsledky.

Hubness. Ve vysokých dimenzích se některé body stávají sousedy nápadně mnoha jiných. Projeví se to tím, že se v doporučeních pořád objevují tytéž položky.

Slavná analogie král - muž + žena ≈ královna funguje hlavně proto, že se při vyhodnocení vylučují vstupní slova. Bez toho bývá nejbližší samo král. Je to hezká ilustrace, ne spolehlivá vlastnost.

nn.Embedding s padding_idx drží gradient daného řádku na nule. sparse=True šetří paměť u velkých slovníků, ale podporuje ho jen část optimalizátorů (SGD, SparseAdam, Adagrad). V jazykových modelech se váhy embeddingu často sdílejí s výstupní vrstvou (weight tying).

Kartičky

Opakování

Vyzkoušej si: Mapa významů

Malá ručně vytvořená ukázka, ne skutečný model: kosinová podobnost, nejbližší sousedé a aritmetika s vektory.