AI & GPU
Hogyan finomítsunk LLaMA2-t gyorsan és könnyedén

Hogyan finomítsunk LLaMA2-t gyorsan és könnyedén

I. Bevezetés az LLaMA-2 finomításába

A. Áttekintés az LLaMA-2-ről és képességeiről

Az LLaMA-2 a nagy méretű nyelvi AI modellek második generációja (LLaMA), amelyet az Anthropic fejlesztett ki. Ez egy erőteljes és sokoldalú nyelvi modell, amelyet számos természetes nyelvfeldolgozási feladatra lehet használni, például szöveggenerálásra, kérdés-válaszadásra és nyelvfordításra.

Az LLaMA-2 az eredeti LLaMA modellre épül, amelyet 2023 elején adtak ki, és gyorsan felhívta magára a figyelmet lenyűgöző teljesítményével számos mérőszámot tekintve. Az LLaMA-2 modell számos fejlesztést tartalmaz, ideértve az eddigiekhez képest továbbfejlesztett tanító adatokat, modellezést és optimalizációs technikákat, ami még fejlettebb nyelvi megértés és generálás képességeit eredményezi.

Az LLaMA-2 egyik fő jellemzője, hogy finomítható domain-specifikus adatkészleteken. Ez lehetővé teszi a modellnek, hogy alkalmazkodjon a specializált feladatokhoz és forgatókönyvekhez. Ezt a finomítási folyamatot tekintjük ennek a bemutatónak a központi témájának, mivel lehetőséget nyújt a felhasználóknak arra, hogy kiaknázzák a meglévő LLaMA-2 modell előnyeit, és testre szabják az igényeiknek megfelelően.

B. A finomítás jelentősége domain-specifikus feladatokhoz

Bár az előre tanított LLaMA-2 modell nagyon képzett, általános célú nyelvi modellnek lett tervezve, amelyet széles körű adatkorpuszon tanítottak. Sok valós világbeli alkalmazás esetén azonban szükség van arra, hogy a modellt specializált tartományokra, feladatokra vagy adatkészletekre alkalmazkodassuk.

Az LLaMA-2 modell finomítása domain-specifikus adatokon több előnnyel járhat:

  1. Jobb teljesítmény: A modell kiképzése olyan adatokon, amelyek relevánsabbak a célfeladathoz vagy tartományhoz, lehetővé teszi a finomított modell számára, hogy jobb teljesítményt érjen el, sokszor felülmúlva az általános célú előre tanított modellt.

  2. Szakosodott tudás: A finomítási folyamat lehetővé teszi a modell számára, hogy szakosodott tudást és megértést szerezzen a céltartományról, lehetővé téve számára, hogy pontosabb, relevánsabb és összefüggőbb kimeneteket generáljon.

  3. Testre szabható képességek: A finomítás képes formálni a modell viselkedését és képességeit a feladat vagy alkalmazás specifikus követelményeinek megfelelően, ezáltal megfelelőbbé téve azt a végfelhasználó igényeinek.

  4. Hatékonyság: Egy előre tanított modell finomítása általában hatékonyabb és gyorsabb, mint egy modell újra kiképzése, mivel az előre tanított modell már megtanulta a nagyméretű tanítóadatkészletekből származó értékes reprezentációkat és mintázatokat.

A következő szakaszokban vezetni fogjuk Önt az LLaMA-2 modell finomítási folyamatának lépései során, feltárva a sikeres és hatékony modelladaptációhoz szükséges szükséges lépéseket és bevált gyakorlatokat.

II. Környezet előkészítése

A. Rendszerkövetelmények

Mielőtt elkezdjük a finomítási folyamatot, fontos meggyőződni arról, hogy a rendszer rendelkezik a szükséges hardver- és szoftverkövetelményekkel.

1. Hardver

Az LLaMA-2 modellek finomítása számításigényes feladat, ezért javasoljuk, hogy hozzáférjen egy erőteljes GPU-hoz, lehetőleg legalább 16 GB videomemóriával. Az pontos hardverkövetelmények változhatnak a dataset méretétől és a feladat komplexitásától függően, de egy high-end GPU jelentősen felgyorsítja a kiképzési folyamatot.

Továbbá, elegendő rendszermemóriára (RAM) lesz szüksége a modell és a kiképzési adatok tárolásához. Általános irányvonalként legalább 32 GB RAM-ot célozzon meg, de az pontos rendelmények változhatnak a konkrét felhasználási esettől függően.

2. Szoftver

A finomítási folyamat Python segítségével lesz elvégezve, tehát telepítenie kell egy Python környezetet a rendszeren. Javasoljuk, hogy használjon Python 3.7-es vagy újabb verziót.

Ezenkívül telepítenie kell a következő kulcsfontosságú könyvtárakat:

  • PyTorch: Ez egy népszerű mélytanulási keretrendszer, amelyet az LLaMA-2 modell betöltéséhez és manipulálásához fogunk használni.
  • Hugging Face Transformers: Ez egy erőteljes könyvtár, amely könnyen használható felületeket biztosít az előre tanított nyelvi modellekkel történő munkához, beleértve az LLaMA-2-et is.
  • NumPy: Ez az alapvető könyvtár a tudományos számításhoz Pythonban, amelyet adatmanipulációra és előfeldolgozásra lehet használni.
  • Pandas: Ez egy adatmanipulációs és elemzési könyvtár, amely segítséget nyújthat táblázatos adatokkal való munkához.
  • Tensorboard: Ez egy megjelenítő eszközkészlet, amellyel különféle metrikákat lehet nyomon követni és vizualizálni a finomítási folyamat során.

B. A szükséges könyvtárak telepítése

A szükséges könyvtárakat telepítheti a pip segítségével, a Python csomag telepítővel. Nyisson meg egy terminált vagy parancssort, és futtassa az alábbi parancsokat:

pip install torch transformers numpy pandas tensorboard

Ehelyett létrehozhat egy virtuális környezetet és telepítheti a függőségeket ebben a környezetben, hogy elkerülje az ütközéseket más Python csomagokkal a rendszeren.

# Virtuális környezet létrehozása
python -m venv finetuning-env
# Aktiválja a virtuális környezetet
source finetuning-env/bin/activate
# Telepítse a szükséges könyvtárakat
pip install torch transformers numpy pandas tensorboard

Miután megvan a szükséges hardver- és szoftverbeállítás, készen áll a következő lépésre: az LLaMA-2 modell beszerzése.

III. Az LLaMA-2 modell beszerzése

A. Az előre tanított LLaMA-2 modell letöltése

Az LLaMA-2 modell jelenleg nem nyilvánosan elérhető, mivel az Anthropic által kifejlesztett védjegyes modell. Azonban az Anthropic kiadott egy előre tanított LLaMA modelleket, amelyeket kiindulópontként lehet használni a finomításhoz.

Az előre tanított LLaMA modell beszerzéséhez kövesse az Anthropic által nyújtott utasításokat. Ez általában magában foglalja az előfizetéshez való regisztrációt és a felhasználási feltételek elfogadását. Amint hozzáférése van, a modellfájlokat letöltheti az Anthropic weboldaláról vagy tárolóhelyéről.

B. A modell integritásának ellenőrzése

Az LLaMA modellfájlok letöltése után fontos ellenőrizni, hogy azok integritása megfelelő-e, hogy megbizonyosodjon arról, hogy a fájlokat helyesen töltötték le, és nem sérültek meg a letöltési folyamat során.

Ezt az ellenőrzést az Anthropic által megadott fájl-hash értékek ellenőrzésével végezheti, összehasonlítva azokat a letöltött fájlok hash-értékeivel. Használhatja a sha256sum parancsot (Linuxon vagy macOS-en) vagy az Get-FileHash nevű eszközt (Windows PowerShell-en), hogy kiszámolja a letöltött fájlok SHA-256 hash-értékét, és összehasonlítsa azokat az elvárt értékekkel.

Itt van egy példa az állomány integritásának ellenőrzésére Linuxon vagy macOS-en:

# Számolja ki az SHA-256 hash-értékét a letöltött modellfájlnak
sha256sum llama.7b.pth

# Hasonlítsa össze a kiszámított hash-értéket az Anthropic által megadott elvárt hash-értékkel

Ha a hash-értékek megegyeznek, biztos lehet benne, hogy a letöltött fájlok hitelesek és nem sérültek meg a letöltési folyamat során.

Miután kézben van az LLaMA-2 modellfájlok és az integritás ellenőrzött, már készen áll a finomítási folyamat elkezdésére.

IV. Az LLaMA-2 modell finomítása egy adott feladatra

A. A feladat és az adatkészlet meghatározása

A finomítási folyamat első lépése az feladat és az adatkészlet világos meghatározása.

1. A feladat meghatározása

A választott feladat típusa az adott felhasználási esettől és követelményektől függ. Néhány gyakori feladat, amelyeket finomítással LLaMA-2 által lehet kezelni, a következők:

  • Szöveggenerálás: Összefüggő és kontextusteremtő szöveg létrehozása, például történetek, cikkek vagy termékismertetők.
  • Kérdés-válaszadás: A model felképzése a kérdések megértésére és pontos és informatív válaszok biztosítására.
  • Nyelvfelismerés: A modell finomítása a szövegek fordítására eltérő nyelvre.
  • Érzelmi elemzés: A modell alkalmazkodása a bemeneti szöveg érzelmének (pozitív, negatív vagy semleges) osztályozásához.
  • Összefoglalás: A modell azon képzése, hogy tömör és informatív összefoglalást készítsen hosszabb szövegből.

2. Az adatkészlet előkészítése

Miután meghatározta a feladatot, elő kell készítenie az adatkészletet, amelyet a finomításhoz fog használni. Ez a következő lépéseket foglalja magában:

a. Adatgyűjtés: Gyűjtsön egy releváns adatkészletet a feladathoz, akár nyilvánosan elérhető forrásokból, akár saját készítésű adatkészletet hozva létre. b. Adat előfeldolgozása: Tisztítsa és előfeldolgozza az adatot, hogy olyan formátumban legyen, amely könnyen feldolgozható a modell által. Ide tartozhatnak olyan feladatok, mint a tokenizáció, a szöveg normalizálása és a különleges karakterek kezelése. c. Kiképzés-ellenőrzés-teszt adatkészlet felosztása: Ossza fel az adatkészletet kiképzési, ellenőrzési és teszt készletekre. A kiképzési készletet a modell finomítására fogja használni, az ellenőrzési készletet a modell teljesítményének figyelemmel kísérésére használja a kiképzés során, és a teszt készletet a végső értékeléshez fogja használni.

A feladat világos meghatározásával és a magas minőségű adatkészlet előkészítésével sikeres alapot teremt a finomítási folyamat számára.

B. A finomítási csővezeték előkészítése

A feladat és az adatkészlet meghatározása után most elkezdheti beállítani a finomítási csővezetéket. Ez a következő lépéseket foglalja magában:

1. Tokenizer beállítása

Az első lépés a tokenizer beállítása, amely a bemeneti szöveget tokenek sorozatává alakítja át, amelyeket a modell feldolgozni tudja. A Hugging Face Transformers könyvtár előre tanított tokenizereket biztosít különböző modellekhez, beleértve az LLaMA-2-t is.

from transformers import LlamaTokenizer
 
tokenizer = LlamaTokenizer.from_pretrained('path/to/llama-2-model')

2. Az adatkészlet betöltése és előfeldolgozása

Ezután be kell töltenie az adatkészletet és elő kell dolgoznia az adatot, hogy az megfeleljen a modell által elvárt formátumnak. Ide tartozhat olyan feladatok, mint a szöveg átkonvertálása token azonosítókká, a sorozatok kitöltése egy fix hosszúságúra és a szükséges bemeneti-kimeneti párok létrehozása a finomítási feladathoz.

from torch.utils.data import Dataset, DataLoader
 
class MyDataset(Dataset):
    def __init__(self, data, tokenizer):
        self.data = data
        self.tokenizer = tokenizer
 
    def __len__(self):
        return len(self.data)
 
    def __getitem__(self, idx):
        # Az adat előfeldolgozása és az bemeneti-kimeneti párok visszaadása

input_ids = self.tokenizer.encode(self.data[idx][0], return_tensors='pt') output_ids = self.tokenizer.encode(self.data[idx][1], return_tensors='pt') return input_ids, output_ids

Hozz létre egy adathalmazt és adatbetöltőt

adathalmaz = SajatAdathalmaz(trening_adat, tokenizer) adatbetöltő = DataLoader(adathalmaz, batch_size=8, shuffle=True)


### 3. A modell inicializálása és konfigurálása

Végül inicializálni kell az LLaMA-2 modellt és be kell állítani a finomhangolási feladatra. Ehhez be kell tölteni a előre betanított modell súlyokat és be kell állítani a szükséges modell komponenseket.

```python
from transformers import LlamaForCausalLM

modell = LlamaForCausalLM.from_pretrained('útvonal/a/llama-2-modellhez')
modell.config.pad_token_id = tokenizer.pad_token_id

A tokenizálóval, adathalmazzal és modelllel beállítva már készen állsz a finomhangolási folyamat megvalósítására.

C. A finomhangolási folyamat megvalósítása

A finomhangolási folyamat arra szolgál, hogy a LLaMA-2 modellt betanítsd a feladatspecifikus adathalmazon, és frissítsd a modell paramétereit annak érdekében, hogy javítsd a teljesítményét a cél feladaton.

1. A tréning ciklus meghatározása

A tréning ciklus az finomhangolási folyamat központi része, ahol a modell paraméterei az adatok alapján frissülnek. Itt van egy alap példa:

import torch.optim as optim
import torch.nn.functional as F
 
# Állítsd be az optimalizálót és a veszteségfüggvényt
optimalizalo = optim.AdamW(modell.parameters(), lr=1e-5)
veszteseg_fuggveny = F.cross_entropy
 
# Tréning ciklus
for epoch in range(num_epochs):
    for bemenetek, kimenetek in adatbetöltő:
        optimalizalo.zero_grad()
        logitok = modell(bemenetek, labels=kimenetek).logits
        veszteseg = veszteseg_fuggveny(logitok.view(-1, logitok.size(-1)), kimenetek.view(-1))
        veszteseg.backward()
        optimalizalo.step()
 
    # Értékelés az érvényesítő adathalmazon
    # és implementálható előzetes leállítás, ha szükséges

Ebben a példában az AdamW optimalizálót és a keresztentropia veszteségfüggvényt használjuk a modell betanítására. Különböző optimalizáló algoritmusokat, veszteségfüggvényeket és hiperparamétereket is kipróbálhatsz, hogy megtaláld a legjobb konfigurációt a konkrét feladatodhoz.

2. A finomhangolás monitorozása és értékelése

A finomhangolási folyamat során fontos figyelemmel kísérned a modell teljesítményét és értékelni a haladását. Ezt megteheted azáltal, hogy időnként kiértékeled a modellt az érvényesítő adathalmazon, és követed az uli különböző metrikákat, például:

  • Perplexitás: Egy mérték arra, hogy mennyire jól jósolja meg a modell a következő tokeneket a sorozatban.
  • BLEU pontszám: Egy mérték, amelyet a gépi fordítás vagy szöveggenerálás minőségének értékelésére használnak.
  • F1 pontszám: Egy metrika a precision és recall értékek egyensúlyozottságának értékelésére.

Konvolúciós neurális hálózatok (CNN-k)

A konvolúciós neurális hálózatok (CNN-k) olyan speciális típusú neurális hálózatok, amelyek különösen jól alkalmasak rácsos szerkezetű adatok, például képek feldolgozására. A CNN-ek több rétegből állnak, mindegyik réteg meghatározott feladatot lát el, például tulajdonságek kinyerését vagy osztályozást.

A CNN legfontosabb összetevői:

  1. Konvolúciós rétegek: Ezek a rétegek alkalmaznak tanulható szűrőket az bemeneti képre, tulajdonságokat kinyerve, például éleket, formákat és textúrákat.
  2. Pooling rétegek: Ezek a rétegek csökkentik a tulajdonságok térbeli dimenzióit, segítve a túltanulás ellenőrzését és a modellel szembeni kis elmozdulásokkal és torzításokkal szembeni ellenállóság növelését.
  3. Teljesen összekapcsolt rétegek: Ezek a rétegek a konvolúciós és pooling rétegek kimenetét veszik át, és azt használják a végső osztályozási vagy regisztrációs feladat elvégzéséhez.

Itt van egy egyszerű kép osztályozásra szolgáló CNN architektúra példa:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
 
modell = Sequential()
modell.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
modell.add(MaxPooling2D((2, 2)))
modell.add(Conv2D(64, (3, 3), activation='relu'))
modell.add(MaxPooling2D((2, 2)))
modell.add(Conv2D(64, (3, 3), activation='relu'))
modell.add(Flatten())
modell.add(Dense(64, activation='relu'))
modell.add(Dense(10, activation='softmax'))

Ez a modell 28x28 pixeles szürkeárnyalatos képeket vesz fel, átviszi őket három konvolúciós rétegen és pooling rétegen keresztül, majd két teljesen összekapcsolt réteget használ a képek osztályozására tíz kategóriába.

Rekurrens neurális hálózatok (RNN-ek)

A rekurrens neurális hálózatok (RNN-ek) olyan típusú neurális hálózatok, amelyek tervezésekor a szekvenciális adatok, például a szöveg, beszéd vagy idősorok kezelése a cél. Míg a feedforward neurális hálózatok függetlenül dolgozzák fel az adatokat, a RNN-ek "memóriát" tartanak fenn a korábbi bemenetekről, aminek segítségével el tudják kapni a temporalis függőségeket az adatokban.

A RNN-ek legfontosabb összetevői:

  1. Rekurzív rétegek: Ezek a rétegek feldolgozzák a bemeneti sorozatot egy elemenként, fenntartva egy rejtett állapotot, amit az egyik időlépésről a következőre továbbítanak.
  2. Teljesen összekapcsolt rétegek: Ezek a rétegek a rekurrens rétegek kimenetét veszik át, és azt használják a végső osztályozási vagy regisztrációs feladat elvégzéséhez.

Itt van egy egyszerű szöveg osztályozására szolgáló RNN példa:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense
 
# Feltételezzük, hogy van egy tokenizált szöveg adathalmazod
szavak_száma = 10000
max_hossz = 100
 
modell = Sequential()
modell.add(Embedding(szavak_száma, 128, input_length=max_hossz))
modell.add(LSTM(64))
modell.add(Dense(1, activation='sigmoid'))

Ez a modell egy 100 szavas sorozatot vesz be, amelynek minden eleme egy szó indexe, átviszi őket embedding rétegen, hogy a sűrű vektorokká konvertálja őket, majd használ egy LSTM réteget a sorozat feldolgozására. A végső, teljesen összekapcsolt réteg egyetlen kimenetet termel, amelyet bináris osztályozási feladatokhoz lehet használni.

Hosszú rövid távú memóriák (LSTM-ek)

A hosszú rövid távú memóriák (LSTM-ek) olyan speciális típusú RNN-ek, amelyek a gradiensz eltűnési problémájának megoldására lettek kifejlesztve. Ez a probléma nehezíti meg a hagyományos RNN-eknek a hosszú távú függőségek tanulását az adatokban.

Az LSTM-ek bevezetnek egy új fogalmat, az "állapottartálékot", amely egy memóriaként működik, és szelektíven frissíthető és továbbítható az egyik időlépésről a másikra. Ez lehetővé teszi az LSTM-eknek, hogy jobban kezeljék a hosszú távú függőségeket az adatokban.

Itt van egy idősorok előrejelzésére szolgáló egyszerű LSTM példa:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
 
# Feltételezzük, hogy van egy idősorok adathalmazod
jellemzők_száma = 5
lépésszám = 10
 
modell = Sequential()
modell.add(LSTM(50, activation='relu', input_shape=(lépésszám, jellemzők_száma)))
modell.add(Dense(1))

Ez a modell egy 10 időlépésből álló sorozatot vesz be, minden időlépésen 5 jellemzővel, és egy LSTM réteget használ a sorozat feldolgozására. A végső, teljesen összekapcsolt réteg egyetlen kimenetet termel, amelyet idősorok előrejelzési feladatokhoz lehet használni.

Generatív ellenséges hálózatok (GAN-ok)

A generatív ellenséges hálózatok (GAN-ok) olyan mély tanulási modellek, amelyek két neurális hálózatból állnak: egy generátorból és egy diszkriminátorból. A generátor hálózat arra van kiképezve, hogy új adatokat generáljon, amelyek hasonlítanak a tréning adathoz, míg a diszkriminátor hálózat arra van kiképezve, hogy megkülönböztesse a valós és a generált adatokat.

A GAN-ok legfontosabb összetevői:

  1. Generátor hálózat: Ez a hálózat egy véletlenszerű zajvektorral dolgozik, és generálja a tréning adathoz hasonló új adatokat.
  2. Diszkriminátor hálózat: Ez a hálózat valós vagy generált adatot kap bemenetként, és valószínűséget ad ki arra, hogy az adat valódi-e.

A két hálózatat ellentmondásos módon tréningezik, ahol a generátor megpróbálja becsapni a diszkriminátort, a diszkriminátor pedig megpróbálja helyesen megkülönböztetni a valós és a generált adatokat.

Itt van egy egyszerű kézzel írt számok generálására szolgáló GAN példa:

import tensorflow as tf
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Dense, Reshape, Flatten, Conv2D, LeakyReLU, BatchNormalization
from tensorflow.keras.optimizers import Adam
 
# Generátor hálózat
generátor = Sequential()
generátor.add(Dense(7*7*256, input_shape=(100,), activation=LeakyReLU()))
generátor.add(Reshape((7, 7, 256)))
generátor.add(Conv2D(128, (5, 5), padding='same', activation=LeakyReLU()))
generátor.add(BatchNormalization())
generátor.add(Conv2D(64, (5, 5), padding='same', activation=LeakyReLU()))
generátor.add(BatchNormalization())
generátor.add(Conv2D(1, (5, 5), padding='same', activation='tanh'))
 
# Diszkriminátor hálózat
diszkriminátor = Sequential()
diszkriminátor.add(Conv2D(64, (5, 5), padding='same', input_shape=(28, 28, 1), activation=LeakyReLU()))
diszkriminátor.add(BatchNormalization())
diszkriminátor.add(Conv2D(128, (5, 5), padding='same', activation=LeakyReLU()))
diszkriminátor.add(BatchNormalization())
diszkriminátor.add(Flatten())
diszkriminátor.add(Dense(1, activation='sigmoid'))
 
# Generátor és diszkriminátor kombinálása egy GAN modellbe
gan = Model(generátor.input, diszkriminátor(generátor.output))

Ez a modell konvolúciós generátort és konvolúciós diszkriminátort használ kézzel írt számok generálására. A generátor egy 100 dimenziós zajvektorral működik, és 28x28 pixeles szürkeárnyalatos képeket generál, míg a diszkriminátor valós vagy generált képeket kap bemenetként, és valószínűséget ad ki arra vonatkozóan, hogy az kép valódi-e.

Következtetés

Ebben a bemutatóban számos fontos mély tanulási architektúrát tárgyaltunk, beleértve a Konvolúciós Neurális Hálózatokat (CNN-ek), a Rekurrens Neurális Hálózatokat (RNN-ek), a Hosszú Rövid Távú Memóriákat (LSTM-ek) és a Generatív Ellenséges Hálózatokat (GAN-ok). Példákkal és kód részletekkel szemléltettük, hogyan lehet ezeket a modelleket implementálni a TensorFlow/Keras könyvtár segítségével.

Ezeknek a mély tanulási modelleknek széles körű alkalmazása van, a számítógépes látástól és a természetes nyelvfeldolgozástól a idősor analízisig és a generáló modellezésig. Ahogy a mély tanulás területe tovább fejlődik, fontos, hogy naprakész legyél a legújabb fejlesztésekkel és legjobb gyakorlatokkal.Reméljük, hogy ez a bemutató megalapozott tudást nyújtott neked a mély tanulás terén, és inspirált arra, hogy további erőteljes technikákkal foglalkozz. Boldog tanulást!

Hogyan értsünk könnyen a konvolúciós neurális hálózatokhoz a TensorFlowbenHogyan érthető meg könnyedén a GAN a PyTorchban kezdők számára