Anslut dig till vÄrt nÀtverk!

Artificiell intelligens

FörstÄ parametrar för stora sprÄkmodeller och minneskrav: En djupdykning

mm

publicerade

1 Ă„r sedan

 on

BerÀkna parametrar i transformatorbaserade LLM:er

Stora sprÄkmodeller (LLMs) har sett anmÀrkningsvÀrda framsteg de senaste Ären. Modeller som GPT-4, Googles Gemini och Claude 3 sÀtter nya standarder för funktioner och applikationer. Dessa modeller förbÀttrar inte bara textgenerering och översÀttning utan bryter ocksÄ ny mark inom multimodal bearbetning, genom att kombinera text-, bild-, ljud- och videoingÄngar för att tillhandahÄlla mer omfattande AI-lösningar.

Till exempel har OpenAI:s GPT-4 visat betydande förbÀttringar i att förstÄ och generera mÀnsklig text, medan Googles Gemini-modeller utmÀrker sig i att hantera olika datatyper, inklusive text, bilder och ljud, vilket möjliggör mer sömlösa och kontextuellt relevanta interaktioner. PÄ samma sÀtt Àr Anthropics Claude 3-modeller kÀnda för sina flersprÄkiga möjligheter och förbÀttrade prestanda i AI-uppgifter.

NÀr utvecklingen av LLM fortsÀtter att accelerera, blir det avgörande att förstÄ dessa modellers krÄngligheter, sÀrskilt deras parametrar och minneskrav. Denna guide syftar till att avmystifiera dessa aspekter och erbjuder en detaljerad och lÀttförstÄelig förklaring.

Grunderna i stora sprÄkmodeller

Vad Àr stora sprÄkmodeller?

Stora sprÄkmodeller Àr neurala nÀtverk som trÀnas pÄ massiva 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.

Vikten av parametrar i LLM

Parametrar Àr kÀrnkomponenterna i dessa modeller. De inkluderar vikter och fördomar, som modellen justerar under trÀning 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Ä transformatorarkitektur

Transformatorer-arkitektur

Transformers arkitektur

Översikt

Transformer-arkitekturen, introducerad i "Attention Is All You Need"-papperet av Vaswani et al. (2017), har blivit grunden för mÄnga LLM. Den bestÄr av en kodare och en avkodare, som var och en bestÄr av flera identiska lager.

Kodar- och avkodarkomponenter

  • kodare: Bearbetar inmatningssekvensen och skapar en kontextmedveten representation.
  • Avkodare: Genererar utdatasekvensen med hjĂ€lp av kodarens representation och de tidigare genererade tokens.

Viktiga byggstenar

  1. Multi-Head Attention: Gör det möjligt för modellen att fokusera pÄ olika delar av inmatningssekvensen samtidigt.
  2. Feed-Forward neurala nÀtverk: LÀgger till icke-linjÀritet och komplexitet till modellen.
  3. Lagernormalisering: Stabiliserar och accelererar trÀningen genom att normalisera mellaneffekterna.

BerÀkna antalet parametrar

Transformator utbildning

Förutbildade modeller för effektiv transformatortrÀning

BerÀkna parametrar i transformatorbaserade LLM:er

LÄt oss bryta ner parameterberÀkningen för varje komponent i en transformatorbaserad LLM. Vi anvÀnder notationen frÄn originalpapperet, dÀr d_model representerar dimensionen av modellens dolda tillstÄnd.

  1. InbÀdda lager:
    • 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 outputprojektioner)
  3. Feed-Forward-nÀtverk:
    • Parametrar = 2 * d_model * d_ff + d_model + d_ff
    • Var d_ff Ă€r vanligtvis 4* d_model
  4. Lagernormalisering:
    • Parametrar = 2 * d_model (för skala och bias)

Totala parametrar för ett transformatorlager:

  • Parameters_layer = Parameters_attention + Parameters_ffn + 2 * Parameters_layernorm

För en modell med N skikten:

  • Totala parametrar = N * Parameters_layer + Parameters_embedding + Parameters_output

Exempel berÀkning

LÄt oss övervÀga en modell med följande specifikationer:

  • d_model = 768
  • h (antal uppmĂ€rksamhetshuvuden) = 12
  • N (antal lager) = 12
  • vocab_size = 50,000
  1. InbÀdda lager:
    • 50,000 * 768 = 38,400,000
  2. Multi-Head Attention:
    • 4 * 768^2 = 2,359,296
  3. Feed-Forward-nÀtverk:
    • 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4,719,616 XNUMX XNUMX
  4. Lagernormalisering:
    • 2 * 768 = 1,536

Totala parametrar per lager:

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

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: Det minne som krÀvs för att lagra modellparametrarna.
  2. Arbetsminnet: Minnet som behövs under slutledning eller trÀning för att lagra mellanliggande aktiveringar, gradienter och optimeringstillstÄnd.

BerÀknar modellminne

Modellminnet Àr direkt relaterat till antalet parametrar. Varje parameter lagras vanligtvis som ett 32-bitars flyttal, Àven om vissa modeller anvÀnder trÀning med blandad precision med 16-bitars flytande.

Modellminne (byte) = Antal parametrar * Byte per parameter

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

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

Uppskattning av arbetsminne

Kraven pÄ arbetsminne kan variera avsevÀrt beroende pÄ den specifika uppgiften, batchstorleken och sekvenslÀngden. En grov uppskattning av arbetsminnet under slutledning Àr:

Arbetsminne ≈ 2 * Modellminne

Detta stÄr för lagring av bÄde modellparametrarna och de mellanliggande aktiveringarna. Under trÀning kan minneskraven vara Ànnu högre pÄ grund av behovet av att lagra gradienter och optimerartillstÄnd:

TrĂ€ningsminne ≈ 4 * Modellminne

För vÄr exempelmodell:

  • Inferens arbetsminne ≈ 2 * 494 MB = 988 MB ≈ 1 GB
  • TrĂ€ningsminne ≈ 4 * 494 MB = 1,976 2 MB ≈ XNUMX GB

Steady-State minnesanvÀndning och maximal minnesanvÀndning

NÀr man trÀnar stora sprÄkmodeller baserade pÄ Transformer-arkitekturen Àr förstÄelse av minnesanvÀndning avgörande för effektiv resursallokering. LÄt oss dela upp minneskraven i tvÄ huvudkategorier: steady-state minnesanvÀndning och maximal minnesanvÀndning.

StationÀr minnesanvÀndning

MinnesanvÀndningen i stationÀrt tillstÄnd bestÄr av följande komponenter:

  1. Modellvikter: FP32-kopior av modellparametrarna, som krÀver 4N byte, dÀr N Àr antalet parametrar.
  2. Optimizer tillstÄnd: För Adam-optimeraren krÀver detta 8N byte (2 tillstÄnd per parameter).
  3. gradienter: FP32-kopior av gradienterna, som krÀver 4N byte.
  4. Indata: Om man antar int64-ingÄngar, krÀver detta 8BD-byte, dÀr B Àr batchstorleken och D Àr inmatningsdimensionen.

Den totala minnesanvÀndningen i stationÀrt tillstÄnd kan uppskattas av:

  • M_steady = 16N + 8BD byte

AnvÀndning av toppminne

Maximal minnesanvÀndning intrÀffar under bakÄtpassningen nÀr aktiveringar lagras för gradientberÀkning. De frÀmsta bidragen till toppminnet Àr:

  1. Lagernormalisering: KrÀver 4E byte per lagernorm, dÀr E = BSH (B: batchstorlek, S: sekvenslÀngd, H: dold storlek).
  2. UppmÀrksamhetsblock:
    • QKV-berĂ€kning: 2E byte
    • UppmĂ€rksamhetsmatris: 4BSS-byte (S: sekvenslĂ€ngd)
    • UppmĂ€rksamhetsutgĂ„ng: 2E byte
  3. Frammatningsblock:
    • Första linjĂ€ra lagret: 2E byte
    • GELU-aktivering: 8E byte
    • Andra linjĂ€ra lagret: 2E byte
  4. Cross-Entropy Förlust:
    • Inloggningar: 6BSV byte (V: ordförrĂ„dsstorlek)

Det totala aktiveringsminnet kan uppskattas som:

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

DÀr L Àr antalet transformatorlager.

Total minnesanvÀndning

Den maximala minnesanvÀndningen under trÀning kan uppskattas genom att kombinera stationÀrt minne och aktiveringsminne:

  • M_peak = M_steady + M_act + 4BSV byte

Den extra 4BSV-terminen stÄr för en extra tilldelning i början av bakÄtpassningen.

Genom att förstÄ dessa komponenter kan vi optimera minnesanvÀndningen under trÀning och slutledning, 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 hos LLM tenderar att följa vissa skalningslagar nÀr antalet parametrar ökar. Kaplan et al. (2020) observerade att modellens prestanda förbÀttras som en kraftlag för antalet parametrar, berÀkna budget och datauppsÀttningsstorlek.

FörhÄllandet mellan modellprestanda och antalet parametrar kan uppskattas genom:

Prestanda ∝ N^α

DÀr N Àr antalet parametrar och α Àr en skalningsexponent vanligtvis runt 0.07 för sprÄkmodelleringsuppgifter.

Detta innebĂ€r att för att uppnĂ„ en 10% förbĂ€ttring av prestanda, mĂ„ste vi öka antalet parametrar med en faktor pĂ„ 10^(1/α) ≈ 3.7.

Effektivitetstekniker

NÀr 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) Modell Parallellism: Fördelning av modellen över flera GPU:er eller TPU:er för att hantera större modeller Àn vad som fÄr plats pÄ en enda enhet.

c) Gradient Checkpointing: Byt berÀkning för minne genom att rÀkna om vissa aktiveringar under bakÄtpassningen istÀllet för att lagra dem.

d) BeskÀrning och kvantisering: Ta bort mindre viktiga vikter eller minska deras precision efter trÀning för att skapa mindre, mer effektiva modeller.

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

Praktiska exempel och berÀkningar

GPT-3, en av de största sprÄkmodellerna, har 175 miljarder parametrar. Den anvÀnder dekoderdelen 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 avkodarlager:

Totala parametrar = 8 * 12288^2 + 8 * 12288 * 49152 + 2 * 12288 ≈ 1.1 miljarder

Totalt för 96 lager:

1.1 miljarder * 96 = 105.6 miljarder

De ÄterstÄende parametrarna kommer frÄn inbÀddning och andra komponenter.

Slutsats

Att förstÄ parametrarna och minneskraven för stora sprÄkmodeller Àr avgörande för att effektivt kunna designa, trÀna och distribuera dessa kraftfulla verktyg. Genom att bryta ner komponenterna i Transformer-arkitektur 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 applikationer, kolla in dessa omfattande guider:

Relaterade Àmnen:
mm

Jag har Àgnat de senaste fem Ären Ät att fördjupa mig i den fascinerande vÀrlden av Machine Learning och Deep Learning. Min passion och expertis har lett mig till att bidra till över 50 olika programvaruutvecklingsprojekt, med sÀrskilt fokus pÄ AI/ML. Min pÄgÄende nyfikenhet har ocksÄ dragit mig mot Natural Language Processing, ett omrÄde som jag Àr ivrig att utforska vidare.