LLaMA, OpenLLaMA in XGen so vrhunski generativni modeli umetne inteligence. Ti modeli dajejo še veliko boljše rezultate, če jih natančno prilagodite na lastnih podatkih. V tem članku si oglejmo, kako te modele natančno prilagoditi na grafičnih procesorjih GPU in TPU z uporabo JAX in knjižnice EasyLM.
Meta je model LLaMA izdala februarja 2023. Ta generativni model umetne inteligence je odprtokodni model, predlagan v več velikostih: Parametri so 7B, 13B, 33B in 65B.
Junija 2021, ko je bil objavljen GPT-J, je svet začel spoznavati, da lahko odprtokodni generativni modeli umetne inteligence resno tekmujejo z OpenAI GPT-3. Zdaj je z LLaMA letvica očitno spet dvignjena in zdi se, da je ta model zelo dobra odprtokodna alternativa OpenAI ChatGPT in GPT-4.
Licenca LLaMA pa ni prijazna do podjetij: tega modela ni mogoče uporabljati v komercialne namene... Dobra novica pa je, da zdaj obstajajo tudi drugi modeli.
OpenLLaMA, ki je izšel junija 2023, je alternativna različica LLaMA, ki jo je razvila ekipa Berkeley AI Research in daje zelo dobre rezultate ter se lahko uporablja za poslovne namene. Od trenutka pisanja tega članka sta na voljo dve različici: 7B parametrov in 13B parametrov.
XGen, ki ga je družba Salesforce izdala junija 2023, je še en zelo zmogljiv temeljni model, ki se lahko uporablja v komercialnih aplikacijah. Po pisanju tega članka je na voljo samo različica s parametri 7B. Omeniti velja, da ta model podpira kontekst 8k žetonov, medtem ko LLaMA in OpenLLaMA podpirata le vsebino 2k žetonov.
Zgornji modeli so temeljni modeli, kar pomeni, da so bili usposobljeni na nenadzorovan način na velikem korpusu besedil.
Ti osnovni modeli umetne inteligence so običajno dobra osnova, vendar jih je treba prilagoditi, da bodo pravilno razumeli, kaj želite, in vrnili dobre rezultate. To najlažje dosežete z učenjem z nekaj posnetki (znanim tudi kot "promptni inženiring"). Tukaj si lahko preberete naš poseben vodnik za učenje z nekaj posnetki.
Učenje z nekaj posnetki je priročno, saj ga je mogoče izvajati sproti, ne da bi bilo treba ustvariti novo različico generativnega modela umetne inteligence, vendar včasih ne zadostuje.
Če želite doseči vrhunske rezultate, boste želeli model umetne inteligence natančno prilagoditi za svoj primer uporabe. Natančno prilagajanje pomeni, da boste na podlagi lastnih podatkov spremenili nekatere parametre v modelu in nato dobili lastno različico modela.
Natančno prilagajanje je veliko cenejše kot usposabljanje generativnega modela umetne inteligence od začetka, vendar še vedno zahteva računsko moč, zato za natančno prilagajanje lastnega modela potrebujete napredno strojno opremo. Nekatere nedavne alternativne tehnike finega uglaševanja zahtevajo manj računske moči (glejte p-tuning, prompt tuning, soft tuning, parameter efficient fine-tuning, adapters, LoRA, QLoRA ...), vendar nam s temi tehnikami do zdaj ni uspelo doseči enake ravni kakovosti, zato jih v tem vodniku ne bomo omenjali.
V tem učbeniku se osredotočamo na natančno nastavitev LLaMA s knjižnico EasyLM, ki jo je izdala ekipa Berkeley AI Research: 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.
Z isto tehniko lahko natančno nastavite tudi OpenLLaMA ali XGen.
LLaMA 7B smo natančno nastavili na Googlovem procesorju TPU V3-8, vendar lahko enako storite tudi na grafičnem procesorju A100 (samo natančno preberite del "Namestitev" v dokumentaciji EasyLM, ki se nekoliko razlikuje). Seveda lahko natančno nastavite tudi večje različice LLaMA (13B, 33B, 65B ...), vendar boste za to potrebovali veliko več kot TPU V3-8 ali en grafični procesor A100.
Začenjamo!
Najprej ustvarite nabor podatkov za ustvarjanje besedila za svoj primer uporabe v obliki JSONL, pri čemer kot ključ za vsak primer uporabite "besedilo". Tukaj je preprost nabor podatkov za analizo čustev:
{"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"}Upoštevajte nekaj pomembnih stvari. Prvič, ta nabor podatkov vsebuje le 3 primere zaradi preprostosti, vendar boste v resničnem življenju potrebovali veliko več primerov. Običajno je 300 primerov dober začetek. Drugič, ko boste za sklepanje uporabljali svoj natančno prilagojeni model, boste morali dosledno upoštevati enako oblikovanje z uporabo predpon "[Content]:" in "[Sentiment]:". Nazadnje, žeton "</s>" je pomemben, ker pomeni, da mora model na tem mestu prenehati generirati. Več primerov podatkovnih nizov najdete v dokumentaciji NLP Cloud: Več informacij najdete tukaj.
Ustvarite VM TPU V3-8 v Googlovem oblaku z različico programske opreme V2 Alpha:
SSH v VM in namestite EasyLM:
git clone https://github.com/young-geng/EasyLM
cd EasyLM
bash ./scripts/tpu_vm_setup.shZdaj lahko prenesete in pretvorite uteži LLaMA. Prva možnost je, da zaprosite Meto za uradne uteži: https://ai.facebook.com/blog/large-language-model-llama-meta-ai/. Nato pretvorite uteži v EasyLM s to skripto: https://github.com/young-geng/EasyLM/blob/main/EasyLM/models/llama/convert_torch_to_easylm.py. Druga možnost je uporaba uteži LLaMA na portalu HuggingFace: https://huggingface.co/decapoda-research/llama-7b-hf. Nato pretvorite uteži v EasyLM s to skripto: https://github.com/young-geng/EasyLM/blob/main/EasyLM/models/llama/convert_hf_to_easylm.py.
Naložite nabor podatkov v VM in preštejte, koliko žetonov vsebuje, z uporabo tokenizerja HF LLaMA:
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())))"Če svoj model usposabljate za kontekst 1024 žetonov, morate vrnjeno število žetonov deliti z 1024.
Če svoj model usposabljate za kontekst 2048 žetonov, boste morali vrnjeno število žetonov deliti z 2048.
To število bo število korakov na epoho. Če želite na primer trenirati 5 epoh (kar je običajno dobra nastavitev), morate to število pomnožiti s 5 in dobljeno vrednost vnesti v spodnji vnos --total_steps.
Konkreten primer: če vaš nabor podatkov vsebuje 100 000 žetonov in želite kontekst 1024 žetonov ter 5 epoh, bo vaše skupno število korakov (100 000/1024)*5 = 488.
Glede na dolžino konteksta nastavite --train_dataset.json_dataset.seq_length kot 1024 ali 2048 spodaj. Upoštevajte, da natančno prilagajanje modela za kontekst z 2048 žetoni zahteva več pomnilnika, zato vam priporočamo, da se držite konteksta z 1024 žetoni, če to ni nujno potrebno.
Zdaj lahko začnete postopek natančnega prilagajanja:
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 &Nekaj razlag:
--save_model_freq: kako pogosto želite shraniti model med postopkom. Če se ukvarjate le z natančnim prilagajanjem majhnega nabora podatkov, lahko shranjujete samo na koncu postopka, v tem primeru bo ta vrednost enaka --total_steps.
--optimizer.adamw_optimizer.lr_warmup_steps: Vrednost: 10 % vseh korakov je običajno dobra vrednost.
--tokenizer.vocab_file: pot do datoteke tokenizer.model. Če na primer uporabljate skladišče decapoda na portalu HuggingFace, je tukaj povezava do tokenizerja: https://huggingface.co/decapoda-research/llama-7b-hf/resolve/main/tokenizer.model
--logger.output_dir: pot do končnega modela in dnevnikov
Drugi parametri ostanejo nedotaknjeni.
Ko je postopek natančnega prilagajanja končan, lahko svoj model prevzamete na poti, ki ste jo določili v ukazu --logger.output_dir.
Zdaj imate svoj lasten, natančno prilagojen model in ga seveda želite uporabljati!
Prva strategija je uporaba knjižnice EasyLM za sklepanje. V tem primeru lahko zaženete strežnik za sklepanje na naslednji način:
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'Nato preprosto pošljite svoje zahteve s cURL, kot sledi:
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]:"]}'Druga strategija je izvoz modela v obliko HuggingFace, da bi lahko izvedli sklepanje z drugim ogrodjem. Tukaj je opisano, kako ga lahko izvozite:
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'Leto 2023 je bilo velik mejnik za odprtokodne generativne modele umetne inteligence. Od tega trenutka lahko vsakdo uporablja odlične modele, kot so LLaMA, OpenLLaMA, XGen, Orca, Falcon...
Natančno prilagajanje teh modelov je najboljši način za doseganje vrhunskih rezultatov, prilagojenih vašemu primeru uporabe, ki lahko znatno presegajo najboljše lastniške modele umetne inteligence, kot so ChatGPT (GPT-3.5), GPT-4, Claude...
V tem vodniku sem vam pokazal, kako natančno nastaviti LLaMA, OpenLLaMA in XGen. Če imate vprašanja, me brez oklevanja kontaktirajte, in če želite preprosto natančno nastaviti in uporabiti napredne generativne modele umetne inteligence brez tehnične zapletenosti, have a look at the NLP Cloud dedicated documentation!
Mark
Inženir strojnega učenja v podjetju NLP Cloud