Den eneste guiden du trenger for å finjustere Llama 3 eller andre åpne kildekodemodeller

Finjustering av store språkmodeller (LLM) som Llama 3 innebærer å tilpasse en forhånds trenet modell til spesifikke oppgaver ved hjelp av en domenespesifikk datasett. Denne prosessen utnytter modellens eksisterende kunnskap, noe som gjør den effektiv og kostnadseffektiv sammenlignet med å trene fra scratch. I denne guiden vil vi gå gjennom stegene for å finjustere Llama 3 ved hjelp av QLoRA (Quantized LoRA), en parameter-effektiv metode som minimerer minnebruk og beregningskostnader.

Overblik over finjustering

Finjustering innebærer flere nøkkelsteg:

1. Valg av forhåndstrent modell: Velg en basismodell som stemmer overens med din ønskede arkitektur.
2. Samling av relevant datasett: Samle inn og forbehandle et datasett som er spesifikt for din oppgave.
3. Finjustering: Tilpass modellen ved hjelp av datasettet for å forbedre dens ytelse på spesifikke oppgaver.
4. Evaluering: Vurdér den finjusterte modellens ytelse ved hjelp av både kvalitative og kvantitative mål.

Begreper og tekniker

Finjustering av store språkmodeller

Full finjustering

Full finjustering oppdaterer alle modellens parametre, noe som gjør den spesifikk for den nye oppgaven. Denne metoden krever betydelige beregningsressurser og er ofte upraktisk for svært store modeller.

Parameter-effektiv finjustering (PEFT)

PEFT oppdaterer bare en undergruppe av modellens parametre, noe som reduserer minnebehov og beregningskostnader. Denne teknikken forhindrer katastrofalt glemsel og beholder modellens generelle kunnskap.

Low-Rank Adaptation (LoRA) og Quantized LoRA (QLoRA)

LoRA finjusterer bare noen få lav-rank matriser, mens QLoRA kvantiserer disse matrisene for å redusere minneavtrykket ytterligere.

Finjusteringsmetoder

1. Full finjustering: Dette innebærer å trene alle modellens parametre på oppgave-spesifikt datasett. Selv om denne metoden kan være svært effektiv, er den også beregningskostbar og krever betydelig minne.
2. Parameter-effektiv finjustering (PEFT): PEFT oppdaterer bare en undergruppe av modellens parametre, noe som gjør den mer minneeffektiv. Teknikker som Low-Rank Adaptation (LoRA) og Quantized LoRA (QLoRA) faller inn under denne kategorien.

Hva er LoRA?

Sammenligning av finjusteringsmetoder: QLORA forbedrer LoRA med 4-bits presisjonskvantisering og pagede optimisatorer for minnehåndtering

LoRA er en forbedret finjusteringsmetode der, i stedet for å finjustere alle vekter i den forhåndstrente modellen, to mindre matriser som approksimerer den større matrisen finjusteres. Disse matrisene utgjør LoRA-adapteren. Denne finjusterte adapteren lastes deretter inn i den forhåndstrente modellen og brukes til inferens.

Nøkkel fordeler med LoRA:

• Minneeffektivitet: LoRA reduserer minneavtrykket ved å finjustere bare små matriser i stedet for hele modellen.
• Gjenbruk: Den opprinnelige modellen forblir uendret, og flere LoRA-adaptere kan brukes med den, noe som faciliterer håndtering av flere oppgaver med lavere minnekrav.

Hva er Quantized LoRA (QLoRA)?

QLoRA tar LoRA et skritt videre ved å kvantisere vekter i LoRA-adapterne til lavere presisjon (f.eks. 4-bits i stedet for 8-bits). Dette reduserer minnebruk og lagringskrav ytterligere, samtidig som det opprettholder en komparabel nivå av effektivitet.

Nøkkel fordeler med QLoRA:

• Enda større minneeffektivitet: Ved å kvantisere vekter, reduserer QLoRA modellens minne- og lagringskrav betydelig.
• Opprettholder ytelse: Til tross for den reduserte presisjonen, opprettholder QLoRA en ytelse på et nivå som er nært fullt presisjonsmodeller.

Oppgave-spesifikk tilpasning

Under finjustering justeres modellens parametre basert på det nye datasettet, noe som hjelper den å bedre forstå og generere innhold som er relevant for den spesifikke oppgaven. Denne prosessen beholder den generelle språkkunnskapen som er tilegnet under forhåndstreningen, samtidig som den tilpasser modellen til nuansene i måldommen.

Finjustering i praksis

Full finjustering vs. PEFT

• Full finjustering: Innebærer å trene hele modellen, noe som kan være beregningskostbart og krever betydelig minne.
• PEFT (LoRA og QLoRA): Finjusterer bare en undergruppe av parametre, noe som reduserer minnekrav og forhindrer katastrofalt glemsel, og er derfor en mer effektiv alternativ.

Implementeringssteg

1. Oppsett av miljø: Installer nødvendige biblioteker og sett opp datamaskinmiljøet.
2. Last inn og forbehandle datasett: Last inn datasettet og forbehandle det til en format som er egnet for modellen.
3. Last inn forhåndstrent modell: Last inn basismodellen med kvantiseringkonfigurasjoner hvis QLoRA brukes.
4. Tokenisering: Tokeniser datasettet for å gjøre det klart for trening.
5. Trening: Finjuster modellen ved hjelp av det forberedte datasettet.
6. Evaluering: Vurdér modellens ytelse på spesifikke oppgaver ved hjelp av både kvalitative og kvantitative mål.

Steg-for-steg guide til finjustering av LLM

Oppsett av miljø

Vi vil bruke en Jupyter-notebook for denne tutorialen. Plattformer som Kaggle, som tilbyr gratis GPU-bruk, eller Google Colab er ideelle for å kjøre disse eksperimentene.

1. Installer nødvendige biblioteker

Først, sikker deg at du har de nødvendige bibliotekene installert:

!pip install -qqq -U bitsandbytes transformers peft accelerate datasets scipy einops evaluate trl rouge_score

2. Importer biblioteker og sett opp miljø

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

# Deaktiver Weights and Biases logging
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. Last inn datasett

Vi vil bruke DialogSum-datasettet for denne tutorialen:

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

4. Opprett BitsAndBytes-konfigurasjon

For å laste inn modellen i 4-bits format:

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. Last inn forhåndstrent modell

Bruker Microsofts Phi-2-modell for denne tutorialen:

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

Konfigurer tokenisatoren:

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 andre modeller

Når du finjusterer modeller som Llama 3 eller andre state-of-the-art åpne kildekodemodeller, er det spesifikke overveielser og justeringer som kreves for å sikre optimal ytelse. Her er detaljerte steg og innsikter om hvordan du kan gå frem for å finjustere disse modellene, inkludert Llama 3, GPT-3 og Mistral.

5.1 Bruk av Llama 3

Modellvalg:

• Sikker deg at du har den korrekte modellidentifikatoren fra Hugging Face-modellhubben. For eksempel kan Llama 3-modellen være identifisert som meta-llama/Meta-Llama-3-8B på Hugging Face.
• Sikker deg at du har tilgang og logger inn på din Hugging Face-konto hvis det er nødvendig for modeller som Llama 3.

Tokenisering:

• Bruk den korrekte tokenisatoren for Llama 3, og sikker deg at den er kompatibel med modellen og støtter nødvendige funksjoner som padding og spesialtegn.

Minne og beregning:

• Finjustering av store modeller som Llama 3 krever betydelig beregningskraft. Sikker deg at din miljø, som en kraftig GPU-oppsetting, kan håndtere minne- og beregningskravene.

Eksempel:

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
)

5.2 Bruk av andre populære modeller (f.eks. GPT-3, Mistral)

Modellvalg:

• For modeller som GPT-3 og Mistral, sikker deg at du bruker den korrekte modellnavn og identifikator fra Hugging Face-modellhubben eller andre kilder.

Tokenisering:

• Lignende med Llama 3, sikker deg at tokenisatoren er korrekt konfigurert og kompatibel med modellen.

Minne og beregning:

• Hver modell kan ha forskjellige minnekrav. Juster din miljøoppsettning etter behov.

7. Test modellen med null-skuddsinferens

Vurdér basismodellen med en prøveinndata:

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"

# Generer 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'INNLEDNINGSPROMPT:\n{formatted_prompt}')
print(f'MODELLGENERERING - NULL-SKUDD: \n{output}')

8. Forbehandling av datasett

Konverter dialog-sum-par til instruksjoner:

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)

Tokeniser det formaterede datasett:

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)

Hyperparametere og deres innvirkning

Hyperparametere spiller en kritisk rolle i å optimalisere modellens ytelse. Her er noen nøkkelhyperparametere å vurdere:

1. Læringsrate: Kontrollerer hastigheten som modellen oppdaterer sine parametre. En høy læringsrate kan føre til raskere konvergens, men kan også overskride den optimale løsningen. En lav læringsrate sikrer stabil konvergens, men kan kreve flere epoker.
2. Batch-størrelse: Antall eksemplarer som prosesseres før modellen oppdaterer sine parametre. Større batch-størrelser kan forbedre stabiliteten, men krever mer minne. Mindre batch-størrelser kan føre til mer støy i treningsprosessen.
3. Gradient-akkumulasjonssteg: Dette parameteret hjelper med å simulere større batch-størrelser ved å akkumulere grader over flere steg før en parameteroppdatering utføres.
4. Antall epoker: Antall ganger hele datasettet prosesseres av modellen. Flere epoker kan forbedre ytelsen, men kan også føre til overfitting hvis det ikke håndteres korrekt.
5. Vekt-forfall: Regulariseringsteknikk for å forhindre overfitting ved å straffe store vekter.
6. Læringsrateskjeder: Justerer læringsraten under trening for å forbedre ytelsen og konvergens.

Tilpass treningskonfigurasjonen ved å justere hyperparametere som læringsrate, batch-størrelse og gradient-akkumulasjonssteg basert på den spesifikke modellen og oppgavens krav.

Eksempel på treningskonfigurasjon

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. Trening av modellen

Sett opp treneren og start treningen:

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")

Vurdering av den finjusterte modellen

Etter trening, vurder modellens ytelse ved hjelp av både kvalitative og kvantitative metoder.

1. Menneskelig vurdering

Sammenlign de genererte summene med menneskeskrevne for å vurdere kvaliteten.

2. Kvantitativ vurdering

Bruk metoder som ROUGE for å vurdere ytelsen:

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)

Vanlige utfordringer og løsninger

1. Minnebegrensninger

Bruk av QLoRA hjelper med å minimere minneproblemer ved å kvantisere modellvekter til 4-bits. Sikker deg at du har tilstrekkelig GPU-minne til å håndtere batch-størrelsen og modellstørrelsen.

2. Overfitting

Overvåk valideringsmetrikker for å forhindre overfitting. Bruk teknikker som tidlig stopp og vektforfall.

3. Langsom trening

Optimer treningshastighet ved å justere batch-størrelse, læringsrate og bruk av gradient-akkumulasjonssteg.

4. Datakvalitet

Sikker deg at datasettet ditt er rent og godt forbehandlet. Dårlig datakvalitet kan ha en betydelig innvirkning på modellens ytelse.

Konklusjon

Finjustering av LLM med QLoRA er en effektiv måte å tilpasse store forhåndstrente modeller til spesifikke oppgaver med reduserte beregningskostnader. Ved å følge denne guiden, kan du finjustere PHI, Llama 3 eller andre åpne kildekodemodeller for å oppnå høy ytelse på dine spesifikke oppgaver.