Ainoa opas, jonka tarvitset Llama 3:n tai minkä tahansa muun avoimen lähdekoodin mallin hienosäätöön

Llama 3:n ja muiden suurten kielen mallien hienosäätö tapahtuu sovittamalla esikoulutettu malli tietyn tehtävän vaatimuksiin käyttäen tehtävän mukaista tietojoukkoa. Tämä prosessi hyödyntää mallin jo olemassa olevaa tietoa, mikä tekee siitä tehokkaan ja kustannustehokkaan verrattuna kouluttamiseen alusta alkaen. Tässä oppaassa käymme läpi Llama 3:n hienosäätöön käytettävät vaiheet QLoRA:n (Quantized LoRA) avulla, joka on parametreja tehokas menetelmä, joka vähentää muistin käyttöä ja laskennallisia kustannuksia.

Hienosäätöön liittyvän yleiskatsaus

Hienosäätö käsittää useita tärkeitä vaiheita:

1. Esikoulutetun mallin valinta: Valitse perusmalli, joka vastaa haluttua arkkitehtuuria.
2. Tietojoukon kerääminen: Kerää ja esikäännä tietojoukko, joka on tehtävän mukainen.
3. Hienosäätö: Sovella mallia tietojoukon avulla parantamaan sen suorituskykyä tietyn tehtävän suhteen.
4. Arviointi: Arvioi hienosäätöä käytettyä mallia sekä kvalitatiivisin että kvantitatiivisin mittarein.

Käsitteet ja tekniikat

Suurten kielen mallien hienosäätö

Täydellinen hienosäätö

Täydellinen hienosäätö päivittää kaikki mallin parametreja, tehdessä siitä tehtävän mukaisen. Tämä menetelmä vaatii merkittäviä laskennallisia resursseja ja on usein epäkäytännöllinen hyvin suurten mallien osalta.

Parametreja tehokas hienosäätö (PEFT)

PEFT päivittää vain osan mallin parametreja, vähentäen muistin tarvetta ja laskennallisia kustannuksia. Tämä tekniikka estää katastrofaalisen unohtamisen ja säilyttää mallin yleisen tiedon.

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

LoRA hienosäätää vain muutamia matalan sijan matriiseja, kun taas QLoRA kvantifioidaan näitä matriiseja vähentääksesi muistin jalanjälkeä edelleen.

Hienosäätömenetelmät

1. Täydellinen hienosäätö: Tämä käsittää kouluttamisen kaikkia mallin parametreja tehtävän mukaisella tietojoukolla. Vaikka tämä menetelmä voi olla hyvin tehokas, se on myös laskennallisesti kallista ja vaatii merkittäviä määriä muistia.
2. Parametreja tehokas hienosäätö (PEFT): PEFT päivittää vain osan mallin parametreja, mikä tekee siitä muistin kannalta tehokkaamman. Tekniikat kuten Low-Rank Adaptation (LoRA) ja Quantized LoRA (QLoRA) kuuluvat tähän kategoriaan.

Mikä on LoRA?

Hienosäätömenetelmien vertailu: QLORA parantaa LoRA:ta 4-bittisen tarkkuuden kvantifiointia ja sivutettuja optimoijia muistin huippujen hallintaan

LoRA on parannettu hienosäätömenetelmä, jossa esikoulutetun mallin painoarvoja ei hienosäätöö täysin, vaan kaksi pienempää matriisia, jotka approksimoivat suurempaa matriisia, hienosäätöö. Nämä matriisit muodostavat LoRA-sovittimen. Tämä hienosäätöity sovitin ladataan esikoulutettuun malliin ja käytetään inferenceksi.

LoRA:n avainetuja:

• Muistin tehokkuus: LoRA vähentää muistin jalanjälkeä hienosäätöämällä vain pieniä matriiseja koko mallin sijaan.
• Uudelleenkäytettävyys: Alkuperäinen malli säilyy muuttumattomana, ja useita LoRA-sovittimia voidaan käyttää sen kanssa, mikä helpottaa useiden tehtävien käsittelyä alhaisemmin muistin vaatimuksin.

Mikä on Quantized LoRA (QLoRA)?

QLoRA vie LoRA:n askelen eteenpäin kvantifioiden LoRA-sovittimien painoarvot alempaan tarkkuuteen (esim. 4-bittiseen sijaan 8-bittisestä). Tämä vähentää edelleen muistin käyttöä ja tallennustilaa säilyttäen samalla vertailukelpoisen tehokkuuden.

QLoRA:n avainetuja:

• Entistä suurempi muistin tehokkuus: Kvantifioiden painoarvojen ansiosta QLoRA vähentää merkittävästi mallin muisti- ja tallennustilavaatimukset.
• Suorituskyvyn ylläpitäminen: Vaikka tarkkuus on vähennetty, QLoRA ylläpitää suorituskykyä, joka on lähellä täysitarkkuisten mallien suorituskykyä.

Tehtävän mukainen sovittaminen

Hienosäätöprosessin aikana mallin parametreja säätöä tehtävän mukaista tietojoukkoa vastaan, jotta se ymmärtäisi ja generoisi sisältöä, joka on relevanttia tehtävälle. Tämä prosessi säilyttää yleisen kielen tiedon, joka on saavutettu esikoulutuksen aikana, samalla sovittaen mallia tehtävän mukaisiin yksityiskohtiin.

Hienosäätö käytännössä

Täydellinen hienosäätö vs. PEFT

• Täydellinen hienosäätö: Kouluttaa koko mallia, mikä voi olla laskennallisesti kallista ja vaatia merkittäviä määriä muistia.
• PEFT (LoRA ja QLoRA): Hienosäätää vain osan parametreja, vähentäen muistin vaatimukset ja estäen katastrofaalisen unohtamisen, mikä tekee siitä tehokkaamman vaihtoehdon.

Implementaatiovaiheet

1. Ympäristön asettaminen: Asenna tarvittavat kirjastot ja aseta laskennallinen ympäristö.
2. Tietojoukon lataus ja esikäsittely: Lataa tietojoukko ja esikäännä se muotoon, joka on sovelias mallille.
3. Esikoulutetun mallin lataus: Lataa perusmalli kvantifiointikonfiguraatioilla, jos käytät QLoRA:ta.
4. Tokenisointi: Tokenisoi tietojoukko valmistelemaan sitä koulutukseen.
5. Koulutus: Hienosäätö mallia valmistellun tietojoukon avulla.
6. Arviointi: Arvioi mallin suorituskykyä tietyn tehtävän suhteen kvalitatiivisin ja kvantitatiivisin mittarein.

Askelen mukainen opas LLM:n hienosäätöön

Ympäristön asettaminen

Käytämme Jupyter-muistikirjaa tähän tutoriaaliin. Alustat kuten Kaggle, jotka tarjoavat ilmaisen GPU-käytön, tai Google Colab ovat ihanteellisia näiden kokeiden suorittamiseen.

1. Tarvittavien kirjastojen asennus

Varmista, että sinulla on tarvittavat kirjastot asennettuna:

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

2. Kirjastojen tuominen ja ympäristön asettaminen

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

# Poista Weights and Biases -lokitus
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. Tietojoukon lataus

Käytämme DialogSum-tietojoukkoa tähän tutoriaaliin:
Esikäännä tietojoukko mallin vaatimusten mukaan, mukaan lukien sovellettavien templaattien käyttö ja varmista, että tietojoukon muoto on sovelias hienosäätöä varten​ (Hugging Face)​​ (DataCamp)​.

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

Tutki tietojoukon rakennetta:

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

4. BitsAndBytes-konfiguraation luominen

Ladataksesi mallin 4-bittisessä muodossa:

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. Esikoulutetun mallin lataus

Käytämme Microsoftin Phi-2-mallia tähän tutoriaaliin:

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

Konfiguroi tokenisaattori:

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

Llama 3:n tai muiden mallien hienosäätö

Kun hienosäätöö mallia kuten Llama 3 tai muita avoimen lähdekoodin LLM-malleja, on tärkeää huomioida tietyt seikat ja sopeuttaa asetuksia optimaalisen suorituskyvyn varmistamiseksi. Tässä on yksityiskohtaiset vaiheet ja näkökulmat siitä, miten lähestyä tätä eri malleille, kuten Llama 3, GPT-3 ja Mistral.

5.1 Käyttäen Llama 3:aa

Mallin valinta:

• Varmista, että sinulla on oikea mallin tunniste Hugging Face -mallihubbista. Esimerkiksi Llama 3 -malli voi olla tunnistettu meta-llama/Meta-Llama-3-8B Hugging Facessa.
• Pyydä pääsyä ja kirjaudu Hugging Face -tiliisi, jos vaaditaan malleja kuten Llama 3 ​ (Hugging Face)​​

Tokenisointi:

• Käytä Llama 3:lle sopivaa tokenisaattoria, varmistaen, että se on yhteensopiva mallin kanssa ja tukee vaadittuja ominaisuuksia, kuten paddingia ja erityisiä tokenia.

Muisti ja laskenta:

• Hienosäätö suurten mallien kuten Llama 3:n vaatii merkittäviä laskennallisia resursseja. Varmista, että ympäristösi, kuten voimakas GPU-asettelu, pystyy käsittelemään muisti- ja laskennalliset vaatimukset. Varmista, että ympäristö pystyy käsittelemään muistin vaatimukset, jotka voidaan lieventää käyttämällä tekniikoita kuten QLoRA:ta muistijalanjäljen vähentämiseksi ​ (Hugging Face Forums)

Esimerkki:

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
)

Tokenisointi:

Riippuen tietyn käyttötapausten ja mallin vaatimusten mukaan, varmista oikea tokenisaattorin konfiguraatio ilman tarpeettomia asetuksia. Esimerkiksi use_fast=True on suositeltavaa paremman suorituskyvyn vuoksi ​ (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 Käyttäen muita suosittuja malleja (esim. GPT-3, Mistral)

Mallin valinta:

• Malleja kuten GPT-3 ja Mistral, varmista, että käytät oikeaa mallinimeä ja tunnistetta Hugging Face -mallihubbista tai muista lähteistä.

Tokenisointi:

• Samoin kuin Llama 3, varmista, että tokenisaattori on oikein asetettu ja yhteensopiva mallin kanssa.

Muisti ja laskenta:

• Jokainen malli voi vaatia erilaisia muistin vaatimuksia. Säädä ympäristösi asetusten mukaan.

Esimerkki GPT-3:lle:

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
)

Esimerkki Mistralille:

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
)

Tokenisointi huomioon: Jokainen malli voi vaatia yksilöllisiä tokenisointivaatimuksia. Varmista, että tokenisaattori vastaa mallia ja on oikein konfiguroitu.

Llama 3 tokenisaattori esimerkki:

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

GPT-3 ja Mistral tokenisaattori esimerkki:

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

7. Mallin testaaminen nollasummittaisella inferenssillä

Arvioi perusmallia näytteellisellä syötteellä:

from transformers import set_seed

<p>set_seed(42)
index = 10
prompt = dataset['test'][index]['dialogue']
formatted_prompt = f"Instruct: Summarize the following conversation.\n{prompt}\nOutput:\n"
# Generoi 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)

<p>res = gen(original_model, formatted_prompt, 100)
output = res[0].split('Output:\n')[1]</p>

<p>print(f'INPUT PROMPT:\n{formatted_prompt}')
print(f'MODEL GENERATION - ZERO SHOT:\n{output}')

8. Tietojoukon esikäsittely

Muunna dialogi-yhteenveto -parit kysymyksiksi:

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

<p>dataset = dataset.map(create_prompt_formats)</p>

Tokenisoi muodostetun tietojoukon:

def preprocess_batch(batch, tokenizer, max_length):
return tokenizer(batch["text"], max_length=max_length, truncation=True)

<p>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)</p>

Valmistele malli parametreja tehokkaaseen hienosäätöön:

original_model = prepare_model_for_kbit_training(original_model)

Hyperparametrit ovat keskeisiä mallin suorituskyvyn optimoimisessa. Tässä on joitakin tärkeitä hyperparametreja, jotka on otettava huomioon:

1. Oppimisnopeus: Säätelee mallin parametreja päivittävän nopeuden. Korkea oppimisnopeus voi johtaa nopeampaan konvergenssiin, mutta voi myös ylittää optimaalisen ratkaisun. Matala oppimisnopeus takaa tasaisen konvergenssin, mutta voi vaatia enemmän epochsaikoja.
2. Batch-koko: Määrä näytteitä, jotka prosessoidaan ennen mallin parametreja päivittämistä. Suuremmat batch-koot voivat parantaa vakausta, mutta vaativat enemmän muistia. Pienemmät batch-koot voivat johtaa enemmän melkuun koulutusprosessissa.
3. Gradientin kertymisen askel: Tämä parametri auttaa simuloimaan suurempia batch-kokoja kertymällä gradientteja useiden askelten yli ennen parametreja päivittämistä.
4. Epochsien määrä: Kertaa, kuinka monta kertaa koko tietojoukko käydään läpi mallilla. Enemmän epochsaikoja voi parantaa suorituskykyä, mutta voi myös johtaa ylioppimiseen, jos ei hallita oikein.
5. Painojen kato: Säännöstysmenetelmä, joka estää ylioppimisen rangaistamalla suuria painoja.
6. Oppimisnopeuden aikataulu: Säätää oppimisnopeutta koulutuksen aikana parantamaan suorituskykyä ja konvergenssia.

Mukauta koulutuskonfiguraatiota säätämällä hyperparametreja, kuten oppimisnopeutta, batch-kokoa ja gradientin kertymisen askelta, riippuen mallista ja tehtävästä. Esimerkiksi Llama 3 -mallit saattavat vaatia erilaisia oppimisnopeuksia verrattuna pienempiin malleihin ​ (Weights & Biases)​​ (GitHub)​

Esimerkki koulutuskonfiguraatiosta

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. Mallin koulutus

Aseta kouluttaja ja aloita koulutus:

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

Hienosäätötyön arviointi

Koulutuksen jälkeen arvioi mallin suorituskykyä sekä kvalitatiivisin että kvantitatiivisin menetelmin.

1. Inhimillinen arviointi

Vertaa generoituja yhteenvetoja ihmisten kirjoittamiin yhteenvetoihin arvioidaksesi laadun.

2. Kvantitatiivinen arviointi

Käytä mittareita kuten ROUGE arvioidaksesi suorituskykyä:

from rouge_score import rouge_scorer

<p>scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
scores = scorer.score(reference_summary, generated_summary)
print(scores)</p>

Yleiset haasteet ja ratkaisut

1. Muistirajoitukset

Käyttäen QLoRA:ta voidaan lieventää muistiongelmia kvantifioiden mallin painoarvot 4-bittiin. Varmista, että sinulla on tarpeeksi GPU-muistia käsitelläksesi batch-koon ja mallin koon.

2. Ylioppiminen

Seuraa validointimittareita estääksesi ylioppimisen. Käytä tekniikoita kuten varhaisen lopettamisen ja painojen kadon.

3. Hidas koulutus

Optimoi koulutusnopeutta säätämällä batch-kokoa, oppimisnopeutta ja käyttämällä gradientin kertymisen askelta.

4. Tietojoukon laatu

Varmista, että tietojoukkosi on puhdas ja hyvin esikäsitelty. Huono tietojoukon laatu voi vaikuttaa merkittävästi mallin suorituskykyyn.

Johtopäätös

Hienosäätö suurten kielen mallien käyttäen QLoRA:ta on tehokas tapa sovittaa suuria esikoulutettuja malleja tietyn tehtävän vaatimuksiin vähentäen laskennallisia kustannuksia. Seuraamalla tätä oppasta voit hienosäätää PHI, Llama 3 tai minkä tahansa avoimen lähdekoodin mallin saavuttaaksesi korkean suorituskyvyn tietyillä tehtävillä.