A LLaMA, az OpenLLaMA és az XGen élvonalbeli generatív AI modellek. Ezek a modellek még sokkal jobb eredményeket adnak, ha az Ön saját adatain finomhangoljuk őket. Ebben a cikkben megnézzük, hogyan lehet ezeket a modelleket finomhangolni GPU-n és TPU-n egyaránt, JAX és az EasyLM könyvtár segítségével.
A LLaMA modellt a Meta 2023 februárjában adta ki. Ez a generatív AI modell egy nyílt forráskódú, több méretben javasolt modell: 7B paraméter, 13B paraméter, 33B paraméter és 65B paraméter.
2021 júniusában, amikor a GPT-J megjelent, a világ kezdett rájönni, hogy a nyílt forráskódú generatív AI modellek komolyan felvehetik a versenyt az OpenAI GPT-3-mal. Most az LLaMA-val a lécet egyértelműen újra felemelték, és ez a modell nagyon jó nyílt forráskódú alternatívának tűnik az OpenAI ChatGPT és a GPT-4 mellett.
A LLaMA licenc azonban nem üzletbarát: ez a modell nem használható kereskedelmi célokra... De jó hír, hogy már léteznek más modellek is.
A 2023 júniusában megjelent OpenLLaMA az LLaMA alternatív változata, amelyet a Berkeley AI Research csapata fejlesztett ki, és amely nagyon jó eredményeket ad, és üzleti célokra is használható. Jelen íráskor 2 verzió áll rendelkezésre: 7B paraméteres és 13B paraméteres.
A Salesforce által 2023 júniusában kiadott XGen egy másik nagyon erős alapmodell, amely kereskedelmi alkalmazásokban használható. Jelen íráskor még csak a 7B paraméterekkel rendelkező verzió áll rendelkezésre. Érdemes megjegyezni, hogy ez a modell 8k tokenes kontextust támogat, míg az LLaMA és az OpenLLaMA csak 2k tokenes tartalmat.
A fenti modellek alapozó modellek, ami azt jelenti, hogy nem felügyelt módon, nagy szövegkorpuszokon tanították őket.
Ezek az alapvető mesterséges intelligencia modellek általában jó alapot jelentenek, de úgy kell őket hangolni, hogy megfelelően megértsék, mit szeretne, és jó eredményeket adjanak vissza. Ezt a legegyszerűbben a néhány lövéses tanulással (más néven "prompt engineering") lehet elérni. Nyugodtan olvassa el a néhány lövéses tanulási útmutatót itt.
A néhány lépéses tanulás kényelmes, mivel menet közben is elvégezhető anélkül, hogy a generatív AI-modell új verzióját kellene létrehozni, de néha nem elégséges.
Ahhoz, hogy a legkorszerűbb eredményeket érje el, az AI-modellt a saját felhasználási esetére kell finomhangolnia. A finomhangolás azt jelenti, hogy a saját adatai alapján módosítja a modell néhány paraméterét, majd megkapja a modell saját verzióját.
A finomhangolás sokkal olcsóbb, mint egy generatív AI-modell nulláról való kiképzése, de továbbra is számítási teljesítményt igényel, így fejlett hardverre van szükség a saját modell finomhangolásához. Néhány újabb alternatív finomhangolási technika kevesebb számítási teljesítményt igényel (lásd p-tuning, prompt tuning, soft tuning, paraméterhatékony finomhangolás, adapterek, LoRA, QLoRA...), de eddig nem sikerült ugyanolyan minőséget elérni ezekkel a technikákkal, ezért nem említjük őket ebben a bemutatóban.
Ebben a bemutatóban a LLaMA finomhangolására összpontosítunk a Berkeley AI Research csapat által kiadott EasyLM könyvtárral: https://github.com/young-geng/EasyLM. This library is based on JAX which makes the fine-tuning process fast and compatible with both GPUs and Google TPUs.
Az OpenLLaMA vagy az XGen finomhangolása is elvégezhető ugyanezzel a technikával.
A LLaMA 7B finomhangolását itt egy Google TPU V3-8-on végezzük, de ugyanezt tökéletesen megteheted egy A100 GPU-n is (egyszerűen olvasd el figyelmesen az EasyLM dokumentáció "Telepítés" részét, amely kissé eltérő). Természetesen a LLaMA nagyobb változatait is finomhangolhatod (13B, 33B, 65B...), de ehhez sokkal többre lesz szükséged, mint egy TPU V3-8 vagy egy A100 GPU.
Itt is vagyunk!
Először is hozzon létre egy szöveggeneráló adathalmazt a felhasználási esethez JSONL formátumban, minden egyes példa esetében a "text" kulcsot használva. Íme egy egyszerű hangulatelemzési adatkészlet:
{"text":"[Content]: I love NLP Cloud, this company is awesome!\n[Sentiment]: Positive"}
{"text":"[Content]: Training LLMs is a complex but rewarding process.\n[Sentiment]: Neutral"}
{"text":"[Content]: My fine-tuning keeps crashing because of an OOM error! It just does not work at all!\n[Sentiment]: Negative"}Kérjük, vegyen figyelembe néhány fontos dolgot. Először is, ez az adatkészlet az egyszerűség kedvéért csak 3 példát tartalmaz, de a való életben sokkal több példára lesz szükség. A 300 példa általában jó kezdet. Másodszor, amikor a finomhangolt modelljét következtetésre fogja használni, szigorúan ugyanazt a formázást kell követnie, a "[Tartalom]:" és "[Érzelem]:" előtagok használatával. Végül pedig az "</s>" token azért fontos, mert azt jelenti, hogy a modellnek itt le kell állnia a generálással. További adatkészlet példákat talál az NLP Cloud dokumentációjában: itt tudhatsz meg többet.
Hozzon létre egy TPU V3-8 VM-et a Google Cloudon a V2 Alpha szoftververzióval:
Lépjen be SSH-n a VM-be, és telepítse az EasyLM-et:
git clone https://github.com/young-geng/EasyLM
cd EasyLM
bash ./scripts/tpu_vm_setup.shMost letöltheti és átalakíthatja az LLaMA súlyokat. Az első lehetőség, hogy a hivatalos súlyokat a Meta-tól kérdezi: https://ai.facebook.com/blog/large-language-model-llama-meta-ai/. Ezután konvertálja a súlyokat EasyLM-be ezzel a szkripttel: https://github.com/young-geng/EasyLM/blob/main/EasyLM/models/llama/convert_torch_to_easylm.py. A második lehetőség az LLaMA súlyok használata az HuggingFace-en: https://huggingface.co/decapoda-research/llama-7b-hf. Ezután konvertálja a súlyokat EasyLM-be ezzel a szkripttel: https://github.com/young-geng/EasyLM/blob/main/EasyLM/models/llama/convert_hf_to_easylm.py.
Töltse fel az adatállományt a VM-re, és számolja meg, hány tokent tartalmaz a HF LLaMA tokenizáló segítségével:
pip install -U transformers
python -c "from transformers import LlamaTokenizer; tokenizer = LlamaTokenizer.from_pretrained('decapoda-research/llama-7b-hf'); f = open('/path/to/your/dataset', 'r'); print(len(tokenizer.encode(f.read())))"Ha a modellt 1024 tokenes kontextusra képzi, akkor a visszaadott tokenek számát el kell osztania 1024-gyel.
Ha a modellt 2048 tokenes kontextusra képzi ki, akkor a visszaadott tokenek számát el kell osztania 2048-cal.
Ez a szám lesz az epochánkénti lépések száma. Tehát például ha 5 epochán keresztül akarsz edzeni (ami általában egy jó beállítás), akkor ezt a számot meg kell szoroznod 5-tel, és az így kapott értéket be kell írnod az alábbi --total_steps értékbe.
Íme egy konkrét példa: ha az adatkészlet 100 000 tokent tartalmaz, és 1024 tokenes kontextust és 5 epochát szeretne, akkor a lépések száma (100 000/1024)*5 = 488 lesz.
A kontextus hosszától függően állítsa be a --train_dataset.json_dataset.seq_length értéket 1024 vagy 2048 értékre. Vegye figyelembe, hogy a modell finomhangolása 2048 tokenes kontextushoz több memóriát igényel, ezért ha ez nem feltétlenül szükséges, javasoljuk, hogy maradjon az 1024 tokenes kontextusnál.
Most már elindíthatja a finomhangolási folyamatot:
nohup python -u EasyLM/EasyLM/models/llama/llama_train.py \
--total_steps=your number of steps \
--save_model_freq=usually same as your number of steps \
--optimizer.adamw_optimizer.lr_warmup_steps=usually 10% of total steps \
--train_dataset.json_dataset.path='/path/to/your/dataset' \
--train_dataset.json_dataset.seq_length=1024 or 2048 \
--load_checkpoint='params::/path/to/converted/model' \
--tokenizer.vocab_file='/path/to/tokenizer' \
--logger.output_dir=/path/to/output \
--mesh_dim='1,4,2' \
--load_llama_config='7b' \
--train_dataset.type='json' \
--train_dataset.text_processor.fields='text' \
--optimizer.type='adamw' \
--optimizer.accumulate_gradient_steps=1 \
--optimizer.adamw_optimizer.lr=0.002 \
--optimizer.adamw_optimizer.end_lr=0.002 \
--optimizer.adamw_optimizer.lr_decay_steps=100000000 \
--optimizer.adamw_optimizer.weight_decay=0.001 \
--optimizer.adamw_optimizer.multiply_by_parameter_scale=True \
--optimizer.adamw_optimizer.bf16_momentum=True &Néhány magyarázat:
--save_model_freq: milyen gyakran szeretné elmenteni a modellt a folyamat során. Ha csak egy kis adathalmazon végez finomhangolást, akkor csak a folyamat végén menthet, és ebben az esetben ez az érték egyenlő lesz a --total_steps értékkel.
--optimizer.adamw_optimizer.lr_warmup_steps: A teljes lépésszám 10%-a általában jó érték.
--tokenizer.vocab_file: a tokenizer.model fájl elérési útja. Ha például a decapoda repository-t használod az HuggingFace-en, itt a link a tokenizerhez: https://huggingface.co/decapoda-research/llama-7b-hf/resolve/main/tokenizer.model.
--logger.output_dir: a végleges modell és a naplók elérési útja
A többi paramétert érintetlenül hagyhatja.
Ha a finomhangolási folyamat befejeződött, a modellt a --logger.output_dir-ben megadott elérési útvonalon tudja lekérdezni.
Most már megvan a saját, finomhangolt modellje, és természetesen használni akarja!
Az első stratégia az EasyLM könyvtár használata a következtetéshez. Ebben az esetben a következőképpen indíthatja el a következtetési kiszolgálót:
python EasyLM/EasyLM/models/llama/llama_serve.py \
--mesh_dim='1,1,-1' \
--load_llama_config='7b' \
--load_checkpoint='params::/path/to/your/model' \
--tokenizer.vocab_file='/path/to/tokenizer'Ezután egyszerűen küldje el a kéréseket a cURL segítségével, így:
curl "http://0.0.0.0:5007/generate" \
-H "Content-Type: application/json" \
-X POST -d '{"prefix_text":["[Content]: EasyLM works really well!\n[Sentiment]:"]}'A második stratégia az, hogy a modellt exportálja az HuggingFace formátumba, hogy egy másik keretrendszerrel végezhessen következtetést. Az alábbi módon exportálhatja:
python EasyLM/EasyLM/models/llama/convert_easylm_to_hf.py \
--load_checkpoint='params::/path/to/output/model/streaming_params' \
--tokenizer_path='/path/to/tokenizer' \
--model_size='7b' \
--output_dir='/path/to/converted/model'2023 nagy mérföldkő a nyílt forráskódú generatív mesterséges intelligencia modellek számára. Ettől az időponttól kezdve bárki használhatja az olyan nagyszerű modelleket, mint a LLaMA, OpenLLaMA, XGen, Orca, Falcon...
Ezeknek a modelleknek a finomhangolása a legjobb módja annak, hogy a saját felhasználási esetre szabott, élvonalbeli eredményeket érjünk el, amelyek jelentősen felülmúlják a legjobb saját AI modelleket, mint például a ChatGPT (GPT-3.5), GPT-4, Claude....
Ebben az útmutatóban megmutattam, hogyan lehet finomhangolni a LLaMA-t, az OpenLLaMA-t és az XGen-t. Ha kérdése van, ne habozzon, forduljon hozzám, és ha szeretne egyszerűen finomhangolni és fejlett generatív AI modelleket telepíteni mindenféle technikai bonyolultság nélkül, have a look at the NLP Cloud dedicated documentation!
Mark
Gépi tanulási mérnök az NLP Cloudnál