Artificiell intelligens
Den enda guiden du behöver för att finjustera Llama 3 eller nÄgon annan modell med öppen kÀllkod

Att finjustera stora sprÄkmodeller (LLM) som Llama 3 innebÀr att anpassa en förtrÀnad modell till specifika uppgifter med hjÀlp av en domÀnspecifik datauppsÀttning. Denna process utnyttjar modellens redan existerande kunskap, vilket gör den effektiv och kostnadseffektiv jÀmfört med trÀning frÄn grunden. I den hÀr guiden gÄr vi igenom stegen för att finjustera Llama 3 med QLoRA (Quantized LoRA), en parametereffektiv metod som minimerar minnesanvÀndning och berÀkningskostnader.
Ăversikt över finjustering
Finjustering innefattar flera viktiga steg:
- VÀlja en förutbildad modell: VÀlj en basmodell som passar din önskade arkitektur.
- Samla in en relevant datauppsÀttning: Samla in och förbearbeta en datauppsÀttning som Àr specifik för din uppgift.
- Finjustering: Anpassa modellen med hjÀlp av datamÀngden för att förbÀttra dess prestanda för specifika uppgifter.
- UtvÀrdering: Bedöm den finjusterade modellen med bÄde kvalitativa och kvantitativa mÄtt.
Koncept och tekniker
Full finjustering
Full finjustering uppdaterar alla parametrar för modellen, vilket gör den specifik för den nya uppgiften. Denna metod krÀver betydande berÀkningsresurser och Àr ofta opraktisk för mycket stora modeller.
Parametereffektiv finjustering (PEFT)
PEFT uppdaterar endast en delmÀngd av modellens parametrar, vilket minskar minneskraven och berÀkningskostnaderna. Denna teknik förhindrar katastrofal glömska och upprÀtthÄller den allmÀnna kunskapen om modellen.
Low-Rank Adaptation (LoRA) och Quantized LoRA (QLoRA)
LoRA finjusterar endast ett fÄtal lÄgrankade matriser, medan QLoRA kvantiserar dessa matriser för att minska minnesfotavtrycket ytterligare.
Finjusteringsmetoder
- Full finjustering: Detta innebĂ€r att man trĂ€nar alla parametrar i modellen pĂ„ den uppgiftsspecifika datamĂ€ngden. Ăven om denna metod kan vara mycket effektiv, Ă€r den ocksĂ„ berĂ€kningsmĂ€ssigt dyr och krĂ€ver betydande minne.
- Parameter Effektiv finjustering (PEFT): PEFT uppdaterar endast en delmÀngd av modellens parametrar, vilket gör den mer minneseffektiv. Tekniker som Low-Rank Adaptation (LoRA) och Quantized LoRA (QLoRA) faller inom denna kategori.
Vad Àr LoRA?

JÀmföra finjusteringsmetoder: QLORA förbÀttrar LoRA med 4-bitars precisionskvantisering och paged optimizers för hantering av minnesspik
LoRA Àr en förbÀttrad finjusteringsmetod dÀr, istÀllet för att finjustera alla vikter i den förtrÀnade modellen, finjusteras tvÄ mindre matriser som approximerar den större matrisen. Dessa matriser utgör LoRA-adaptern. Denna finjusterade adapter laddas sedan in i den förtrÀnade modellen och anvÀnds för slutledning.
Viktiga fördelar med LoRA:
- Minneseffektivitet: LoRA minskar minnesfotavtrycket genom att bara finjustera smÄ matriser istÀllet för hela modellen.
- reus FörmÄga: Den ursprungliga modellen förblir oförÀndrad och flera LoRA-adaptrar kan anvÀndas med den, vilket underlÀttar hanteringen av flera uppgifter med lÀgre minneskrav.
Vad Àr Quantized LoRA (QLoRA)?
QLoRA tar LoRA ett steg lÀngre genom att kvantisera LoRA-adaptrarnas vikter till lÀgre precision (t.ex. 4-bitars istÀllet för 8-bitars). Detta minskar ytterligare minnesanvÀndning och lagringskrav samtidigt som en jÀmförbar effektivitetsnivÄ bibehÄlls.
Viktiga fördelar med QLoRA:
- Ănnu större minneseffektivitet: Genom att kvantisera vikterna minskar QLoRA avsevĂ€rt modellens minnes- och lagringskrav.
- UpprÀtthÄller prestanda: Trots den minskade precisionen bibehÄller QLoRA prestandanivÄer nÀra den för fullprecisionsmodeller.
Uppgiftsspecifik anpassning
Under finjusteringen justeras modellens parametrar baserat pÄ den nya datamÀngden, vilket hjÀlper den att bÀttre förstÄ och generera innehÄll som Àr relevant för den specifika uppgiften. Denna process behÄller de allmÀnna sprÄkkunskaper som erhÄllits under förutbildningen samtidigt som modellen skrÀddarsys efter nyanserna i mÄldomÀnen.
Finjustering i praktiken
Full finjustering kontra PEFT
- Full finjustering: InnebÀr att trÀna hela modellen, vilket kan vara berÀkningsmÀssigt dyrt och krÀver betydande minne.
- PEFT (LoRA och QLoRA): Finjusterar endast en delmÀngd av parametrar, minskar minneskraven och förhindrar katastrofal glömning, vilket gör det till ett mer effektivt alternativ.
Implementeringssteg
- InstÀllningsmiljö: Installera nödvÀndiga bibliotek och stÀll in datormiljön.
- Ladda och förbearbeta datauppsÀttning: Ladda datauppsÀttningen och förbearbeta den till ett format som passar modellen.
- Ladda förtrÀnad modell: Ladda basmodellen med kvantiseringskonfigurationer om du anvÀnder QLoRA.
- tokenization: Tokenisera datasetet för att förbereda det för trÀning.
- Utbildning: Finjustera modellen med den förberedda datamÀngden.
- UtvÀrdering: UtvÀrdera modellens prestanda pÄ specifika uppgifter med hjÀlp av kvalitativa och kvantitativa mÄtt.
Steo för steg-guide till Fine Tune LLM
StÀlla in miljön
Vi kommer att anvÀnda en Jupyter-anteckningsbok för den hÀr handledningen. Plattformar som Kaggle, som erbjuder gratis GPU-anvÀndning, eller Google Colab Àr idealiska för att köra dessa experiment.
1. Installera nödvÀndiga bibliotek
Se först till att du har de nödvÀndiga biblioteken installerade:
!pip install -qqq -U bitsandbytes transformers peft accelerate datasets scipy einops evaluate trl rouge_score</div>
2. Importera bibliotek och stÀll in miljön
import os import torch from datasets import load_dataset from transformers import ( AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TrainingArguments, pipeline, HfArgumentParser ) from trl import ORPOConfig, ORPOTrainer, setup_chat_format, SFTTrainer from tqdm import tqdm import gc import pandas as pd import numpy as np from huggingface_hub import interpreter_login # Disable Weights and Biases logging os.environ['WANDB_DISABLED'] = "true" interpreter_login()
3. Ladda datamÀngden
Vi kommer att anvÀnda DialogSum-dataset för denna handledning:
Förbearbeta datasetet enligt modellens krav, inklusive att tillĂ€mpa lĂ€mpliga mallar och se till att dataformatet Ă€r lĂ€mpligt för finjustering (Kramande ansikte)ââ (DataCamp).
dataset_name = "neil-code/dialogsum-test" dataset = load_dataset(dataset_name)
Inspektera datasetstrukturen:
print(dataset['test'][0])
4. Skapa BitsAndBytes-konfiguration
SÄ hÀr laddar du modellen i 4-bitarsformat:
compute_dtype = getattr(torch, "float16") bnb_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type='nf4', bnb_4bit_compute_dtype=compute_dtype, bnb_4bit_use_double_quant=False, )
5. Ladda den förtrÀnade modellen
AnvÀnda Microsofts Phi-2-modell för denna handledning:
model_name = 'microsoft/phi-2' device_map = {"": 0} original_model = AutoModelForCausalLM.from_pretrained( model_name, device_map=device_map, quantization_config=bnb_config, trust_remote_code=True, use_auth_token=True )
6. Tokenisering
Konfigurera tokenizern:
tokenizer = AutoTokenizer.from_pretrained( model_name, trust_remote_code=True, padding_side="left", add_eos_token=True, add_bos_token=True, use_fast=False ) tokenizer.pad_token = tokenizer.eos_token
Finjustera Llama 3 eller andra modeller
NÀr du finjusterar modeller som Llama 3 eller andra toppmoderna LLM:er med öppen kÀllkod krÀvs specifika övervÀganden och justeringar för att sÀkerstÀlla optimal prestanda. HÀr Àr de detaljerade stegen och insikterna om hur du kan nÀrma dig detta för olika modeller, inklusive Llama 3, GPT-3 och Mistral.
5.1 AnvÀnda Llama 3
Modellval:
- Se till att du har rÀtt modellbeteckning frÄn Hugging Face-modellhubben. Till exempel kan Llama 3-modellen identifieras som
meta-llama/Meta-Llama-3-8B
pĂ„ Hugging Face. - Se till att begĂ€ra Ă„tkomst och logga in pĂ„ ditt Hugging Face-konto om det behövs för modeller som Llama 3 (Kramande ansikte)ââ
tokenization:
- AnvÀnd lÀmplig tokenizer för Llama 3, se till att den Àr kompatibel med modellen och stöder nödvÀndiga funktioner som stoppning och speciella tokens.
Minne och berÀkning:
- Att finjustera stora modeller som Llama 3 krÀver betydande berÀkningsresurser. Se till att din miljö, till exempel en kraftfull GPU-installation, kan hantera minnes- och bearbetningskraven. Se till att miljön kan hantera minneskraven, vilket kan mildras genom att anvÀnda tekniker som QLoRA för att minska minnesavtrycket (Kramar ansikten Forum)
Exempelvis:
model_name = 'meta-llama/Meta-Llama-3-8B' device_map = {"": 0} bnb_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.float16, bnb_4bit_use_double_quant=True, ) original_model = AutoModelForCausalLM.from_pretrained( model_name, device_map=device_map, quantization_config=bnb_config, trust_remote_code=True, use_auth_token=True )
tokenization:
Beroende pÄ det specifika anvÀndningsfallet och modellkraven, sÀkerstÀll korrekt tokenizerkonfiguration utan redundanta instÀllningar. Till exempel, use_fast=True
rekommenderas för bĂ€ttre prestanda (Kramande ansikte)ââ (Vikter och fördomar).
tokenizer = AutoTokenizer.from_pretrained( model_name, trust_remote_code=True, padding_side="left", add_eos_token=True, add_bos_token=True, use_fast=False ) tokenizer.pad_token = tokenizer.eos_token
5.2 AnvÀnda andra populÀra modeller (t.ex. GPT-3, Mistral)
Modellval:
- För modeller som GPT-3 och Mistral, se till att du anvÀnder rÀtt modellnamn och identifierare frÄn Hugging Face-modellhubben eller andra kÀllor.
tokenization:
- I likhet med Llama 3, se till att tokenizern Àr korrekt instÀlld och kompatibel med modellen.
Minne och berÀkning:
- Varje modell kan ha olika minneskrav. Justera din miljöinstÀllning dÀrefter.
Exempel för GPT-3:
model_name = 'openai/gpt-3' device_map = {"": 0} bnb_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.float16, bnb_4bit_use_double_quant=True, ) original_model = AutoModelForCausalLM.from_pretrained( model_name, device_map=device_map, quantization_config=bnb_config, trust_remote_code=True, use_auth_token=True )
Exempel för Mistral:
model_name = 'mistral-7B' device_map = {"": 0} bnb_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.float16, bnb_4bit_use_double_quant=True, ) original_model = AutoModelForCausalLM.from_pretrained( model_name, device_map=device_map, quantization_config=bnb_config, trust_remote_code=True, use_auth_token=True )
TokeniseringsövervÀganden: Varje modell kan ha unika tokeniseringskrav. Se till att tokenizern matchar modellen och Àr korrekt konfigurerad.
Exempel pÄ Llama 3 Tokenizer:
tokenizer = AutoTokenizer.from_pretrained( model_name, trust_remote_code=True, padding_side="left", add_eos_token=True, add_bos_token=True, use_fast=False ) tokenizer.pad_token = tokenizer.eos_token
Exempel pÄ GPT-3 och Mistral Tokenizer:
tokenizer = AutoTokenizer.from_pretrained( model_name, use_fast=True )
7. Testa modellen med Zero-Shot-inferencing
UtvÀrdera basmodellen med ett exempel:
from transformers import set_seed set_seed(42) index = 10 prompt = dataset['test'][index]['dialogue'] formatted_prompt = f"Instruct: Summarize the following conversation.\n{prompt}\nOutput:\n" # Generate output def gen(model, prompt, max_length): inputs = tokenizer(prompt, return_tensors="pt").to(model.device) outputs = model.generate(**inputs, max_length=max_length) return tokenizer.batch_decode(outputs, skip_special_tokens=True) res = gen(original_model, formatted_prompt, 100) output = res[0].split('Output:\n')[1] print(f'INPUT PROMPT:\n{formatted_prompt}') print(f'MODEL GENERATION - ZERO SHOT:\n{output}')
8. Förbearbeta datamÀngden
Konvertera dialog-sammanfattningspar till uppmaningar:
def create_prompt_formats(sample): blurb = "Below is an instruction that describes a task. Write a response that appropriately completes the request." instruction = "### Instruct: Summarize the below conversation." input_context = sample['dialogue'] response = f"### Output:\n{sample['summary']}" end = "### End" parts = [blurb, instruction, input_context, response, end] formatted_prompt = "\n\n".join(parts) sample["text"] = formatted_prompt return sample dataset = dataset.map(create_prompt_formats)
Tokenisera den formaterade datamÀngden:
def preprocess_batch(batch, tokenizer, max_length): return tokenizer(batch["text"], max_length=max_length, truncation=True) max_length = 1024 train_dataset = dataset["train"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True) eval_dataset = dataset["validation"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)
9. Förbered modellen för QLoRA
Förbered modellen för parametereffektiv finjustering:
original_model = prepare_model_for_kbit_training(original_model)
Hyperparametrar och deras inverkan
Hyperparametrar spelar en avgörande roll för att optimera prestandan för din modell. HÀr Àr nÄgra viktiga hyperparametrar att tÀnka pÄ:
- InlÀrningshastighet: Styr hastigheten med vilken modellen uppdaterar sina parametrar. En hög inlÀrningshastighet kan leda till snabbare konvergens men kan överskrida den optimala lösningen. En lÄg inlÀrningshastighet sÀkerstÀller stadig konvergens men kan krÀva fler epoker.
- Satsstorlek: Antalet prover som behandlas innan modellen uppdaterar sina parametrar. Större batchstorlekar kan förbÀttra stabiliteten men krÀver mer minne. Mindre batchstorlekar kan leda till mer buller i trÀningsprocessen.
- Gradientackumuleringssteg: Denna parameter hjÀlper till att simulera större batchstorlekar genom att ackumulera gradienter över flera steg innan en parameteruppdatering utförs.
- Antal epoker: Antalet gÄnger hela datamÀngden passeras genom modellen. Fler epoker kan förbÀttra prestandan men kan leda till övermontering om de inte hanteras pÄ rÀtt sÀtt.
- ViktnedgÄng: Reguleringsteknik för att förhindra överanpassning genom att straffa stora vikter.
- InlÀrningshastighetsschemalÀggare: Justerar inlÀrningshastigheten under trÀning för att förbÀttra prestanda och konvergens.
Anpassa trĂ€ningskonfigurationen genom att justera hyperparametrar som inlĂ€rningshastighet, batchstorlek och gradientackumuleringssteg baserat pĂ„ den specifika modellen och uppgiftskraven. Till exempel kan Llama 3-modeller krĂ€va olika inlĂ€rningshastigheter jĂ€mfört med mindre modeller (Vikter och fördomar)ââ (GitHub)Ăą ⏠<
Exempel pÄ trÀningskonfiguration
orpo_args = ORPOConfig( learning_rate=8e-6, lr_scheduler_type="linear",max_length=1024,max_prompt_length=512, beta=0.1,per_device_train_batch_size=2,per_device_eval_batch_size=2, gradient_accumulation_steps=4,optim="paged_adamw_8bit",num_train_epochs=1, evaluation_strategy="steps",eval_steps=0.2,logging_steps=1,warmup_steps=10, report_to="wandb",output_dir="./results/",)
10. TrÀna modellen
StÀll in trÀnaren och börja trÀna:
trainer = ORPOTrainer( model=original_model, args=orpo_args, train_dataset=train_dataset, eval_dataset=eval_dataset, tokenizer=tokenizer,) trainer.train() trainer.save_model("fine-tuned-llama-3")
UtvÀrdera den finjusterade modellen
UtvÀrdera efter utbildningen modellens prestanda med bÄde kvalitativa och kvantitativa metoder.
1. MÀnsklig utvÀrdering
JÀmför de genererade sammanfattningarna med mÀnskliga för att bedöma kvaliteten.
2. Kvantitativ utvÀrdering
AnvÀnd mÀtvÀrden som ROUGE för att bedöma resultatet:
from rouge_score import rouge_scorer scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True) scores = scorer.score(reference_summary, generated_summary) print(scores)
Vanliga utmaningar och lösningar
1. MinnesbegrÀnsningar
Att anvÀnda QLoRA hjÀlper till att lindra minnesproblem genom att kvantisera modellvikter till 4-bitars. Se till att du har tillrÀckligt med GPU-minne för att hantera din batchstorlek och modellstorlek.
2. Ăveranpassning
Ăvervaka valideringsmĂ„tt för att förhindra överanpassning. AnvĂ€nd tekniker som tidig stopp och viktminskning.
3. LÄngsam trÀning
Optimera trÀningshastigheten genom att justera batchstorlek, inlÀrningshastighet och anvÀnda gradientackumulering.
4. Datakvalitet
Se till att din datauppsÀttning Àr ren och vÀl förbehandlad. DÄlig datakvalitet kan avsevÀrt pÄverka modellens prestanda.
Slutsats
Att finjustera LLM med QLoRA Àr ett effektivt sÀtt att anpassa stora förtrÀnade modeller till specifika uppgifter med minskade berÀkningskostnader. Genom att följa den hÀr guiden kan du finjustera PHI, Llama 3 eller nÄgon annan modell med öppen kÀllkod för att uppnÄ hög prestanda för dina specifika uppgifter.