AI-modeller och plattformar

Förståelse av stora språkmodellers parametrar och minneskrav: En djupdykning

mm
Publicerad
Uppdaterad
Lägg till Unite.AI bland dina föredragna källor på Google

Stora språkmodeller (LLM) har sett remarkabla framsteg under de senaste åren. Modeller som GPT-4, Google’s Gemini och Claude 3 sätter nya standarder för kapacitet och tillämpningar. Dessa modeller förbättrar inte bara textgenerering och översättning, utan bryter också ny mark i multimodal bearbetning, som kombinerar text, bild, ljud och videoinmatningar för att ge mer omfattande AI-lösningar.

Till exempel har OpenAI’s GPT-4 visat betydande förbättringar i förståelse och generering av mänsklig text, medan Google’s Gemini-modeller excellerar i hantering av olika datatyper, inklusive text, bilder och ljud, vilket möjliggör mer sömlösa och kontextuellt relevanta interaktioner. Likaså är Anthropic’s Claude 3-modeller kända för sina flerspråkiga förmågor och förbättrade prestanda i AI-uppgifter.

Medan utvecklingen av LLM fortsätter att accelerera, blir det viktigt att förstå de intrikata delarna av dessa modeller, särskilt deras parametrar och minneskrav. Den här guiden syftar till att avmystifiera dessa aspekter och erbjuda en detaljerad och lättförståelig förklaring.

Grundläggande om stora språkmodeller

Vad är stora språkmodeller?

Stora språkmodeller är neurala nätverk som tränas på stora datamängder för att förstå och generera mänskligt språk. De förlitar sig på arkitekturer som Transformers, som använder mekanismer som självuppmärksamhet för att bearbeta och producera text.

Parametrarnas betydelse i LLM

Parametrar är de centrala komponenterna i dessa modeller. De inkluderar vikter och bias, som modellen justerar under träningsprocessen för att minimera fel i förutsägelser. Antalet parametrar korrelerar ofta med modellens kapacitet och prestanda, men påverkar också dess beräknings- och minneskrav.

Förstå Transformer-arkitektur

Transformers-arkitektur

Transformers-arkitektur

Översikt

Transformer-arkitekturen, som introducerades i “Attention Is All You Need”-artikeln av Vaswani et al. (2017), har blivit grunden för många LLM. Den består av en encoder och en decoder, var och en bestående av flera identiska lager.

Encoder- och decoder-komponenter

  • Encoder: Bearbetar inmatningssekvensen och skapar en kontextmedveten representation.
  • Decoder: Genererar utmatningssekvensen med hjälp av encoderns representation och tidigare genererade token.

Nyckelbyggstenar

  1. Multi-Head Attention: Tillåter modellen att fokusera på olika delar av inmatningssekvensen samtidigt.
  2. Feed-Forward Neural Networks: Lägger till icke-linjäritet och komplexitet till modellen.
  3. Layer Normalization: Stabiliserar och accelererar träningsprocessen genom att normalisera mellanliggande utmatningar.

Beräkning av antalet parametrar

Transformer Training

Förtränade modeller för effektiv Transformer-träning

Beräkning av parametrar i Transformer-baserade LLM

Låt oss bryta ner parameterberäkningen för varje komponent i en Transformer-baserad LLM. Vi kommer att använda notationen från den ursprungliga artikeln, där d_model representerar dimensionen för modellens dolda tillstånd.

  1. Infogningslager:
    • Parametrar = vocab_size * d_model
  2. Multi-Head Attention:
    • För h huvuden, med d_k = d_v = d_model / h:
    • Parametrar = 4 * d_model^2 (för Q, K, V och utmatningsprojektioner)
  3. Feed-Forward Network:
    • Parametrar = 2 * d_model * d_ff + d_model + d_ff
    • Där d_ff vanligtvis är 4 * d_model
  4. Lager-normalisering:
    • Parametrar = 2 * d_model (för skala och bias)

Totala parametrar för ett Transformer-lager:

  • Parameters_layer = Parameters_attention + Parameters_ffn + 2 * Parameters_layernorm

För en modell med N lager:

  • Totala parametrar = N * Parameters_layer + Parameters_embedding + Parameters_output

Exempelberäkning

Låt oss överväga en modell med följande specifikationer:

  • d_model = 768
  • h (antal uppmärksamhets-huvuden) = 12
  • N (antal lager) = 12
  • vocab_size = 50 000
  1. Infogningslager:
    • 50 000 * 768 = 38 400 000
  2. Multi-Head Attention:
    • 4 * 768^2 = 2 359 296
  3. Feed-Forward Network:
    • 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4 719 616
  4. Lager-normalisering:
    • 2 * 768 = 1 536

Totala parametrar per lager:

  • 2 359 296 + 4 719 616 + (2 * 1 536) = 7 081 984

Totala parametrar för 12 lager:

  • 12 * 7 081 984 = 84 983 808

Totala modellparametrar:

  • 84 983 808 + 38 400 000 = 123 383 808

Denna modell skulle ha cirka 123 miljoner parametrar.

Typer av minnesanvändning

När vi arbetar med LLM, måste vi överväga två huvudtyper av minnesanvändning:

  1. Modellminne: Minnet som krävs för att lagra modellparametrarna.
  2. Arbetsminne: Minnet som behövs under inferens eller träning för att lagra mellanliggande aktiveringar, grader och optimeringslägen.

Beräkning av modellminne

Modellminnet är direkt relaterat till antalet parametrar. Varje parameter lagras vanligtvis som en 32-bitars flyttalsnummer, även om vissa modeller använder blandad precisionsträning med 16-bitars flyttal.

Modellminne (byte) = Antal parametrar * Byte per parameter

För vår exempelmodell med 123 miljoner parametrar:

  • Modellminne (32-bit) = 123 383 808 * 4 byte = 493 535 232 byte ≈ 494 MB
  • Modellminne (16-bit) = 123 383 808 * 2 byte = 246 767 616 byte ≈ 247 MB

Uppskattning av arbetsminne

Arbetsminneskraven kan variera avsevärt beroende på den specifika uppgiften, batchstorlek och sekvenslängd. En grov uppskattning för arbetsminne under inferens är:

Arbetsminne ≈ 2 * Modellminne

Detta beräknar både modellparametrar och mellanliggande aktiveringar. Under träning kan minneskraven vara ännu högre på grund av behovet av att lagra grader och optimeringslägen:

Träningsminne ≈ 4 * Modellminne

För vår exempelmodell:

  • Inferensarbetsminne ≈ 2 * 494 MB = 988 MB ≈ 1 GB
  • Träningsminne ≈ 4 * 494 MB = 1 976 MB ≈ 2 GB

Steady-state minnesanvändning och toppminnesanvändning

När vi tränar stora språkmodeller baserade på Transformer-arkitekturen, är det viktigt att förstå minnesanvändningen för effektiv resursallokering. Låt oss bryta ner minneskraven i två huvudkategorier: steady-state minnesanvändning och toppminnesanvändning.

Steady-state minnesanvändning

Steady-state minnesanvändningen består av följande komponenter:

  1. Modellvikter: FP32-kopior av modellparametrarna, som kräver 4N byte, där N är antalet parametrar.
  2. Optimeringslägen: För Adam-optimeraren kräver detta 8N byte (2 lägen per parameter).
  3. Grader: FP32-kopior av grader, som kräver 4N byte.
  4. Inmatningsdata: Antagande int64-inmatningar, detta kräver 8BD byte, där B är batchstorlek och D är inmatningsdimension.

Den totala steady-state minnesanvändningen kan approximeras av:

  • M_steady = 16N + 8BD byte

Topminnesanvändning

Topminnesanvändning inträffar under bakåtspassningen när aktiveringar lagras för gradientberäkning. De viktigaste bidragsgivarna till topminnesanvändning är:

  1. Lager-normalisering: Kräver 4E byte per lager-normalisering, där E = BSH (B: batchstorlek, S: sekvenslängd, H: dolt storlek).
  2. Attention-block:
    • QKV-beräkning: 2E byte
    • Attention-matris: 4BSS byte (S: sekvenslängd)
    • Attention-utmatning: 2E byte
  3. Feed-Forward-block:
    • Första linjära lagret: 2E byte
    • GELU-aktivering: 8E byte
    • Andra linjära lagret: 2E byte
  4. Cross-Entropy-förlust:
    • Logits: 6BSV byte (V: ordförråd)

Den totala aktiveringsminnesanvändningen kan uppskattas som:

  • M_act = L * (14E + 4BSS) + 6BSV byte

Där L är antalet Transformer-lager.

Total topminnesanvändning

Topminnesanvändningen under träning kan approximeras genom att kombinera steady-state minnesanvändningen och aktiveringsminnesanvändningen:

  • M_peak = M_steady + M_act + 4BSV byte

Den extra 4BSV-termen beräknar en extra allokering i början av bakåtspassningen.

Genom att förstå dessa komponenter kan vi optimera minnesanvändningen under träning och inferens, vilket säkerställer effektiv resursallokering och förbättrad prestanda för stora språkmodeller.

Skalningslagar och effektivitetsöverväganden

Skalningslagar för LLM

Forskning har visat att prestandan för LLM tenderar att följa vissa skalningslagar när antalet parametrar ökar. Kaplan et al. (2020) observerade att modellprestandan förbättras som en potenslag av antalet parametrar, beräkningsbudget och datamängd.

Förhållandet mellan modellprestanda och antal parametrar kan approximeras som:

Prestanda ∝ N^α

Där N är antalet parametrar och α är en skalningsexponent vanligtvis runt 0,07 för språkmodellering.

Detta innebär att för att uppnå en 10% förbättring av prestanda, måste vi öka antalet parametrar med en faktor av 10^(1/α) ≈ 3,7.

Effektivitetstekniker

Medan LLM fortsätter att växa, har forskare och praktiker utvecklat olika tekniker för att förbättra effektiviteten:

a) Blandad precisionsträning: Användning av 16-bitars eller till och med 8-bitars flyttal för vissa operationer för att minska minnesanvändning och beräkningskrav.

b) Modellparallellism: Distribution av modellen över flera GPU:er eller TPU:er för att hantera större modeller än vad som kan passa på en enda enhet.

c) Gradientkontroll: Handel med beräkning för minne genom att omberäkna vissa aktiveringar under bakåtspassningen i stället för att lagra dem.

d) Beskärning och kvantisering: Borttagning av mindre viktiga vikter eller minskning av deras precision efter träning för att skapa mindre och mer effektiva modeller.

e) Destillering: Träning av mindre modeller för att imitera beteendet hos större modeller, vilket potentiellt bevarar mycket av prestandan med färre parametrar.

Praktiskt exempel och beräkningar

GPT-3, en av de största språkmodellerna, har 175 miljarder parametrar. Den använder decoderdelen av Transformer-arkitekturen. För att förstå dess skala, låt oss bryta ner parameterantalet med hypotetiska värden:

  • d_model = 12288
  • d_ff = 4 * 12288 = 49152
  • Antal lager = 96

För ett decodarlager:

Totala parametrar = 8 * 12288^2 + 8 * 12288 * 49152 + 2 * 12288 ≈ 1,1 miljard

Totalt för 96 lager:

1,1 miljard * 96 = 105,6 miljarder

De återstående parametrarna kommer från infognings- och andra komponenter.

Slutsats

Förståelse av parametrar och minneskrav för stora språkmodeller är avgörande för effektiv design, träning och distribution av dessa kraftfulla verktyg. Genom att bryta ner komponenterna i Transformer-arkitekturen och undersöka praktiska exempel som GPT, får vi en djupare insikt i komplexiteten och skalan hos dessa modeller.

För att ytterligare förstå de senaste framstegen inom stora språkmodeller och deras tillämpningar, se dessa omfattande guider:

mm

Jag har tillbringat de senaste fem åren med att dyka djupt in i den fascinerande världen av Maskinlärning och Djupinlärning. Min passion och expertis har lett mig till att bidra till över 50 olika mjukvaruprojekt, med särskild fokus på AI/ML. Min pågående nyfikenhet har också lett mig mot Naturlig Språkbehandling, ett område som jag är angelägen om att utforska vidare.