Den enda guiden du behöver för att finjustera Llama 3 eller någon annan öppen källmodell

Finjustering av 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 datamängd. Denna process utnyttjar modellens förkunskaper, vilket gör den effektiv och kostnadseffektiv jämfört med att träna från scratch. I den här guiden kommer vi att gå igenom stegen för att finjustera Llama 3 med hjälp av QLoRA (Quantized LoRA), en parameter-effektiv metod som minimerar minnesanvändning och beräkningskostnader.

Översikt av finjustering

Finjustering innebär flera viktiga steg:

1. Val av förtränad modell: Välj en basmodell som överensstämmer med din önskade arkitektur.
2. Insamling av relevant datamängd: Samla in och förbehandla en datamängd som är specifik för din uppgift.
3. Finjustering: Anpassa modellen med hjälp av datamängden för att förbättra dess prestanda på specifika uppgifter.
4. Utvardering: Utvärdera den finjusterade modellens prestanda med hjälp av både kvalitativa och kvantitativa mått.

Begrepp och tekniker

Finjustering av stora språkmodeller

Full finjustering

Full finjustering uppdaterar alla modellens parametrar, 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.

Parameter-effektiv finjustering (PEFT)

PEFT uppdaterar endast en delmängd av modellens parametrar, vilket minskar minneskraven och beräkningskostnaderna. Denna teknik förhindrar katastrofalt glömska och bibehåller modellens allmänna kunskap.

Låg-rank-adaptation (LoRA) och Quantized LoRA (QLoRA)

LoRA finjusterar endast ett fåtal låg-rank-matriser, medan QLoRA kvantiserar dessa matriser för att ytterligare minska minnesavtrycket.

Finjusteringsmetoder

1. Full finjustering: Detta innebär att träna hela modellen, vilket kan vara mycket effektivt, men också beräkningskrävande och kräver betydande minne.
2. 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örelse av finjusteringsmetoder: QLORA förbättrar LoRA med 4-bitars precision och sidordnade optimerare för minnesspikshantering

LoRA är en förbättrad finjusteringsmetod där, istället för att finjustera alla vikter i den förtränade modellen, två mindre matriser som approximerar den större matrisen finjusteras. Dessa matriser utgör LoRA-adaptern. Denna finjusterade adapter laddas sedan in i den förtränade modellen och används för inferens.

Nyckelfördelar med LoRA:

• Minneseffektivitet: LoRA minskar minnesavtrycket genom att finjustera endast små matriser istället för hela modellen.
• Återanvändbarhet: Den ursprungliga modellen förblir oförändrad, och flera LoRA-adapter kan användas med den, vilket underlättar hantering av flera uppgifter med lägre minneskrav.

Vad är Quantized LoRA (QLoRA)?

QLoRA tar LoRA ett steg längre genom att kvantisera vikterna i LoRA-adaptern till lägre precision (t.ex. 4-bitars istället för 8-bitars). Detta minskar ytterligare minnesanvändning och lagringskrav samtidigt som det bibehåller en jämförbar nivå av effektivitet.

Nyckelfördelar med QLoRA:

• Ännu större minneseffektivitet: Genom att kvantisera vikterna minskar QLoRA modellens minnes- och lagringskrav avsevärt.
• Bibehåller prestanda: Trots den reducerade precisionen bibehåller QLoRA prestandanivåer som är jämförbara med fullprecisionsmodeller.

Uppgiftsspecifik anpassning

Under finjustering 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 bibehåller den allmänna språkkunskapen som erhållits under förträning samtidigt som den anpassar modellen till nyanserna i måldomänen.

Finjustering i praktiken

Full finjustering vs. PEFT

• Full finjustering: Detta innebär att träna hela modellen, vilket kan vara beräkningskrävande och kräver betydande minne.
• PEFT (LoRA och QLoRA): PEFT finjusterar endast en delmängd av parametrarna, vilket gör den mer minneseffektiv. Tekniker som Low-Rank Adaptation (LoRA) och Quantized LoRA (QLoRA) faller inom denna kategori.

Implementeringssteg

1. Konfigurera miljön: Installera nödvändiga bibliotek och konfigurera beräkningsmiljön.
2. Ladda och förbehandla datamängden: Ladda datamängden och förbehandla den till ett format som är lämpligt för modellen.
3. Ladda förtränad modell: Ladda basmodellen med kvantiseringkonfigurationer om du använder QLoRA.
4. Tokenisering: Tokenisera datamängden för att förbereda den för träning.
5. Träning: Finjustera modellen med den förberedda datamängden.
6. Utvärdering: Utvärdera modellens prestanda på specifika uppgifter med hjälp av kvalitativa och kvantitativa mått.

Steg-för-steg-guide för finjustering av LLM

Konfigurera miljön

Vi kommer att använda en Jupyter-anteckningsbok för den här guiden. 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 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

2. Importera bibliotek och konfigurera 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

# Inaktivera Weights and Biases-loggning
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. Ladda datamängden

Vi kommer att använda DialogSum-datamängden för den här guiden:

Förbehandla datamängden enligt modellens krav, inklusive tillämpning av lämpliga mallar och säkerställande av att dataformatet är lämpligt för finjustering​ (Hugging Face)​​ (DataCamp)​.

dataset_name = "neil-code/dialogsum-test"
dataset = load_dataset(dataset_name)

Inspektera datamängdens struktur:

print(dataset['test'][0])

4. Skapa BitsAndBytes-konfiguration

För att ladda 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änd Microsofts Phi-2-modell för den här guiden:

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 tokenisatorn:

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

Finjustering av Llama 3 eller andra modeller

När du finjusterar modeller som Llama 3 eller andra state-of-the-art-öppen källmodeller, finns det specifika överväganden och justeringar som krävs för att säkerställa optimal prestanda. Här är de detaljerade stegen och insikterna om hur du kan gå tillväga för olika modeller, inklusive Llama 3, GPT-3 och Mistral.

5.1 Användning av Llama 3

Modellval:

• Säkerställ att du har den korrekta modellidentifieraren från Hugging Face-modellhubben. Till exempel kan Llama 3-modellen identifieras som meta-llama/Meta-Llama-3-8B på Hugging Face.
• Säkerställ att du begär åtkomst och loggar in på ditt Hugging Face-konto om det krävs för modeller som Llama 3​ (Hugging Face)​​

Tokenisering:

• Använd den lämpliga tokenisatorn för Llama 3, säkerställ att den är kompatibel med modellen och stöder krävda funktioner som padding och specialtecken.

Minne och beräkning:

• Finjustering av stora modeller som Llama 3 kräver betydande beräkningsresurser. Säkerställ att din miljö, som en kraftfull GPU-uppsättning, kan hantera minnes- och beräkningskraven. Säkerställ att miljön kan hantera minneskraven, som kan minskas med hjälp av tekniker som QLoRA för att minska minnesavtrycket​ (Hugging Face Forums)

Exempel:

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
)

Tokenisering:
Beroende på den specifika användningen och modellkraven, säkerställ att tokenisatorn matchar modellen och är konfigurerad korrekt.

Llama 3-tokenisator-exempel:

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

GPT-3 och Mistral-tokenisator-exempel:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
use_fast=True
)

7. Testa modellen med zero-shot-inferens

Utvärdera basmodellen med en exempelindata:

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"

# Generera utdata
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örbehandla datamängden

Konvertera dialog-sammanfattning-par till prompt:

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)

Förbered modellen för parameter-effektiv finjustering:

original_model = prepare_model_for_kbit_training(original_model)

Hyperparametrar spelar en avgörande roll för att optimera modellens prestanda. Här är några viktiga hyperparametrar att överväga:

1. Inlärningstakt: Kontrollerar hur snabbt modellen uppdaterar sina parametrar. En hög inlärningstakt kan leda till snabbare konvergens, men kan också överskrida den optimala lösningen. En låg inlärningstakt säkerställer stadig konvergens, men kan kräva fler epoker.
2. Batchstorlek: Antalet prover som bearbetas innan modellen uppdaterar sina parametrar. Större batchstorlekar kan förbättra stabiliteten, men kräver mer minne. Mindre batchstorlekar kan leda till mer brus i träningsprocessen.
3. Gradientackumuleringssteg: Denna parameter hjälper till att simulera större batchstorlekar genom att ackumulera gradienter över flera steg innan en parameteruppdatering utförs.
4. Antal epoker: Antalet gånger som hela datamängden passerar genom modellen. Fler epoker kan förbättra prestandan, men kan också leda till överanpassning om det inte hanteras korrekt.
5. Viktminskning: En regleringsteknik för att förhindra överanpassning genom att bestraffa stora vikter.
6. Inlärningstaktsschema: Justerar inlärningstakten under träningsprocessen för att förbättra prestandan och konvergensen.

Anpassa träningskonfigurationen genom att justera hyperparametrar som inlärningstakt, batchstorlek och gradientackumuleringssteg baserat på den specifika modellen och uppgiftens krav. Till exempel kan Llama 3-modeller kräva olika inlärningstakter jämfört med mindre modeller​ (Weights & Biases)​​ (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

Konfigurera tränaren och starta träningsprocessen:

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ärdering av den finjusterade modellen

Efter träningsprocessen, utvärdera modellens prestanda med hjälp av både kvalitativa och kvantitativa metoder.

1. Mänsklig utvärdering

Jämför de genererade sammanfattningarna med mänskligt skrivna för att bedöma kvaliteten.

2. Kvantitativ utvärdering

Använd mått som ROUGE för att bedöma prestandan:

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

Användning av QLoRA hjälper till att mildra minnesproblem genom att kvantisera modellvikter till 4-bitars. Säkerställ 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 stoppning och viktminskning.

3. Långsam träningsprocess

Optimera träningshastigheten genom att justera batchstorlek, inlärningstakt och använda gradientackumuleringssteg.

4. Datakvalitet

Säkerställ att din datamängd är ren och väl förbehandlad. Dålig datakvalitet kan påverka modellens prestanda avsevärt.

Slutsats

Finjustering av LLM med QLoRA är ett effektivt sätt att anpassa stora förtränade modeller till specifika uppgifter med reducerade beräkningskostnader. Genom att följa den här guiden kan du finjustera PHI, Llama 3 eller någon annan öppen källmodell för att uppnå hög prestanda på dina specifika uppgifter.