De enige gids die u nodig heeft om Llama 3 of een andere open-source model te fine-tunen

Het fine-tunen van grote taalmodellen (LLM’s) zoals Llama 3 omvat het aanpassen van een vooraf getraind model aan specifieke taken met behulp van een domeinspecifieke dataset. Dit proces maakt gebruik van de reeds bestaande kennis van het model, waardoor het efficiënter en kostenefficiënter is in vergelijking met het trainen vanaf scratch. In deze gids zullen we de stappen doorlopen om Llama 3 te fine-tunen met behulp van QLoRA (Quantized LoRA), een parameter-efficiënte methode die het geheugenverbruik en de berekeningskosten minimaliseert.

Overzicht van fine-tunen

Fine-tunen omvat verschillende belangrijke stappen:

1. Selectie van een vooraf getraind model: Kies een basismodel dat overeenkomt met uw gewenste architectuur.
2. Verzameling van een relevante dataset: Verzamel en verwerk een dataset die specifiek is voor uw taak.
3. Fine-tunen: Pas het model aan met behulp van de dataset om de prestaties op specifieke taken te verbeteren.
4. Evaluatie: Beoordeel de prestaties van het fine-getune model met behulp van zowel kwalitatieve als kwantitatieve metrieken.

Concepten en technieken

Fine-tuning Large Language Models

Volledig fine-tunen

Volledig fine-tunen werkt alle parameters van het model bij, waardoor het specifiek wordt voor de nieuwe taak. Deze methode vereist aanzienlijke berekeningsbronnen en is vaak niet praktisch voor zeer grote modellen.

Parameter-efficiënt fine-tunen (PEFT)

PEFT werkt alleen een deel van de parameters van het model bij, waardoor het geheugenverbruik en de berekeningskosten worden verlaagd. Deze techniek voorkomt catastrofale vergetelheid en behoudt de algemene kennis van het model.

Lage-rang-aanpassing (LoRA) en Quantized LoRA (QLoRA)

LoRA fine-tuned alleen een paar lage-rang-matrices, terwijl QLoRA deze matrices kwantiseert om het geheugenverbruik verder te verlagen.

Fine-tunen methoden

1. Volledig fine-tunen: Dit omvat het trainen van alle parameters van het model op de taak-specifieke dataset. Hoewel deze methode zeer effectief kan zijn, is het ook berekeningsintensief en vereist aanzienlijk geheugen.
2. Parameter-efficiënt fine-tunen (PEFT): PEFT werkt alleen een deel van de parameters van het model bij, waardoor het geheugenverbruik wordt verlaagd. Technieken zoals LoRA en QLoRA vallen in deze categorie.

Wat is LoRA?

Comparing finetuning methods: QLORA enhances LoRA with 4-bit precision quantization and paged optimizers for memory spike management

LoRA is een verbeterde fine-tunen methode waarbij, in plaats van het fine-tunen van alle gewichten van het vooraf getrainde model, twee kleinere matrices die de grotere matrix benaderen, worden fine-getuned. Deze matrices vormen de LoRA-adapter. Deze fine-getune adapter wordt vervolgens geladen in het vooraf getrainde model en gebruikt voor inferentie.

Sleutelvoordelen van LoRA:

• Geheugenefficiëntie: LoRA verlaagt het geheugenverbruik door alleen kleine matrices te fine-tunen in plaats van het hele model.
• Herbruikbaarheid: Het oorspronkelijke model blijft ongewijzigd en meerdere LoRA-adapters kunnen worden gebruikt, waardoor het afhandelen van meerdere taken met lagere geheugeneisen wordt vergemakkelijkt.

Wat is Quantized LoRA (QLoRA)?

QLoRA gaat een stap verder met LoRA door de gewichten van de LoRA-adapters te kwantiseren naar een lagere precisie (bijv. 4-bit in plaats van 8-bit). Dit verlaagt het geheugenverbruik en de opslagvereisten verder, terwijl het een vergelijkbaar niveau van effectiviteit behoudt.

Sleutelvoordelen van QLoRA:

• Nog grotere geheugenefficiëntie: Door de gewichten te kwantiseren, verlaagt QLoRA het geheugenverbruik en de opslagvereisten van het model aanzienlijk.
• Behoudt prestaties: Ondanks de verlaagde precisie, behoudt QLoRA prestatieniveaus die dicht bij die van volledig precisie-modellen liggen.

Taak-specifieke aanpassing

Tijdens het fine-tunen worden de parameters van het model aangepast op basis van de nieuwe dataset, waardoor het model beter begrijpt en inhoud genereert die relevant is voor de specifieke taak. Dit proces behoudt de algemene taalkennis die tijdens de voorafgaande training is verkregen, terwijl het model wordt aangepast aan de nuances van het doeldomein.

Fine-tunen in de praktijk

Volledig fine-tunen vs. PEFT

• Volledig fine-tunen: Dit omvat het trainen van het hele model, wat berekeningsintensief kan zijn en aanzienlijk geheugen vereist.
• PEFT (LoRA en QLoRA): PEFT werkt alleen een deel van de parameters van het model bij, waardoor het geheugenverbruik wordt verlaagd en catastrofale vergetelheid wordt voorkomen, waardoor het een efficiëntere optie wordt.

Implementatiestappen

1. Omgevingsinstellingen: Installeer de benodigde bibliotheken en stel de berekeningsomgeving in.
2. Laad en verwerk de dataset: Laad de dataset en verwerk deze in een formaat dat geschikt is voor het model.
3. Laad het vooraf getrainde model: Laad het basismodel met kwantiseringsconfiguraties als u QLoRA gebruikt.
4. Tokenisatie: Tokeniseer de dataset om deze voor te bereiden op training.
5. Training: Fine-tune het model met de voorbereide dataset.
6. Evaluatie: Beoordeel de prestaties van het model op specifieke taken met behulp van kwalitatieve en kwantitatieve metrieken.

Stap-voor-stap gids voor fine-tunen van LLM

Instellen van de omgeving

We zullen een Jupyter-notebook gebruiken voor deze tutorial. Platforms zoals Kaggle, die gratis GPU-gebruik bieden, of Google Colab zijn ideaal voor het uitvoeren van deze experimenten.

1. Installeer de benodigde bibliotheken

Zorg ervoor dat u de benodigde bibliotheken heeft geïnstalleerd:

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

2. Importeer bibliotheken en stel de omgeving in

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. Laad de dataset

We zullen de DialogSum-dataset gebruiken voor deze tutorial:

Verwerk de dataset volgens de vereisten van het model, inclusief het toepassen van geschikte sjablonen en het waarborgen dat de gegevensindeling geschikt is voor fine-tunen​ (Hugging Face)​​ (DataCamp)​.

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

Inspecteer de structuur van de dataset:

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

4. Maak een BitsAndBytes-configuratie

Om het model in 4-bit formaat te laden:

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. Laad het vooraf getrainde model

Met behulp van Microsoft’s Phi-2-model voor deze 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. Tokenisatie

Configureer de tokenisator:

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

Fine-tunen van Llama 3 of andere modellen

Bij het fine-tunen van modellen zoals Llama 3 of andere state-of-the-art open-source LLM’s, zijn er specifieke overwegingen en aanpassingen vereist om optimale prestaties te garanderen. Hier zijn de gedetailleerde stappen en inzichten over hoe u dit moet aanpakken voor verschillende modellen, inclusief Llama 3, GPT-3 en Mistral.

5.1 Gebruik van Llama 3

Modelselectie:

• Zorg ervoor dat u de correcte modelidentifier heeft van de Hugging Face-modelhub. Bijvoorbeeld, het Llama 3-model kan worden geïdentificeerd als meta-llama/Meta-Llama-3-8B op Hugging Face.
• Zorg ervoor dat u toegang aanvraagt en inlogt op uw Hugging Face-account als dat nodig is voor modellen zoals Llama 3​ (Hugging Face)​​

Tokenisatie:

• Gebruik de geschikte tokenisator voor Llama 3, waarbij u ervoor zorgt dat deze compatibel is met het model en de vereiste functies zoals padding en speciale tokens ondersteunt.

Geheugen en berekening:

• Het fine-tunen van grote modellen zoals Llama 3 vereist aanzienlijke berekeningsbronnen. Zorg ervoor dat uw omgeving, zoals een krachtige GPU-opstelling, de geheugen- en verwerkingsvereisten aankan. Zorg ervoor dat de omgeving de geheugeneisen kan verwerken, die kunnen worden verlaagd door technieken zoals QLoRA te gebruiken om het geheugenverbruik te verlagen​ (Hugging Face Forums)

Voorbeeld:

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
)

Tokenisatie:

Afhankelijk van de specifieke use case en modelvereisten, zorg ervoor dat de tokenisator correct is geconfigureerd zonder overbodige instellingen. Bijvoorbeeld, use_fast=True wordt aanbevolen voor betere prestaties​ (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 Gebruik van andere populaire modellen (bijv. GPT-3, Mistral)

Modelselectie:

• Voor modellen zoals GPT-3 en Mistral, zorg ervoor dat u de correcte modelnaam en -identifier gebruikt van de Hugging Face-modelhub of andere bronnen.

Tokenisatie:

• Soortgelijk aan Llama 3, zorg ervoor dat de tokenisator correct is geconfigureerd en compatibel is met het model.

Geheugen en berekening:

• Elk model kan verschillende geheugeneisen hebben. Pas uw omgevingsinstellingen dienovereenkomstig aan.

Voorbeeld voor 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
)

Voorbeeld voor 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
)

Tokenisatie-overwegingen: Elk model kan unieke tokenisatievereisten hebben. Zorg ervoor dat de tokenisator overeenkomt met het model en correct is geconfigureerd.

Voorbeeld van Llama 3-tokenisator:

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

Voorbeeld van GPT-3- en Mistral-tokenisator:

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

7. Test het model met zero-shot-inferencing

Evalueer het basismodel met een voorbeeldinput:

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"

# Genereer 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. Verwerk de dataset

Converteer gespreks-samenvattingen in prompts:

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)

Tokeniseer de geformateerde dataset:

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)

Bereid het model voor op parameter-efficiënt fine-tunen:

original_model = prepare_model_for_kbit_training(original_model)

Hyperparameters spelen een cruciale rol bij het optimaliseren van de prestaties van uw model. Hier zijn enkele belangrijke hyperparameters om te overwegen:

1. Leer tempo: Beheert de snelheid waarmee het model zijn parameters bijwerkt. Een hoog leer tempo kan leiden tot snellere convergentie, maar kan ook het optimale oplossing overschrijden. Een laag leer tempo zorgt voor stabiele convergentie, maar kan meer epochs vereisen.
2. Batch grootte: Het aantal samples dat wordt verwerkt voordat het model zijn parameters bijwerkt. Grotere batch groottes kunnen de stabiliteit verbeteren, maar vereisen meer geheugen. Kleine batch groottes kunnen leiden tot meer ruis in het trainingsproces.
3. Gradient accumulatie stappen: Deze parameter helpt bij het simuleren van grotere batch groottes door gradients te accumuleren over meerdere stappen voordat een parameter update wordt uitgevoerd.
4. Aantal epochs: Het aantal keren dat de gehele dataset door het model wordt verwerkt. Meer epochs kunnen de prestaties verbeteren, maar kunnen ook leiden tot overfitting als niet goed beheerd.
5. Gewichtsverval: Een regularisatietechniek om overfitting te voorkomen door grote gewichten te bestraffen.
6. Leer tempo planner: Past het leer tempo aan tijdens de training om de prestaties en convergentie te verbeteren.

Pas de trainingsconfiguratie aan door hyperparameters zoals leer tempo, batch grootte en gradient accumulatie stappen aan te passen op basis van de specifieke model- en taakvereisten. Bijvoorbeeld, Llama 3-modellen kunnen andere leer tempi vereisen in vergelijking met kleinere modellen​ (Weights & Biases)​​ (GitHub)​

Voorbeeld trainingsconfiguratie

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. Train het model

Stel de trainer in en start de training:

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

Evalueer het fine-getune model

Na de training, evalueer de prestaties van het model met behulp van zowel kwalitatieve als kwantitatieve methoden.

1. Menselijke evaluatie

Vergelijk de gegenereerde samenvattingen met door mensen geschreven samenvattingen om de kwaliteit te beoordelen.

2. Kwantitatieve evaluatie

Gebruik metrieken zoals ROUGE om de prestaties te beoordelen:

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)

Veelvoorkomende uitdagingen en oplossingen

1. Geheugengrenzen

Het gebruik van QLoRA helpt om geheugengrenzen te verlichten door modelgewichten te kwantiseren naar 4-bit. Zorg ervoor dat u voldoende GPU-geheugen heeft om uw batchgrootte en modelgrootte aan te kunnen.

2. Overfitting

Bewaak de validatiemetrieken om overfitting te voorkomen. Gebruik technieken zoals vroegtijdige stopzetting en gewichtsverval.

3. Trage training

Optimaliseer de trainingsnelheid door de batchgrootte, leer tempo en gradient accumulatie stappen aan te passen.

4. Gegevenskwaliteit

Zorg ervoor dat uw dataset schoon en goed verwerkt is. Slechte gegevenskwaliteit kan de prestaties van het model aanzienlijk beïnvloeden.

Conclusie

Het fine-tunen van LLM’s met QLoRA is een efficiënte manier om grote vooraf getrainde modellen aan te passen aan specifieke taken met verlaagde berekeningskosten. Door deze gids te volgen, kunt u Llama 3 of elk ander open-source model fine-tunen om hoge prestaties te bereiken op uw specifieke taken.