0 dní v řadě · 0 bodů

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

Jak fungují velké jazykové modely

Tokeny, předpověď dalšího slova, teplota, top-k, top-p, chatová šablona a proč si model umí sebejistě vymýšlet.

Hloubka
Úkoly
Lidsky řečeno

Znáš napovídání slov v telefonu. Napíšeš „dobrý“ a nabídne „den“. Velký jazykový model dělá v principu totéž, jen se při tom opírá o obrovské množství přečteného textu a o celý dosavadní rozhovor. Slovo za slovem odhaduje, co by tu nejspíš mohlo stát. Nic si přitom nevyhledává v encyklopedii. To vysvětluje, proč umí napsat skvělý e-mail i úplný nesmysl stejně přesvědčivým tónem.

Text se mění na tokeny

Velký jazykový model, anglicky large language model, zkráceně LLM, je transformer natrénovaný na velkém množství textu. Neuronová síť ale počítá s čísly, takže text je potřeba nejdřív rozsekat na kousky a každému přidělit číslo. Kousek se jmenuje token a program, který sekání provádí, tokenizer.

Token není totéž co slovo ani písmeno. Bývá to běžná část slova. Základem bývá text v bajtech, kde česká písmena s diakritikou zaberou víc místa než písmena bez ní.

for text in ["kocka", "kočka", "příliš"]:
    data = text.encode("utf-8")
    print(text, "| znaků:", len(text), "| bajtů:", len(data), "|", list(data))
Výstup
kocka | znaků: 5 | bajtů: 5 | [107, 111, 99, 107, 97]
kočka | znaků: 5 | bajtů: 6 | [107, 111, 196, 141, 107, 97]
příliš | znaků: 6 | bajtů: 9 | [112, 197, 153, 195, 173, 108, 105, 197, 161]

Oblíbená metoda byte pair encoding (BPE) je překvapivě jednoduchá. Začne jednotlivými bajty, najde dvojici, která se v textu vyskytuje nejčastěji, a nahradí ji novým tokenem. Pak to opakuje. Časté kousky slov tak samy srostou dohromady.

from collections import Counter

def merge(ids, pair, new_id):
    out, i = [], 0
    while i < len(ids):
        if i + 1 < len(ids) and (ids[i], ids[i + 1]) == pair:
            out.append(new_id)
            i += 2
        else:
            out.append(ids[i])
            i += 1
    return out

text = ("pekař peče chleba, pekařka peče koláče, "
        "pekaři pečou rohlíky a pekárna voní chlebem. ") * 3

ids = list(text.encode("utf-8"))
vocab = {i: bytes([i]) for i in range(256)}
merges = {}
start = len(ids)

for new_id in range(256, 286):
    counts = Counter(zip(ids, ids[1:]))
    pair = max(counts, key=lambda p: (counts[p], p))
    ids = merge(ids, pair, new_id)
    merges[pair] = new_id
    vocab[new_id] = vocab[pair[0]] + vocab[pair[1]]

def encode(s):
    ids = list(s.encode("utf-8"))
    while len(ids) > 1:
        known = [p for p in zip(ids, ids[1:]) if p in merges]
        if not known:
            break
        pair = min(known, key=merges.get)
        ids = merge(ids, pair, merges[pair])
    return ids

print("délka trénovacího textu:", start, "->", len(ids), "tokenů")
for word in ["pekař peče", "pekárna", "zebra"]:
    tokens = encode(word)
    print(repr(word), "->", [vocab[t].decode("utf-8", "replace") for t in tokens])
Výstup
délka trénovacího textu: 288 -> 92 tokenů
'pekař peče' -> ['pe', 'kař', ' pe', 'če']
'pekárna' -> ['pe', 'k', 'á', 'r', 'n', 'a']
'zebra' -> ['z', 'e', 'b', 'r', 'a']

Slova podobná tréninkovému textu se složí z několika dlouhých kousků. Neznámé slovo se rozpadne na drobky. Z toho plyne praktický důsledek: text v jazyce, který byl v tréninku slabě zastoupený, typicky spotřebuje víc tokenů, a tokeny jsou to, čím se měří délka vstupu i cena výpočtu.

Úkol

Slij dvojici tokenů

Napiš funkci merge(ids, pair, new_id). Projde seznam zleva doprava a každý výskyt dvojice pair nahradí jedním číslem new_id. Překrývající se výskyty se počítají zleva, takže [1, 1, 1] s dvojicí (1, 1) dá [new_id, 1].

def merge(ids, pair, new_id):
    # doplň
    return ids
Výstup

Celý trik: co přijde dál

Model dostane tokeny a na výstupu vrátí pro každý možný další token jedno číslo, logit. Funkce softmax z logitů udělá pravděpodobnosti. Jeden token se vybere, připojí k textu a všechno se opakuje. Odpověď tedy nevzniká naráz, ale po jednom tokenu.

Ten princip jde ukázat bez neuronové sítě. Nejmenší možný jazykový model se dívá jen na poslední znak a pamatuje si, co po něm v textu obvykle následovalo. Říká se mu bigramový model.

import numpy as np

text = ("v lese roste les a v lese roste mech. "
        "na louce roste tráva a na louce kvete mák. "
        "v řece plave ryba a v moři plave velryba. "
        "ráno roste chuť na kávu a večer roste chuť na spánek. ") * 4

chars = sorted(set(text))
index = {c: i for i, c in enumerate(chars)}
ids = np.array([index[c] for c in text])

counts = np.ones((len(chars), len(chars)))
np.add.at(counts, (ids[:-1], ids[1:]), 1)
probs = counts / counts.sum(axis=1, keepdims=True)

row = probs[index["r"]]
print("po písmenu r nejčastěji následuje:")
for i in row.argsort()[::-1][:4]:
    print(f"  {chars[i]!r}: {row[i]:.2f}")

rng = np.random.RandomState(7)
tokens = [index["v"]]
for _ in range(70):
    tokens.append(rng.choice(len(chars), p=probs[tokens[-1]]))
print("".join(chars[t] for t in tokens))
Výstup
po písmenu r nejčastěji následuje:
  'o': 0.33
  'á': 0.14
  'y': 0.14
  ' ': 0.08
v terřlk. noucbav ná.křecybkvea na máva. nae nosv roste  allořp. rnřřyi

Výsledek připomíná češtinu asi jako opilý papoušek. Model totiž vidí jediný znak zpátky. Transformer dělá stejnou úlohu, ale každý token se pomocí attention dívá na tisíce předchozích tokenů a zachytí tak gramatiku, souvislosti i styl. Vnější smyčka generování zůstává stejná.

Slož kód

Generovací smyčka

Slož funkci, která generuje tokeny. Model smí vidět jen posledních window tokenů, zastaví se u tokenu eos nebo po max_new krocích.

Teplota: odvaha modelu

Kdyby model vždy bral nejpravděpodobnější token, psal by předvídatelně a často by se zacyklil. Proto se vzorkuje, tedy losuje podle pravděpodobností. Míru náhody řídí teplota: logity se před softmaxem vydělí číslem T. Malá teplota zvýrazní favorita, velká rozdíly stírá. Posouvej ji a sleduj, jak se mění rozdělení.

import numpy as np

words = ["město", "nádraží", "třída", "ulice", "banán"]
logits = np.array([5.0, 3.2, 2.9, 2.0, -1.0])

scaled = logits / teplota
p = np.exp(scaled - scaled.max())
p = p / p.sum()

print(f"Praha je hlavní ...   (teplota {teplota:.1f})")
for word, value in zip(words, p):
    print(f"{word:8} {value:6.1%} {'#' * round(value * 40)}")
Výstup
Praha je hlavní ...   (teplota 1.0)
město     74.6% ##############################
nádraží   12.3% #####
třída      9.1% ####
ulice      3.7% #
banán      0.2%

Top-k a top-p: odřízni nesmysly

Při losování hrozí, že občas padne token s malou pravděpodobností, a jeden nesmysl pak stočí zbytek textu. Dvě běžné pojistky:

  • Top-k nechá jen k nejpravděpodobnějších tokenů.
  • Top-p (nucleus sampling) nechá nejmenší skupinu nejlepších tokenů, jejichž součet dosáhne aspoň p. Když si je model jistý, zůstane jich málo. Když váhá, víc.

Po odříznutí se zbytek znovu přepočítá, aby dával součet 1.

import numpy as np

def top_p(probs, p):
    order = np.argsort(probs)[::-1]
    total = np.cumsum(probs[order])
    keep = np.searchsorted(total, p) + 1
    out = np.zeros_like(probs)
    out[order[:keep]] = probs[order[:keep]]
    return out / out.sum()

confident = np.array([0.90, 0.05, 0.03, 0.01, 0.01])
unsure = np.array([0.30, 0.25, 0.20, 0.15, 0.10])

for name, probs in [("jistý", confident), ("váhavý", unsure)]:
    filtered = top_p(probs, 0.8)
    print(f"{name:7} zůstalo tokenů: {np.count_nonzero(filtered)}  {filtered.round(2).tolist()}")
Výstup
jistý   zůstalo tokenů: 1  [1.0, 0.0, 0.0, 0.0, 0.0]
váhavý  zůstalo tokenů: 4  [0.33, 0.28, 0.22, 0.17, 0.0]
Úkol

Filtr top-k

Napiš funkci top_k(probs, k). Vrátí nové pole stejné délky, kde zůstane k největších pravděpodobností na svých místech, ostatní budou 0 a součet bude 1. Vstup neměň. Když je k větší než počet tokenů, vrať normalizovanou kopii.

import numpy as np

def top_k(probs, k):
    # doplň
    return probs
Výstup
Spoj dvojice

Spoj nastavení s účinkem

Co které nastavení udělá?

Jak se model učí

Trénink je překvapivě přímočarý. Z textu se vezme úsek a cíl je tentýž úsek posunutý o jeden token. Model na každém místě hádá další token a chyba se měří křížovou entropií: čím menší pravděpodobnost dal správnému tokenu, tím větší trest.

text
vstup:  P  r  a  h  a
cíl:    r  a  h  a  ␣

Průměrná chyba má hezký výklad. Vezmeš-li z ní exp, dostaneš perplexitu: mezi kolika tokeny se model v průměru rozhoduje, jako by je měl rovnocenné. Porovnej rovnoměrné hádání s bigramem na textu, který model při učení neviděl.

import numpy as np

train = ("les roste a v lese je ticho. v lese roste mech a v trávě žije brouk. "
         "na louce roste tráva a nad loukou letí pták. ") * 5
test = "v trávě roste mech a nad lesem letí brouk."

chars = sorted(set(train))
index = {c: i for i, c in enumerate(chars)}
ids = np.array([index[c] for c in train])
test_ids = np.array([index[c] for c in test])

counts = np.full((len(chars), len(chars)), 0.1)
np.add.at(counts, (ids[:-1], ids[1:]), 1)
probs = counts / counts.sum(axis=1, keepdims=True)

uniform = np.log(len(chars))
bigram = -np.log(probs[test_ids[:-1], test_ids[1:]]).mean()

print(f"velikost slovníku: {len(chars)}")
print(f"rovnoměrné hádání: chyba {uniform:.2f}, perplexita {np.exp(uniform):.1f}")
print(f"bigramový model:   chyba {bigram:.2f}, perplexita {np.exp(bigram):.1f}")
Výstup
velikost slovníku: 25
rovnoměrné hádání: chyba 3.22, perplexita 25.0
bigramový model:   chyba 1.40, perplexita 4.1

Předtrénovaný model umí pokračovat v textu, ale sám od sebe nemusí být užitečný asistent. Proto následuje doladění na příkladech typu „požadavek a dobrá odpověď“ a často i učení ze zpětné vazby, které odpovědi lidé nebo jiný model hodnotili lépe. Styl a ochota pomáhat tedy vznikají až v této fázi. Základní mechanismus se nemění: pořád je to předpověď dalšího tokenu.

Roztřiď

Trénink, nebo generování?

Kdy se co děje?

Chat je jeden dlouhý text

Rozhovor s modelem působí jako výměna zpráv. Model ale vidí jedinou posloupnost tokenů. Chatová šablona zprávy spojí pomocí speciálních značek. Značky níže jsou smyšlené, každý model má vlastní.

messages = [
    {"role": "system", "content": "Odpovídej stručně."},
    {"role": "user", "content": "Kolik má týden dní?"},
    {"role": "assistant", "content": "Sedm."},
    {"role": "user", "content": "A rok měsíců?"},
]

def apply_template(messages):
    parts = [f"<|{m['role']}|>\n{m['content']}\n<|end|>\n" for m in messages]
    return "".join(parts) + "<|assistant|>\n"

print(apply_template(messages))
Výstup
<|system|>
Odpovídej stručně.
<|end|>
<|user|>
Kolik má týden dní?
<|end|>
<|assistant|>
Sedm.
<|end|>
<|user|>
A rok měsíců?
<|end|>
<|assistant|>

Z toho vyplývají tři věci, které šetří spoustu zmatků:

  • Model si mezi voláními nic nepamatuje. Aplikace mu při každém dotazu pošle historii znovu. Váhy se během odpovídání nemění.
  • Kontext má omezenou délku. Co se do něj nevejde, model nevidí. Aplikace musí historii zkracovat nebo shrnovat.
  • Systémový pokyn není zeď. Je to jen další text v posloupnosti, i když se model učí mu dávat přednost. Důsledky rozebírá lekce RAG a práce s LLM v aplikaci.
Úkol

Vejdi se do kontextu

Napiš funkci trim_history(messages, limit). První zpráva je systémová a zůstává vždy. Z ostatních nech co nejvíc nejnovějších souvislých zpráv tak, aby součet slov všech ponechaných zpráv včetně systémové nepřesáhl limit. Slova počítej přes len(text.split()). Pořadí zachovej.

def trim_history(messages, limit):
    # doplň
    return messages
Výstup

Proč si model vymýšlí

Softmax vrací rozdělení, které má vždycky součet 1. Model nemá přirozenou možnost říct „tohle nevím“, pokud se ji nenaučil jako další text. Navíc platí, že pravděpodobnost není jistota pravdy. Malá ukázka: lineární model se třemi třídami dostane vstup, který je čím dál dál od všeho rozumného. Jeho sebejistota přitom roste.

import numpy as np

W = np.array([[1.0, -0.5], [-0.8, 1.2], [0.1, -1.0]])
direction = np.array([0.6, 0.8])

for scale in [0.5, 1, 5, 20, 100]:
    logits = W @ (direction * scale)
    p = np.exp(logits - logits.max())
    p = p / p.sum()
    print(f"vstup x{scale:<4} nejlepší třída {p.argmax()}, jistota {p.max():.1%}")
Výstup
vstup x0.5  nejlepší třída 1, jistota 41.4%
vstup x1    nejlepší třída 1, jistota 48.8%
vstup x5    nejlepší třída 1, jistota 80.1%
vstup x20   nejlepší třída 1, jistota 99.6%
vstup x100  nejlepší třída 1, jistota 100.0%

Jazykový model není tak jednoduchý, ale základní poučení platí. Když dostane otázku, na kterou nezná odpověď, statisticky věrohodné pokračování často vypadá jako fakt: správný tvar věty, přesvědčivé jméno, datum. Takovému výstupu se říká halucinace. Model nelže, protože nemá záměr. Generuje věrohodný text a věrohodnost není totéž co pravda.

Kvíz

Proč model po zavření rozhovoru „neví“, o čem byla řeč?

Kvíz

Co udělá snížení teploty?

Pod kapotou · výkon, paměť a realita inference

KV cache. Při generování se klíče a hodnoty dřívějších tokenů nemění, protože kauzální maska brání vlivu pozdějších tokenů. Stačí je uložit a počítat jen nový řádek. Cenou je paměť rostoucí s délkou kontextu a počtem vrstev. Ukázka počítá dvojice tokenů, které attention porovná:

def pairs_without_cache(n):
    return sum(t * t for t in range(1, n + 1))

def pairs_with_cache(n):
    return sum(range(1, n + 1))

for n in [100, 1000, 4000]:
    a, b = pairs_without_cache(n), pairs_with_cache(n)
    print(f"{n:5} tokenů: bez cache {a:>14,}  s cache {b:>10,}  poměr {a / b:,.0f}x")
Výstup
  100 tokenů: bez cache        338,350  s cache      5,050  poměr 67x
 1000 tokenů: bez cache    333,833,500  s cache    500,500  poměr 667x
 4000 tokenů: bez cache 21,341,334,000  s cache  8,002,000  poměr 2,667x

Prompt caching rozšiřuje stejnou myšlenku mezi požadavky: shodný začátek kontextu se nemusí počítat znovu. Proto se vyplatí dát stabilní část promptu dopředu a proměnlivou na konec. Jakákoli změna na začátku invaliduje všechno za ní.

Paměť vah. Hrubý odhad je počet parametrů × bity na parametr / 8. Kvantizace na 8 nebo 4 bity paměť zmenší a často zrychlí CPU inferenci, ale kvalitu je nutné změřit na vlastní úloze. Samotné váhy nejsou všechno, další paměť bere KV cache a roste s počtem souběžných požadavků.

Determinismus. Stejné seedy nestačí. Výsledek ovlivní verze knihovny, hardware, pořadí v dávce i zaokrouhlování. Ani temperature=0 neznamená záruku bitově stejného výstupu napříč prostředími.

Padding. Při generování v dávce se doplňuje zleva, aby poslední skutečný token každé sekvence byl na konci, odkud model pokračuje. Pravé doplňování je častá příčina záhadně špatných výstupů.

Lokální generování přes transformers vypadá takto. Šablonu vždy ber z tokenizeru, ručně psaná se snadno liší ve speciálních tokenech.

python
from transformers import AutoModelForCausalLM, AutoTokenizer

path = "path/to/local-model"
tokenizer = AutoTokenizer.from_pretrained(path, padding_side="left")
model = AutoModelForCausalLM.from_pretrained(path)

messages = [{"role": "user", "content": "Vysvětli rekurzi jednou větou."}]
inputs = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True,
    return_tensors="pt", return_dict=True,
).to(model.device)

output = model.generate(**inputs, max_new_tokens=80, do_sample=True,
                        temperature=0.7, top_p=0.9)
answer = output[0, inputs["input_ids"].shape[1]:]
print(tokenizer.decode(answer, skip_special_tokens=True))
Kartičky

Opakování

Vyzkoušej si: Teplota a výběr dalšího slova

Uprav skóre, teplotu a top-k a sleduj, jak se mění rozdělení pravděpodobností a vzorkování.

Vyzkoušej si: Jak se text rozseká na tokeny

Napiš text a porovnej rozdělení po znacích, po slovech a jednoduchým učeným tokenizérem.