Umělá inteligence
Jediný průvodce, kterého potřebujete k jemnému ladění Llama 3 nebo jiného open-source modelu
Jemné ladění velkých jazykových modelů (LLM) jako Llama 3 zahrnuje přizpůsobení předem trénovaného modelu specifickým úlohám pomocí doménově specifické datové sady. Tento proces využívá předchozí znalosti modelu, což z něj činí efektivní a nákladově efektivní ve srovnání se školením od začátku. V tomto průvodci procházíme kroky pro jemné ladění Llama 3 pomocí QLoRA (Quantized LoRA), parametricky efektivní metody, která minimalizuje využití paměti a výpočetní náklady.
Přehled jemného ladění
Jemné ladění zahrnuje několik klíčových kroků:
- Výběr předem trénovaného modelu: Vyberte základní model, který odpovídá vaší požadované architektuře.
- Shromáždění relevantní datové sady: Shromážděte a předzpracujte datovou sadu specifickou pro vaši úlohu.
- Jemné ladění: Přizpůsobte model pomocí datové sady pro zlepšení jeho výkonu na specifických úlohách.
- Hodnocení: Ohodnoťte jemně laděný model pomocí kvalitativních a kvantitativních metrik.
Koncepty a techniky
Jemné ladění velkých jazykových modelů
Plné jemné ladění
Plné jemné ladění aktualizuje všechny parametry modelu, což jej činí specifickým pro novou úlohu. Tato metoda vyžaduje významné výpočetní zdroje a je často nepraktická pro velmi velké modely.
Parametricky efektivní jemné ladění (PEFT)
PEFT aktualizuje pouze podmnožinu parametrů modelu, což snižuje požadavky na paměť a výpočetní náklady. Tato technika zabraňuje katastrofickému zapomínání a zachovává obecné znalosti modelu.
Nízkorozměrová adaptace (LoRA) a kvantizovaná LoRA (QLoRA)
LoRA jemně ladí pouze několik nízkorozměrových matic, zatímco QLoRA kvantizuje tyto matice pro další snížení paměťové stopy.
Metody jemného ladění
- Plné jemné ladění: Toto zahrnuje školení celého modelu, což může být velmi efektivní, ale je také výpočetně nákladné a vyžaduje významné množství paměti.
- Parametricky efektivní jemné ladění (PEFT): PEFT aktualizuje pouze podmnožinu parametrů modelu, což z něj činí více paměťově efektivní. Techniky jako LoRA a QLoRA spadají do této kategorie.
Co je LoRA?
Porovnání metod jemného ladění: QLoRA vylepšuje LoRA pomocí 4bitové kvantizace a optimalizátorů pro správu paměťových špiček
LoRA je vylepšená metoda jemného ladění, kde místo jemného ladění všech váh modelu jsou jemně laděny dvě menší matice, které aproximují větší matici. Tyto matice tvoří LoRA adaptér. Tento jemně laděný adaptér je pak nahrán do předem trénovaného modelu a použit pro inferenci.
Klíčové výhody LoRA:
- Paměťová efektivita: LoRA snižuje paměťovou stopu jemným laděním pouze malých matic místo celého modelu.
- Opětovné použití: Původní model zůstává nezměněn a multiple LoRA adaptéry lze použít s ním, což usnadňuje zpracování více úloh s nižšími paměťovými požadavky.
Co je kvantizovaná LoRA (QLoRA)?
QLoRA jde dále než LoRA tím, že kvantizuje váhy LoRA adaptérů na nižší přesnost (například 4bit místo 8bit). To dále snižuje využití paměti a úložné požadavky, 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: Navzdory snížené přesnosti QLoRA zachovává výkonnost na úrovni plné přesnosti.
Úkolově specifická adaptace
Během jemného ladění jsou parametry modelu přizpůsobeny na základě nové datové sady, což mu pomáhá lépe porozumět a generovat obsah relevantní pro specifickou úlohu. Tento proces zachovává obecné jazykové znalosti získané během předchozího školení, zatímco přizpůsobuje model nuancím cílové domény.
Jemné ladění v praxi
Plné jemné ladění vs. PEFT
- Plné jemné ladění: 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): Jemně ladí pouze podmnožinu parametrů, což snižuje paměťové požadavky a zabraňuje katastrofickému zapomínání, což z něj činí více efektivní alternativu.
Implementační kroky
- Nastavení prostředí: Nainstalujte nezbytné knihovny a nastavte výpočetní prostředí.
- Načtení a předzpracování datové sady: Načtěte datovou sadu a předzpracujte ji do formátu vhodného pro model.
- Načtení předem trénovaného modelu: Načtěte základní model s konfiguracemi kvantizace, pokud používáte QLoRA.
- Tokenizace: Tokenizujte datovou sadu pro přípravu na školení.
- Školení: Jemně laděte model pomocí připravené datové sady.
- Hodnocení: Ohodnoťte výkon modelu na specifických úlohách pomocí kvalitativních a kvantitativních metrik.
Krok za krokem průvodce jemným laděním LLM
Nastavení prostředí
Budeme používat Jupyter notebook pro tuto tutoriál. Platformy jako Kaggle, které nabízejí bezplatné použití GPU, nebo Google Colab jsou ideální pro spouštění 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 # Zakažte Weights and Biases logging os.environ['WANDB_DISABLED'] = "true" interpreter_login()
3. Načtení datové sady
Budeme používat datovou sadu DialogSum pro tuto tutoriál:
Předzpracujte datovou sadu podle požadavků modelu, včetně aplikování vhodných šablon a zajištění formátu datové sady pro jemné ladění (Hugging Face) (DataCamp) .
dataset_name = "neil-code/dialogsum-test" dataset = load_dataset(dataset_name)
Prohlédněte si strukturu datové sady:
print(dataset['test'][0])
4. Vytvoření konfigurace BitsAndBytes
Pro načtení modelu v 4bitovém 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 trénovaného modelu
Používáme model Microsoftu Phi-2 pro tuto 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
Nakonfigurujte tokenizér:
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
Jemné ladění Llama 3 nebo jiného modelu
Při jemném ladění modelů jako Llama 3 nebo jiného špičkového open-source 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 přistupovat k tomu pro různé modely, včetně Llama 3, GPT-3 a Mistral.
5.1 Používání Llama 3
Výběr modelu:
- Zajistěte, že máte správný identifikátor modelu z Hugging Face model hub. Například model Llama 3 může být identifikován jako
meta-llama/Meta-Llama-3-8Bna 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 (Hugging Face) .
Tokenizace:
- Použijte vhodný tokenizér 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:
- Jemné ladění 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á GPU sestava, může zvládnout paměťové a výpočetní požadavky. Zajistěte, že prostředí může zvládnout paměťové požadavky, které lze zmírnit pomocí technik jako QLoRA pro snížení paměťové stopy (Hugging Face Forums) .
Příklad:
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
)
Tokenizace:
V závislosti na specifické úloze a požadavcích modelu zajistěte správnou konfiguraci tokenizéru bez redundantních nastavení. Například use_fast=True se doporučuje pro lepší výkon (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 Používání 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 modelu a identifikátor z Hugging Face model hub nebo jiných zdrojů.
Tokenizace:
- Podobně jako u Llama 3 zajistěte, že tokenizér 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.
Příklad pro 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
)
Příklad pro 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
)
Úvahy o tokenizaci: Každý model může mít specifické požadavky na tokenizaci. Zajistěte, že tokenizér odpovídá modelu a je správně nakonfigurován.
Příklad tokenizéru pro 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
Příklad tokenizéru pro GPT-3 a Mistral:
tokenizer = AutoTokenizer.from_pretrained( model_name, use_fast=True )
7. Testování modelu s nulovým šetřením
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 formuláře:
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)
9. Připravte model pro QLoRA
