Jediný průvodce, kterého potřebujete pro fine-tuning Llama 3 nebo jiného otevřeného modelu

Fine-tuning velkých jazykových modelů (LLM) jako Llama 3 zahrnuje přizpůsobení předem vyškoleného modelu specifickým úkolům pomocí doménově specifické datové sady. Tento proces využívá předem existující znalosti modelu, což ho činí efektivním a nákladově efektivní ve srovnání se školením od začátku. V tomto průvodci procházíme kroky pro fine-tuning Llama 3 pomocí QLoRA (Quantized LoRA), parametricky efektivní metody, která minimalizuje využití paměti a výpočetní náklady.

Přehled fine-tuningu

Fine-tuning zahrnuje několik klíčových kroků:

1. Výběr předem vyškoleného modelu: Vyberte základní model, který odpovídá vaší požadované architektuře.
2. Shromáždění relevantní datové sady: Shromážděte a předzpracujte datovou sadu specifickou pro váš úkol.
3. Fine-tuning: Přizpůsobte model pomocí datové sady pro zlepšení jeho výkonu na specifických úkolech.
4. Hodnocení: Ohodnoťte fine-tunovaný model pomocí kvalitativních a kvantitativních metrik.

Koncepty a techniky

Fine-tuning Large Language Models

Úplný fine-tuning

Úplný fine-tuning aktualizuje všechny parametry modelu,使ující ho specifickým pro nový úkol. Tato metoda vyžaduje významné výpočetní zdroje a je často nepraktická pro velmi velké modely.

Parametricky efektivní fine-tuning (PEFT)

PEFT aktualizuje pouze podmnožinu parametrů modelu, snižuje tak požadavky na paměť a výpočetní náklady. Tato technika brání katastrofickému zapomínání a zachovává obecné znalosti modelu.

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

LoRA fine-tune pouze několik low-rank matic, zatímco QLoRA kvantizuje tyto matice pro další snížení paměťového otisku.

Metody fine-tuningu

1. Úplný fine-tuning: Tento postup zahrnuje školení všech parametrů modelu na úkolově specifické datové sadě. Přestože tato metoda může být velmi efektivní, je také výpočetně nákladná a vyžaduje významné množství paměti.
2. Parametricky efektivní fine-tuning (PEFT): PEFT aktualizuje pouze podmnožinu parametrů modelu,使ující ho více paměťově efektivní. Techniky jako Low-Rank Adaptation (LoRA) a Quantized LoRA (QLoRA) spadají do této kategorie.

Co je LoRA?

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

LoRA je vylepšená metoda fine-tuningu, při které se místo fine-tuningu všech váh předem vyškoleného modelu fine-tunují pouze dvě menší matice, které aproximují větší matici. Tyto matice tvoří LoRA adaptér. Tento fine-tunovaný adaptér se pak načte do předem vyškoleného modelu a používá se pro inferenci.

Klíčové výhody LoRA:

• Paměťová efektivita: LoRA snižuje paměťový otisk fine-tunováním pouze malých matic místo celého modelu.
• Opakovatelnost: Původní model zůstává nezměněn a lze s ním použít více LoRA adaptérů, což usnadňuje zpracování více úkolů s nižšími paměťovými požadavky.

Co je Quantized LoRA (QLoRA)?

QLoRA dále rozvíjí LoRA tím, že kvantizuje váhy LoRA adaptérů na nižší přesnost (například 4-bit místo 8-bit). To dále snižuje požadavky na paměť a úložiště, zatímco zachovává srovnatelnou úroveň efektivity.

Klíčové výhody QLoRA:

• Ještě větší paměťová efektivita: Kvantizací váh QLoRA významně snižuje paměťové a úložné požadavky modelu.
• Zachování výkonu: Přes sníženou přesnost QLoRA zachovává úroveň výkonu blízkou plně přesným modelům.

Úkolově specifická adaptace

Během fine-tuningu se parametry modelu přizpůsobují nové datové sadě, což mu pomáhá lépe porozumět a generovat obsah relevantní pro specifický úkol. Tento proces zachovává obecné jazykové znalosti získané během předškolení, zatímco přizpůsobuje model nuancím cílové domény.

Fine-tuning v praxi

Úplný fine-tuning vs. PEFT

• Úplný fine-tuning: Zahrnuje školení celého modelu, což může být výpočetně nákladné a vyžaduje významné množství paměti.
• PEFT (LoRA a QLoRA): Fine-tune pouze podmnožinu parametrů, snižuje tak paměťové požadavky a brání katastrofickému zapomínání, což ho činí více efektivní alternativou.

Implementační kroky

1. Nastavení prostředí: Nainstalujte nezbytné knihovny a nastavte výpočetní prostředí.
2. Načtení a předzpracování datové sady: Načtěte datovou sadu a předzpracujte ji do formátu vhodného pro model.
3. Načtení předem vyškoleného modelu: Načtěte základní model s konfiguracemi kvantizace, pokud používáte QLoRA.
4. Tokenizace: Tokenizujte datovou sadu pro přípravu na školení.
5. Školení: Fine-tune model pomocí připravené datové sady.
6. Hodnocení: Ohodnoťte výkon modelu na specifických úkolech pomocí kvalitativních a kvantitativních metrik.

Krok za krokem průvodce fine-tunováním LLM

Nastavení prostředí

Použijeme Jupyter notebook pro tento tutoriál. Platformy jako Kaggle, které nabízejí bezplatné použití GPU, nebo Google Colab jsou ideální pro běh těchto experimentů.

1. Instalace požadovaných knihoven

Nejprve zajistěte, že máte nainstalované nezbytné knihovny:

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

2. Import knihoven a nastavení prostředí

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

# Zakázání Weights and Biases logging
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. Načtení datové sady

Použijeme datovou sadu DialogSum pro tento tutoriál:

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

4. Vytvoření konfigurace BitsAndBytes

Pro načtení modelu v 4-bit formátu:

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. Načtení předem vyškoleného modelu

Použijeme model Microsoftu Phi-2 pro tento tutoriál:

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

Konfigurace tokenizátoru:

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-tuning Llama 3 nebo jiných modelů

Při fine-tuningu modelů jako Llama 3 nebo jiných špičkových otevřených LLM je třeba vzít v úvahu specifické požadavky a úpravy pro zajištění optimálního výkonu. Zde jsou podrobné kroky a poznatky o tom, jak na to pro různé modely, včetně Llama 3, GPT-3 a Mistral.

5.1 Použití Llama 3

Výběr modelu:

• Zajistěte, že máte správný identifikátor modelu z Hugging Face model hub. Pro model Llama 3 to může být meta-llama/Meta-Llama-3-8B na Hugging Face.
• Zajistěte, že máte přístup a přihlášení k vašemu účtu Hugging Face, pokud je to vyžadováno pro modely jako Llama 3.

Tokenizace:

• Použijte příslušný tokenizátor pro Llama 3, zajistěte, že je kompatibilní s modelem a podporuje požadované funkce, jako je padding a speciální tokeny.

Paměť a výpočet:

• Fine-tuning velkých modelů jako Llama 3 vyžaduje významné výpočetní zdroje. Zajistěte, že vaše prostředí, jako je výkonná konfigurace GPU, může zvládnout paměťové a výpočetní požadavky.

5.2 Použití jiných populárních modelů (například GPT-3, Mistral)

Výběr modelu:

• Pro modely jako GPT-3 a Mistral zajistěte, že používáte správný název a identifikátor modelu z Hugging Face model hub nebo jiných zdrojů.

Tokenizace:

• Podobně jako u Llama 3 zajistěte, že tokenizátor je správně nastaven a kompatibilní s modelem.

Paměť a výpočet:

• Každý model může mít odlišné paměťové požadavky. Přizpůsobte své prostředí podle toho.

7. Testování modelu s zero-shot inferencí

Ohodnoťte základní model se vzorkem vstupu:

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"

# Generujte výstup
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. Předzpracování datové sady

Převeďte dialog-sumářové páry na vstupní formáty:

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)

Tokenizujte formátovanou datovou sadu:

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)

Hyperparametry a jejich dopad

Hyperparametry hrají zásadní roli při optimalizaci výkonu modelu. Zde jsou einige klíčové hyperparametry, které je třeba zvážit:

1. Learning Rate: Řídí rychlost, s níž model aktualizuje své parametry. Vysoká learning rate může vést k rychlejší konvergenci, ale může také přeskočit optimální řešení. Nízká learning rate zajišťuje stabilní konvergenci, ale může vyžadovat více epoch.
2. Batch Size: Počet vzorků zpracovaných před aktualizací parametrů modelu. Larger batch sizes mohou zlepšit stabilitu, ale vyžadují více paměti. Menší batch sizes mohou vést k více šumu ve školicím procesu.
3. Gradient Accumulation Steps: Tento parametr pomáhá simulovat větší batch sizes akumulací gradientů přes více kroků před provedením aktualizace parametrů.
4. Number of Epochs: Početkrát, kolikrát je celá datová sada proškolena modelem. Více epoch může zlepšit výkon, ale může také vést k přeučení, pokud není správně řízeno.
5. Weight Decay: Regulační technika, která brání přeučení tím, že penalizuje velké váhy.
6. Learning Rate Scheduler: Přizpůsobuje learning rate během školení pro zlepšení výkonu a konvergence.

Příklad školicí konfigurace

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. Školení modelu

Nastavte trenéra a spusťte školení:

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

Hodnocení fine-tunovaného modelu

Po školení ohodnoťte výkon modelu pomocí kvalitativních a kvantitativních metod.

1. Lidské hodnocení

Srovnайте vygenerované sumáře s lidsky psanými, aby ohodnotili kvalitu.

2. Kvantitativní hodnocení

Použijte metriky jako ROUGE pro ohodnocení výkonu:

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)

Časté problémy a řešení

1. Omezení paměti

Použití QLoRA pomáhá zmírnit paměťové problémy kvantizací modelových váh na 4-bit. Zajistěte, že máte dostatečnou paměť GPU pro zvládnutí vaší batch size a velikosti modelu.

2. Přeučení

Sledujte validační metriky, aby se předešlo přeučení. Použijte techniky jako early stopping a weight decay.

3. Pomalé školení

Optimalizujte rychlost školení úpravou batch size, learning rate a použitím gradient accumulation.

4. Kvalita dat

Zajistěte, že vaše datová sada je čistá a dobře předzpracovaná. Špatná kvalita dat může významně ovlivnit výkon modelu.

Závěr

Fine-tuning LLM pomocí QLoRA je efektivní způsob, jak přizpůsobit velké předem vyškolené modely specifickým úkolům s redukovanými výpočetními náklady. Sledováním tohoto průvodce můžete fine-tunovat PHI, Llama 3 nebo jakýkoli jiný otevřený model pro dosažení vysokého výkonu na svých specifických úkolech.