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åndstrening modell til bestemte oppgaver ved hjelp av en domenespesifikk datasett. Denne prosessen utnytter modellens eksisterende kunnskap, noe som gjør det effektivt og kostnadseffektivt 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åndstrening modell: Velg en basismodell som stemmer overens med din ønskede arkitektur.
2. Samling av en relevant datasett: Samle og forbehandle en datasett som er spesifikk for din oppgave.
3. Finjustering: Tilpass modellen ved hjelp av datasettet for å forbedre dens ytelse på bestemte oppgaver.
4. Evaluering: Vurdér den finjusterte modellens ytelse ved hjelp av både kvalitative og kvantitative metrikker.

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 minnekrav og beregningskostnader. Denne teknikken forhindrer katastrofalt glemsel og opprettholder modellens generelle kunnskap.

Lav-ranks tilpasning (LoRA) og Quantized LoRA (QLoRA)

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

Finjusteringsmetoder

1. Full finjustering: Dette innebærer å trene hele modellen på den oppgavesspesifikke datasetten. Selv om denne metoden kan være svært effektiv, er den også beregningskostbar og krever betydelige minne.
2. Parameter-effektiv finjustering (PEFT): PEFT oppdaterer bare en undergruppe av modellens parametre, noe som gjør den mer minneeffektiv. Teknikker som Lav-ranks tilpasning (LoRA) og Quantized LoRA (QLoRA) faller inn under denne kategorien.

Hva er LoRA?

Sammenligning av finjusteringsmetoder: QLORA forbedrer LoRA med 4-bits presisjons kvantifisering og paged optimizers for minnehåndtering

LoRA er en forbedret finjusteringsmetode der, i stedet for å finjustere alle vekter i den forhåndstrede 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åndstrede modellen og brukes til inferens.

Nøkelfordeler 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 å kvantifisere 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 sammenlignbar nivå av effektivitet.

Nøkelfordeler med QLoRA:

• Enda større minneeffektivitet: Ved å kvantifisere vekter, reduserer QLoRA modellens minne- og lagringskrav betydelig.
• Opprettholder ytelse: Til tross for den reduserte presisjon, opprettholder QLoRA ytelsesnivåer nær full-presisjonsmodeller.

Oppgavesspesifikk tilpasning

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

Finjustering i praksis

Full finjustering vs. PEFT

• Full finjustering: Dette innebærer å trene hele modellen, noe som kan være beregningskostbart og krever betydelige minne.
• PEFT (LoRA og QLoRA): PEFT finjusterer bare en undergruppe av parametre, noe som gjør den mer minneeffektiv. Teknikker som Lav-ranks tilpasning (LoRA) og Quantized LoRA (QLoRA) faller inn under denne kategorien.

Implementeringssteg

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

Steg-for-steg guide til finjustering av LLM

Oppsett av miljø

Vi vil bruke en Jupyter-notebook for denne guiden. 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, sikre at du har installert de nødvendige bibliotekene:

!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-datasett for denne guiden:

Forbehandle datasett i henhold til modellens krav, inkludert å bruke egnet mal og sikre at dataformatet er egnet for finjustering​ (Hugging Face)​​ (DataCamp)​.

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

Inspeker datasettstrukturen:

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

4. Opprett BitsAndBytes-konfigurasjon

For å laste 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åndstrening modell

Bruker Microsofts Phi-2-modell for denne 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

Konfigurer tokenisering:

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 bestemte overveielser og justeringer som kreves for å sikre optimal ytelse. Her er detaljerte steg og innsikt i hvordan du kan finjustere PHI, Llama 3 eller andre modeller for å oppnå høy ytelse på dine spesifikke oppgaver.

5.1 Bruk av Llama 3

Modellvalg:

• Sikre at du har den riktige modellidentifikatoren fra Hugging Face-modellhub. For eksempel kan Llama 3-modellen identifiseres som meta-llama/Meta-Llama-3-8B på Hugging Face.
• Sikre at du har tilgang og logger inn på din Hugging Face-konto hvis det er nødvendig for modeller som Llama 3​ (Hugging Face)​​

Tokenisering:

• Bruke den riktige tokenisering for Llama 3, og sikre 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 betydelige beregningsressurser. Sikre at din miljø, som en kraftig GPU-oppssett, kan håndtere minne- og beregningskravene. Sikre at miljøet kan håndtere minnekravene, som kan mildnes ved å bruke teknikker som QLoRA for å redusere minneavtrykket​ (Hugging Face Forums)

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
)

Tokenisering:

Avhengig av den spesifikke bruksområdet og modellkravene, sikre riktig tokenisering konfigurasjon uten unødvendige innstillinger. For eksempel, use_fast=True anbefales for bedre ytelse​ (Hugging Face)​​ (Weights & Biases)​.

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 Bruk av andre populære modeller (f.eks. GPT-3, Mistral)

Modellvalg:

• For modeller som GPT-3 og Mistral, sikre at du bruker den riktige modellnavnet og identifikatoren fra Hugging Face-modellhub eller andre kilder.

Tokenisering:

• Lignende med Llama 3, sikre at tokeniseringen er riktig konfigurert og kompatibel med modellen.

Minne og beregning:

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

Eksempel for 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
)

Eksempel for 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
)

Tokeniseringsoverveielser: Hver modell kan ha unike tokeniseringkrav. Sikre at tokeniseringen matcher modellen og er riktig konfigurert.

Llama 3 Tokenisering Eksempel:

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 og Mistral Tokenisering Eksempel:

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

7. Test modellen med nullskuddsinferens

Evaluér basismodellen med et eksempel innlegg:

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 utgang
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'INNPROMPT:\n{formatted_prompt}')
print(f'MODELGENERERING - NULLSKUDDSINFERENS:\n{output}')

8. Forbehandling av datasett

Konverter dialog-summar par til innlegg:

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)

Forbered modellen for parameter-effektiv finjustering:

original_model = prepare_model_for_kbit_training(original_model)

Hyperparametere spiller en avgjørende rolle i å optimalisere modellens ytelse. Her er noen nøkkelhyperparametere å overveie:

1. Læringshastighet: Kontrollerer hvor raskt modellen oppdaterer sine parametre. En høy læringshastighet kan føre til raskere konvergens, men kan også overskygge den optimale løsningen. En lav læringshastighet sikrer stabil konvergens, men kan kreve flere epoker.
2. Batchstørrelse: Antall eksempler som prosesseres før modellen oppdaterer sine parametre. Større batchstørrelser kan forbedre stabiliteten, men krever mer minne. Mindre batchstørrelser kan føre til mer støy i treningprosessen.
3. Gradientakkumuleringssteg: Dette parameteret hjelper med å simulere større batchstørrelser ved å akkumulere gradienter over flere steg før en parameteroppdatering utføres.
4. Antall epoker: Antall ganger hele datasett prosesseres gjennom modellen. Flere epoker kan forbedre ytelsen, men kan også føre til overfitting hvis det ikke håndteres riktig.
5. Vektforfall: En reguleringsteknikk for å forhindre overfitting ved å straffe store vekter.
6. Læringshastighedsskalerer: Justerer læringshastigheten under trening for å forbedre ytelsen og konvergens.

Tilpass treningkonfigurasjonen ved å justere hyperparametere som læringshastighet, batchstørrelse og gradientakkumuleringssteg basert på den spesifikke modellen og oppgavens krav. For eksempel kan Llama 3-modeller kreve forskjellige læringshastigheter sammenlignet med mindre modeller​ (Weights & Biases)​​ (GitHub)​

Eksempel på treningkonfigurasjon

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

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

Evaluering av den finjusterte modellen

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

1. Menneskelig evaluering

Sammenlign de genererte summariene med menneskeskrevne for å vurdere kvaliteten.

2. Kvantitativ evaluering

Bruk metrikker 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 å mildne minneproblemer ved å kvantifisere modellvekter til 4-bits. Sikre at du har nok GPU-minne til å håndtere batchstø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 batchstørrelse, læringshastighet og bruke gradientakkumuleringssteg.

4. Datakvalitet

Sikre at datasett er rent og godt forbehandlet. Dårlig datakvalitet kan påvirke modellens ytelse betydelig.

Konklusjon

Finjustering av store språkmodeller ved hjelp av QLoRA er en effektiv måte å tilpasse store forhåndstrede modeller til bestemte 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.