Anslut dig till vårt nätverk! 
   Artificiell intelligens  
Förstå parametrar för stora språkmodeller och minneskrav: En djupdykning
 mm
publicerade
 6 dagar 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.