bootnoun.pages.dev






Antal parametrar som människor kan hantera

Förstå parametrar till stora språkmodeller samt minneskrav: ett djupdykning

Stora språkmodeller (LLMs) besitter sett anmärkningsvärda framsteg dem senaste år. Modeller såsom GPT-4, Googles Gemini samt Claude 3 sätter nya standarder på grund av funktioner samt applikationer. Dessa modeller förbättrar ej bara textgenerering samt översättning utan bryter även färsk mark inom multimodal bearbetning, genom för att sammanföra text-, bild-, ljud- samt videoingångar på grund av för att tillhandahålla mer grundlig AI-lösningar.

Till modell besitter OpenAI:s GPT-4 demonstrerat avgörande förbättringar inom för att förstå samt generera mänsklig skrivelse, medan Googles Gemini-modeller utmärker sig inom för att hantera olika datatyper, inklusive skrivelse, bilder samt ljud, vilket möjliggör mer sömlösa samt kontextuellt relevanta interaktioner.

Det handlar om vad vi gör, hur vi lever och vad vi är med om, men också om de rättigheter, möjligheter eller begränsningar som

vid identisk sätt existerar Anthropics Claude 3-modeller kända till sina flerspråkiga möjligheter samt förbättrade prestanda inom AI-uppgifter.

När utvecklingen från LLM fortsätter för att påskynda, blir detta kritisk för att förstå dessa modellers krångligheter, särskilt deras parametrar samt minneskrav. Denna guide syftar mot för att avmystifiera dessa aspekter samt erbjuder ett omfattande samt lättförståelig förklaring.

Grunderna inom stora språkmodeller

Vad existerar stora språkmodeller?

Stora språkmodeller existerar neurala nätverk såsom tränas vid massiva datamängder till för att förstå samt generera mänskligt tungomål.

dem förlitar sig vid arkitekturer likt Transformers, vilket använder mekanismer likt självuppmärksamhet på grund av för att bearbeta samt producera text.

Vikten från parametrar inom LLM

Parametrar existerar kärnkomponenterna inom dessa modeller. dem inkluderar vikter samt fördomar, vilket modellen justerar beneath träning till för att minimera fel inom förutsägelser.

Ordmolnet är skapat i wordclouds

Antalet parametrar korrelerar ofta tillsammans modellens kapacitet samt prestanda dock påverkar även dess beräknings- samt minneskrav.

Förstå transformatorarkitektur

Transformers arkitektur

Översikt

Transformer-arkitekturen, introducerad inom "Attention fryst vatten All You Need"-papperet från Vaswani et al. (2017), besitter blivit grunden på grund av flera LLM.

Den består från enstaka en person som skriver datorprogram eller kod samt ett avkodare, såsom fanns samt ett består från flera identiska lager.

Kodar- samt avkodarkomponenter

  • kodare: Bearbetar inmatningssekvensen samt skapar ett kontextmedveten representation.
  • Avkodare: Genererar utdatasekvensen tillsammans med hjälp från kodarens representation samt dem tidigare genererade tokens.

Viktiga byggstenar

  1. Multi-Head Attention: fullfölja detta möjligt på grund av modellen för att fokusera vid olika delar från inmatningssekvensen samtidigt.
  2. Feed-Forward neurala nätverk: Lägger mot icke-linjäritet samt komplexitet mot modellen.
  3. Lagernormalisering: Stabiliserar samt accelererar träningen genom för att normalisera mellaneffekterna.

Beräkna antalet parametrar

Förutbildade modeller på grund av produktiv transformatorträning

Beräkna parametrar inom transformatorbaserade LLM:er

Låt oss avbryta ner parameterberäkningen på grund av varenda komponent inom ett transformatorbaserad LLM.

oss använder notationen ifrån originalpapperet, var representerar dimensionen från modellens gömda tillstånd.

  1. Inbädda lager:
    • Parametrar = *
  2. Multi-Head Attention:
    • För huvuden, tillsammans :
    • Parametrar = 4 * ^2 (för Q-, K-, V- samt outputprojektioner)
  3. Feed-Forward-nätverk:
    • Parametrar = 2 * * + +
    • Var existerar vanligtvis 4*
  4. Lagernormalisering:
    • Parametrar = 2 * (för skal samt bias)

Totala parametrar på grund av en transformatorlager:

  • = + + 2 *

För ett modell tillsammans med skikten:

  • Totala parametrar = * + +

Exempel beräkning

Låt oss betänka enstaka modell tillsammans med nästa specifikationer:

  • = 768
  • (antal uppmärksamhetshuvuden) = 12
  • (antal lager) = 12
  • = 50,000
  1. Inbädda lager:
    • 50,000 * 768 = 38,400,000
  2. Multi-Head Attention:
  3. Feed-Forward-nätverk:
    • 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4,719,616 XNUMX XNUMX
  4. Lagernormalisering:

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 till 12 lager:

  • 12 * 7,081,984 = 84,983,808

Totala modellparametrar:

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

Denna modell skulle äga cirka 123 miljoner parametrar.

Typer från minnesanvändning

När oss arbetar tillsammans LLM måste oss reflektera numeriskt värde huvudtyper från minnesanvändning:

  1. Modellminne: detta minne vilket behövs på grund av för att lagra modellparametrarna.
  2. Arbetsminnet: Minnet likt behövs beneath slutledning alternativt träning till för att lagra mellanliggande aktiveringar, gradienter samt optimeringstillstånd.

Beräknar modellminne

Modellminnet existerar direkt relaterat mot antalet parametrar.

varenda parameter lagras vanligtvis liksom en 32-bitars flyttal, även angående vissa modeller använder träning tillsammans blandad noggrannhet tillsammans med 16-bitars flytande.

Modellminne (byte) = Antal parametrar * Byte per parameter

För vår exempelmodell tillsammans 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 från arbetsminne

Kraven vid arbetsminne är kapabel variera avsevärt beroende vid den specifika uppgiften, batchstorleken samt sekvenslängden.

enstaka grov uppskattning från arbetsminnet beneath slutledning är:

Arbetsminne ≈ 2 * Modellminne

Detta står på grund av lagring från både modellparametrarna samt dem mellanliggande aktiveringarna. beneath träning kunna minneskraven existera ännu högre vid bas från nödvändigheten från för att lagra gradienter samt 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 samt maximal minnesanvändning

När man tränar stora språkmodeller baserade vid Transformer-arkitekturen existerar medvetande från minnesanvändning kritisk på grund av produktiv resursallokering.

Låt oss dela upp minneskraven inom numeriskt värde huvudkategorier: steady-state minnesanvändning samt maximal minnesanvändning.

Stationär minnesanvändning

Minnesanvändningen inom fast tillåtelse består från nästa komponenter:

  1. Modellvikter: FP32-kopior från modellparametrarna, såsom kräver 4N byte, var N existerar antalet parametrar.
  2. Optimizer tillstånd: på grund av Adam-optimeraren kräver detta 8N byte (2 status per parameter).
  3. gradienter: FP32-kopior från gradienterna, likt kräver 4N byte.
  4. Indata: angående man antar int64-ingångar, kräver detta 8BD-byte, var B existerar batchstorleken samt D existerar inmatningsdimensionen.

Den totala minnesanvändningen inom fast status är kapabel uppskattas av:

  • M_steady = 16N + 8BD byte

Användning från toppminne

Maximal minnesanvändning inträffar beneath bakåtpassningen då aktiveringar lagras på grund av gradientberäkning.

dem främsta bidragen mot toppminnet är:

  1. Lagernormalisering: Kräver 4E byte per lagernorm, var E = BSH (B: batchstorlek, S: sekvenslängd, H: gömd 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 raka lagret: 2E byte
    • GELU-aktivering: 8E byte
    • Andra raka lagret: 2E byte
  4. Cross-Entropy Förlust:
    • Inloggningar: 6BSV byte (V: ordförrådsstorlek)

Det totala aktiveringsminnet kunna uppskattas som:

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

Där L existerar antalet transformatorlager.

Total minnesanvändning

Den maximala minnesanvändningen beneath träning kunna uppskattas genom för att sammanföra fast minne samt aktiveringsminne:

  • M_peak = M_steady + M_act + 4BSV byte

Den ytterligare 4BSV-terminen står till ett extra tilldelning inom start från bakåtpassningen.

Genom för att förstå dessa komponenter förmå oss optimera minnesanvändningen beneath träning samt slutledning, vilket säkerställer produktiv resursallokering samt förbättrad prestanda på grund av stora språkmodeller.

Skalningslagar samt effektivitetsöverväganden

 Skalningslagar på grund av LLM

Forskning äger demonstrerat för att prestandan hos LLM tenderar för att följa vissa skalningslagar då antalet parametrar ökar.

Kaplan et al. (2020) observerade för att modellens prestanda förbättras likt ett kraftlag på grund av antalet parametrar, beräkna ekonomisk plan samt datauppsättningsstorlek.

Förhållandet mellan modellprestanda samt antalet parametrar är kapabel uppskattas genom:

Prestanda ∝ N^α

Där N existerar antalet parametrar samt α existerar ett skalningsexponent vanligtvis runt 0.07 på grund av språkmodelleringsuppgifter.

Detta innebär för att till för att nå enstaka 10% förbättring från prestanda, måste oss öka antalet parametrar tillsammans med ett faktor vid 10^(1/α) ≈ 3.7.

Effektivitetstekniker

När LLM fortsätter för att växa besitter vetenskapsman samt praktiker utvecklat olika tekniker på grund av för att utveckla effektiviteten:

a) Blandad precisionsträning: Användning från 16-bitars alternativt mot samt tillsammans 8-bitars flyttal till vissa operationer till för att minska minnesanvändning samt beräkningskrav.

b) Modell Parallellism: Fördelning från modellen ovan flera GPU:er alternativt TPU:er på grund av för att hantera större modeller än vilket likt får område vid ett enda enhet.

c) Gradient Checkpointing: Byt kalkyl till minne genom för att räkna angående vissa aktiveringar beneath bakåtpassningen istället på grund av för att lagra dem.

d) Beskärning samt kvantisering: Ta försvunnen mindre viktiga vikter alternativt minska deras noggrannhet efter träning till för att producera mindre, mer verksamma modeller.

e) Destillering: Träna mindre modeller till för att efterlikna beteendet hos större, vilket potentiellt bevarar många från prestandan tillsammans färre parametrar.

Praktiska modell samt beräkningar

GPT-3, enstaka från dem största språkmodellerna, besitter 175 miljarder parametrar.

Hälsans bestämningsfaktorer kan beskrivas i Whiteheads och Dahlgrens regnbågsmodell

Den använder dekoderdelen från Transformer-arkitekturen. till för att förstå dess skal, låt oss avbryta ner parameterantalet tillsammans hypotetiska värden:

  • Antal lager = 96

För en avkodarlager:

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

Totalt till 96 lager:

1.1 miljarder * 96 = 105.6 miljarder

De återstående parametrarna kommer ifrån inbäddning samt andra komponenter.

Slutsats

Att förstå parametrarna samt minneskraven till stora språkmodeller existerar kritisk till för att effektivt behärska designa, träna samt distribuera dessa kraftfulla verktyg.

Genom för att avbryta ner komponenterna inom Transformer-arkitektur samt undersöka praktiska modell liksom GPT får oss ett djupare förståelse inom komplexiteten samt skalan hos dessa modeller.

För för att ytterligare förstå dem senaste framstegen inom stora språkmodeller samt deras applikationer, kolla in dessa grundlig guider:


  • antal parametrar som människor kan hantera