Følg os
   Kunstig intelligens  
Forståelse af store sprogmodelparametre og hukommelseskrav: Et dybt dyk
 mm
Udgivet
 6 dage siden
 on
   
 Beregning af parametre i transformatorbaserede LLM'er
Store sprogmodeller (LLM'er) har set bemærkelsesværdige fremskridt i de seneste år. Modeller som GPT-4, Googles Gemini og Claude 3 sætter nye standarder inden for muligheder og applikationer. Disse modeller forbedrer ikke kun tekstgenerering og oversættelse, men bryder også nye veje inden for multimodal behandling, der kombinerer tekst-, billede-, lyd- og videoinput for at give mere omfattende AI-løsninger.
For eksempel har OpenAIs GPT-4 vist betydelige forbedringer i forståelse og generering af menneskelignende tekst, mens Googles Gemini-modeller udmærker sig ved at håndtere forskellige datatyper, herunder tekst, billeder og lyd, hvilket muliggør mere sømløse og kontekstuelt relevante interaktioner. På samme måde er Anthropics Claude 3-modeller kendt for deres flersprogede evner og forbedrede ydeevne i AI-opgaver.
Efterhånden som udviklingen af ​​LLM'er fortsætter med at accelerere, bliver forståelsen af ​​disse modellers forviklinger, især deres parametre og hukommelseskrav, afgørende. Denne vejledning har til formål at afmystificere disse aspekter og giver en detaljeret og letforståelig forklaring.
Grundlæggende om store sprogmodeller
Hvad er store sprogmodeller?
Store sprogmodeller er neurale netværk trænet på massive datasæt til at forstå og generere menneskeligt sprog. De er afhængige af arkitekturer som Transformers, der bruger mekanismer såsom selvopmærksomhed til at behandle og producere tekst.
Betydningen af ​​parametre i LLM'er
Parametre er kernekomponenterne i disse modeller. De inkluderer vægte og skævheder, som modellen justerer under træning for at minimere fejl i forudsigelser. Antallet af parametre korrelerer ofte med modellens kapacitet og ydeevne, men påvirker også dens beregnings- og hukommelseskrav.
Forståelse af transformatorarkitektur
Transformers-arkitektur
Transformers arkitektur
Oversigt
Transformer-arkitekturen, introduceret i papiret "Attention Is All You Need" af Vaswani et al. (2017), er blevet grundlaget for mange LLM'er. Den består af en koder og en dekoder, der hver består af flere identiske lag.
Encoder- og dekoderkomponenter
  • Encoder: Behandler inputsekvensen og skaber en kontekstbevidst repræsentation.
  • Dekoder: Genererer outputsekvensen ved hjælp af indkoderens repræsentation og de tidligere genererede tokens.
Nøgle byggeklodser
  1. Multi-Hoved opmærksomhed: Gør det muligt for modellen at fokusere på forskellige dele af inputsekvensen samtidigt.
  2. Feed-Forward neurale netværk: Tilføjer ikke-linearitet og kompleksitet til modellen.
  3. Lag normalisering: Stabiliserer og accelererer træningen ved at normalisere mellemoutput.
Beregning af antallet af parametre
Transformer træning
Foruddannede modeller til effektiv transformatortræning
Beregning af parametre i transformatorbaserede LLM'er
Lad os nedbryde parameterberegningen for hver komponent i en transformer-baseret LLM. Vi bruger notationen fra det originale papir, hvor d_model repræsenterer dimensionen af ​​modellens skjulte tilstande.
  1. Indlejring af lag:
    • Parametre = vocab_size * d_model
  2. Multi-Hoved opmærksomhed:
    • Til h hoveder, med d_k = d_v = d_model / h:
    • Parametre = 4 * d_model^2 (for Q-, K-, V- og outputprojektioner)
  3. Feed-Forward-netværk:
    • Parametre = 2 * d_model * d_ff + d_model + d_ff
    • Hvor d_ff er typisk 4* d_model
  4. Lag normalisering:
    • Parametre = 2 * d_model (for skala og bias)
Samlede parametre for et transformerlag:
  • Parameters_layer = Parameters_attention + Parameters_ffn + 2 * Parameters_layernorm
Til en model med N lag:
  • Samlede parametre = N * Parameters_layer + Parameters_embedding + Parameters_output
Eksempel på beregning
Lad os overveje en model med følgende specifikationer:
  • d_model = 768
  • h (antal opmærksomhedshoveder) = 12
  • N (antal lag) = 12
  • vocab_size = 50,000
  1. Indlejring af lag:
    • 50,000 * 768 = 38,400,000
  2. Multi-Hoved opmærksomhed:
    • 4 * 768^2 = 2,359,296
  3. Feed-Forward-netværk:
    • 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4,719,616
  4. Lag normalisering:
    • 2 * 768 = 1,536
Samlede parametre pr. lag:
  • 2,359,296 + 4,719,616 + (2 * 1,536) = 7,081,984
Samlede parametre for 12 lag:
  • 12 * 7,081,984 = 84,983,808
Samlede modelparametre:
  • 84,983,808 + 38,400,000 = 123,383,808
Denne model ville have cirka 123 millioner parametre.
Typer af hukommelsesbrug
Når vi arbejder med LLM'er, skal vi overveje to hovedtyper af hukommelsesbrug:
  1. Modelhukommelse: Den nødvendige hukommelse til at gemme modelparametrene.
  2. Arbejde hukommelse: Den hukommelse, der er nødvendig under inferens eller træning for at gemme mellemaktiveringer, gradienter og optimeringstilstande.
Beregning af modelhukommelse
Modelhukommelsen er direkte relateret til antallet af parametre. Hver parameter gemmes typisk som et 32-bit flydende kommanummer, selvom nogle modeller bruger blandet præcisionstræning med 16-bit flydere.
Modelhukommelse (bytes) = Antal parametre * Bytes pr. parameter
For vores eksempelmodel med 123 millioner parametre:
  • Modelhukommelse (32-bit) = 123,383,808 * 4 bytes = 493,535,232 bytes ≈ 494 MB
  • Modelhukommelse (16-bit) = 123,383,808 * 2 bytes = 246,767,616 bytes ≈ 247 MB
Estimering af arbejdshukommelse
Kravene til arbejdshukommelse kan variere betydeligt baseret på den specifikke opgave, batchstørrelse og sekvenslængde. Et groft skøn for arbejdshukommelsen under inferens er:
Arbejdshukommelse ≈ 2 * Modelhukommelse
Dette tager højde for lagring af både modelparametrene og de mellemliggende aktiveringer. Under træning kan hukommelseskravene være endnu højere på grund af behovet for at gemme gradienter og optimeringstilstande:
Træningshukommelse ≈ 4 * Modelhukommelse
For vores eksempelmodel:
  • Inferens arbejdshukommelse ≈ 2 * 494 MB = 988 MB ≈ 1 GB
  • Træningshukommelse ≈ 4 * 494 MB = 1,976 MB ≈ 2 GB
Steady-State Hukommelsesbrug og Peak Memory Usage
Når du træner store sprogmodeller baseret på Transformer-arkitekturen, er forståelse af hukommelsesbrug afgørende for effektiv ressourceallokering. Lad os opdele hukommelseskravene i to hovedkategorier: steady-state hukommelsesbrug og maksimal hukommelsesbrug.
Steady-State Hukommelsesbrug
steady-state hukommelsesforbruget omfatter følgende komponenter:
  1. Modelvægte: FP32-kopier af modelparametrene, der kræver 4N bytes, hvor N er antallet af parametre.
  2. Optimizer stater: For Adam optimizer kræver dette 8N bytes (2 tilstande pr. parameter).
  3. farveforløb: FP32-kopier af gradienterne, der kræver 4N bytes.
  4. Inputdata: Forudsat int64-input, kræver dette 8BD-bytes, hvor B er batchstørrelsen og D er inputdimensionen.
Det samlede steady-state hukommelsesforbrug kan tilnærmes ved:
  • M_steady = 16N + 8BD bytes
Peak Memory Usage
Maksimal hukommelsesbrug opstår under tilbageløbet, når aktiveringer gemmes til gradientberegning. De vigtigste bidragydere til peak memory er:
  1. Lag normalisering: Kræver 4E bytes pr. lag norm, hvor E = BSH (B: batchstørrelse, S: sekvenslængde, H: skjult størrelse).
  2. Opmærksomhedsblok:
    • QKV-beregning: 2E bytes
    • Opmærksomhedsmatrix: 4BSS bytes (S: sekvenslængde)
    • Opmærksomhedsudgang: 2E bytes
  3. Feed-Forward blok:
    • Første lineære lag: 2E bytes
    • GELU-aktivering: 8E bytes
    • Andet lineært lag: 2E bytes
  4. Tværentropitab:
    • Logits: 6BSV bytes (V: ordforrådsstørrelse)
Den samlede aktiveringshukommelse kan estimeres som:
  • M_act = L * (14E + 4BSS) + 6BSV bytes
Hvor L er antallet af transformatorlag.
Total peak hukommelsesforbrug
Det maksimale hukommelsesforbrug under træning kan tilnærmes ved at kombinere steady-state hukommelsen og aktiveringshukommelsen:
  • M_peak = M_steady + M_act + 4BSV bytes
Den ekstra 4BSV-term tegner sig for en ekstra tildeling ved starten af ​​tilbageløbet.
Ved at forstå disse komponenter kan vi optimere hukommelsesforbruget under træning og inferens, hvilket sikrer effektiv ressourceallokering og forbedret ydeevne af store sprogmodeller.
Skaleringslove og effektivitetsovervejelser
 Skaleringslove for LLM'er
Forskning har vist, at ydeevnen af ​​LLM'er har en tendens til at følge visse skaleringslove, efterhånden som antallet af parametre stiger. Kaplan et al. (2020) observerede, at modellens ydeevne forbedres som en magtlov for antallet af parametre, beregningsbudget og datasætstørrelse.
Forholdet mellem modellens ydeevne og antallet af parametre kan tilnærmes ved:
Ydeevne ∝ N^α
Hvor N er antallet af parametre, og α er en skaleringseksponent typisk omkring 0.07 for sprogmodelleringsopgaver.
Dette indebærer, at for at opnå en 10% forbedring af ydeevnen, skal vi øge antallet af parametre med en faktor på 10^(1/α) ≈ 3.7.
Effektivitetsteknikker
Efterhånden som LLM'er fortsætter med at vokse, har forskere og praktikere udviklet forskellige teknikker til at forbedre effektiviteten:
a) Blandet præcisionstræning: Brug af 16-bit eller endda 8-bit flydende kommatal til visse operationer for at reducere hukommelsesforbrug og beregningskrav.
b) Modelparallelisme: Fordeling af modellen på tværs af flere GPU'er eller TPU'er for at håndtere større modeller, end der kan passe på en enkelt enhed.
c) Gradient Checkpointing: Handel med beregning for hukommelse ved at genberegne visse aktiveringer under tilbageløbet i stedet for at gemme dem.
d) Beskæring og kvantisering: Fjernelse af mindre vigtige vægte eller reduktion af deres præcision efter træning for at skabe mindre, mere effektive modeller.
e) Destillation: Træning af mindre modeller til at efterligne opførselen af ​​større modeller, hvilket potentielt bevarer meget af ydeevnen med færre parametre.
Praktisk eksempel og beregninger
GPT-3, en af ​​de største sprogmodeller, har 175 milliarder parametre. Den bruger dekoderdelen af ​​Transformer-arkitekturen. For at forstå dens skala, lad os nedbryde parameterantallet med hypotetiske værdier:
  • d_model = 12288
  • d_ff = 4 * 12288 = 49152
  • Antal lag = 96
For et dekoderlag:
Samlede parametre = 8 * 12288^2 + 8 * 12288 * 49152 + 2 * 12288 ≈ 1.1 mia.
I alt for 96 lag:
1.1 milliarder * 96 = 105.6 milliarder
De resterende parametre kommer fra indlejring og andre komponenter.
Konklusion
At forstå parametrene og hukommelseskravene for store sprogmodeller er afgørende for effektivt at designe, træne og implementere disse kraftfulde værktøjer. Ved at nedbryde komponenterne i Transformer-arkitektur og undersøge praktiske eksempler som GPT, får vi en dybere indsigt i kompleksiteten og skalaen af ​​disse modeller.
For yderligere at forstå de seneste fremskridt inden for store sprogmodeller og deres applikationer, tjek disse omfattende vejledninger:
       
 Relaterede emner:
 mm
Jeg har brugt de sidste fem år på at fordybe mig i den fascinerende verden af ​​Machine Learning og Deep Learning. Min passion og ekspertise har ført mig til at bidrage til over 50 forskellige software engineering projekter, med særligt fokus på AI/ML. Min vedvarende nysgerrighed har også trukket mig hen imod Natural Language Processing, et felt jeg er ivrig efter at udforske yderligere.