Tecken, Exponent, Mantissa
IEEE 754 Floating-Point Format
Varje flyttal lagrar tre fält:
- Teckenbit (1 bit): positiv eller negativ
- Exponent (E bit): magnitudskalan, en heltalspotens av 2
- Mantissa (M bit): den fraktionella precisionen, ett tal mellan 1.0 och ~2.0
Totala bit = 1 + E + M. Värdet är ungefär (-1)^sign (1 + mantissa) 2^(exponent - bias).
Två egenskaper är viktiga för träning:
Dynamiskt intervall = 2^(2^E) (ungefär). Fler exponentbitar betyder att man kan representera mindre & större tal utan överflöde.
Precision = 2^M distinkta värden per potens av 2. Fler mantissa-bitars betyder finare representation mellan konsekutiva potenser av 2.
De tre formaten
| Format | Totala bitar | Tecken | Exp | Mant | Dynamiskt intervall | Precision |
|---|---|---|---|---|---|---|
| FP32 | 32 | 1 | 8 | 23 | ~10^-38 till ~10^38 | ~7 siffror |
| FP16 | 16 | 1 | 5 | 10 | ~10^-5 to ~10^5 | ~3 siffror |
| FP8 E4M3 | 8 | 1 | 4 | 3 | ~2^-9 to ~448 | ~2 siffror |
FP8 E4M3 läses "4 exponentbitar, 3 mantissabitar". Ett alternativ FP8 E5M2 byter precision mot intervall; ANDREA-experimenten använder E4M3 eftersom transformeraktiveringar håller sig i smala magnitudband där extra precision vinner över extra intervall.
Byte Per Parameter
Varför lägre precision kör snabbare
Minnesbandbredd dominerar träningens hastighet
Moderna GPU:er spenderar mer tid på att vänta på minne än på att beräkna. RTX 4090 har 1008 GB/s minnesbandbredd & 165 TFLOPS FP16-beräkning. Ett typiskt lager läser vikter från VRAM, multiplicerar aktiveringar, skriver tillbaka resultat. Bandbredd, inte beräkning, avgör genomströmning.
Att halvera precisionen halverar bytes per parameter, så att läsa samma vikter använder hälften så mycket minnesbandbredd. Genomströmningen fördubblas ungefär.
Tensor Cores: Maskinvaruaccelererad MatrisMultiplikation
RTX 4090 levereras med dedikerade tensor core-enheter som beräknar matris-multiplikationer vid FP16 eller FP8 direkt. En enda tensor core-operation multiplicerar en liten block (t.ex. 16x16) på en cykel, dramatiskt snabbare än skalära FP32-multiplikationer.
Empiriska siffror från ANDREA-120M:
| Precision | Steg/min | Noteringar |
|---|---|---|
| FP32 | ~3 | baslinje; ingen tensor core-acceleration |
| FP16 | ~6 | cuBLAS tensor cores; 2x speedup |
| FP8 E4M3 | ~6 | tensor cores; jämförbar med FP16 |
FP8 slog inte FP16 i genomströmning i denna arbetsbelastning eftersom beräkningsgenomströmningen slutade vara flaskhalsen; minnesbandbredd & startöverkast blev bindande. ANDREA-120M v3 levereras med FP16 cuBLAS vid 6 steg/min för en bekväm säkerhetsmarginal utan att förlora genomströmning.
NaN-risk vid FP8
FP8 E4M3 representerar tal från ~2^-9 till ~448. Aktiveringar eller gradienter utanför det intervallet överflödar till NaN (not a number) eller underflödar till noll. En enda NaN förgiftar varje efterföljande beräkning: matris-multiplikationer med en NaN returnerar all-NaN; all-NaN-gradienter korrumperar AdamW-tillstånd; AdamW med NaN m & v ger NaN-uppdateringar; vikterna blir NaN; hela träningskörningen dör.
ANDREA:s FP8-experiment producerade tillfälliga NaN-klipp som krävde loss scaling, schemalagd precisionväxling eller fallback-vägar. FP16 dynamiska intervall (~10^-5 till ~10^5) är tillräckligt brett för att NaN-händelser ska förbli sällsynta utan invecklade skalningstrick.
Välja Precision för en Ny Körning
Att få plats med 120M på en enda 4090
Multiplikatorn 6-8x från Introlektionen
Kom ihåg från grow_a_language_model_intro att träningsminnet är ungefär 6-8x rå viktantalet, vilket inkluderar:
- Vikt (1x)
- Adam första moment m (1x)
- Adam andra moment v (1x)
- Gradientbuffer (1x)
- Aktiveringar & temporärer (~2-4x, beror på batch & kontext)
ANDREA-120M vid FP16 med batch_size=8, context=1024:
| Komponent | FP16-storlek |
|---|---|
| Viktningar | 240 MB |
| m (första momentet) | 240 MB |
| v (andra momentet) | 240 MB |
| Gradienter | 240 MB |
| Aktiveringar | ~2-4 GB (batch, ctx) |
| Totalt | ~3.5 GB |
RTX 4090 har 24 GB VRAM. ANDREA-120M använder ~14% vid FP16. Massor av utrymme för större batch-storlekar eller längre kontextfönster. ANDREA-12M använde endast 1.4 GB totalt.
Var blandad precision används
ANDREA håller INTE allt på en enda precision. Blandad-precisionsträning lagrar:
- Mastervikter: FP32 (bevarar träningsstabilitet)
- Framåt- & bakåtberäkning: FP16 (använder tensor cores)
- AdamW-optimerartillstånd: FP32 (m & v behöver precision för långsvansuppdateringar)
- Gradientbuffert: FP16 (beräkningssida)
Slutlig minnesbudget blandar båda. ANDREA:s faktiska fotavtryck ligger mellan ren FP16 (720 MB optimizer state) & ren FP32 (1.44 GB optimizer state), närmare FP32 eftersom m & v stannar i FP32.
Att dimensionera en budget för ANDREA-480M
Precision i praktiken
Relaterade aktiviteter
Tre syskonaktiviteter länkar till precision:
- Aktivitet 1: Intro / VRAM-budget. Precision multiplicerar varje term i minnesbudget-aritmetiken. Tumregeln om 6-8x-multiplikator är dimensionslös; bytes-per-param ger den enheter.
- Aktivitet 10: AdamW. Optimiserarens tillstånd (m & v) förblir vanligtvis i FP32 även när framåt/bakåtberäkning körs i FP16. Anledning: precisionen i långsvansackumulatorn är viktigare än körtidshastighet för optimiseringen.
- Aktivitet 12: Gradientklippning. Klippning begränsar gradienternas magnituder innan optimiserarens tillstånd uppdateras. Med FP16 framåt/bakåt & FP32-optimiserare sker klippningen vid gränsen där precisionen ändras & där risken för överflöde koncentreras.
Precision är en gratis ratt: ändra den, modellen tränas snabbare & använder mindre minne. Kostnaden är numerisk omsorg: NaN-hantering, förlustskalning, disciplin i blandad precision. ANDREA-120M v3 demonstrerar utdelningen: 120M parametrar tränade på konsumenthårdvara på 23 dagar eftersom FP16 halverade allt.