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

Fine-tunen van grote taalmodellen (LLM’s) zoals Llama 3 houdt in dat een voorgetraind model wordt aangepast aan specifieke taken met behulp van een domeinspecifieke dataset. Dit proces maakt gebruik van de reeds bestaande kennis van het model, waardoor het efficiënt en kosteneffectief 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 de geheugengebruik en rekenkundige kosten minimaliseert.

Overzicht van fine-tunen

Fine-tunen omvat verschillende belangrijke stappen:

1. Selectie van een voorgetraind 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-tunen van grote taalmodellen

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 rekenkundige middelen en is vaak onpraktisch voor zeer grote modellen.

Parameter-efficiënt fine-tunen (PEFT)

PEFT werkt alleen een subset van de parameters van het model bij, waardoor de geheugengebruik en rekenkundige kosten worden verlaagd. Deze techniek voorkomt catastrofale vergetelheid en behoudt de algemene kennis van het model.

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

LoRA fine-tunt alleen een paar lage-rangmatrices, terwijl QLoRA deze matrices kwantiseert om de geheugengebruik verder te verlagen.

Fine-tunen methoden

1. Volledig fine-tunen: Dit omvat het trainen van alle parameters van het model op de taakspecifieke dataset. Hoewel deze methode zeer effectief kan zijn, is het ook rekenkundig duur en vereist aanzienlijke geheugengebruik.
2. Parameter-efficiënt fine-tunen (PEFT): PEFT werkt alleen een subset van de parameters van het model bij, waardoor de geheugengebruik wordt verlaagd. Technieken zoals Low-Rank Adaptation (LoRA) en Quantized LoRA (QLoRA) vallen onder deze categorie.

Wat is LoRA?

Vergelijking van fine-tunen methoden: QLORA verbetert LoRA met 4-bit precisie kwantiseren en paginagereedschappen voor geheugenspikebeheer

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

Sleutelvoordelen van LoRA:

• Geheugenefficiëntie: LoRA verlaagt de geheugengebruik 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 met het, waardoor het mogelijk is om meerdere taken te verwerken met lagere geheugengebruik.

Wat is Quantized LoRA (QLoRA)?

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

Sleutelvoordelen van QLoRA:

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

Taakspecifieke adaptatie

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

Fine-tunen in de praktijk

Volledig fine-tunen vs. PEFT

• Volledig fine-tunen: Omvat het trainen van het hele model, wat rekenkundig duur kan zijn en aanzienlijke geheugengebruik vereist.
• PEFT (LoRA en QLoRA): Fine-tunt alleen een subset van parameters, waardoor de geheugengebruik wordt verlaagd en catastrofale vergetelheid wordt voorkomen, waardoor het een efficiëntere alternatief is.

Implementatiestappen

1. Omgevingsinstelling: Installeer de benodigde bibliotheken en stel de rekenomgeving in.
2. Laden en voorverwerken van de dataset: Laad de dataset en verwerk deze in een formaat dat geschikt is voor het model.
3. Laden van het voorgetrainde 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 behulp van 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

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

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

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 voorgetrainde 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 tokenizer:

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 dit te doen voor verschillende modellen, waaronder Llama 3, GPT-3 en Mistral.

5.1 Gebruik van Llama 3

Modelselectie:

• Zorg ervoor dat u de correcte modelidentifier van de Hugging Face-modelhub heeft. 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.

Tokenisatie:

• Gebruik de juiste tokenizer voor Llama 3, zorg ervoor dat deze compatibel is met het model en ondersteuning biedt voor vereiste functies zoals padding en speciale tokens.

Geheugen en rekenen:

• Fine-tunen van grote modellen zoals Llama 3 vereist aanzienlijke rekenkundige middelen. Zorg ervoor dat uw omgeving, zoals een krachtige GPU-opstelling, de geheugengebruik en rekenkundige vereisten aankan.

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
)

5.2 Gebruik van andere populaire modellen (bijv. GPT-3, Mistral)

Modelselectie:

• Gebruik de correcte modelnaam en identifier van de Hugging Face-modelhub of andere bronnen voor modellen zoals GPT-3 en Mistral.

Tokenisatie:

• Zorg ervoor dat de tokenizer correct is ingesteld en compatibel is met het model.

Geheugen en rekenen:

• Elk model kan andere geheugengebruik vereisen. 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
)

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. Voorverwerking van de dataset

Converteer dialoog-samenvattingen naar 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 geformatteerde 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)

Hyperparameters en hun impact

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: Bepaalt 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 garandeert 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 geheugengebruik. 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 keer dat de gehele dataset door het model wordt verwerkt. Meer epochs kunnen de prestaties verbeteren, maar kunnen ook leiden tot overfitting als dit niet goed wordt 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.

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

Evaluatie van 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. Geheugengebruik

Het gebruik van QLoRA helpt om geheugengebruik te verminderen door modelgewichten te kwantiseren naar 4-bit. Zorg ervoor dat u voldoende GPU-geheugengebruik heeft om uw batch grootte en modelgrootte aan te kunnen.

2. Overfitting

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

3. Trage training

Optimaliseer de trainingsnelheid door de batch grootte, leer tempo en gradient accumulatie aan te passen.

4. Gegevenskwaliteit

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

Conclusie

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