Kontakt med oss
   Kunstig intelligens  
Forstå parametere for store språkmodeller og minnekrav: Et dypdykk
 mm
Publisert
 6 dager siden
 on
   
 Beregne parametere i transformatorbaserte LLM-er
Store språkmodeller (LLMs) har sett bemerkelsesverdige fremskritt de siste årene. Modeller som GPT-4, Googles Gemini og Claude 3 setter nye standarder for funksjoner og applikasjoner. Disse modellene forbedrer ikke bare tekstgenerering og oversettelse, men bryter også ny mark innen multimodal prosessering, og kombinerer tekst-, bilde-, lyd- og videoinnganger for å gi mer omfattende AI-løsninger.
For eksempel har OpenAIs GPT-4 vist betydelige forbedringer i å forstå og generere menneskelignende tekst, mens Googles Gemini-modeller utmerker seg i å håndtere forskjellige datatyper, inkludert tekst, bilder og lyd, og muliggjør mer sømløs og kontekstuelt relevante interaksjoner. På samme måte er Anthropics Claude 3-modeller kjent for sine flerspråklige evner og forbedret ytelse i AI-oppgaver.
Etter hvert som utviklingen av LLM-er fortsetter å akselerere, blir det avgjørende å forstå vanskelighetene til disse modellene, spesielt deres parametere og minnekrav. Denne veiledningen tar sikte på å avmystifisere disse aspektene, og tilbyr en detaljert og lettfattelig forklaring.
Grunnleggende om store språkmodeller
Hva er store språkmodeller?
Store språkmodeller er nevrale nettverk som er trent på massive datasett for å forstå og generere menneskelig språk. De er avhengige av arkitekturer som Transformers, som bruker mekanismer som selvoppmerksomhet for å behandle og produsere tekst.
Viktigheten av parametere i LLM-er
Parametre er kjernekomponentene i disse modellene. De inkluderer vekter og skjevheter, som modellen justerer under trening for å minimere feil i spådommer. Antall parametere korrelerer ofte med modellens kapasitet og ytelse, men påvirker også beregnings- og minnekravene.
Forstå transformatorarkitektur
Transformatorer-arkitektur
Transformers arkitektur
Oversikt
Transformer-arkitekturen, introdusert i papiret "Attention Is All You Need" av Vaswani et al. (2017), har blitt grunnlaget for mange LLM-er. Den består av en koder og en dekoder, som hver består av flere identiske lag.
Koder- og dekoderkomponenter
  • Encoder: Behandler inndatasekvensen og lager en kontekstbevisst representasjon.
  • dekoder: Genererer utgangssekvensen ved å bruke koderens representasjon og de tidligere genererte tokenene.
Nøkkel byggeklosser
  1. Multi-hode oppmerksomhet: Gjør det mulig for modellen å fokusere på forskjellige deler av inndatasekvensen samtidig.
  2. Feed-Forward nevrale nettverk: Legger til ikke-linearitet og kompleksitet til modellen.
  3. Lagnormalisering: Stabiliserer og akselererer treningen ved å normalisere mellomeffekter.
Beregning av antall parametere
Transformatoropplæring
Forhåndsutdannede modeller for effektiv transformatortrening
Beregne parametere i transformatorbaserte LLM-er
La oss bryte ned parameterberegningen for hver komponent i en transformatorbasert LLM. Vi bruker notasjonen fra originaloppgaven, hvor d_model representerer dimensjonen til modellens skjulte tilstander.
  1. Innebyggingslag:
    • Parametere = vocab_size * d_model
  2. Multi-hode oppmerksomhet:
    • Til h hoder, med d_k = d_v = d_model / h:
    • Parametere = 4 * d_model^2 (for Q-, K-, V- og utgangsprojeksjoner)
  3. Feed-Forward-nettverk:
    • Parametere = 2 * d_model * d_ff + d_model + d_ff
    • Hvor d_ff er vanligvis 4* d_model
  4. Lagnormalisering:
    • Parametere = 2 * d_model (for skala og skjevhet)
Totale parametere for ett transformatorlag:
  • Parameters_layer = Parameters_attention + Parameters_ffn + 2 * Parameters_layernorm
For en modell med N lag:
  • Totale parametere = N * Parameters_layer + Parameters_embedding + Parameters_output
Eksempel på beregning
La oss vurdere en modell med følgende spesifikasjoner:
  • d_model = 768
  • h (antall oppmerksomhetshoder) = 12
  • N (antall lag) = 12
  • vocab_size = 50,000
  1. Innebyggingslag:
    • 50,000 * 768 = 38,400,000
  2. Multi-hode oppmerksomhet:
    • 4 * 768^2 = 2,359,296
  3. Feed-Forward-nettverk:
    • 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4,719,616 XNUMX XNUMX
  4. Lagnormalisering:
    • 2 * 768 = 1,536
Totale parametere per lag:
  • 2,359,296 4,719,616 2 + 1,536 7,081,984 XNUMX + (XNUMX * XNUMX XNUMX) = XNUMX XNUMX XNUMX
Totale parametere for 12 lag:
  • 12 * 7,081,984 = 84,983,808
Totale modellparametere:
  • 84,983,808 + 38,400,000 = 123,383,808
Denne modellen vil ha omtrent 123 millioner parametere.
Typer minnebruk
Når vi jobber med LLM-er, må vi vurdere to hovedtyper minnebruk:
  1. Modellminne: Minnet som kreves for å lagre modellparametrene.
  2. Arbeidsminnet: Minnet som trengs under inferens eller trening for å lagre mellomliggende aktiveringer, gradienter og optimeringstilstander.
Beregne modellminne
Modellminnet er direkte relatert til antall parametere. Hver parameter er vanligvis lagret som et 32-bits flytende kommanummer, selv om noen modeller bruker blandet presisjonstrening med 16-bits flyter.
Modellminne (bytes) = Antall parametere * Byte per parameter
For vår eksempelmodell med 123 millioner parametere:
  • Modellminne (32-bit) = 123,383,808 4 493,535,232 * 494 byte = XNUMX XNUMX XNUMX byte ≈ XNUMX MB
  • Modellminne (16-bit) = 123,383,808 2 246,767,616 * 247 byte = XNUMX XNUMX XNUMX byte ≈ XNUMX MB
Beregning av arbeidsminne
Kravene til arbeidsminne kan variere betydelig basert på den spesifikke oppgaven, batchstørrelsen og sekvenslengden. Et grovt estimat for arbeidsminne under inferens er:
Arbeidsminne ≈ 2 * Modellminne
Dette tar hensyn til lagring av både modellparametrene og mellomaktiveringene. Under trening kan minnekravene være enda høyere på grunn av behovet for å lagre gradienter og optimeringstilstander:
Treningsminne ≈ 4 * Modellminne
For eksempelmodellen vår:
  • Inferens arbeidsminne ≈ 2 * 494 MB = 988 MB ≈ 1 GB
  • Treningsminne ≈ 4 * 494 MB = 1,976 2 MB ≈ XNUMX GB
Steady-State minnebruk og topp minnebruk
Når du trener store språkmodeller basert på Transformer-arkitekturen, er forståelse av minnebruk avgjørende for effektiv ressursallokering. La oss bryte ned minnekravene i to hovedkategorier: steady-state minnebruk og topp minnebruk.
Steady-State minnebruk
Bruken av steady-state minne består av følgende komponenter:
  1. Modellvekter: FP32-kopier av modellparametrene, som krever 4N byte, der N er antall parametere.
  2. Optimaliseringsstater: For Adam-optimalisatoren krever dette 8N byte (2 tilstander per parameter).
  3. gradienter: FP32-kopier av gradientene, krever 4N byte.
  4. Inngangsdata: Forutsatt int64-innganger, krever dette 8BD-byte, der B er batchstørrelsen og D er inngangsdimensjonen.
Den totale steady-state minnebruken kan tilnærmes ved:
  • M_steady = 16N + 8BD byte
Bruk av maksimalt minne
Maksimal minnebruk oppstår under bakoverpasseringen når aktiveringer lagres for gradientberegning. De viktigste bidragsyterne til toppminne er:
  1. Lagnormalisering: Krever 4E byte per lag norm, der E = BSH (B: batchstørrelse, S: sekvenslengde, H: skjult størrelse).
  2. Oppmerksomhetsblokk:
    • QKV-beregning: 2E byte
    • Oppmerksomhetsmatrise: 4BSS byte (S: sekvenslengde)
    • Oppmerksomhetsutgang: 2E byte
  3. Fremmatingsblokk:
    • Første lineære lag: 2E byte
    • GELU-aktivering: 8E byte
    • Andre lineære lag: 2E byte
  4. Cross-Entropy Tap:
    • Logitter: 6BSV byte (V: vokabularstørrelse)
Det totale aktiveringsminnet kan estimeres som:
  • M_act = L * (14E + 4BSS) + 6BSV byte
Hvor L er antall transformatorlag.
Totalt maksimalt minnebruk
Høyeste minnebruk under trening kan tilnærmes ved å kombinere steady-state minne og aktiveringsminne:
  • M_peak = M_steady + M_act + 4BSV byte
Den ekstra 4BSV-terminen står for en ekstra tildeling ved starten av bakoverpasseringen.
Ved å forstå disse komponentene kan vi optimere minnebruken under trening og slutninger, og sikre effektiv ressursallokering og forbedret ytelse for store språkmodeller.
Skaleringslover og effektivitetshensyn
 Skaleringslover for LLM-er
Forskning har vist at ytelsen til LLM-er har en tendens til å følge visse skaleringslover når antallet parametere øker. Kaplan et al. (2020) observerte at modellytelsen forbedres som en kraftlov for antall parametere, beregningsbudsjett og datasettstørrelse.
Forholdet mellom modellytelse og antall parametere kan tilnærmes ved:
Ytelse ∝ N^α
Der N er antall parametere og α er en skaleringseksponent typisk rundt 0.07 for språkmodelleringsoppgaver.
Dette innebærer at for å oppnå en 10 % forbedring i ytelse, må vi øke antall parametere med en faktor på 10^(1/α) ≈ 3.7.
Effektivitetsteknikker
Etter hvert som LLM-er fortsetter å vokse, har forskere og praktikere utviklet ulike teknikker for å forbedre effektiviteten:
a) Blandet presisjonstrening: Bruk av 16-biters eller til og med 8-biters flytende kommatall for visse operasjoner for å redusere minnebruk og beregningskrav.
b) Modellparallellisme: Distribuerer modellen på tvers av flere GPUer eller TPUer for å håndtere større modeller enn det som får plass på en enkelt enhet.
c) Gradient Checkpointing: Handel med beregning for minne ved å beregne visse aktiveringer på nytt under bakoverpasseringen i stedet for å lagre dem.
d) Beskjæring og kvantisering: Fjerner mindre viktige vekter eller reduserer presisjonen etter trening for å lage mindre, mer effektive modeller.
e) destillasjon: Trening av mindre modeller for å etterligne oppførselen til større modeller, og potensielt bevare mye av ytelsen med færre parametere.
Praktisk eksempel og beregninger
GPT-3, en av de største språkmodellene, har 175 milliarder parametere. Den bruker dekoderdelen av Transformer-arkitekturen. For å forstå skalaen, la oss bryte ned parameterantallet med hypotetiske verdier:
  • d_model = 12288
  • d_ff = 4 * 12288 = 49152
  • Antall lag = 96
For ett dekoderlag:
Totale parametere = 8 * 12288^2 + 8 * 12288 * 49152 + 2 * 12288 ≈ 1.1 milliarder
Totalt for 96 lag:
1.1 milliarder * 96 = 105.6 milliarder
De resterende parameterne kommer fra innbygging og andre komponenter.
konklusjonen
Å forstå parameterne og minnekravene til store språkmodeller er avgjørende for å effektivt utforme, trene og distribuere disse kraftige verktøyene. Ved å bryte ned komponentene i Transformer-arkitektur og undersøke praktiske eksempler som GPT, får vi en dypere innsikt i kompleksiteten og skalaen til disse modellene.
For ytterligere å forstå de siste fremskrittene innen store språkmodeller og deres applikasjoner, sjekk ut disse omfattende veiledningene:
       
 Relaterte temaer:
 mm
Jeg har brukt de siste fem årene på å fordype meg i den fascinerende verdenen av maskinlæring og dyplæring. Min lidenskap og ekspertise har ført til at jeg har bidratt til over 50 ulike programvareprosjekter, med spesielt fokus på AI/ML. Min pågående nysgjerrighet har også trukket meg mot naturlig språkbehandling, et felt jeg er ivrig etter å utforske videre.