AI-modeller og platforme

Forståelse af store sprogmodellers parametre og hukommelseskrav: En dybdegående gennemgang

mm
Udgivet den
Opdateret den
Føj Unite.AI til dine foretrukne kilder på Google

Store sprogmodeller (LLM’er) har oplevet bemærkelsesværdige fremskridt i de seneste år. Modeller som GPT-4, Google’s Gemini og Claude 3 sætter nye standarder for kapaciteter og anvendelser. Disse modeller forbedrer ikke kun tekstgenerering og oversættelse, men bryder også ny grund i multimodal procesering, kombinerer tekst, billeder, lyd og videoindgang for at give mere omfattende AI-løsninger.

For eksempel har OpenAI’s GPT-4 vist betydelige forbedringer i forståelse og generering af menneske-lignende tekst, mens Google’s Gemini-modeller excellerer i håndtering af diverse data typer, herunder tekst, billeder og lyd, hvilket muliggør mere sammenhængende og kontekstuel relevant interaktion. Lignende har Anthropic’s Claude 3-modeller vist multilingval kapacitet og forbedret ydelse i AI-opgaver.

Da udviklingen af LLM’er fortsætter med at accelerere, bliver det vigtigt at forstå de indre mekanismer i disse modeller, især deres parametre og hukommelseskrav. Denne vejledning har til formål at afmystificere disse aspekter og tilbyde en detaljeret og letforståelig forklaring.

Grundlæggende om store sprogmodeller

Hvad er store sprogmodeller?

Store sprogmodeller er neurale netværk, der er trænet på massive datasæt for at forstå og generere menneskesprog. De afhænger af arkitekturer som Transformers, der bruger mekanismer som selv-opmærksomhed til at behandle og producere tekst.

Parametrenes betydning i LLM’er

Parametrene er de centrale komponenter i disse modeller. De omfatter vægte og bias, som modellen justerer under træning for at minimere fejl i forudsigelser. Antallet af parametre korrelerer ofte med modellens kapacitet og ydelse, men påvirker også dens beregnings- og hukommelseskrav.

Forståelse af Transformer-arkitektur

Transformers-arkitektur

Transformers-arkitektur

Overblik

Transformer-arkitekturen, der blev introduceret i “Attention Is All You Need”-artiklen af Vaswani et al. (2017), er blevet grundlaget for mange LLM’er. Den består af en encoder og en decoder, hver bestående af flere identiske lag.

Encoder- og decoder-komponenter

  • Encoder: Behandler input-sekvensen og opretter en kontekst-bevidst repræsentation.
  • Decoder: Genererer output-sekvensen ved hjælp af encoderens repræsentation og de tidligere genererede token.

Nøgle-byggesten

  1. Multi-Head Attention: Muliggør, at modellen kan fokusere på forskellige dele af input-sekvensen samtidigt.
  2. Feed-Forward Neural Networks: Tilføjer ikke-linearity og kompleksitet til modellen.
  3. Layer Normalization: Stabiliserer og accelererer træning ved at normalisere intermediate outputs.

Beregning af antallet af parametre

Transformer-træning

Forudtrænede modeller til effektiv Transformer-træning

Beregning af parametre i Transformer-baserede LLM’er

Lad os bryde ned parameter-beregningen for hver komponent af en Transformer-baseret LLM. Vi vil bruge notationen fra den originale artikel, hvor d_model repræsenterer dimensionen af modellens skjulte tilstande.

  1. Indlejringsskikt:
    • Parametre = vocab_size * d_model
  2. Multi-Head Attention:
    • For h hoveder, med d_k = d_v = d_model / h:
    • Parametre = 4 * d_model^2 (for Q, K, V og output-projekter)
  3. Feed-Forward Network:
    • Parametre = 2 * d_model * d_ff + d_model + d_ff
    • Where d_ff er typisk 4 * d_model
  4. Layer Normalization:
    • Parametre = 2 * d_model (for skala og bias)

Total parametre for ét Transformer-lag:

  • Parameters_layer = Parameters_attention + Parameters_ffn + 2 * Parameters_layernorm

For en model med N lag:

  • Total Parametre = N * Parameters_layer + Parameters_embedding + Parameters_output

Eksempel-beregning

Lad os overveje en model med følgende specifikationer:

  • d_model = 768
  • h (antallet af attention-hoveder) = 12
  • N (antallet af lag) = 12
  • vocab_size = 50.000
  1. Indlejringsskikt:
    • 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

Total parametre pr. lag:

  • 2.359.296 + 4.719.616 + (2 * 1.536) = 7.081.984

Total parametre for 12 lag:

  • 12 * 7.081.984 = 84.983.808

Total model-parametre:

  • 84.983.808 + 38.400.000 = 123.383.808

Denne model ville have ca. 123 millioner parametre.

Typer af hukommelsesbrug

Når vi arbejder med LLM’er, skal vi overveje to hovedtyper af hukommelsesbrug:

  1. Model-hukommelse: Hukommelsen, der kræves for at gemme model-parametrene.
  2. Arbejdshukommelse: Hukommelsen, der kræves under inferens eller træning for at gemme intermediate aktiveringer, gradienter og optimizer-tilstande.

Beregning af model-hukommelse

Model-hukommelsen er direkte relateret til antallet af parametre. Hver parameter er typisk gemt som en 32-bit flydende punkt-nummer, selvom nogle modeller bruger mixed-precision-træning med 16-bit flydende punkt-numre.

Model-hukommelse (bytes) = Antallet af parametre * Bytes pr. parameter

For vores eksempel-model med 123 millioner parametre:

  • Model-hukommelse (32-bit) = 123.383.808 * 4 bytes = 493.535.232 bytes ≈ 494 MB
  • Model-hukommelse (16-bit) = 123.383.808 * 2 bytes = 246.767.616 bytes ≈ 247 MB

Estimering af arbejdshukommelse

Arbejdshukommelseskrav kan variere betydeligt afhængigt af den specifikke opgave, batch-størrelse og sekvenslængde. En omtrentlig estimering for arbejdshukommelse under inferens er:

Arbejdshukommelse ≈ 2 * Model-hukommelse

Dette tager hensyn til både model-parametre og intermediate aktiveringer. Under træning kan hukommelseskravene være endnu højere på grund af behovet for at gemme gradienter og optimizer-tilstande:

Trænings-hukommelse ≈ 4 * Model-hukommelse

For vores eksempel-model:

  • Inferens-arbejdshukommelse ≈ 2 * 494 MB = 988 MB ≈ 1 GB
  • Trænings-hukommelse ≈ 4 * 494 MB = 1.976 MB ≈ 2 GB

Steady-state hukommelsesbrug og peak hukommelsesbrug

Når vi træner store sprogmodeller baseret på Transformer-arkitekturen, er det vigtigt at forstå hukommelsesbrug for at kunne allokerer ressourcer effektivt. Lad os bryde ned hukommelseskravene i to hovedkategorier: steady-state hukommelsesbrug og peak hukommelsesbrug.

Steady-state hukommelsesbrug

Steady-state hukommelsesbrug består af følgende komponenter:

  1. Model-vægte: FP32-kopier af model-parametrene, der kræver 4N bytes, hvor N er antallet af parametre.
  2. Optimizer-tilstande: For Adam-optimizeren kræver dette 8N bytes (2 tilstande pr. parameter).
  3. Gradienter: FP32-kopier af gradienterne, der kræver 4N bytes.
  4. Input-data: Antag int64-input, dette kræver 8BD bytes, hvor B er batch-størrelsen og D er input-dimensionen.

Den totale steady-state hukommelsesbrug kan estimeres som:

  • M_steady = 16N + 8BD bytes

Peak hukommelsesbrug

Peak hukommelsesbrug opstår under backward-passet, når aktiveringer gemmes for gradient-beregning. De vigtigste bidragende til peak hukommelsesbrug er:

  1. Layer Normalization: Kræver 4E bytes pr. lag-normalisering, hvor E = BSH (B: batch-størrelse, S: sekvenslængde, H: skjult størrelse).
  2. Attention-block:
    • QKV-beregning: 2E bytes
    • Attention-matrix: 4BSS bytes (S: sekvenslængde)
    • Attention-output: 2E bytes
  3. Feed-Forward-block:
    • Første lineær lag: 2E bytes
    • GELU-aktivering: 8E bytes
    • Andet lineær lag: 2E bytes
  4. Cross-Entropy-tab:
    • Logits: 6BSV bytes (V: ord-antallet)

Den totale aktiverings-hukommelse kan estimeres som:

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

Hvor L er antallet af Transformer-lag.

Total peak hukommelsesbrug

Peak hukommelsesbrug under træning kan estimeres ved at kombinere steady-state hukommelsesbrug og aktiverings-hukommelse:

  • M_peak = M_steady + M_act + 4BSV bytes

Den ekstra 4BSV-term tager hensyn til en ekstra allokerings-omkostning i starten af backward-passet.

Ved at forstå disse komponenter kan vi optimere hukommelsesbrug under træning og inferens, hvilket sikrer effektiv ressource-allokering og forbedrer ydelse af store sprogmodeller.

Skalering og effektivitet

Skalering for LLM’er

Forskning har vist, at ydelsen af LLM’er tenderer til at følge visse skalering-love, når antallet af parametre øges. Kaplan et al. (2020) observerede, at model-ydelse forbedres som en potens-lov af antallet af parametre, beregnings-budget og datasæt-størrelse.

Forholdet mellem model-ydelse og antallet af parametre kan estimeres som:

Ydelse ∝ N^α

Hvor N er antallet af parametre og α er en skalering-eksponent, der typisk er omkring 0,07 for sprog-model-opgaver.

Dette indebærer, at for at opnå en 10% forbedring af ydelse, skal vi øge antallet af parametre med en faktor på 10^(1/α) ≈ 3,7.

Effektivitetsteknikker

Da 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 punkt-numre for visse operationer for at reducere hukommelsesbrug og beregningskrav.

b) Model-parallellisering: Fordeling af modellen over flere GPU’er eller TPU’er for at håndtere større modeller end hvad der kan gemmes på en enkelt enhed.

c) Gradient-checkpointing: Handel med beregning for hukommelse ved at genberegne visse aktiveringer under backward-passet i stedet for at gemme dem.

d) Pruning og kvantificering: Fjernelse af mindre vigtige vægte eller reduktion af deres præcision efter træning for at skabe mindre og mere effektive modeller.

e) Destillation: Træning af mindre modeller til at efterligne adfærd af større modeller, muligvis med bevarelse af en stor del af ydelsen med færre parametre.

Praktisk eksempel og beregninger

GPT-3, en af de største sprogmodeller, har 175 milliarder parametre. Den bruger decoder-delen af Transformer-arkitekturen. For at forstå dens skala, lad os bryde ned parameter-antallet med hypotetiske værdier:

  • d_model = 12288
  • d_ff = 4 * 12288 = 49152
  • Antallet af lag = 96

For ét decoder-lag:

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

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

De resterende parametre kommer fra indlejring og andre komponenter.

Konklusion

Forståelse af parametre og hukommelseskrav for store sprogmodeller er afgørende for effektiv design, træning og implementering af disse kraftfulde værktøjer. Ved at bryde ned komponenterne i Transformer-arkitekturen og undersøge praktiske eksempler som GPT, får vi en dybere indsigt i kompleksiteten og skalaen af disse modeller.

For at yderligere forstå de seneste fremskridt i store sprogmodeller og deres anvendelser, se disse omfattende vejledninger:

mm

Jeg har brugt de sidste fem år på at dykke ned 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-ingeniørprojekter, med en særlig fokus på AI/ML. Min fortsatte nysgerrighed har også ført mig mod Natural Language Processing, et felt jeg er ivrig efter at udforske yderligere.