Singurul Ghid de Care Aveți Nevoie pentru a Ajusta Llama 3 sau orice Alt Model Deschis

Ajustarea modelelor de limbaj mari (LLM) precum Llama 3 implică adaptarea unui model pre-antrenat la sarcini specifice utilizând un set de date specific domeniului. Acest proces utilizează cunoștințele pre-existente ale modelului, făcându-l eficient și rentabil din punct de vedere al costurilor, comparativ cu antrenarea de la zero. În acest ghid, vom parcurge pașii pentru a ajusta Llama 3 utilizând QLoRA (Quantized LoRA), o metodă eficientă din punct de vedere al parametrilor care minimizează utilizarea memoriei și costurile computaționale.

Prezentare Generală a Ajustării

Ajustarea implică mai multe pași cheie:

1. Alegerea unui Model Pre-antrenat: Alegeți un model de bază care se aliniază cu arhitectura dorită.
2. Colectarea unui Set de Date Relevant: Colectați și preprocesați un set de date specific sarcinii.
3. Ajustare: Adaptați modelul utilizând setul de date pentru a îmbunătăți performanța sa la sarcini specifice.
4. Evaluare: Evaluați modelul ajustat utilizând atât metrice calitative, cât și cantitative.

Concepte și Tehnici

Ajustarea Modelelor de Limbaj Mari

Ajustare Completa

Ajustarea completă actualizează toți parametrii modelului, făcându-l specific noii sarcini. Această metodă necesită resurse computaționale semnificative și este adesea impracticabilă pentru modele foarte mari.

Ajustare Eficientă din Punct de Vedere al Parametrilor (PEFT)

PEFT actualizează doar o submulțime a parametrilor modelului, reducând cerințele de memorie și costurile computaționale. Această tehnică previne uitarea catastrofală și menține cunoștințele generale ale modelului.

Ajustare de Rang Scăzut (LoRA) și QLoRA

LoRA ajustează doar câteva matrice de rang scăzut, în timp ce QLoRA cuantifică aceste matrice pentru a reduce și mai mult amprenta de memorie.

Metode de Ajustare

1. Ajustare Completă: Aceasta implică antrenarea tuturor parametrilor modelului pe setul de date specific sarcinii. Deși această metodă poate fi foarte eficientă, este și computațional scumpă și necesită multă memorie.
2. Ajustare Eficientă din Punct de Vedere al Parametrilor (PEFT): PEFT actualizează doar o submulțime a parametrilor modelului, făcându-l mai eficient din punct de vedere al memoriei. Tehnici precum LoRA și QLoRA fac parte din această categorie.

Ce este LoRA?

Compararea Metodelor de Ajustare: QLORA Îmbunătățește LoRA cu Cuantificare de 4 Biți și Optimizatori Paginați pentru Managementul Vârfurilor de Memorire

LoRA este o metodă îmbunătățită de ajustare în care, în loc de a ajusta toți parametrii modelului pre-antrenat, se ajustează două matrice mai mici care aproximează matricea mai mare. Aceste matrice constituie adaptorul LoRA. Acest adaptor ajustat este încărcat apoi în modelul pre-antrenat și utilizat pentru inferență.

Avantajele Cheie ale LoRA:

• Eficiență din Punct de Vedere al Memoriei: LoRA reduce amprenta de memorie ajustând doar matrice mici în loc de întregul model.
• Reutilizare: Modelul original rămâne nemodificat, și multiple adaptoare LoRA pot fi utilizate cu el, facilitând gestionarea mai multor sarcini cu cerințe de memorie mai scăzute.

Ce este QLoRA?

QLoRA duce LoRA mai departe prin cuantificarea greutăților adaptoarelor LoRA la o precizie mai scăzută (de exemplu, 4 biți în loc de 8 biți). Acest lucru reduce și mai mult utilizarea memoriei și cerințele de stocare, menținând în același timp un nivel comparabil de eficiență.

Avantajele Cheie ale QLoRA:

• Eficiență și Mai Mare din Punct de Vedere al Memoriei: Prin cuantificarea greutăților, QLoRA reduce semnificativ cerințele de memorie și stocare ale modelului.
• Menține Performanța: În ciuda preciziei reduse, QLoRA menține niveluri de performanță apropiate de cele ale modelelor cu precizie completă.

Ajustare Specifică Sarcinii

În timpul ajustării, parametrii modelului sunt ajustați pe baza noului set de date, ajutându-l să înțeleagă și să genereze conținut relevant pentru sarcina specifică. Acest proces păstrează cunoștințele generale de limbaj dobândite în timpul pre-antrenării, în timp ce se adaptează modelul la nuanțele domeniului țintă.

Ajustare în Practică

Ajustare Completă vs. PEFT

• Ajustare Completă: Implică antrenarea întregului model, ceea ce poate fi costisitor din punct de vedere computațional și necesită multă memorie.
• PEFT (LoRA și QLoRA): Ajustează doar o submulțime a parametrilor, reducând cerințele de memorie și prevenind uitarea catastrofală, făcându-l o alternativă mai eficientă.

Pașii de Implementare

1. Configurarea Mediului: Instalați bibliotecile necesare și configurați mediul de calcul.
2. Încărcarea și Preprocesarea Setului de Date: Încărcați setul de date și preprocesați-l într-un format potrivit pentru model.
3. Încărcarea Modelului Pre-antrenat: Încărcați modelul de bază cu configurări de cuantificare dacă se utilizează QLoRA.
4. Tokenizare: Tokenizați setul de date pentru a-l pregăti pentru antrenare.
5. Antrenare: Ajustați modelul utilizând setul de date pregătit.
6. Evaluare: Evaluați performanța modelului pe sarcini specifice utilizând metrice calitative și cantitative.

Ghid Pas cu Pas pentru Ajustarea LLM

Configurarea Mediului

Vom utiliza un notebook Jupyter pentru acest tutorial. Platforme precum Kaggle, care oferă utilizare gratuită de GPU, sau Google Colab sunt ideale pentru rularea acestor experimente.

1. Instalarea Bibliotecilor Necessare

Mai întâi, asigurați-vă că aveți instalate bibliotecile necesare:

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

2. Importarea Bibliotecilor și Configurarea Mediului

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

# Dezactivați logarea Weights and Biases
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. Încărcarea Setului de Date

Vom utiliza setul de date DialogSum pentru acest tutorial:
Preprocesați setul de date conform cerințelor modelului, inclusiv aplicarea șablonului adecvat și asigurarea formatului de date potrivit pentru ajustare​ (Hugging Face)​​ (DataCamp)​.

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

Inspectați structura setului de date:

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

4. Crearea Configurației BitsAndBytes

Pentru a încărca modelul în format de 4 biți:

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. Încărcarea Modelului Pre-antrenat

Utilizând modelul Phi-2 de la Microsoft (MSFT ) pentru acest tutorial:

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. Tokenizare

Configurați tokenizatorul:

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

Ajustarea Llama 3 sau a Altui Model

Atunci când ajustați modele precum Llama 3 sau orice alt model deschis de ultimă generație, există considerații și ajustări specifice necesare pentru a asigura o performanță optimă. Iată pașii detaliați și insight-uri despre cum să abordați acest lucru pentru diferite modele, inclusiv Llama 3, GPT-3 și Mistral.

5.1 Utilizarea Llama 3

Alegerea Modelului:

• Asigurați-vă că aveți identificatorul corect al modelului din hub-ul de modele Hugging Face. De exemplu, modelul Llama 3 ar putea fi identificat ca meta-llama/Meta-Llama-3-8B pe Hugging Face.
• Asigurați-vă că solicitați acces și vă autentificați în contul dvs. Hugging Face, dacă este necesar, pentru modele precum Llama 3​ (Hugging Face)​​

Tokenizare:

• Utilizați tokenizatorul adecvat pentru Llama 3, asigurându-vă că este compatibil cu modelul și suportă funcții necesare precum padding și tokeni speciali.

Memorie și Calcul:

• Ajustarea modelelor mari precum Llama 3 necesită resurse computaționale semnificative. Asigurați-vă că mediul dvs., cum ar fi o configurație puternică de GPU, poate gestiona cerințele de memorie și procesare. Asigurați-vă că mediul poate gestiona cerințele de memorie, care pot fi atenuate prin utilizarea tehnicilor precum QLoRA pentru a reduce amprenta de memorie​ (Hugging Face Forums)

Exemplu:

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
)

Tokenizare:

În funcție de cazul de utilizare specific și cerințele modelului, asigurați-vă că configurația tokenizatorului este corectă și fără setări redundante. De exemplu, use_fast=True este recomandat pentru o performanță mai bună​ (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 Utilizarea Altui Model Popular (de exemplu, GPT-3, Mistral)

Alegerea Modelului:

• Pentru modele precum GPT-3 și Mistral, asigurați-vă că utilizați numele și identificatorul corect al modelului din hub-ul de modele Hugging Face sau din alte surse.

Tokenizare:

• Similar cu Llama 3, asigurați-vă că tokenizatorul este configurat corect și compatibil cu modelul.

Memorie și Calcul:

• Fiecare model poate avea cerințe de memorie diferite. Ajustați configurația mediului dvs. în consecință.

Exemplu pentru 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
)

Exemplu pentru 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
)

Considerații de Tokenizare: Fiecare model poate avea cerințe unice de tokenizare. Asigurați-vă că tokenizatorul se potrivește modelului și este configurat corect.

Exemplu de Tokenizator pentru Llama 3:

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

Exemplu de Tokenizator pentru GPT-3 și Mistral:

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

7. Testarea Modelului cu Inferență Zero-Shot

Evaluati modelul de bază cu un input de test:

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"

# Generați 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. Preprocesarea Setului de Date

Conversia perechilor de dialog și rezumat în prompturi:

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)

Tokenizați setul de date formatat:

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. Pregătirea Modelului pentru QLoRA

Pregătiți modelul pentru ajustarea eficientă din punct de vedere al parametrilor:

original_model = prepare_model_for_kbit_training(original_model)

Hyperparametrii joacă un rol crucial în optimizarea performanței modelului. Iată câțiva hyperparametri cheie de luat în considerare:

1. Rata de Învățare: Controlează viteza cu care modelul își actualizează parametrii. O rată de învățare ridicată poate duce la o convergență mai rapidă, dar poate sări peste soluția optimă. O rată de învățare scăzută asigură o convergență stabilă, dar poate necesita mai multe epoci.
2. Dimensiunea Lotului: Numărul de exemple procesate înainte ca modelul să-și actualizeze parametrii. Dimensiuni mai mari de lot pot îmbunătăți stabilitatea, dar necesită mai multă memorie. Dimensiuni mai mici de lot pot duce la mai mult zgomot în procesul de antrenare.
3. Pașii de Accumulare a Gradientului: Acest parametru ajută la simularea unor dimensiuni mai mari de lot prin acumularea gradientelor pe mai multe pași înainte de a efectua o actualizare a parametrilor.
4. Numărul de Epoci: Numărul de ori în care întregul set de date este procesat de model. Mai multe epoci pot îmbunătăți performanța, dar pot duce la supranivelare dacă nu sunt gestionate corespunzător.
5. Decaderea Greutăților: Tehnică de regularizare pentru a preveni supranivelarea, penalizând greutăți mari.
6. Planificatorul Ratei de Învățare: Ajustează rata de învățare în timpul antrenării pentru a îmbunătăți performanța și convergența.

Personalizați configurația de antrenare ajustând hyperparametri precum rata de învățare, dimensiunea lotului și pașii de acumulare a gradientului, în funcție de cerințele specifice ale modelului și sarcinii. De exemplu, modelele Llama 3 pot necesita rate de învățare diferite comparativ cu modelele mai mici​ (Weights & Biases)​​ (GitHub)​

Exemplu de Configurație de Antrenare

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. Antrenarea Modelului

Configurați antrenorul și începeți antrenarea:

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

Evaluarea Modelului Ajustat

După antrenare, evaluați performanța modelului utilizând atât metode calitative, cât și cantitative.

1. Evaluare Umană

Comparați rezumatul generat cu cel scris de om pentru a evalua calitatea.

2. Evaluare Cantitativă

Utilizați metrice precum ROUGE pentru a evalua performanța:

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)

Provocări Comune și Soluții

1. Limitări de Memorire

Utilizarea QLoRA ajută la mitigarea problemelor de memorie prin cuantificarea greutăților modelului la 4 biți. Asigurați-vă că aveți suficientă memorie GPU pentru a gestiona dimensiunea lotului și mărimea modelului.

2. Supranivelare

Monitorizați metricile de validare pentru a preveni supranivelarea. Utilizați tehnici precum oprirea timpurie și decaderea greutăților.

3. Antrenare Lentă

Optimizați viteza de antrenare ajustând dimensiunea lotului, rata de învățare și utilizând acumularea gradientului.

4. Calitatea Datelor

Asigurați-vă că setul de date este curat și bine preprocesat. Calitatea slabă a datelor poate afecta semnificativ performanța modelului.

Concluzie

Ajustarea modelelor de limbaj mari utilizând QLoRA este o modalitate eficientă de a adapta modele pre-antrenate la sarcini specifice cu costuri computaționale reduse. Urmand acest ghid, puteți ajusta PHI, Llama 3 sau orice alt model deschis pentru a obține performanțe ridicate pe sarcinile dvs. specifice.