Kapcsolatba velünk
   Mesterséges Intelligencia  
A nagy nyelvű modellek paramétereinek és memóriakövetelményeinek megértése: mély merülés
 mm
Közzététel:
 6 napja
 on
   
 Paraméterek kiszámítása Transformer-alapú LLM-ekben
Nagy nyelvi modellek (LLMs) figyelemre méltó fejlődésen ment keresztül az elmúlt években. Az olyan modellek, mint a GPT-4, a Google Gemini és a Claude 3 új mércét állítanak fel a képességek és alkalmazások terén. Ezek a modellek nemcsak a szöveggenerálást és -fordítást javítják, hanem a multimodális feldolgozásban is új utat törnek, a szöveg-, kép-, hang- és videobemenetek kombinálásával átfogóbb mesterségesintelligencia-megoldásokat kínálnak.
Az OpenAI GPT-4 például jelentős javulást mutatott az emberszerű szöveg megértésében és létrehozásában, míg a Google Gemini modelljei kiválóan kezelik a különféle adattípusokat, beleértve a szöveget, képeket és hangot, lehetővé téve a zökkenőmentes és kontextus szempontjából releváns interakciókat. Hasonlóképpen, az Anthropic Claude 3 modelljei többnyelvűségükről és az AI-feladatokban nyújtott fokozott teljesítményükről ismertek.
Ahogy az LLM-ek fejlesztése folyamatosan felgyorsul, döntő fontosságúvá válik e modellek bonyolultságának megértése, különösen paramétereik és memóriaigényeik. Ez az útmutató ezeket a szempontokat kívánja tisztázni, részletes és könnyen érthető magyarázatot kínálva.
A nagynyelvi modellek alapjai
Mik azok a nagy nyelvi modellek?
A nagy nyelvi modellek olyan neurális hálózatok, amelyek hatalmas adathalmazokra vannak kiképezve, hogy megértsék és generálják az emberi nyelvet. Olyan architektúrákra támaszkodnak, mint a Transformers, amelyek olyan mechanizmusokat használnak, mint például az önfigyelem a szöveg feldolgozásához és előállításához.
A paraméterek jelentősége az LLM-ekben
Ezeknek a modelleknek a fő összetevői a paraméterek. Tartalmazzák a súlyokat és a torzításokat, amelyeket a modell az edzés során módosít az előrejelzések hibáinak minimalizálása érdekében. A paraméterek száma gyakran korrelál a modell kapacitásával és teljesítményével, de hatással van a számítási és memóriaigényére is.
A Transformer architektúra megértése
Transformers-architektúra
Transformers építészet
Áttekintés
A Transformer architektúra, amelyet Vaswani és társai „Attention Is All You Need” című tanulmányában mutattak be. (2017) sok LLM alapjává vált. Ez egy kódolóból és egy dekódolóból áll, amelyek mindegyike több azonos rétegből áll.
Kódoló és dekódoló alkatrészek
  • Encoder: Feldolgozza a bemeneti szekvenciát, és környezettudatos reprezentációt hoz létre.
  • Decoder: A kódoló reprezentációja és a korábban generált tokenek felhasználásával állítja elő a kimeneti sorozatot.
Kulcs építőelemek
  1. Többfejű figyelem: Lehetővé teszi, hogy a modell egyidejűleg a beviteli sorozat különböző részeire fókuszáljon.
  2. Feed-Forward neurális hálózatok: Nemlinearitást és összetettséget ad a modellnek.
  3. Réteg normalizálása: Stabilizálja és felgyorsítja az edzést a köztes kimenetek normalizálásával.
A paraméterek számának kiszámítása
Transformer képzés
Előre betanított modellek a hatékony transzformátoroktatáshoz
Paraméterek kiszámítása Transformer-alapú LLM-ekben
Bontsuk le a paraméterszámítást a Transformer-alapú LLM egyes összetevőire. Használjuk az eredeti papír jelölését, ahol d_model a modell rejtett állapotainak dimenzióját jelenti.
  1. Réteg beágyazása:
    • Paraméterek = vocab_size * d_model
  2. Többfejű figyelem:
    • A h fejekkel, azzal d_k = d_v = d_model / h:
    • Paraméterek = 4 * d_model^2 (Q, K, V és kimeneti vetületekhez)
  3. Feed-Forward hálózat:
    • Paraméterek = 2 * d_model * d_ff + d_model + d_ff
    • Hol d_ff általában 4* d_model
  4. Réteg normalizálása:
    • Paraméterek = 2 * d_model (léptékhez és torzításhoz)
Összes paraméter egy transzformátor réteghez:
  • Parameters_layer = Parameters_attention + Parameters_ffn + 2* Parameters_layernorm
Egy modellhez N rétegek:
  • Összes paraméter = N * Parameters_layer + Parameters_embedding + Parameters_output
Példa számítás
Vegyünk egy modellt a következő specifikációkkal:
  • d_model = 768
  • h (figyelemfejek száma) = 12
  • N (rétegek száma) = 12
  • vocab_size = 50,000
  1. Réteg beágyazása:
    • 50,000 * 768 = 38,400,000
  2. Többfejű figyelem:
    • 4 * 768^ 2 = 2,359,296
  3. Feed-Forward hálózat:
    • 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4,719,616 XNUMX XNUMX
  4. Réteg normalizálása:
    • 2 * 768 = 1,536
Összes paraméter rétegenként:
  • 2,359,296 4,719,616 2 + 1,536 7,081,984 XNUMX + (XNUMX * XNUMX XNUMX) = XNUMX XNUMX XNUMX
Összes paraméter 12 réteghez:
  • 12 * 7,081,984 = 84,983,808
A modell összes paramétere:
  • 84,983,808 + 38,400,000 = 123,383,808
Ennek a modellnek körülbelül 123 millió paramétere lenne.
A memóriahasználat típusai
Amikor LLM-ekkel dolgozunk, a memóriahasználat két fő típusát kell figyelembe vennünk:
  1. Memória modell: A modellparaméterek tárolásához szükséges memória.
  2. Munka memória: A következtetés vagy a betanítás során szükséges memória a közbenső aktiválások, gradiensek és optimalizáló állapotok tárolására.
Modellmemória számítása
A modell memóriája közvetlenül kapcsolódik a paraméterek számához. Az egyes paraméterek általában 32 bites lebegőpontos számként vannak tárolva, bár egyes modellek vegyes precíziós képzést alkalmaznak 16 bites lebegésekkel.
Modellmemória (byte) = Paraméterek száma * Bájt paraméterenként
Példamodellünkhöz 123 millió paraméterrel:
  • Modellmemória (32 bites) = 123,383,808 4 493,535,232 * 494 bájt = XNUMX XNUMX XNUMX bájt ≈ XNUMX MB
  • Modellmemória (16 bites) = 123,383,808 2 246,767,616 * 247 bájt = XNUMX XNUMX XNUMX bájt ≈ XNUMX MB
A munkamemória becslése
A munkamemória követelményei jelentősen eltérhetnek az adott feladattól, a köteg méretétől és a sorozat hosszától függően. A munkamemória durva becslése a következtetés során:
Munkamemória ≈ 2 * Modell memória
Ez figyelembe veszi a modellparaméterek és a közbenső aktiválások tárolását. Az edzés során a memóriaigény még magasabb lehet a színátmenetek és az optimalizáló állapotok tárolásának szükségessége miatt:
Edzésmemória ≈ 4 * Modell memória
Példamodellünkhöz:
  • Következtetés munkamemória ≈ 2 * 494 MB = 988 MB ≈ 1 GB
  • Edzési memória ≈ 4 * 494 MB = 1,976 2 MB ≈ XNUMX GB
Steady-state memóriahasználat és csúcsmemóriahasználat
A Transformer architektúrán alapuló nagy nyelvi modellek betanításakor a memóriahasználat megértése kulcsfontosságú a hatékony erőforrás-elosztáshoz. Bontsuk fel a memóriakövetelményeket két fő kategóriába: az állandósult memóriahasználatra és a csúcs memóriahasználatra.
Állandó állapotú memóriahasználat
Az állandó állapotú memóriahasználat a következő összetevőket tartalmazza:
  1. Modell súlyok: A modell paramétereinek FP32 másolatai, 4N bájtot igényelnek, ahol N a paraméterek száma.
  2. Optimalizáló állapotok: Az Adam optimalizálóhoz ehhez 8N bájt szükséges (paraméterenként 2 állapot).
  3. színátmenetek: A színátmenetek FP32 másolatai, 4N bájtot igényelnek.
  4. Beviteli adat: Int64 bemeneteket feltételezve ehhez 8 BD bájt szükséges, ahol B a köteg mérete és D a bemeneti méret.
A teljes steady-state memóriahasználat a következőképpen közelíthető meg:
  • M_steady = 16N + 8BD bájt
Csúcs memóriahasználat
A memóriahasználat csúcsértéke a visszafelé haladás során következik be, amikor az aktiválásokat a rendszer a gradiens számításhoz tárolja. A csúcsmemória főbb tényezői a következők:
  1. Réteg normalizálása: 4E bájt szükséges rétegnormánként, ahol E = BSH (B: kötegméret, S: sorozathossz, H: rejtett méret).
  2. Figyelemblokk:
    • QKV számítás: 2E bájt
    • Figyelem mátrix: 4BSS bájt (S: sorozat hossza)
    • Figyelemkimenet: 2E bájt
  3. Feed-Forward blokk:
    • Első lineáris réteg: 2E bájt
    • GELU aktiválás: 8E bájt
    • Második lineáris réteg: 2E bájt
  4. Keresztentrópia elvesztése:
    • Logitok: 6BSV bájt (V: szókincs mérete)
A teljes aktiválási memória a következőképpen becsülhető meg:
  • M_act = L * (14E + 4BSS) + 6BSV bájt
Ahol L a transzformátorrétegek száma.
Teljes csúcs memóriahasználat
Az edzés közbeni memóriahasználat csúcsértéke az állandósult állapotú memória és az aktiválási memória kombinálásával közelíthető meg:
  • M_peak = M_steady + M_act + 4BSV bájt
A további 4BSV kifejezés extra kiosztást jelent a visszafelé haladás kezdetén.
Ezen összetevők megértésével optimalizálhatjuk a memóriahasználatot a betanítás és a következtetés során, biztosítva a hatékony erőforrás-allokációt és a nagy nyelvi modellek jobb teljesítményét.
Méretezési törvények és hatékonysági szempontok
 Méretezési törvények LLM-ek számára
A kutatások kimutatták, hogy az LLM-ek teljesítménye hajlamos követni bizonyos skálázási törvényeket a paraméterek számának növekedésével. Kaplan et al. (2020) megfigyelte, hogy a modell teljesítménye a paraméterek számának, a számítási költségvetésnek és az adatkészlet méretének hatványtörvényeként javul.
A modell teljesítménye és a paraméterek száma közötti kapcsolat a következőképpen közelíthető meg:
Teljesítmény ∝ N^α
Ahol N a paraméterek száma, α pedig egy skálázási kitevő, amely jellemzően 0.07 körül van a nyelvi modellezési feladatoknál.
Ez azt jelenti, hogy a teljesítmény 10%-os javulásához a paraméterek számát 10^(1/α) ≈ 3.7-szeresére kell növelnünk.
Hatékonysági technikák
Ahogy az LLM-ek folyamatosan növekszenek, a kutatók és a gyakorlati szakemberek különféle technikákat fejlesztettek ki a hatékonyság javítására:
a) Vegyes precíziós képzés: 16 bites vagy akár 8 bites lebegőpontos számok használata bizonyos műveletekhez a memóriahasználat és a számítási követelmények csökkentése érdekében.
b) Modellpárhuzam: A modell elosztása több GPU-n vagy TPU-n keresztül nagyobb modellek kezelésére, mint amennyi egyetlen eszközre elfér.
c) Gradiens ellenőrzőpont: Memória számításának cseréje bizonyos aktiválások újraszámításával a visszafelé lépés során a tárolás helyett.
d) Metszés és kvantálás: Kevésbé fontos súlyok eltávolítása vagy edzés utáni pontosságuk csökkentése kisebb, hatékonyabb modellek létrehozása érdekében.
e) Lepárlás: Kisebb modellek betanítása a nagyobb modellek viselkedésének utánzására, potenciálisan a teljesítmény nagy részének megőrzése kevesebb paraméterrel.
Gyakorlati példa és számítások
A GPT-3, az egyik legnagyobb nyelvi modell, 175 milliárd paraméterrel rendelkezik. A Transformer architektúra dekódoló részét használja. A léptékének megértéséhez bontsuk fel a paraméterek számát hipotetikus értékekkel:
  • d_model = 12288
  • d_ff = 4 * 12288 = 49152
  • Rétegek száma = 96
Egy dekódoló réteghez:
Összes paraméter = 8 * 12288^2 + 8 * 12288 * 49152 + 2 * 12288 ≈ 1.1 milliárd
Összesen 96 rétegre:
1.1 milliárd * 96 = 105.6 milliárd
A többi paraméter a beágyazásból és egyéb összetevőkből származik.
Következtetés
A nagy nyelvi modellek paramétereinek és memóriaigényeinek megértése döntő fontosságú ezen hatékony eszközök hatékony tervezéséhez, betanításához és telepítéséhez. A Transformer architektúra összetevőinek lebontásával és a gyakorlati példák, például a GPT vizsgálatával mélyebb betekintést nyerünk e modellek összetettségébe és léptékébe.
A nagy nyelvi modellek és alkalmazásaik legújabb fejlesztéseinek további megértéséhez tekintse meg ezeket az átfogó útmutatókat:
       
 Kapcsolódó témák:
 mm
Az elmúlt öt évet azzal töltöttem, hogy elmerüljek a gépi tanulás és a mélytanulás lenyűgöző világában. Szenvedélyem és szakértelmem késztetett arra, hogy több mint 50 különféle szoftverfejlesztési projektben működjek közre, különös tekintettel az AI/ML-re. Folyamatos kíváncsiságom a természetes nyelvi feldolgozás felé is vonzott, amely terület, amelyet szívesen fedezek fel.