Kunstig intelligens

ForstÄelse av store sprÄkmodellers parametre og minnekrev: En dyptgÄende analyse

mm
Publisert
Oppdatert
Calculating Parameters in Transformer-based LLMs

Store språkmodeller (LLM) har sett betydelige fremgang i de siste årene. Modeller som GPT-4, Google’s Gemini og Claude 3 setter nye standarder for kapasitet og anvendelser. Disse modellene forbedrer ikke bare tekstgenerering og oversettelse, men bryter også ny grund i multimodal prosessering, kombinert tekst, bilde, lyd og videoinndata for å gi mer omfattende AI-løsninger.

For eksempel har OpenAI’s GPT-4 vist betydelige forbedringer i forståelse og generering av menneske-lignende tekst, mens Google’s Gemini-modeller excellerer i å håndtere ulike datatyper, inkludert tekst, bilder og lyd, og muliggjør mer sammenhengende og kontekstuell relevante interaksjoner. Liksom Anthropic’s Claude 3-modeller er kjent for deres flerspråklige evner og forbedret ytelse i AI-oppdrag.

Ettersom utviklingen av LLM fortsatt akselererer, blir det viktig å forstå de intrikate aspektene av disse modellene, særlig deres parametre og minnekrev. Denne guiden har som mål å avmystifisere disse aspektene og tilby en detaljert og lettforståelig forklaring.

Grunnleggende aspekter av store språkmodeller

Hva er store språkmodeller?

Store språkmodeller er neurale nettverk trent på store datamengder for å forstå og generere menneskespråk. De avhenger av arkitekturer som Transformers, som bruker mekanismer som selv-oppmerksomhet for å prosessere og produsere tekst.

Parametrenes betydning i LLM

Parametrene er de grunnleggende komponentene av disse modellene. De inkluderer vekter og forvrengninger, som modellen justerer under trening for å minimere feil i prediksjoner. Antallet parametre korrelerer ofte med modellens kapasitet og ytelse, men påvirker også dens beregnings- og minnekrev.

Forståelse av Transformer-arkitektur

Transformers-arkitektur

Transformers-arkitektur

Overblik

Transformer-arkitekturen, introdusert i “Attention Is All You Need”-paperet av Vaswani et al. (2017), har blitt grunnlaget for mange LLM. Den består av en encoder og en decoder, hver bestående av flere identiske lag.

Encoder- og decoder-komponenter

  • Encoder: Prosesserer inndata-sekvensen og skaper en kontekst-bevisst representasjon.
  • Decoder: Genererer utdata-sekvensen ved hjelp av encoderens representasjon og tidligere genererte token.

Nøkkel-byggeklosser

  1. Multi-Head Attention: Muliggjør at modellen kan fokusere på ulike deler av inndata-sekvensen samtidig.
  2. Feed-Forward Neural Networks: Legger til ikke-lineærhet og kompleksitet til modellen.
  3. Layer Normalization: Stabiliserer og akselererer trening ved å normalisere mellomliggende utdata.

Beregning av antall parametre

Transformer-trening

Forhånds-trent modell for effektiv Transformer-trening

Beregning av parametre i Transformer-baserte LLM

La oss bryte ned parameter-beregningen for hver komponent av en Transformer-basert LLM. Vi vil bruke notasjonen fra det originale papiret, der d_model representerer dimensjonen av modellens skjulte tilstander.

  1. Embedding-lag:
    • Parametre = vocab_size * d_model
  2. Multi-Head Attention:
    • For h hoder, med d_k = d_v = d_model / h:
    • Parametre = 4 * d_model^2 (for Q, K, V og utgangs-projeksjoner)
  3. Feed-Forward Network:
    • Parametre = 2 * d_model * d_ff + d_model + d_ff
    • Der d_ff vanligvis er 4 * d_model
  4. Layer Normalization:
    • Parametre = 2 * d_model (for skala og forvrengning)

Totalt antall parametre for ett Transformer-lag:

  • Parameters_layer = Parameters_attention + Parameters_ffn + 2 * Parameters_layernorm

For en modell med N lag:

  • Totalt antall parametre = N * Parameters_layer + Parameters_embedding + Parameters_output

Eksempel-beregning

La oss betrakte en modell med følgende spesifikasjoner:

  • d_model = 768
  • h (antall oppmerksomhets-hoder) = 12
  • N (antall lag) = 12
  • vocab_size = 50 000
  1. Embedding-lag:
    • 50 000 * 768 = 38 400 000
  2. Multi-Head Attention:
    • 4 * 768^2 = 2 359 296
  3. Feed-Forward Network:
    • 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4 719 616
  4. Layer Normalization:
    • 2 * 768 = 1 536

Totalt antall parametre per lag:

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

Totalt antall parametre for 12 lag:

  • 12 * 7 081 984 = 84 983 808

Totalt modell-parametre:

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

Denne modellen ville ha omtrent 123 millioner parametre.

Typer av minnekrev

Når vi arbeider med LLM, må vi betrakte to hovedtyper av minnekrev:

  1. Modell-minne: Minnet som kreves for å lagre modell-parametrene.
  2. Arbeidsminne: Minnet som trengs under inferens eller trening for å lagre mellomliggende aktiveringer, grader og optimizer-tilstander.

Beregning av modell-minne

Modell-minnet er direkte relatert til antall parametre. Hver parameter lagres vanligvis som en 32-bit flyttall, selv om noen modeller bruker blandet presisjonstrening med 16-bit flyttall.

Modell-minne (bytes) = Antall parametre * Bytes per parameter

For vår eksempel-modell med 123 millioner parametre:

  • Modell-minne (32-bit) = 123 383 808 * 4 bytes = 493 535 232 bytes ≈ 494 MB
  • Modell-minne (16-bit) = 123 383 808 * 2 bytes = 246 767 616 bytes ≈ 247 MB

Estimere arbeidsminne

Arbeidsminne-krev kan variere betydelig basert på den spesifikke oppgaven, batch-størrelse og sekvenslengde. En grov estimat for arbeidsminne under inferens er:

Arbeidsminne ≈ 2 * Modell-minne

Dette dekker lagring av både modell-parametre og mellomliggende aktiveringer. Under trening kan minnekrev være enda høyere på grunn av behovet for å lagre grader og optimizer-tilstander:

Trening-minne ≈ 4 * Modell-minne

For vår eksempel-modell:

  • Inferens-arbeidsminne ≈ 2 * 494 MB = 988 MB ≈ 1 GB
  • Trening-minne ≈ 4 * 494 MB = 1 976 MB ≈ 2 GB

Steady-state minnekrev og peak minnekrev

Når vi trener store språkmodeller basert på Transformer-arkitekturen, er det viktig å forstå minnekrev for effektiv ressurs-tilordning. La oss bryte ned minnekrev i to hovedkategorier: steady-state minnekrev og peak minnekrev.

Steady-state minnekrev

Steady-state minnekrev består av følgende komponenter:

  1. Modell-vektorer: FP32-kopier av modell-parametrene, som krever 4N bytes, der N er antall parametre.
  2. Optimizer-tilstander: For Adam-optimizer, krever dette 8N bytes (2 tilstander per parameter).
  3. Grader: FP32-kopier av grader, som krever 4N bytes.
  4. Inndata: Anta int64-inndata, dette krever 8BD bytes, der B er batch-størrelse og D er inndata-dimensjon.

Totalt steady-state minnekrev kan estimeres som:

  • M_steady = 16N + 8BD bytes

Peak minnekrev

Peak minnekrev skjer under bakover-passet når aktiveringer lagres for grad-komputasjon. Hoved-bidragene til peak minnekrev er:

  1. Layer Normalization: Krever 4E bytes per lag-normalisering, der E = BSH (B: batch-størrelse, S: sekvenslengde, H: skjult størrelse).
  2. Attention-blokk:
    • QKV-komputasjon: 2E bytes
    • Attention-matrise: 4BSS bytes (S: sekvenslengde)
    • Attention-utgang: 2E bytes
  3. Feed-Forward-blokk:
    • Første lineær lag: 2E bytes
    • GELU-aktivering: 8E bytes
    • Andre lineær lag: 2E bytes
  4. Cross-Entropy-tap:
    • Logitt: 6BSV bytes (V: vokabular-størrelse)

Totalt aktiveringsminne kan estimeres som:

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

Der L er antall Transformer-lag.

Totalt peak minnekrev

Peak minnekrev under trening kan estimeres som:

  • M_peak = M_steady + M_act + 4BSV bytes

Den ekstra 4BSV-termen dekker en ekstra allokasjon i begynnelsen av bakover-passet.

Ved å forstå disse komponentene, kan vi optimere minnekrev under trening og inferens, og sikre effektiv ressurs-tilordning og forbedret ytelse av store språkmodeller.

Skalering og effisiens-overveielser

Skalering for LLM

Forskning har vist at ytelsen av LLM følger bestemte skalering-lover når antall parametre øker. Kaplan et al. (2020) observerte at modell-ytelse forbedres som en potens-lov av antall parametre, beregnings-budsjett og datamengde-størrelse.

Forholdet mellom modell-ytelse og antall parametre kan estimeres som:

Ytelse ∝ N^α

Der N er antall parametre og α er en skalering-eksponent vanligvis rundt 0,07 for språk-modellering-oppgaver.

Dette impliserer at for å oppnå en 10% forbedring av ytelse, må vi øke antall parametre med en faktor av 10^(1/α) ≈ 3,7.

Effisiens-teknikker

Ettersom LLM fortsatt vokser, har forskere og praktikere utviklet ulike tekniker for å forbedre effisiensen:

a) Blandet presisjonstrening: Bruker 16-bit eller selv 8-bit flyttall for visse operasjoner for å redusere minnekrev og beregnings-krav.

b) Modell-parallellisering: Fordeler modellen over flere GPU-er eller TPUs for å håndtere større modeller enn hva som kan passe på en enkelt enhet.

c) Gradient-sjekkpunkt: Bytter beregning mot minne ved å regenerere visse aktiveringer under bakover-passet i stedet for å lagre dem.

d) Pruning og kvantisering: Fjerner mindre viktige vekter eller reduserer deres presisjon etter trening for å skape mindre og mer effektive modeller.

e) Destillasjon: Trener mindre modeller for å etterligne atferden til større modeller, potensielt bevare mye av ytelsen med færre parametre.

Praktisk eksempel og beregninger

GPT-3, en av de største språkmodellene, har 175 milliarder parametre. Den bruker decoder-delen av Transformer-arkitekturen. For å forstå dens skala, la oss bryte ned parameter-tellingen med hypotetiske verdier:

  • d_model = 12288
  • d_ff = 4 * 12288 = 49152
  • Antall lag = 96

For ett decoder-lag:

Totalt antall parametre = 8 * 12288^2 + 8 * 12288 * 49152 + 2 * 12288 ≈ 1,1 milliard

Totalt for 96 lag:
1,1 milliard * 96 = 105,6 milliarder

De resterende parameterne kommer fra innlegg og andre komponenter.

Konklusjon

For å forstå parameterne og minnekrev til store språkmodeller er avgjørende for å designe, trene og distribuere disse kraftfulle verktøyene effektivt. Ved å bryte ned komponentene av Transformer-arkitekturen og undersøke praktiske eksempler som GPT, får vi en dypere innsikt i kompleksiteten og skalaen av disse modellene.

For å få en dypere forståelse av de nyeste fremgangene i store språkmodeller og deres anvendelser, se disse omfattende guidene:

mm

Jeg har brukt de siste fem Ärene pÄ Ä dykke ned i den fasiniserende verden av MaskinlÊring og Dypt LÊring. Min lidenskap og ekspertise har ledet meg til Ä bidra til over 50 ulike programvareprosjekter, med sÊrlig fokus pÄ AI/ML. Min pÄgÄende nysgjÞrhet har ogsÄ trukket meg mot Naturlig SprÄkbehandling, et felt jeg er ivrig etter Ä utforske videre.