LLaMA, OpenLLaMA un XGen ir progresīvi ģeneratīvie mākslīgā intelekta modeļi. Šie modeļi sniedz vēl daudz labākus rezultātus, ja tos precizē, izmantojot jūsu datus. Šajā rakstā aplūkosim, kā šos modeļus precizēt gan uz GPU, gan TPU, izmantojot JAX un EasyLM bibliotēku.
LLaMA modeli Meta izlaida 2023. gada februārī. Šis ģeneratīvais mākslīgā intelekta modelis ir atvērtā koda modelis, kas ierosināts vairākos izmēros: 7B parametru, 13B parametru, 33B parametru un 65B parametru modeļos.
2021. gada jūnijā, kad tika izdots GPT-J, pasaule sāka saprast, ka atvērtā koda ģeneratīvā mākslīgā intelekta modeļi var nopietni konkurēt ar OpenAI GPT-3. Tagad ar LLaMA latiņa atkal ir skaidri pacelta, un šis modelis, šķiet, ir ļoti laba atvērtā koda alternatīva OpenAI ChatGPT un GPT-4.
Tomēr LLaMA licence nav draudzīga uzņēmējdarbībai: šo modeli nevar izmantot komerciāliem mērķiem... Taču labā ziņa ir tā, ka tagad ir arī citi modeļi.
OpenLLaMA, kas izlaists 2023. gada jūnijā, ir alternatīva LLaMA versija, ko izstrādājusi Berklijas mākslīgā intelekta pētniecības komanda, kas sniedz ļoti labus rezultātus un ko var izmantot uzņēmējdarbībā. Šobrīd ir pieejamas 2 versijas: 7B parametri un 13B parametri.
XGen, ko Salesforce izlaida 2023. gada jūnijā, ir vēl viens ļoti jaudīgs pamatmodelis, ko var izmantot komerciālās lietojumprogrammās. Šobrīd ir pieejama tikai 7B parametru versija. Ir vērts atzīmēt, ka šis modelis atbalsta 8k žetonu kontekstu, savukārt LLaMA un OpenLLaMA atbalsta tikai 2k žetonu saturu.
Iepriekš minētie modeļi ir pamatmodeļi, kas nozīmē, ka tie ir apmācīti neuzraudzītā veidā, izmantojot lielu tekstu korpusu.
Šie AI pamatmodeļi parasti ir labs pamats, taču tie ir jānoregulē, lai pareizi saprastu, ko vēlaties, un sniegtu labus rezultātus. Visvienkāršākais veids, kā to panākt, ir izmantot mācīšanos ar dažiem kadriem (pazīstama arī kā "tūlītēja inženierija"). Šeit varat izlasīt mūsu speciāli šim nolūkam veltīto mācību ceļvedi ar dažiem šāvieniem.
Mācīšanās ar dažiem kadriem ir ērta, jo to var veikt "uzreiz", neveidojot jaunu ģeneratīvā mākslīgā intelekta modeļa versiju, taču dažkārt ar to nepietiek.
Lai iegūtu vismodernākos rezultātus, vēlaties precīzi pielāgot AI modeli savam lietošanas gadījumam. Precīza pielāgošana nozīmē, ka jūs modificēsiet dažus modeļa parametrus, pamatojoties uz saviem datiem, un pēc tam iegūsiet savu modeļa versiju.
Precīza pielāgošana ir daudz lētāka nekā ģeneratīvā mākslīgā intelekta modeļa apmācība no nulles, taču tā joprojām prasa skaitļošanas jaudu, tāpēc, lai pielāgotu savu modeli, ir nepieciešama moderna aparatūra. Dažas jaunākās alternatīvās precizēšanas metodes prasa mazāku skaitļošanas jaudu (sk. p-tuning, prompt tuning, soft tuning, parameter efficient fine-tuning, adapteri, LoRA, QLoRA...), taču līdz šim ar šīm metodēm mums nav izdevies sasniegt tādu pašu kvalitātes līmeni, tāpēc šajā pamācībā tās nepieminēsim.
Šajā pamācībā mēs pievērsīsimies LLaMA pielāgošanai ar bibliotēku EasyLM, ko izdeva Berklijas mākslīgā intelekta pētījumu komanda: 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.
Izmantojot to pašu metodi, varat arī precīzi noregulēt OpenLLaMA vai XGen.
Šeit mēs precīzi pielāgojam LLaMA 7B uz Google TPU V3-8, taču to pašu varat paveikt arī uz A100 GPU (vienkārši uzmanīgi izlasiet EasyLM dokumentācijas daļu "Instalēšana", kas ir nedaudz atšķirīga). Protams, jūs varat precīzi noregulēt arī lielākas LLaMA versijas (13B, 33B, 65B...), bet jums būs nepieciešams daudz vairāk nekā TPU V3-8 vai viens A100 GPU.
Lūk, sākam!
Vispirms izveidojiet teksta ģenerēšanas datu kopu savam lietošanas gadījumam JSONL formātā, kā atslēgu katram piemēram izmantojot "text". Šeit ir vienkāršs noskaņojuma analīzes datu kopums:
{"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"}Lūdzu, ņemiet vērā dažas svarīgas lietas. Pirmkārt, vienkāršības labad šajā datu kopā ir tikai 3 piemēri, taču reālajā dzīvē piemēru būs nepieciešams daudz vairāk. 300 piemēri parasti ir labs sākums. Otrkārt, kad izmantosiet savu precizēto modeli secinājumiem, jums būs stingri jāievēro tas pats formatējums, izmantojot prefiksus "[Saturs]:" un "[Noskaņojums]:". Visbeidzot, "</s>" simbols ir svarīgs, jo tas nozīmē, ka šeit modelim jāpārtrauc ģenerēšana. Vairāk datu kopas piemēru var atrast NLP Cloud dokumentācijā: Uzzināt vairāk šeit.
Izveidojiet TPU V3-8 VM Google mākoņa vidē ar V2 Alpha programmatūras versiju:
Ieejiet VM ar SSH un instalējiet EasyLM:
git clone https://github.com/young-geng/EasyLM
cd EasyLM
bash ./scripts/tpu_vm_setup.shTagad varat lejupielādēt un konvertēt LLaMA svarus. Pirmā iespēja ir lūgt Meta oficiālos svarus: https://ai.facebook.com/blog/large-language-model-llama-meta-ai/. Pēc tam konvertējiet svarus uz EasyLM, izmantojot šo skriptu: https://github.com/young-geng/EasyLM/blob/main/EasyLM/models/llama/convert_torch_to_easylm.py. Otra iespēja ir izmantot LLaMA svaru uz HuggingFace: https://huggingface.co/decapoda-research/llama-7b-hf. Pēc tam konvertējiet svarus uz EasyLM, izmantojot šo skriptu: https://github.com/young-geng/EasyLM/blob/main/EasyLM/models/llama/convert_hf_to_easylm.py.
Augšupielādējiet savu datu kopu virtuālajā datorā, saskaitiet, cik daudz žetonu tā satur, izmantojot HF LLaMA tokenizatoru:
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())))"Ja apmācāt savu modeli 1024 žetonu kontekstam, jums vajadzēs izdalīt iegūto žetonu skaitu ar 1024.
Ja apmācāt savu modeli 2048 žetonu kontekstam, jums vajadzēs izdalīt iegūto žetonu skaitu ar 2048.
Šis skaitlis būs soļu skaits epohā. Piemēram, ja vēlaties apmācīt 5 epohās (kas parasti ir labs iestatījums), jums šis skaitlis jāreizina ar 5 un iegūtā vērtība jāievada --total_steps.
Konkrēts piemērs: ja jūsu datu kopa satur 100 000 žetonu un vēlaties 1024 žetonu kontekstu un 5 epohas, kopējais soļu skaits būs (100 000/1024)*5 = 488.
Atkarībā no jūsu konteksta garuma, zemāk iestatiet --train_dataset.json_dataset.seq_length kā 1024 vai 2048. Ņemiet vērā, ka modeļa precīza pielāgošana 2048 žetonu kontekstam prasa vairāk atmiņas, tāpēc, ja tas nav obligāti nepieciešams, iesakām pieturēties pie 1024 žetonu konteksta.
Tagad varat sākt precizēšanas procesu:
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 &Daži paskaidrojumi:
--save_model_freq: cik bieži vēlaties saglabāt modeli procesa laikā. Ja veicat tikai sīku pielāgošanu nelielai datu kopai, varat saglabāt tikai procesa beigās, un tādā gadījumā šī vērtība būs vienāda ar --total_steps.
--optimizer.adamw_optimizer.lr_warmup_steps: Parasti 10% no kopējā soļu skaita ir laba vērtība.
--tokenizer.vocab_file: ceļš uz tokenizer.model failu. Piemēram, ja jūs izmantojat dekapoda repozitoriju vietnē HuggingFace, šeit ir saite uz tokenizatoru: https://huggingface.co/decapoda-research/llama-7b-hf/resolve/main/tokenizer.model.
--logger.output_dir: ceļš uz galīgo modeli un žurnāliem
Pārējos parametrus var nemainīt.
Kad precizēšanas process ir pabeigts, varat iegūt savu modeli ceļā, kas norādīts parametrā --logger.output_dir.
Tagad jums ir savs pielāgots modelis, un jūs, protams, vēlaties to izmantot!
Pirmā stratēģija ir izmantot EasyLM bibliotēku, lai izdarītu secinājumus. Tādā gadījumā varat palaist secinājumu serveri šādi:
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'Pēc tam vienkārši nosūtiet pieprasījumus, izmantojot cURL šādi:
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]:"]}'Otra stratēģija ir eksportēt savu modeli HuggingFace formātā, lai veiktu secinājumus ar citu sistēmu. Šeit ir norādīts, kā to eksportēt:
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. gads ir bijis liels pagrieziena punkts atvērtā pirmkoda ģeneratīvo mākslīgā intelekta modeļu jomā. No šī brīža ikviens var izmantot tādus lieliskus modeļus kā LLaMA, OpenLaMA, XGen, Orca, Falcon...
Šo modeļu precīza pielāgošana ir labākais veids, kā iegūt progresīvus rezultātus, kas pielāgoti jūsu vajadzībām un var ievērojami pārspēt labākos patentētos AI modeļus, piemēram, ChatGPT (GPT-3.5), GPT-4, Claude...
Šajā rokasgrāmatā es parādīju, kā precīzi noregulēt LLaMA, OpenLLaMA un XGen. Ja jums ir jautājumi, lūdzu, sazinieties ar mani, un, ja vēlaties viegli noregulēt un izvietot progresīvus ģeneratīvos mākslīgā intelekta modeļus bez tehniskas sarežģītības, have a look at the NLP Cloud dedicated documentation!
Mark
Mašīnmācīšanās inženieris uzņēmumā NLP Cloud