Anslut dig till vÄrt nÀtverk!

Artificiell intelligens

Den enda guiden du behöver för att finjustera Llama 3 eller nÄgon annan modell med öppen kÀllkod

mm
FININSTÄLLNING ÖPPEN KÄLLA LLM PYTHONGUIDE

Att finjustera stora sprÄkmodeller (LLM) som Llama 3 innebÀr att anpassa en förtrÀnad modell till specifika uppgifter med hjÀlp av en domÀnspecifik datauppsÀttning. Denna process utnyttjar modellens redan existerande kunskap, vilket gör den effektiv och kostnadseffektiv jÀmfört med trÀning frÄn grunden. I den hÀr guiden gÄr vi igenom stegen för att finjustera Llama 3 med QLoRA (Quantized LoRA), en parametereffektiv metod som minimerar minnesanvÀndning och berÀkningskostnader.

Översikt över finjustering

Finjustering innefattar flera viktiga steg:

  1. VÀlja en förutbildad modell: VÀlj en basmodell som passar din önskade arkitektur.
  2. Samla in en relevant datauppsÀttning: Samla in och förbearbeta en datauppsÀttning som Àr specifik för din uppgift.
  3. Finjustering: Anpassa modellen med hjÀlp av datamÀngden för att förbÀttra dess prestanda för specifika uppgifter.
  4. UtvÀrdering: Bedöm den finjusterade modellen med bÄde kvalitativa och kvantitativa mÄtt.

Koncept och tekniker

Finjustera stora sprÄkmodeller

Finjustera stora sprÄkmodeller

Full finjustering

Full finjustering uppdaterar alla parametrar för modellen, vilket gör den specifik för den nya uppgiften. Denna metod krÀver betydande berÀkningsresurser och Àr ofta opraktisk för mycket stora modeller.

Parametereffektiv finjustering (PEFT)

PEFT uppdaterar endast en delmÀngd av modellens parametrar, vilket minskar minneskraven och berÀkningskostnaderna. Denna teknik förhindrar katastrofal glömska och upprÀtthÄller den allmÀnna kunskapen om modellen.

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

LoRA finjusterar endast ett fÄtal lÄgrankade matriser, medan QLoRA kvantiserar dessa matriser för att minska minnesfotavtrycket ytterligare.

Finjusteringsmetoder

  1. Full finjustering: Detta innebĂ€r att man trĂ€nar alla parametrar i modellen pĂ„ den uppgiftsspecifika datamĂ€ngden. Även om denna metod kan vara mycket effektiv, Ă€r den ocksĂ„ berĂ€kningsmĂ€ssigt dyr och krĂ€ver betydande minne.
  2. Parameter Effektiv finjustering (PEFT): PEFT uppdaterar endast en delmÀngd av modellens parametrar, vilket gör den mer minneseffektiv. Tekniker som Low-Rank Adaptation (LoRA) och Quantized LoRA (QLoRA) faller inom denna kategori.

Vad Àr LoRA?

JÀmföra finjusteringsmetoder: QLORA förbÀttrar LoRA med 4-bitars precisionskvantisering och paged optimizers för hantering av minnesspik

JÀmföra finjusteringsmetoder: QLORA förbÀttrar LoRA med 4-bitars precisionskvantisering och paged optimizers för hantering av minnesspik

LoRA Àr en förbÀttrad finjusteringsmetod dÀr, istÀllet för att finjustera alla vikter i den förtrÀnade modellen, finjusteras tvÄ mindre matriser som approximerar den större matrisen. Dessa matriser utgör LoRA-adaptern. Denna finjusterade adapter laddas sedan in i den förtrÀnade modellen och anvÀnds för slutledning.

Viktiga fördelar med LoRA:

  • Minneseffektivitet: LoRA minskar minnesfotavtrycket genom att bara finjustera smĂ„ matriser istĂ€llet för hela modellen.
  • reus FörmĂ„ga: Den ursprungliga modellen förblir oförĂ€ndrad och flera LoRA-adaptrar kan anvĂ€ndas med den, vilket underlĂ€ttar hanteringen av flera uppgifter med lĂ€gre minneskrav.

Vad Àr Quantized LoRA (QLoRA)?

QLoRA tar LoRA ett steg lÀngre genom att kvantisera LoRA-adaptrarnas vikter till lÀgre precision (t.ex. 4-bitars istÀllet för 8-bitars). Detta minskar ytterligare minnesanvÀndning och lagringskrav samtidigt som en jÀmförbar effektivitetsnivÄ bibehÄlls.

Viktiga fördelar med QLoRA:

  • Ännu större minneseffektivitet: Genom att kvantisera vikterna minskar QLoRA avsevĂ€rt modellens minnes- och lagringskrav.
  • UpprĂ€tthĂ„ller prestanda: Trots den minskade precisionen bibehĂ„ller QLoRA prestandanivĂ„er nĂ€ra den för fullprecisionsmodeller.

Uppgiftsspecifik anpassning

Under finjusteringen justeras modellens parametrar baserat pÄ den nya datamÀngden, vilket hjÀlper den att bÀttre förstÄ och generera innehÄll som Àr relevant för den specifika uppgiften. Denna process behÄller de allmÀnna sprÄkkunskaper som erhÄllits under förutbildningen samtidigt som modellen skrÀddarsys efter nyanserna i mÄldomÀnen.

Finjustering i praktiken

Full finjustering kontra PEFT

  • Full finjustering: InnebĂ€r att trĂ€na hela modellen, vilket kan vara berĂ€kningsmĂ€ssigt dyrt och krĂ€ver betydande minne.
  • PEFT (LoRA och QLoRA): Finjusterar endast en delmĂ€ngd av parametrar, minskar minneskraven och förhindrar katastrofal glömning, vilket gör det till ett mer effektivt alternativ.

Implementeringssteg

  1. InstÀllningsmiljö: Installera nödvÀndiga bibliotek och stÀll in datormiljön.
  2. Ladda och förbearbeta datauppsÀttning: Ladda datauppsÀttningen och förbearbeta den till ett format som passar modellen.
  3. Ladda förtrÀnad modell: Ladda basmodellen med kvantiseringskonfigurationer om du anvÀnder QLoRA.
  4. tokenization: Tokenisera datasetet för att förbereda det för trÀning.
  5. Utbildning: Finjustera modellen med den förberedda datamÀngden.
  6. UtvÀrdering: UtvÀrdera modellens prestanda pÄ specifika uppgifter med hjÀlp av kvalitativa och kvantitativa mÄtt.

Steo för steg-guide till Fine Tune LLM

StÀlla in miljön

Vi kommer att anvÀnda en Jupyter-anteckningsbok för den hÀr handledningen. Plattformar som Kaggle, som erbjuder gratis GPU-anvÀndning, eller Google Colab Àr idealiska för att köra dessa experiment.

1. Installera nödvÀndiga bibliotek

Se först till att du har de nödvÀndiga biblioteken installerade:

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

2. Importera bibliotek och stÀll in miljön

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. Ladda datamÀngden

Vi kommer att anvÀnda DialogSum-dataset för denna handledning:

Förbearbeta datasetet enligt modellens krav, inklusive att tillĂ€mpa lĂ€mpliga mallar och se till att dataformatet Ă€r lĂ€mpligt för finjustering (Kramande ansikte)​​ (DataCamp).

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

Inspektera datasetstrukturen:

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

4. Skapa BitsAndBytes-konfiguration

SÄ hÀr laddar du modellen i 4-bitarsformat:

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. Ladda den förtrÀnade modellen

AnvÀnda Microsofts Phi-2-modell för denna handledning:

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

Konfigurera tokenizern:

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

Finjustera Llama 3 eller andra modeller

NÀr du finjusterar modeller som Llama 3 eller andra toppmoderna LLM:er med öppen kÀllkod krÀvs specifika övervÀganden och justeringar för att sÀkerstÀlla optimal prestanda. HÀr Àr de detaljerade stegen och insikterna om hur du kan nÀrma dig detta för olika modeller, inklusive Llama 3, GPT-3 och Mistral.

5.1 AnvÀnda Llama 3

Modellval:

  • Se till att du har rĂ€tt modellbeteckning frĂ„n Hugging Face-modellhubben. Till exempel kan Llama 3-modellen identifieras som meta-llama/Meta-Llama-3-8B pĂ„ Hugging Face.
  • Se till att begĂ€ra Ă„tkomst och logga in pĂ„ ditt Hugging Face-konto om det behövs för modeller som Llama 3 (Kramande ansikte)​​

tokenization:

  • AnvĂ€nd lĂ€mplig tokenizer för Llama 3, se till att den Ă€r kompatibel med modellen och stöder nödvĂ€ndiga funktioner som stoppning och speciella tokens.

Minne och berÀkning:

  • Att finjustera stora modeller som Llama 3 krĂ€ver betydande berĂ€kningsresurser. Se till att din miljö, till exempel en kraftfull GPU-installation, kan hantera minnes- och bearbetningskraven. Se till att miljön kan hantera minneskraven, vilket kan mildras genom att anvĂ€nda tekniker som QLoRA för att minska minnesavtrycket (Kramar ansikten Forum)

Exempelvis:

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
)

tokenization:

Beroende pĂ„ det specifika anvĂ€ndningsfallet och modellkraven, sĂ€kerstĂ€ll korrekt tokenizerkonfiguration utan redundanta instĂ€llningar. Till exempel, use_fast=True rekommenderas för bĂ€ttre prestanda (Kramande ansikte)​​ (Vikter och fördomar).

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 AnvÀnda andra populÀra modeller (t.ex. GPT-3, Mistral)

Modellval:

  • För modeller som GPT-3 och Mistral, se till att du anvĂ€nder rĂ€tt modellnamn och identifierare frĂ„n Hugging Face-modellhubben eller andra kĂ€llor.

tokenization:

  • I likhet med Llama 3, se till att tokenizern Ă€r korrekt instĂ€lld och kompatibel med modellen.

Minne och berÀkning:

  • Varje modell kan ha olika minneskrav. Justera din miljöinstĂ€llning dĂ€refter.

Exempel för 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
)

Exempel för 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
)

TokeniseringsövervÀganden: Varje modell kan ha unika tokeniseringskrav. Se till att tokenizern matchar modellen och Àr korrekt konfigurerad.

Exempel pÄ Llama 3 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

Exempel pÄ GPT-3 och Mistral Tokenizer:

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

7. Testa modellen med Zero-Shot-inferencing

UtvÀrdera basmodellen med ett exempel:

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"

# Generate 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. Förbearbeta datamÀngden

Konvertera dialog-sammanfattningspar till uppmaningar:

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)

Tokenisera den formaterade datamÀngden:

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. Förbered modellen för QLoRA

Förbered modellen för parametereffektiv finjustering:

original_model = prepare_model_for_kbit_training(original_model)

Hyperparametrar och deras inverkan

Hyperparametrar spelar en avgörande roll för att optimera prestandan för din modell. HÀr Àr nÄgra viktiga hyperparametrar att tÀnka pÄ:

  1. InlÀrningshastighet: Styr hastigheten med vilken modellen uppdaterar sina parametrar. En hög inlÀrningshastighet kan leda till snabbare konvergens men kan överskrida den optimala lösningen. En lÄg inlÀrningshastighet sÀkerstÀller stadig konvergens men kan krÀva fler epoker.
  2. Satsstorlek: Antalet prover som behandlas innan modellen uppdaterar sina parametrar. Större batchstorlekar kan förbÀttra stabiliteten men krÀver mer minne. Mindre batchstorlekar kan leda till mer buller i trÀningsprocessen.
  3. Gradientackumuleringssteg: Denna parameter hjÀlper till att simulera större batchstorlekar genom att ackumulera gradienter över flera steg innan en parameteruppdatering utförs.
  4. Antal epoker: Antalet gÄnger hela datamÀngden passeras genom modellen. Fler epoker kan förbÀttra prestandan men kan leda till övermontering om de inte hanteras pÄ rÀtt sÀtt.
  5. ViktnedgÄng: Reguleringsteknik för att förhindra överanpassning genom att straffa stora vikter.
  6. InlÀrningshastighetsschemalÀggare: Justerar inlÀrningshastigheten under trÀning för att förbÀttra prestanda och konvergens.

Anpassa trĂ€ningskonfigurationen genom att justera hyperparametrar som inlĂ€rningshastighet, batchstorlek och gradientackumuleringssteg baserat pĂ„ den specifika modellen och uppgiftskraven. Till exempel kan Llama 3-modeller krĂ€va olika inlĂ€rningshastigheter jĂ€mfört med mindre modeller (Vikter och fördomar)​​ (GitHub)Ăą € <

Exempel pÄ trÀningskonfiguration

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. TrÀna modellen

StÀll in trÀnaren och börja trÀna:

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

UtvÀrdera den finjusterade modellen

UtvÀrdera efter utbildningen modellens prestanda med bÄde kvalitativa och kvantitativa metoder.

1. MÀnsklig utvÀrdering

JÀmför de genererade sammanfattningarna med mÀnskliga för att bedöma kvaliteten.

2. Kvantitativ utvÀrdering

AnvÀnd mÀtvÀrden som ROUGE för att bedöma resultatet:

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)

Vanliga utmaningar och lösningar

1. MinnesbegrÀnsningar

Att anvÀnda QLoRA hjÀlper till att lindra minnesproblem genom att kvantisera modellvikter till 4-bitars. Se till att du har tillrÀckligt med GPU-minne för att hantera din batchstorlek och modellstorlek.

2. Överanpassning

Övervaka valideringsmĂ„tt för att förhindra överanpassning. AnvĂ€nd tekniker som tidig stopp och viktminskning.

3. LÄngsam trÀning

Optimera trÀningshastigheten genom att justera batchstorlek, inlÀrningshastighet och anvÀnda gradientackumulering.

4. Datakvalitet

Se till att din datauppsÀttning Àr ren och vÀl förbehandlad. DÄlig datakvalitet kan avsevÀrt pÄverka modellens prestanda.

Slutsats

Att finjustera LLM med QLoRA Àr ett effektivt sÀtt att anpassa stora förtrÀnade modeller till specifika uppgifter med minskade berÀkningskostnader. Genom att följa den hÀr guiden kan du finjustera PHI, Llama 3 eller nÄgon annan modell med öppen kÀllkod för att uppnÄ hög prestanda för dina specifika uppgifter.

Jag har Àgnat de senaste fem Ären Ät att fördjupa mig i den fascinerande vÀrlden av Machine Learning och Deep Learning. Min passion och expertis har lett mig till att bidra till över 50 olika programvaruutvecklingsprojekt, med sÀrskilt fokus pÄ AI/ML. Min pÄgÄende nyfikenhet har ocksÄ dragit mig mot Natural Language Processing, ett omrÄde som jag Àr ivrig att utforska vidare.