LLaMA, OpenLLaMA en XGen zijn geavanceerde generatieve AI-modellen. Deze modellen geven nog veel betere resultaten wanneer ze worden verfijnd op je eigen gegevens. In dit artikel laten we zien hoe je deze modellen kunt fine-tunen op zowel een GPU als een TPU, met behulp van JAX en de EasyLM bibliotheek.
Het LLaMA-model werd in februari 2023 uitgebracht door Meta. Dit generatieve AI-model is een open-source model dat wordt voorgesteld in verschillende groottes: 7B parameters, 13B parameters, 33B parameters en 65B parameters.
In juni 2021, toen GPT-J werd uitgebracht, begon de wereld te beseffen dat open-source generatieve AI-modellen serieus konden concurreren met OpenAI GPT-3. Nu met LLaMA is de lat duidelijk weer hoger gelegd en dit model lijkt een zeer goed open-source alternatief te zijn voor OpenAI ChatGPT en GPT-4.
De licentie van LLaMA is echter niet bedrijfsvriendelijk: dit model kan niet voor commerciële doeleinden worden gebruikt... Maar goed nieuws is dat er nu andere modellen bestaan.
OpenLLaMA, uitgebracht in juni 2023, is een alternatieve versie van LLaMA, ontwikkeld door het Berkeley AI Research team dat zeer goede resultaten geeft en gebruikt kan worden voor het bedrijfsleven. Op het moment van schrijven zijn er 2 versies beschikbaar: 7B parameters en 13B parameters.
XGen, uitgebracht door Salesforce in juni 2023, is een ander zeer krachtig basismodel dat kan worden gebruikt in commerciële toepassingen. Op het moment van schrijven is er alleen een versie met 7B-parameters beschikbaar. Het is vermeldenswaard dat dit model een context van 8k tokens ondersteunt, terwijl LLaMA en OpenLLaMA alleen een inhoud van 2k tokens ondersteunen.
De bovenstaande modellen zijn basismodellen, wat betekent dat ze zonder supervisie zijn getraind op een groot corpus met teksten.
Deze AI-modellen vormen meestal een goede basis, maar ze moeten worden afgestemd om goed te begrijpen wat je wilt en goede resultaten te leveren. De eenvoudigste manier om dit te bereiken is door gebruik te maken van "few-shot learning" (ook bekend als "prompt engineering"). Voel je vrij om hier onze speciale leergids met een paar foto's te lezen.
Few-shot learning is handig omdat het on-the-fly kan worden uitgevoerd zonder een nieuwe versie van het generatieve AI-model te hoeven maken, maar soms is het niet genoeg.
Om state-of-the-art resultaten te krijgen, wil je een AI-model fine-tunen voor je eigen use case. Verfijning betekent dat je enkele parameters in het model aanpast op basis van je eigen gegevens, en dan je eigen versie van het model krijgt.
Fine-tuning is veel goedkoper dan het trainen van een generatief AI model vanaf nul, maar het vereist nog steeds rekenkracht, dus je hebt geavanceerde hardware nodig om je eigen model te fine-tunen. Sommige recente alternatieve fine-tuning technieken vereisen minder rekenkracht (zie p-tuning, prompt tuning, soft tuning, parameter efficient fine-tuning, adapters, LoRA, QLoRA...) maar tot nu toe zijn we er niet in geslaagd om hetzelfde kwaliteitsniveau te bereiken met deze technieken, dus we gaan ze niet vermelden in deze tutorial.
In deze tutorial richten we ons op het verfijnen van LLaMA met de EasyLM bibliotheek, uitgebracht door het Berkeley AI Research team: 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.
Je kunt ook OpenLLaMA of XGen afstellen met dezelfde techniek.
We finetunen LLaMA 7B hier op een Google TPU V3-8, maar je kunt hetzelfde perfect doen op een A100 GPU (lees gewoon zorgvuldig het gedeelte "Installatie" in de EasyLM documentatie, die iets anders is). Natuurlijk kun je ook grotere versies van LLaMA fijntunen (13B, 33B, 65B...) maar dan heb je veel meer nodig dan een TPU V3-8 of een enkele A100 GPU.
Daar gaan we!
Maak eerst een tekstgeneratie dataset voor je use case, in JSONL formaat, met "tekst" als sleutel voor elk voorbeeld. Hier is een eenvoudige dataset voor sentimentanalyse:
{"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"}Let op een paar belangrijke dingen. Ten eerste bevat deze dataset slechts 3 voorbeelden omwille van de eenvoud, maar in het echte leven zul je veel meer voorbeelden nodig hebben. 300 voorbeelden is meestal een goed begin. Ten tweede, als je je verfijnde model gaat gebruiken voor inferentie, moet je strikt dezelfde opmaak volgen, met "[Inhoud]:" en "[Sentiment]:" voorvoegsels. Tot slot is de "</s>" token belangrijk omdat dit betekent dat het model hier moet stoppen met genereren. Je kunt meer datasetvoorbeelden vinden in de NLP Cloud documentatie: Lees hier meer.
Maak een TPU V3-8 VM op Google Cloud met de V2 Alpha softwareversie:
SSH naar de VM en installeer EasyLM:
git clone https://github.com/young-geng/EasyLM
cd EasyLM
bash ./scripts/tpu_vm_setup.shJe kunt nu de LLaMA-gewichten downloaden en converteren. De eerste optie is om Meta om de officiële gewichten te vragen: https://ai.facebook.com/blog/large-language-model-llama-meta-ai/. Converteer vervolgens de gewichten naar EasyLM met dit script: https://github.com/young-geng/EasyLM/blob/main/EasyLM/models/llama/convert_torch_to_easylm.py. De tweede optie is om de LLaMA-gewichten op HuggingFace te gebruiken: https://huggingface.co/decapoda-research/llama-7b-hf. Converteer vervolgens de gewichten naar EasyLM met dit script: https://github.com/young-geng/EasyLM/blob/main/EasyLM/models/llama/convert_hf_to_easylm.py.
Upload je dataset naar de VM, tel hoeveel tokens deze bevat met behulp van de HF LLaMA tokenizer:
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())))"Als u uw model traint voor een context van 1024 tokens, moet u het geretourneerde aantal tokens delen door 1024.
Als u uw model traint voor een context van 2048 tokens, moet u het geretourneerde aantal tokens delen door 2048.
Dit getal is het aantal stappen per epoch. Dus als je bijvoorbeeld 5 epochs wilt trainen (wat meestal een goede instelling is), moet je dit getal vermenigvuldigen met 5 en de resulterende waarde in --total_steps hieronder zetten.
Hier is een concreet voorbeeld: als je dataset 100.000 tokens bevat en je wilt een context van 1024 tokens en 5 epochs, dan zal je totale aantal stappen (100.000/1024)*5 = 488 zijn.
Afhankelijk van de lengte van je context, stel je --train_dataset.json_dataset.seq_length in als 1024 of 2048 hieronder. Merk op dat het fine-tunen van een model voor een 2048 tokens context meer geheugen vereist, dus als dit niet strikt noodzakelijk is, raden we aan om het bij een 1024 tokens context te houden.
U kunt nu de fijnafstelling starten:
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 &Enkele verklaringen:
--save_model_freq: hoe vaak u uw model wilt opslaan tijdens het proces. Als u alleen fijnafstemt op een kleine dataset, kunt u alleen aan het einde van het proces opslaan en in dat geval is deze waarde gelijk aan --total_steps.
--Optimizer.adamw_optimizer.lr_warmup_steps: 10% van de totale stappen is meestal een goede waarde.
--tokenizer.vocab_file: het pad naar het tokenizer.model bestand. Als je bijvoorbeeld de decapoda repository op HuggingFace gebruikt, is hier de link naar de tokenizer: https://huggingface.co/decapoda-research/llama-7b-hf/resolve/main/tokenizer.model
--logger.output_dir: pad naar het uiteindelijke model en de logbestanden
De andere parameters kunnen onaangeroerd blijven.
Zodra het fine-tuning proces klaar is, kunt u uw model ophalen op het pad dat u hebt opgegeven in --logger.output_dir.
Je hebt nu je eigen verfijnde model en je wilt het natuurlijk gebruiken!
Een eerste strategie is om de EasyLM bibliotheek te gebruiken voor inferentie. In dat geval kun je de inferentieserver als volgt starten:
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'Stuur dan gewoon je verzoeken met cURL zoals dit:
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]:"]}'Een tweede strategie is om je model te exporteren naar het HuggingFace formaat om inferentie uit te voeren met een ander framework. Dit is hoe je het kunt exporteren:
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 is een grote mijlpaal geweest voor open-source generatieve AI-modellen. Vanaf dit moment kan iedereen geweldige modellen gebruiken zoals LLaMA, OpenLLaMA, XGen, Orca, Falcon...
Het verfijnen van deze modellen is de beste manier om geavanceerde resultaten te verkrijgen, op maat van je eigen use case, die aanzienlijk beter kunnen presteren dan de beste eigen AI-modellen zoals ChatGPT (GPT-3.5), GPT-4, Claude...
In deze gids heb ik laten zien hoe je LLaMA, OpenLLaMA en XGen kunt fine-tunen. Als je vragen hebt, aarzel dan niet om contact met me op te nemen, en als je eenvoudig geavanceerde generatieve AI-modellen wilt fine-tunen en implementeren zonder technische complexiteit, have a look at the NLP Cloud dedicated documentation!
Mark
Machine learning ingenieur bij NLP Cloud