Large language model architectures (SV)

Arkitekturer för stora språkmodeller (LLM) — detta är grundläggande principer och strukturer som bestämmer hur stora språkmodeller byggs, tränas och fungerar. Moderna LLM, som kan förstå och generera mänskligt språk, är nästan helt baserade på Transformer-arkitekturen, men inkluderar en mängd förbättringar och olika tillvägagångssätt som syftar till att öka effektivitet, skalbarhet och kapacitet.

Familjer av LLM-arkitekturer (transformers)

Moderna stora språkmodeller bygger på transformer-arkitekturen, men använder den på olika sätt beroende på syftet: att förstå text, generera en fortsättning eller omvandla en text till en annan. I praktiken urskiljer man tre familjer med bibehållna grundprinciper för transformer.

1. Encoder-only (endast kodare, endast encoder)

Modellen använder enbart ett kodarstapel och behandlar hela inmatningstexten bidirektionellt. Förträning bygger vanligtvis på masked language modeling (MLM, språkmodellering med maskering): en del tokens döljs och modellen lär sig att återskapa dem utifrån omgivningen. Tack vare det bidirektionella sammanhanget är sådana modeller starka i uppgifter som rör förståelse och poängsättning: klassificering, igenkänning av namngivna entiteter, omrangordning av dokument och extraktiv QA. För autoregressive generering "från grunden" är de inte avsedda.

Dessutom används i praktiken alternativa förträningmål för encoder-only-familjen: replaced token detection (RTD) i ELECTRA (diskriminatormodellen känner igen ersatta tokens) och kontrastiv träning av bi-encoders för semantisk sökning/retrieval (InfoNCE/softmax-loss på par "fråga–dokument", som i Dense Passage Retrieval). Vid användning i RAG fungerar encoder-only antingen som bi-encoder (separat kodning av fråga och dokument för snabb ANN-sökning) eller som cross-encoder (gemensam kodning av paret för exakt omrangordning).

Fördelar:

• Hög kvalitet på textförståelse tack vare bidirektionellt sammanhang: klassificering, NER, faktaextraktion, omrangordning, extraktiv QA.
• Parallell bearbetning och hög genomströmning: ett enda framåtpass utan auto-regression; bekvämt att batcha massiv poängsättning.
• Naturlig integration med sökning och RAG: i rollen som bi-encoder — snabb semantisk sökning; i rollen som cross-encoder — exakt omrangordning.
• Effektiv anpassning: relativt kompakta varianter (≈100–300 miljoner parametrar; BERT-base ≈110 miljoner) ger hög kvalitet efter målinriktad finjustering.
• Stabil latens som inte beror på längden på det genererade svaret (ingen stegvis avkodning); passar bra för offline-poängsättning av stora samlingar.
• Möjlighet att utöka kontextfönstret hos encoders via relativa/rotationella positioner och/eller lokalt gles uppmärksamhet (t.ex. Longformer/BigBird), vilket är användbart för långa dokument.

Nackdelar:

• Inga egna generativa förmågor: för dialoger och utförliga svar krävs en dekoder eller extern generativ modul.
• Begränsningar i interaktiva scenarier: ingen stegvis generering med tillståndsbevarande.
• Bristande överensstämmelse mellan förträningmålet och uppgifter för fri generering: MLM stämmer sämre med generering jämfört med kausal modellering.
• Historiskt begränsat kontextfönster (ofta 512 tokens i grundkonfigurationer med absoluta positioner); utökning kräver speciella positions-/uppmärksamhetsscheman och/eller finjustering.
• För retrieval-uppgifter krävs separat kontrastiv finjustering av bi-encoder och/eller cross-encoder; utan detta är kvaliteten på sökning/omrangordning vanligtvis lägre än hos specialtränade modeller.

Representativa modeller: BERT och derivat, samt RoBERTa och DeBERTa (utökade encoder-only-varianter); bland alternativa förträningmål — ELECTRA (RTD).

2. Decoder-only (endast avkodare, endast decoder)

Enbart ett dekodarstapel med kausal (vänsterriktad) uppmärksamhet används: modellen förutsäger nästa token utifrån ett redan givet prefix. Denna träningsregim — causal language modeling (CLM) — gör dessa modeller till ett naturligt val för generering: dialoger, utförliga svar, kreativ text, programkod. Kompromissen är ökad latens och ökad KV-cachestorlek vid långa prompts. I praktiken används en rad tekniska metoder brett för decoder-only: minskning av KV-cache via MQA och GQA, accelerering av inferens via spekulativ avkodning och serveroptimiseringar (PagedAttention/vLLM, continuous batching, chunked prefill).

Fördelar:

• Naturlig textgenerering (CLM): starka zero-shot- och few-shot-förmågor; skaleras väl.
• Mångsidighet i tillämpning: en enda modell löser många uppgifter via instruktioner och exempel i prompten; passar naturligt med RAG och verktygsanrop (tool use).
• Mogen ekosystem: praxis för instruktionsfinjustering och beteendejustering (RLHF, DPO); öppna och kommersiella implementationer finns tillgängliga.
• Rikt optimeringsstack för inferens: MQA/GQA minskar KV-cache-volymen och ökar genomströmningen; spekulativ avkodning accelererar inferens utan att ändra fördelningen; PagedAttention/vLLM med continuous batching och chunked prefill ökar GPU-utnyttjandegraden.
• Stöd för strukturerad generering för strikta svarsformat (JSON/SQL/DSL), vilket förenklar integration med informationssystem och API.

Nackdelar:

• Ökad genereringslatens: sekventiell inferens; kostnaden för en ny token ökar med längden på det redan "lästa" sammanhanget (KV-cache).
• Mindre fördelaktig vid profilen "lång inmatning – kort utmatning" (sammanfattning, översättning) jämfört med encoder–decoder, där inmatningen kodas en gång.
• Begränsning till enkelriktat sammanhang: i förståelseuppgifter är den ibland sämre än modeller med bidirektionell representation (encoder-only / encoder–decoder).
• Minne för KV-cache kan bli en "flaskhals" vid långa prompts och stora batchar;
• Kvantisering av aktiveringar/KV (INT8/FP8) accelererar inferens men kan försämra kvaliteten på långa kontexter/kod; kräver noggrann validering (särskilt vid strikta SLA).

Representativa modeller: GPT-3, GPT-4 (arkitektur- och datasetdetaljer har inte offentliggjorts), LLaMA och Llama 3 (8B/70B, 2024).

3. Encoder–decoder (kodare–avkodare, encoder-decoder)

Arkitekturen kombinerar båda komponenterna. Encodern arbetar i bidirektionellt läge och dekodern — kausalt. Encodern analyserar inmatningen en gång och bildar en representation av den; dekodern genererar utmatningen med hänvisning till denna representation via cross-attention. Detta separata tillvägagångssätt är särskilt användbart där det krävs att en lång inmatningstext omvandlas till en kort utmatning: maskinöversättning, sammanfattning, svar baserade på dokument. Även om metoden kräver större sammanlagda beräkningskostnader (två staplar och kors-uppmärksamhet) är dess fördel — kontrollerad generering baserad på fullständig analys av källtexten; kodningen utförs en enda gång och återanvänds under hela inferensprocessen.

Fördelar:

• Villkorlig generering: dekodern använder cross-attention till inmatningsrepresentationen.
• Effektiv i scenariot "lång inmatning → kort utmatning": inmatningen kodas en gång.
• Bekväm för formatet "text-to-text" och kontrollerad inferens (uppgiftsprefixer, speciella instruktioner).
• Stabilitet och effektivitet vid lång källa: under avkodningsfasen ökar bara self-attention på utmatningen, medan cross-attention återanvänder fasta nycklar/värden från encodern (inmatningen "läses inte om" vid varje steg).

Nackdelar:

• Två staplar ökar krav på minne och beräkning vid träning och användning.
• Vid extremt långa sekvenser är den totala latensen jämförbar med decoder-only; auto-regression förblir flaskhalsen.
• Färre universella chattmodeller än bland decoder-only; används oftare som en högkvalitativ seq2seq-motor för specifika uppgifter.
• Vid mycket lång inmatning ökar minnet för nycklar/värden i cross-attention i varje dekodarlager (för hela källan), vilket kräver noggrann planering av serving.

Representativa modeller: T5 (inklusive T5 v1.1 och praxis för instruktionsfinjustering i FLAN-T5) och BART.

Täta (dense) transformers

Den klassiska och mest utbredda LLM-arkitekturen: vid bearbetning av varje token deltar praktiskt taget hela modellens parameteruppsättning. Till skillnad från glesa tillvägagångssätt (t.ex. Mixture-of-Experts) sker ingen selektiv aktivering av delnätverk — varje block arbetar för varje token.

Arbetssätt och arkitektur

Grundläggande struktur. Modellen är en stapel av N likartade transformerblock. Varje block innehåller:

1. Multi-Head Self-Attention (flerhuvudad självuppmärksamhet). För varje token beräknas tre vektorer: Q (query), K (key), V (value); uppmärksamheten definieras som $\mathrm{softmax}\left(\frac{Q{K}^{\mathrm{\top }}+M}{\sqrt{d_k}}\right)\cdot V$, där $M$ är en mask (kausal och/eller paddningsmask) som utesluter otillåtna positioner. Flera "huvuden" för uppmärksamhet tar parallellt hänsyn till olika aspekter av sammanhanget (H huvuden, vanligtvis $d_{\mathrm{h}\mathrm{e}\mathrm{a}\mathrm{d}}=\frac{d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}}{H}$); deras antal ökar med modellskalan.
2. Fullt kopplat nätverk (Feed-Forward Network, FFN). Två linjära lager med en icke-linearitet emellan (vanligtvis GELU/SiLU; i ett antal moderna modeller — SwiGLU). Det mellanliggande dimensionsmåttet är vanligtvis $\approx 4d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}$; vid användning av SwiGLU används ofta $\approx \frac{8}{3}{d}_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}$ för att bevara ett jämförbart antal parametrar. FFN innehåller en betydande andel av parametrarna.

Ytterligare komponenter. Residuala (residual) förbindelser och lagernormalisering används; i moderna LLM tillämpas oftare Pre-LN (normalisering före delblock) — detta förbättrar träningsstabiliteten vid stora djup. Utöver klassisk LayerNorm används allt bredare RMSNorm (minskar beräkningskostnader och fungerar bra i stora modeller); i vissa familjer används också normalisering i uppmärksamhetsutrymmet (t.ex. normalisering av Q/K före softmax). Positionsrepresentationer kan vara absoluta eller relativa; för långt sammanhang har RoPE blivit de-facto-standard.

Modellexempel och skala

• BERT-Large: 24 lager, dimensionsmått 1024, 16 uppmärksamhetshuvuden, ≈340 miljoner parametrar.
• GPT-3 (175B): 96 lager, dimensionsmått 12288, 96 uppmärksamhetshuvuden, ≈175 miljarder parametrar.
• LLaMA-65B: 80 lager, dimensionsmått 8192, 64 uppmärksamhetshuvuden, ≈65 miljarder parametrar.
• PaLM-540B: 118 lager, dimensionsmått i storleksordningen 18432, ≈540 miljarder parametrar.

Fördelar

• Enhetliga block, välstuderade träningsregimer och förutsägbart beteende vid skalning.
• Kvaliteten förbättras enligt en potenslag vid ökning av parametrar och data; compute-optimal-regimen innebär att modellstorleken och volymen av träningstoken ökas gemensamt.
• Samma arkitektur täcker efter finjustering ett brett spektrum av uppgifter utan ändringar på lagernivå.

Nackdelar

• Full självuppmärksamhet har kvadratisk komplexitet med avseende på sekvensens längd ($O(n^2)$), vilket begränsar kontextfönstret.
• Full parameteraktivering vid genereringssteget: i dekodern utan MoE ökar inferenskostnaden per token ungefär proportionellt mot antalet parametrar.
• Flaskhalsen är minnesbandbredden (memory-bound): laddning av vikter från HBM begränsar ofta inferenshastigheten.

Skalnings- och kontextbegränsningar

• Parameterminnet ökar linjärt med modellstorleken; träningsminnet ökar på grund av gradienter och optimerartillstånd.
• Grundkonfigurationer var historiskt begränsade till 2–4 tusen tokens. Moderna positionsscheman (RoPE) och utvidgningstekniker (Position Interpolation, YaRN m.fl.) gör det möjligt att utöka fönstret med en storleksordning eller mer, men till priset av ytterligare beräknings-/minnesbörda.

Moderna optimeringar

• FlashAttention. Exakt uppmärksamhet med hänsyn till GPU-minneshierarkin; minskar minneskostnaderna och accelererar träning/inferens vid långa sekvenser.
• Reduktion och hantering av KV-cache. Multi-Query Attention och Grouped-Query Attention minskar cachevolym och minnestrafik; på servernivå ökar PagedAttention (vLLM) genomströmningen via sidhantering av cachen.
• Spekulativ avkodning. En utkastmodell (draft) föreslår en fortsättning och huvudmodellen verifierar den snabbt; acceleration uppnås utan att inferensfördelningen ändras.

Glesa modeller (Sparse Models) och Mixture-of-Experts (MoE)

MoE är ett sätt att öka modellkapaciteten utan proportionell ökning av beräkningarna per token. Istället för ett enda stort FFN-block i lagret används en uppsättning parallella "experter" (flera oberoende FFN), och ett inlärbart routernätverk (gating network) väljer för varje token de top-k mest relevanta experterna (vanligtvis k=1–2; i vissa modeller k=4). Bara de valda experterna aktiveras; deras utdata viktas och summeras. På så vis kan det totala antalet parametrar vara hundratals miljarder och till och med biljoner, men vid varje steg används bara en liten andel.

Modellexempel och skala

• Switch Transformer (Google): upp till ~1.6T parametrar; top-1-routing (en expert per token). Visade att MoE gör det möjligt att kraftigt öka kapaciteten med jämförbara kostnader per token.
• GLaM (Google): 1.2T parametrar, 64 experter per lager, top-2; för varje token aktiveras ≈96.6B parametrar (≈8%).
• Mixtral 8×7B (Mistral AI): ~46.7B parametrar totalt, ≈12.9B aktiva per token, top-2.
• Mixtral 8×22B: ~141B parametrar totalt, ≈39B aktiva per token, top-2.
• DBRX (Databricks): 132B parametrar totalt, ≈36B aktiva per token; 16 experter och top-4-routing (fine-grained MoE).

Fördelar

• Beräkningskostnaden bestäms av antalet aktiva experter k, inte det totala antalet parametrar: man kan träna och använda modeller i biljonskalaa till en kostnad jämförbar med täta modeller av märkbart mindre storlek.
• Specialisering: experterna "anpassar sig" automatiskt till språk/domäner/mönster, vilket förbättrar kvaliteten i multidomänuppgifter.
• Flexibel driftsättning: man kan hålla ofta använda experter i minnet och ladda in sällsynta (med lämplig infrastruktur).

Begränsningar

• Lastbalansering: utan regularisering kan routern "fastna" på en del av experterna (router collapse). Auxiliary losses (load-balancing) och förbättrade routingscheman behövs.
• Komplexiteten i distribuerade beräkningar: expert parallelism och all-to-all-kommunikation krävs; kommunikationskostnader och minneshantering blir flaskhalsarna.
• Träningsstabilitet: routerinställningar och kapacitetsbegränsningar är viktiga, annars kan kvalitets-/konvergensdegradation uppstå.

Moderna förbättringar

• Expert-Choice routing: experterna "väljer" tokens, vilket förbättrar balansering och konvergens till jämförbara kostnader.
• Fine-grained MoE: ett större antal mer finkorniga experter (som i DBRX) ger finare specialiseringsgranularitet.
• Sparse Upcycling: omvandling av en tät modell till MoE från dess checkpoint gör det möjligt att avsevärt höja kvaliteten till måttliga kostnader.

Lämplighet för MoE

• Stora multidomänassistenter med begränsad compute-budget.
• Träning på omfattande korpusar där specialisering ger en fördel.
• Scenarier med välutvecklad distribuerad infrastruktur (många GPU/TPU och snabba nätverk).

När täta modeller är bättre: begränsad infrastruktur (1–2 GPU), strikta krav på förutsägbar latens och enkel driftsättning.

Retrieval-Augmented Generation (RAG)

RAG är ett arkitekturellt systemmönster kring LLM, inte en intern arkitektur för modellen själv. Det kombinerar LLM (den generativa komponenten) med en extern kunskapsbas (hämtningskomponenten), vilket gör det möjligt att kompensera för begränsningarna i modellens "parametriska minne".

• Arbetssätt: Innan generering hämtar LLM relevanta dokument från en extern källa (wiki, företagets kunskapsbas, webben) och förlitar sig på dem när svaret formas.
• Fördelar:
  • Minskning av hallucinationer och förbättrad faktamässig noggrannhet.
  • Aktualitet utan fullständig omträning av modellen.
  • Citerbarhet och spårbarhet i svaren.
• Tillämpning: De-facto-standard för företagsassistenter och system där verifierbara fakta och arbete med privata/specialiserade data krävs.

Uppmärksamhetsmekanismer och kontexthantering

Grundläggande självuppmärksamhet har kvadratisk komplexitet med avseende på sekvensens längd ($O(n^2)$), varför optimeringar har uppstått.

• Gles uppmärksamhet (Sparse Attention): Begränsning av uppmärksamhet till lokala fönster/mönster. Exempel: Longformer, BigBird.
• FlashAttention: Omstrukturering av beräkningsordningen med hänsyn till GPU-minneshierarkin; ger en väsentlig vinst i tid och minne och har blivit de-facto-standard vid träning av LLM med långt sammanhang.
• MQA/GQA (avkodningsacceleration): Multi-Query Attention (gemensamma nycklar/värden för alla huvuden) minskar KV-cache-trafiken. Grouped-Query Attention balanserar kvalitet/hastighet.
• Förbättrade positionsrepresentationer:
  • ALiBi (Attention with Linear Biases): Linjära förskjutningar till uppmärksamhetsbedömningarna förbättrar generaliseringen till större längder.
  • RoPE (Rotary Position Embeddings): Relativ positionsinformation via rotation av Q/K; används brett i moderna modeller (t.ex. LLaMA).
  • Kontextutvidgning för RoPE-modeller: Position Interpolation , YaRN , samt NTK-aware-modifieringar gör det möjligt att effektivt utöka kontextfönstret utan att ändra arkitekturen.

• Andra tillvägagångssätt för långa sekvenser:
  • Transformer-XL: rekurrent minne mellan segment för modellering av långdistansberoenden.
  • Reformer: LSH-attention och reversibla residualblock för minnesbesparing.
  • Performer: linjär approximation av softmax-attention (FAVOR+).
  • Linformer: lågrangsapproximation av uppmärksamhetsmatrisen.

Modelloptimering och träningsinfrastruktur

Specialiserade tekniker och ramverk används för träning och driftsättning av LLM.

• Kvantisering (Quantization): Minskning av vikternas bitdjup reducerar minnet och accelererar inferens. QLoRA möjliggör effektiv finjustering av 4-bitarsmodeller (inklusive 65B) med kvalitet nära full precision.
• Kunskapsdestillation (Knowledge Distillation): Teacher→Student-träning för kompakta modeller; exempel — DistilBERT.
• Distribuerad träning:
  • DeepSpeed och ZeRO — distribution av parametrar/gradienter/optimerartillstånd för träning av biljonsmodeller.
  • Megatron-LM — tensor- och pipelineparallellism för mycket stora transformers.
• Ekosystem och verktyg: Hugging Face Transformers och Accelerate tillhandahåller standardimplementationer av modeller och integration med DeepSpeed/FSDP för träning och inferens.

Skalningslagar och compute-optimal träning

Empiriska skalningslagar visar att kors-entropiförlusten minskar som en potenslag vid ökning av parametrar, data och beräkningar. Arbetet Chinchilla preciserade compute-optimal-regimerna: för optimal effektivitet bör modellstorleken och antalet träningstoken skalas gemensamt (exempel — en 70B-modell tränad på ~1.4T tokens, som överträffar större undertränade modeller).

Tillståndsrumsmodeller (State Space Models, SSM)

State Space Models (SSM) — en arkitektur som är ett alternativ till transformers för arbete med långa sekvenser. Den lånar idéer från reglerteorin och digital signalbehandling och löser det huvudsakliga problemet med self-attention: kvadratisk ökning av beräkningarna i takt med att textlängden ökar.

Grundläggande problem och lösning

Transformers problem. Det huvudsakliga problemet med traditionella transformers är den kvadratiska komplexiteten hos uppmärksamheten: text som är 10 gånger längre kräver ungefär 100 gånger mer beräkningar.

SSM:s tillvägagångssätt. Istället för "simultan uppmärksamhet på alla ord" rör sig modellen sekventiellt genom texten och upprätthåller ett kompakt internt minnestillstånd som uppdateras vid varje steg. Som ett resultat ökar tid och minnesförbrukning ungefär linjärt med textlängden. Träning kan utföras parallellt — via en faltningsrepresentation av kärnan (hög genomströmning på långa sekvenser).

Arbetssätt

En diskret SSM beskrivs av tillstånds- och utgångsekvationer:

$x_t=A{x}_{t-1}+B{u}_t,y_t=C{x}_t+D{u}_t$

där $x_t$ — minnestillståndet, $u_t$ — inmatningen (token), $y_t$ — utmatningen. I djupa SSM parametriseras matriserna $A,B,C,D$ för att säkerställa stabilitet och effektiva beräkningar på långa sekvenser. Samma lager kan betraktas som:

• rekurrent (skanning per steg) — minnessparande inferens utan KV-cache;
• faltnings- — parallell träning med förberäknad kärna.

Huvudsakliga arkitekturer och hybrider

• S4 (Structured State Spaces). Grundläggande SSM med stabil parametrisering av tillståndsmatrisen; visar effektivitet på mycket långa sekvenser.
• Mamba. Selektiva SSM: reglerna för minnesuppdatering beror på den aktuella inmatningen (modellen bestämmer själv vad den ska "hålla i minnet" och vad den ska "glömma"). Implementationen är orienterad mot GPU-minneshierarkin; enligt författarnas uppgifter uppnås en mångfaldig ökning av inferensgenomströmning vid linjär komplexitet med avseende på längden.
• RetNet. En retention-mekanism med tre lägen: parallell träning, rekurrent och blockrekurrent inferens. Målet är att kombinera snabb träning (som hos transformers) med ekonomiskt flöde vid inferens (O(1) minne per token).
• Hybrider Attention+SSM. Exempel — Jamba (växlande Transformer- och Mamba-lager plus MoE): rapporterar stöd för kontexter i storleksordningen ~256K tokens med väsentligt lägre minneskrav jämfört med rent transformerbaserade modeller av liknande klass.

Fördelar

• Linjär komplexitet och minnesbesparing vid inferens. Inget globalt self-attention och ingen KV-cache; bara ett kompakt tillstånd lagras.
• Parallell träning på långa sekvenser. Faltningsläget ökar träningsgenomströmningen.
• Maskinvarueffektivitet. Implementationerna är orienterade mot modern minneshierarki (HBM/SRAM).
• Långa kontexter och streaming. Hybrider SSM+Attention är praktiska för hundratusentals tokens vid måttliga resurser.

Begränsningar och nuvarande praxis

• Ekosystemets mognad. Verktyg och skalningsrecept (instruktioner, RLHF/DPO) är fortfarande sämre än transformerstacken.
• Kvalitet och stabilitet. I ett antal uppgifter visar hybrider (Attention+SSM) en mer stabil kompromiss "kvalitet/hastighet/minne" än "rena" SSM.

Jämförelse av tillvägagångssätt (sammanfattande)

Egenskap	Transformers	SSM	Hybrider (Attention+SSM)
Komplexitet med avseende på längd	Kvadratisk (self-attention)	Linjär (skanning/faltning)	Nära linjär
Minne per token (inferens)	KV-cache växer med kontexten	O(1) tillstånd	Måttlig tillväxt
Långa kontexter	Speciella optimeringar krävs	Naturligt stöd	Praktiska upp till ~256K
Ekosystemets mognad	Hög	Under utveckling	Under utveckling

Praktiska tillämpningar

• Analys av mycket långa dokument (böcker, rapporter, vetenskapliga översikter).
• Strömningsbearbetning och chattscenarier med lång historik utan minneskostnadsökning.
• Miljöer med begränsade resurser (mobila/edge-enheter).
• Tidsserier och andra sekventiella data.

Representativa modeller: S4, Mamba, RetNet; hybrider Attention+SSM (Jamba).

Arkitekturernas evolution

• 2017 — artikeln "Attention Is All You Need" publicerades. Transformer-arkitekturen presenterades: flerhuvudad självuppmärksamhet och positionskodningar gör det möjligt att träna modeller utan rekurrens och faltningar; samtidigt har uppmärksamheten kvadratisk komplexitet med avseende på kontextlängden.

• 2018 — GPT-1 och BERT presenterades. GPT-1 använder en stapel med enbart dekoders med kausal uppmärksamhet för generering och efterföljande finjustering; BERT introducerar en bidirektionell encoder och MLM-förträning för uppgifter som rör textförståelse.

• 2019 — metoder för att arbeta med långa sekvenser föreslogs och decoder-only skalades. Transformer-XL lägger till "minne" och relativa positioner för att gå bortom det fasta fönstret; GPT-2 visar ökning av zero-shot-förmågor vid ökad skala; BART visar effektiviteten hos denoising-förträning för seq2seq.

• 2020 — formatet "text-to-text" enhetligades och metoder för långa dokument visades. T5 formulerar ett enhetligt encoder–decoder-tillvägagångssätt för olika uppgifter; Longformer och BigBird använder gles/strukturerad uppmärksamhet för långa texter; GPT-3 bekräftar effektiviteten hos skalning av tät decoder-only.

• 2021 — positionsrepresentationer förbättrades och parameterglesheten visades (MoE). RoPE och ALiBi förbättrar generaliseringen vid större längder; Switch Transformer och GLaM aktiverar bara en del experter per token, vilket ökar kapaciteten utan proportionell ökning av inferenskostnaden.

• 2022 — compute-optimal-regimen preciserades och inferens på långa prompts accelererades. Chinchilla visar fördelen med fler träningstoken vid måttlig modellstorlek; PaLM med Multi-Query Attention minskar KV-cache-volymen; FlashAttention accelererar uppmärksamhet på GPU.

• 2023 — kontextfönster utökades utan att ändra lager och serving förbättrades. LLaMA-linjen befäster praxis (RMSNorm, SwiGLU, RoPE); Position Interpolation och YaRN utökar kontexten; vLLM/PagedAttention hanterar KV-cache mer effektivt.

• 2023 — GPT-4 och Gemini visar bearbetning och generering i flera modaliteter inom ramen för en enda modellfamilj.

• 2023 — tillståndsrumsmodeller (SSM) föreslogs. Mamba och RetNet återinför sekventiell bearbetning med kompakt tillstånd istället för KV-cache och lägger grunden för hybridarkitekturer.

• 2024 — öppna MoE-modeller och Attention+SSM-hybrider publicerades; uppmärksamhet accelererades på nya GPU:er. Mixtral 8×7B/8×22B och DBRX bekräftar MoE:s praktiska användbarhet; Jamba kombinerar Transformer och Mamba för mycket långa kontexter; FlashAttention-3 ökar genomströmningen.

Referenser

• https://jalammar.github.io/illustrated-transformer/ The Illustrated Transformer — visuell förklaring

Litteratur

• Vaswani, A. et al. (2017). Attention Is All You Need. NIPS. https://arxiv.org/abs/1706.03762
• Devlin, J. et al. (2019). BERT. NAACL. https://arxiv.org/abs/1810.04805
• Brown, T. et al. (2020). Language Models are Few-Shot Learners. NeurIPS. https://arxiv.org/abs/2005.14165
• Raffel, C. et al. (2020). Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer (T5). JMLR. https://jmlr.org/papers/volume21/20-074/20-074.pdf
• Lewis, M. et al. (2019). BART: Denoising Sequence-to-Sequence Pre-training. https://arxiv.org/abs/1910.13461
• Touvron, H. et al. (2023). LLaMA. https://arxiv.org/abs/2302.13971
• Chowdhery, A. et al. (2022). PaLM: Scaling Language Modeling with Pathways. https://arxiv.org/abs/2204.02311
• Dao, T. et al. (2022–2024). FlashAttention (1/2/3). https://arxiv.org/abs/2205.14135 ; https://arxiv.org/abs/2307.08691 ; https://arxiv.org/abs/2407.08608
• Shazeer, N. (2019). MQA. https://arxiv.org/abs/1911.02150
• Ainslie, J. et al. (2023). GQA. https://arxiv.org/abs/2305.13245
• Kwon, W. et al. (2023). PagedAttention / vLLM. https://arxiv.org/abs/2309.06180
• Leviathan, Y. et al. (2023). Speculative Decoding. https://arxiv.org/abs/2211.17192
• Fedus, W.; Zoph, B.; Shazeer, N. (2021/2022). Switch Transformers. https://arxiv.org/abs/2101.03961
• Du, N. et al. (2022). GLaM. https://proceedings.mlr.press/v162/du22c/du22c.pdf
• Jiang, A.Q. et al. (2024). Mixtral of Experts. https://arxiv.org/abs/2401.04088
• Databricks (2024). Introducing DBRX. https://www.databricks.com/blog/introducing-dbrx-new-state-art-open-llm
• NVIDIA (2024). Applying Mixture of Experts in LLM Architectures. https://developer.nvidia.com/blog/applying-mixture-of-experts-in-llm-architectures/
• Zhou, Y. et al. (2022). Expert Choice Routing. https://arxiv.org/abs/2202.09368
• Komatsuzaki, A. et al. (2022). Sparse Upcycling. https://arxiv.org/abs/2212.05055
• Lewis, P. et al. (2020). RAG. https://arxiv.org/abs/2005.11401
• Beltagy, I. et al. (2020). Longformer. https://arxiv.org/abs/2004.05150
• Zaheer, M. et al. (2020). BigBird. https://arxiv.org/abs/2007.14062
• Press, O. et al. (2022). ALiBi. https://arxiv.org/abs/2108.12409
• Su, J. et al. (2021). RoFormer (RoPE). https://arxiv.org/abs/2104.09864
• Chen, S. et al. (2023). Position Interpolation. https://arxiv.org/abs/2306.15595
• Peng, B. et al. (2023). YaRN. https://arxiv.org/abs/2309.00071
• Dettmers, T. et al. (2023). QLoRA. https://arxiv.org/abs/2305.14314
• Rajbhandari, S. et al. (2020). ZeRO. https://www.microsoft.com/en-us/research/publication/zero-memory-optimizations-toward-training-trillion-parameter-models/
• Shoeybi, M. et al. (2019). Megatron-LM. https://arxiv.org/abs/1909.08053
• Kaplan, J. et al. (2020). Scaling Laws. https://arxiv.org/abs/2001.08361
• Hoffmann, J. et al. (2022). Chinchilla / Compute-Optimal. https://arxiv.org/abs/2203.15556
• Gemini Team (2023). Gemini. https://arxiv.org/abs/2312.11805
• Bai, Y. et al. (2022). Constitutional AI. https://arxiv.org/abs/2212.08073
• OpenAI (2023). GPT-4 Technical Report. https://arxiv.org/abs/2303.08774
• OpenAI (2023). DevDay: GPT-4 Turbo 128k. https://openai.com/index/new-models-and-developer-products-announced-at-devday/
• Zhang, B.; Sennrich, R. (2019). RMSNorm. https://arxiv.org/abs/1910.07467
• Shazeer, N. (2020). GLU Variants / SwiGLU. https://arxiv.org/abs/2002.05202
• Gu, A.; Goel, K.; Ré, C. (2021). S4: Structured State Spaces. https://arxiv.org/abs/2111.00396
• Gu, A.; Dao, T. (2023/2024). Mamba: Selective State Spaces. https://arxiv.org/abs/2312.00752
• Sun, Y. et al. (2023). RetNet. https://arxiv.org/abs/2307.08621
• Lieber, O. et al. (2024). Jamba: Hybrid Transformer-Mamba. https://arxiv.org/abs/2403.19887
• Dai, Z. et al. (2019). Transformer-XL. https://arxiv.org/abs/1901.02860
• Kitaev, N.; Kaiser, L.; Levskaya, A. (2020). Reformer. https://arxiv.org/abs/2001.04451
• Choromanski, K. et al. (2021). Performer. https://arxiv.org/abs/2009.14794
• Wang, S. et al. (2020). Linformer. https://arxiv.org/abs/2006.04768