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))
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])
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.
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
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))
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á.
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)}")
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
knejpravdě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()}")
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]
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
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.
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}")
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.
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))
<|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.
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
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%}")
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.
Proč model po zavření rozhovoru „neví“, o čem byla řeč?
Při generování se váhy nemění. Historie existuje jen jako vstupní text. Paměť napříč rozhovory musí zajistit aplikace.
Co udělá snížení teploty?
Vydělení malým číslem roztáhne rozdíly logitů, takže softmax dá favoritovi větší podíl.
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")
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.
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))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.