Teoretiska grunder för LLM

Teoretiska grunder för stora språkmodeller (baserade på transformer-arkitekturen) — detta är en samling matematiska, statistiska och informationsteoretiska principer som ligger till grund för hur moderna stora språkmodeller (LLM) fungerar, tränas och vilka förmågor de besitter. Dessa grunder förklarar hur modeller byggda på Transformer-arkitekturen kan förstå och generera mänskligt språk med hög grad av koherens.

Arkitektoniska grunder: Transformer-arkitekturen

Moderna LLM baseras nästan uteslutande på Transformer-arkitekturen, som presenterades 2017 i artikeln «Attention Is All You Need». Denna arkitektur övergav rekurrenta lager (som i RNN och LSTM) och satsade istället på attention-mekanismen, vilket möjliggjorde effektiv bearbetning av långa sekvenser och parallellisering av beräkningar.

Self-Attention - Självuppmärksamhetsmekanismen

Detta är kärnan i Transformer-arkitekturen. Självuppmärksamhetsmekanismen gör det möjligt för modellen att vikta betydelsen av varje ord (token) i en sekvens i förhållande till alla andra ord i samma sekvens. För varje token skapas tre vektorer:

• Query (Q, Fråga): en vektor som representerar det aktuella ordet.
• Key (K, Nyckel): en vektor mot vilken frågor från andra ord jämförs.
• Value (V, Värde): en vektor som innehåller information om ordet som ska föras vidare.

Attention-poängen beräknas som en skalad skalärprodukt:

$\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V$

där $d_k$ är dimensionen hos nycklarvektorerna. Denna mekanism gör det möjligt för modellen att fånga komplexa kontextuella beroenden, oberoende av avståndet mellan orden.

Multi-Head Attention — detta är en parallell körning av flera sådana beräkningar med olika projektionsmatriser, vilket gör att modellen samtidigt kan fokusera på olika aspekter av syntax och semantik.

Typer av arkitekturer baserade på Transformer

Det finns tre huvudsakliga varianter för hur Transformer-komponenterna används:

1. Encoder-Decoder (Kodare-avkodare): Den klassiska arkitekturen för sekvens-till-sekvens-omvandlingsuppgifter (t.ex. maskinöversättning). Kodaren bearbetar indatasekvensen och avkodaren genererar utdatasekvensen. Exempel: T5, BART.
2. Encoder-Only (Endast kodare): Modeller som enbart använder ett kodarstapel. De lämpar sig utmärkt för uppgifter som kräver djup förståelse av hela sekvensens kontext (textklassificering, igenkänning av namngivna entiteter). Exempel: BERT.
3. Decoder-Only (Endast avkodare): Modeller som enbart använder ett avkodarstapel. De arbetar autoregressivt och förutsäger nästa token utifrån de föregående. Detta är standarden för generativa modeller. Exempel: GPT, LLaMA, Claude.

Positionskodning

Eftersom självuppmärksamhetsmekanismen inte tar hänsyn till ordordningen läggs positionskodning till i arkitekturen. Vektorer som kodar deras position i sekvensen adderas till token-embeddingarna. I den ursprungliga modellen användes sinusoidala funktioner:

$\text{PE}(\text{pos},2i)=\sin (\text{pos}/10000^{2i/d_{\text{model}}})$

$\text{PE}(\text{pos},2i+1)=\cos (\text{pos}/10000^{2i/d_{\text{model}}})$

I moderna modeller används även inlärbara och rotationsbaserade positionskodningar (Rotary Position Embeddings, RoPE).

Träningsprinciper: från sannolikhet till optimering

Språkmodellering som ett sannolikhetsproblem

Grunden för LLM är uppgiften språkmodellering — att förutsäga sannolikheten för en textsekvens. Formellt skattar modellen, för en sekvens $X=(x_1,x_2,\dots ,x_T)$, sannolikheten $P(X)$. Med hjälp av kedjans regel för sannolikheter bryts detta ned i en produkt av betingade sannolikheter:

$P(X)=\prod _{t=1}^{T}P(x_t|x_1,\dots ,x_{t-1})$

Sålunda reduceras träningen av modellen till att förutsäga nästa token $x_t$ utifrån kontexten av föregående tokens.

Förlustfunktion och informationsteori

För att utvärdera kvaliteten på förutsägelserna och träna modellen används kors-entropiförlustfunktionen. Den mäter avvikelsen mellan sannolikhetsfördelningen som modellen förutsäger ($q$) och den sanna fördelningen ($p$), där nästa korrekta token har sannolikheten 1 och övriga 0.

$H(p,q)=-\sum _{i}p(i)\log q(i)$

Minimering av kors-entropin är ekvivalent med maximering av träningsdatans likelihood.

Ett relaterat kvalitetsmått är perplexitet, som definieras som exponentialen av kors-entropin: $\text{Perplexity}=2^{H(p,q)}$. Intuitivt visar perplexiteten det genomsnittliga antalet alternativ som modellen «väljer mellan» vid varje steg. Ju lägre perplexitet, desto säkrare och mer exakt är modellen.

Optimering

Träning av LLM är en process för att minimera förlustfunktionen genom att justera miljarder modellparametrar. För detta används metoder baserade på gradientnedstigning. Den vanligaste är optimeraren Adam (Adaptive Moment Estimation) och dess varianter (t.ex. AdamW), som adaptivt anpassar inlärningshastigheten för varje parameter.

Träningsparadigm

1. Förträning (Pre-training): Modellen tränas på enorma omärkta textkorpusar (Common Crawl, The Pile, C4) med hjälp av självövervakade uppgifter, såsom:
   • Kausal språkmodellering (CLM): Förutsägelse av nästa token (används i GPT).
   • Maskerad språkmodellering (MLM): Återställning av slumpmässigt maskerade tokens i texten (används i BERT).
2. Finjustering (Fine-tuning): Efter förträningen anpassas modellen till specifika uppgifter på små märkta datamängder.
3. Anpassning (Alignment): Ett speciellt finjusteringssteg som syftar till att anpassa modellens beteende till mänskliga preferenser och värderingar. Nyckelmetoden är RLHF (Reinforcement Learning from Human Feedback), där modellen finjusteras med hjälp av en belöningssignal från en modell som förutsäger mänskliga preferenser.

Skalningslagar och emergenta förmågor

Empiriska studier har visat att prestandan hos LLM förbättras förutsägbart med en ökning av tre faktorer: modellstorleken (antalet parametrar, $N$), storleken på träningsdatamängden ($D$) och mängden beräkningar ($C$). Detta samband beskrivs av potenslagar (scaling laws).

Lagen som föreslogs i OpenAI:s arbete (Kaplan et al., 2020) visar att förlustfunktionen $L$ avtar som en potensfunktion av $N$, $D$ och $C$. Ett senare arbete från DeepMind (Hoffmann et al., 2022) förfinade dessa lagar (Chinchilla-lagarna) och visade att optimal träning kräver en balanserad ökning av både modellstorlek och datamängd.

En viktig följd av skalning är uppkomsten av emergenta förmågor — kvalitativa språng i prestanda där modellen börjar lösa uppgifter som den inte uttryckligen tränats på (t.ex. aritmetik, logiskt resonemang, kodskrivning). Dessa förmågor saknas vanligtvis hos mindre modeller och manifesteras endast efter att ett visst skalningströskel uppnåtts.

Textgenerering: avkodningsstrategier

Efter träning genererar modellen text genom att iterativt förutsäga nästa token. Valet av nästa token från sannolikhetsfördelningen som modellen producerar sker med hjälp av olika avkodningsstrategier:

• Girig sökning (Greedy Search): Den mest sannolika token väljs alltid. Snabbt, men leder ofta till repetitiv och tråkig text.
• Strålsökning (Beam Search): Vid varje steg sparas de $k$ mest sannolika sekvenserna, vilket gör det möjligt att hitta mer optimala globala lösningar.
• Sampling med temperatur: Token-sannolikheterna justeras med en temperaturparameter ($T$). Vid $T>1$ blir fördelningen mer jämn (mer kreativitet), vid $T<1$ mer spetsig (mindre slumpmässighet).
• Top-k sampling: Vid varje steg begränsas urvalet till de $k$ mest sannolika tokens.
• Top-p (Nucleus) sampling: Urvalet begränsas till den minimala uppsättning tokens vars sammanlagda sannolikhet överstiger tröskeln $p$. Detta möjliggör dynamisk anpassning av kandidatpoolens storlek.

Teoretiska problem och begränsningar

• Hallucinationer: Modellernas tendens att generera faktamässigt felaktig men trovärdig information. Detta beror på att modellerna optimerar textens sannolikhet snarare än dess sanningshalt.
• Bias (Fördomsfullhet): LLM ärver och förstärker sociala, kulturella och andra fördomar som finns i träningsdatan.
• Tolkningsbarhet («svart låda»): På grund av det enorma antalet parametrar är det mycket svårt att förstå exakt hur modellen fattar beslut, vilket försvårar felsökning och skapar risker.
• Beräkningskomplexitet: Självuppmärksamhetsmekanismen har kvadratisk komplexitet med avseende på sekvenslängden ($O(n^2)$), vilket begränsar den maximala längden på det bearbetade kontextet.

Se även

• Stora språkmodeller
• BERT
• GPT

Litteratur

• Vaswani, A. et al. (2017). Attention Is All You Need. arXiv:1706.03762.
• Devlin, J. et al. (2019). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. arXiv:1810.04805.
• Brown, T. B. et al. (2020). Language Models Are Few-Shot Learners. arXiv:2005.14165.
• Kaplan, J. et al. (2020). Scaling Laws for Neural Language Models. arXiv:2001.08361.
• Hoffmann, J. et al. (2022). Training Compute-Optimal Large Language Models. arXiv:2203.15556.
• Wei, J. et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. arXiv:2201.11903.
• Ouyang, L. et al. (2022). Training Language Models to Follow Instructions with Human Feedback. arXiv:2203.02155.
• Bai, Y. et al. (2022). Constitutional AI: Harmlessness from AI Feedback. arXiv:2212.08073.
• Bubeck, S. et al. (2023). Sparks of Artificial General Intelligence: Early Experiments with GPT-4. arXiv:2303.12712.
• Touvron, H. et al. (2024). The Llama 3 Herd of Models. arXiv:2407.21783.
• Bender, E. M. et al. (2021). On the Dangers of Stochastic Parrots: Can Language Models Be Too Big?. DOI:10.1145/3442188.3445922.