LLaMA, OpenLLaMA și XGen sunt modele generative AI de ultimă generație. Aceste modele oferă rezultate chiar mult mai bune atunci când sunt ajustate cu precizie pe propriile dvs. date. În acest articol vom vedea cum să ajustăm aceste modele atât pe un GPU, cât și pe un TPU, folosind JAX și biblioteca EasyLM.
Modelul LLaMA a fost lansat de Meta în februarie 2023. Acest model generativ de inteligență artificială este un model open-source propus în mai multe dimensiuni: 7B de parametri, 13B de parametri, 33B de parametri și 65B de parametri.
În iunie 2021, când a fost lansat GPT-J, lumea a început să realizeze că modelele de inteligență artificială generativă open-source puteau concura serios cu OpenAI GPT-3. Acum, cu LLaMA, ștacheta a fost în mod clar ridicată din nou, iar acest model pare a fi o alternativă open-source foarte bună la OpenAI ChatGPT și GPT-4.
Licența LLaMA nu este însă prietenoasă cu mediul de afaceri: acest model nu poate fi folosit în scopuri comerciale... Dar vestea bună este că acum există și alte modele.
OpenLLaMA, lansată în iunie 2023, este o versiune alternativă a LLaMA, dezvoltată de echipa Berkeley AI Research, care oferă rezultate foarte bune și poate fi utilizată în afaceri. La momentul redactării acestui articol sunt disponibile 2 versiuni: 7B parametri și 13B parametri.
XGen, lansat de Salesforce în iunie 2023, este un alt model de bază foarte puternic care poate fi utilizat în aplicații comerciale. La momentul redactării acestui articol, este disponibilă doar o versiune cu parametrii 7B. Este demn de remarcat faptul că acest model suportă un context de 8k tokens, în timp ce LLaMA și OpenLLaMA suportă doar un conținut de 2k tokens.
Modelele de mai sus sunt modele fundamentale, ceea ce înseamnă că au fost antrenate într-un mod nesupervizat pe un corpus mare de texte.
Aceste modele de inteligență artificială de bază reprezintă de obicei o bază bună, dar trebuie să fie ajustate pentru a înțelege corect ceea ce doriți și pentru a vă oferi rezultate bune. Cel mai simplu mod de a realiza acest lucru este prin utilizarea învățării în câteva rânduri (cunoscută și sub numele de "inginerie promptă"). Nu ezitați să citiți aici ghidul nostru de învățare dedicat pentru câteva fotografii.
Învățarea în câteva momente este convenabilă, deoarece poate fi efectuată din mers, fără a fi necesară crearea unei noi versiuni a modelului generativ de inteligență artificială, dar uneori nu este suficientă.
Pentru a obține rezultate de ultimă generație, veți dori să ajustați un model de inteligență artificială pentru propriul caz de utilizare. Ajustarea fină înseamnă că veți modifica unii parametri din model pe baza propriilor dumneavoastră date și apoi veți obține propria versiune a modelului.
Ajustarea fină este mult mai ieftină decât antrenarea unui model generativ de inteligență artificială de la zero, dar necesită totuși putere de calcul, astfel încât aveți nevoie de hardware avansat pentru a vă ajusta propriul model. Unele tehnici alternative recente de reglaj fin necesită mai puțină putere de calcul (a se vedea p-tuning, prompt tuning, soft tuning, reglaj fin eficient al parametrilor, adaptoare, LoRA, QLoRA...), dar până în prezent nu am reușit să obținem același nivel de calitate cu aceste tehnici, așa că nu le vom menționa în acest tutorial.
În acest tutorial ne concentrăm pe reglarea fină a LLaMA cu biblioteca EasyLM, lansată de echipa 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.
Puteți, de asemenea, să reglați OpenLLaMA sau XGen folosind aceeași tehnică.
Noi am reglat LLaMA 7B pe un Google TPU V3-8 aici, dar puteți face același lucru și pe un GPU A100 (citiți cu atenție partea de "Instalare" din documentația EasyLM, care este ușor diferită). Bineînțeles că puteți, de asemenea, să reglați fin versiunile mai mari ale LLaMA (13B, 33B, 65B...), dar veți avea nevoie de mult mai mult decât un TPU V3-8 sau un singur GPU A100.
Iată-ne!
În primul rând, creați un set de date de generare de text pentru cazul dumneavoastră de utilizare, în format JSONL, utilizând "text" ca cheie pentru fiecare exemplu. Iată un set de date simplu de analiză a sentimentelor:
{"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"}Vă rugăm să rețineți câteva lucruri importante. În primul rând, acest set de date conține doar 3 exemple pentru simplificare, dar în viața reală veți avea nevoie de mult mai multe exemple. 300 de exemple este de obicei un bun început. În al doilea rând, atunci când veți utiliza modelul dvs. ajustat pentru inferență, va trebui să urmați cu strictețe aceeași formatare, utilizând prefixele "[Content]:" și "[Sentiment]:". În cele din urmă, simbolul "</s>" este important, deoarece înseamnă că modelul trebuie să se oprească din generare aici. Puteți găsi mai multe exemple de seturi de date în documentația NLP Cloud: Aflați mai multe aici.
Creați o VM TPU V3-8 pe Google Cloud cu versiunea de software V2 Alpha:
Intrați prin SSH în VM și instalați EasyLM:
git clone https://github.com/young-geng/EasyLM
cd EasyLM
bash ./scripts/tpu_vm_setup.shAcum puteți descărca și converti greutățile LLaMA. Prima opțiune este să cereți la Meta greutățile oficiale: https://ai.facebook.com/blog/large-language-model-llama-meta-ai/. Apoi, convertiți ponderile în EasyLM cu acest script: https://github.com/young-geng/EasyLM/blob/main/EasyLM/models/llama/convert_torch_to_easylm.py. A doua opțiune este de a utiliza greutățile LLaMA pe HuggingFace: https://huggingface.co/decapoda-research/llama-7b-hf. Apoi, convertiți ponderile în EasyLM cu acest script: https://github.com/young-geng/EasyLM/blob/main/EasyLM/models/llama/convert_hf_to_easylm.py.
Încărcați setul de date în mașina virtuală, numărați câte simboluri conține, utilizând tokenizatorul 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())))"Dacă vă antrenați modelul pentru un context de 1024 de simboluri, va trebui să împărțiți numărul de simboluri returnate la 1024.
Dacă vă antrenați modelul pentru un context de 2048 de simboluri, va trebui să împărțiți numărul de simboluri returnate la 2048.
Acest număr va fi numărul de pași pe epocă. Astfel, de exemplu, dacă doriți să vă antrenați timp de 5 epoci (ceea ce este de obicei o setare bună), va trebui să înmulțițiți acest număr cu 5 și să introduceți valoarea rezultată în --total_steps de mai jos.
Iată un exemplu concret: dacă setul dvs. de date conține 100 000 de token-uri și doriți un context de 1024 token-uri și 5 epoci, numărul total de pași va fi (100 000/1024)*5 = 488.
În funcție de lungimea contextului, setați --train_dataset.json_dataset.seq_length la 1024 sau 2048 mai jos. Rețineți că reglarea fină a unui model pentru un context de 2048 de jetoane necesită mai multă memorie, astfel încât, dacă acest lucru nu este strict necesar, vă recomandăm să rămâneți la un context de 1024 de jetoane.
Acum puteți lansa procesul de reglare fină:
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 &Câteva explicații:
--save_model_freq: cât de des doriți să salvați modelul în timpul procesului. Dacă efectuați un reglaj fin doar pe un set de date mic, puteți salva doar la sfârșitul procesului, iar în acest caz această valoare va fi egală cu --total_steps.
--optimizer.adamw_optimizer.lr_warmup_steps: 10% din numărul total de pași este, de obicei, o valoare bună.
--tokenizer.vocab_file: calea către fișierul tokenizer.model. De exemplu, dacă folosiți depozitul decapoda de pe HuggingFace, iată link-ul către tokenizer: https://huggingface.co/decapoda-research/llama-7b-hf/resolve/main/tokenizer.model
--logger.output_dir: calea către modelul final și jurnalele de ieșire
Ceilalți parametri pot fi lăsați neatinși.
După ce procesul de ajustare este finalizat, puteți prelua modelul în calea pe care ați specificat-o în --logger.output_dir.
Acum aveți propriul model bine pus la punct și doriți să-l folosiți, bineînțeles!
O primă strategie constă în utilizarea bibliotecii EasyLM pentru inferență. În acest caz, puteți lansa serverul de inferență în felul următor:
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'Apoi, trimiteți pur și simplu cererile cu cURL, astfel:
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]:"]}'O a doua strategie este de a exporta modelul dvs. în formatul HuggingFace pentru a efectua inferența cu un alt cadru. Iată cum îl puteți exporta:
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 a fost o piatră de hotar pentru modelele generative de inteligență artificială cu sursă deschisă. Din acest moment, toată lumea poate folosi modele grozave precum LLaMA, OpenLLaMA, XGen, Orca, Falcon...
Ajustarea acestor modele este cea mai bună modalitate de a obține rezultate de ultimă oră, adaptate la propriul dvs. caz de utilizare, care pot depăși semnificativ cele mai bune modele de inteligență artificială proprietare, cum ar fi ChatGPT (GPT-3.5), GPT-4, Claude...
În acest ghid v-am arătat cum să reglați LLaMA, OpenLLaMA și XGen. Dacă aveți întrebări, nu ezitați să mă contactați și dacă doriți să reglați și să implementați cu ușurință modele avansate de inteligență artificială generativă fără nicio complexitate tehnică, have a look at the NLP Cloud dedicated documentation!
Mark
Inginer de învățare automată la NLP Cloud