Introduktion
Efter Llama- og Mistral-modellerne blev frigivet, tog open source LLM'erne rampelyset ud af OpenAI. Siden da er flere modeller blevet frigivet baseret på Llama- og Mistral-arkitektur, der præsterer på niveau med proprietære modeller som GPT-3.5 Turbo, Claude, Gemini osv. Disse modeller er dog for store til at blive brugt i forbrugerhardware.
Men på det seneste har der været en fremkomst af en ny klasse af LLM'er. Disse er LLM'erne i sub-7B parameterkategorien. Færre parametre gør dem kompakte nok til at blive kørt i forbrugerhardware, mens de holder effektiviteten sammenlignelig med 7B-modellerne. Modeller som Tiny-Llama-1B, Microsofts Phi-2 og Alibabas Qwen-3b kan være gode erstatninger for større modeller til at køre lokalt eller implementere på kanten. Samtidig er finjustering afgørende for at få det bedste ud af enhver basismodel til alle downstream-opgaver.
Her vil vi undersøge, hvordan man finjusterer en base Tiny-Llama model på et renset Alpaca-datasæt.
Læringsmål
- Forstå finjustering og forskellige metoder til det.
- Lær om værktøjer og teknikker til effektiv finjustering.
- Lær om WandB til logning af træningslogfiler.
- Finjuster Tiny-Llama på Alpaca-datasættet i Colab.
Denne artikel blev offentliggjort som en del af Data Science Blogathon.
Indholdsfortegnelse
Hvad er LLM Fine-Tuning?
Finjustering er processen med at få en præ-trænet model til at lære ny viden. Den præ-trænede model er en generel model, der er trænet på en stor mængde data. Men i de fleste tilfælde klarer de sig ikke efter hensigten, og finjustering er den mest effektive måde at få modellen til at tilpasse sig til specifikke brugstilfælde. For eksempel base LLM'er klarer sig godt til tekstgenerering på single-turn QA, men kæmper med multi-turn-samtaler som chatmodeller.
Basismodellerne skal trænes i transskriptioner af dialoger for at kunne afholde multi-turn samtaler. Finjustering er afgørende for at forme fortrænede modeller til forskellige avatarer. Kvaliteten af finjusterede modeller afhænger af kvaliteten af data og basismodelkapaciteter. Der er flere måder at modellere finjustering på, som LoRA, QLoRA osv.
Lad os kort gennemgå disse begreber.
LoRA
LoRA står for Low-rank Adaptation, en populær finjusteringsteknik, hvor vi vælger nogle få parametre, der kan trænes, i stedet for at opdatere alle parametrene via en lav-rangs tilnærmelse af originale vægtmatricer. LoRA-modellen kan finjusteres hurtigere på mindre computerkrævende hardware.
QLoRA
QLoRA eller Quantized LoRA er et skridt videre end LoRA. I stedet for en model med fuld præcision, kvantiserer den modelvægtene for at sænke flydende kommapræcision, før LoRA påføres. Kvantisering er processen med at nedkaste højere bitværdier til lavere værdier. En 4-bit kvantiseringsproces involverer kvantisering af 16-bit vægtene til 4-bit flydende værdier.
Kvantificering af modellen fører til en væsentlig reduktion i modelstørrelsen med samme nøjagtighed som den originale model. I QLoRA tager vi en kvantiseret model og anvender LoRA på den. Modellerne kan kvantiseres på flere måder, såsom gennem llama.cpp, AWQ, bitsandbytes osv.
Finjustering med Unsloth
Unsloth er en open source-platform til hurtigere finjustering af populære store sprogmodeller. Den understøtter populære LLM'er, inklusive Llama-2 og Mistral, og deres derivater som Yi, Open-hermes osv. Den implementerer tilpassede tritonkerner og en manuel back-prop-motor for at forbedre hastigheden af modeltræningen.
Her vil vi bruge Unsloth til at finjustere en base 4-bit kvantiseret Tiny-Llama model på Alpaca datasæt. Modellen er kvantificeret med bits og bytes, og kerner er optimeret med OpenAI's Triton.
Logning med WandB
I maskinlæring er det afgørende at logge trænings- og evalueringsmålinger. Dette giver os et komplet billede af togkørslen. Vægte og skævheder (WandB) er et open source-bibliotek til visualisering og sporing af maskinlæringseksperimenter. Den har en dedikeret webapp til visualisering af træningsmålinger i realtid. Det lader os også styre produktionsmodeller centralt. Vi bruger kun WandB til at spore vores Tiny-Llama finjusteringsløb.
For at bruge WandB skal du oprette en gratis konto og oprette en API-nøgle.
Lad os nu begynde at finjustere vores model.
Hvordan finjusterer man Tiny-Llama?
Finjustering er en computertung opgave. Det kræver en maskine med 10-15 GB VRAM, eller du kan bruge Colabs gratis Tesla T4 GPU runtime.
Installer nu Unsloth og WandB
%%capture
import torch
major_version, minor_version = torch.cuda.get_device_capability()
!pip install wandb
if major_version >= 8:
# Use this for new GPUs like Ampere, Hopper GPUs (RTX 30xx, RTX 40xx, A100, H100, L40)
!pip install "unsloth[colab_ampere] @ git+https://github.com/unslothai/unsloth.git"
else:
# Use this for older GPUs (V100, Tesla T4, RTX 20xx)
!pip install "unsloth[colab] @ git+https://github.com/unslothai/unsloth.git"
pass
Den næste ting er at indlæse den 4-bit kvantificerede præ-trænede model med Unsloth.
from unsloth import FastLanguageModel
import torch
max_seq_length = 4096 # Choose any! We auto support RoPE Scaling internally!
dtype = None # None for auto detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+
load_in_4bit = True # Use 4bit quantization to reduce memory usage. Can be False.
model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "unsloth/tinyllama-bnb-4bit", # "unsloth/tinyllama" for 16bit loading
max_seq_length = max_seq_length,
dtype = dtype,
load_in_4bit = load_in_4bit,
)
Dette vil installere modellen lokalt. 4-bit modelstørrelsen vil være omkring 760 MBs.
Ansøg nu PEFT til 4-bit Tiny-Llama-modellen.
model = FastLanguageModel.get_peft_model(
model,
r = 32, # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj",],
lora_alpha = 32,
lora_dropout = 0, # Currently only supports dropout = 0
bias = "none", # Currently only supports bias = "none"
use_gradient_checkpointing = True, # @@@ IF YOU GET OUT OF MEMORY - set to True @@@
random_state = 3407,
use_rslora = False, # We support rank stabilized LoRA
loftq_config = None, # And LoftQ
)
Forbered data
Det næste trin er at forberede datasættet til finjustering. Som jeg nævnte tidligere, vil vi bruge en renset Alpaca datasæt. Dette er en renset version af det originale Alpaca-datasæt. Det følger instruktion-input-svar-formatet. Her er et eksempel på Alpaca-data
Lad os nu forberede vores data.
@title prepare data
#alpaca_prompt = """Below is an instruction that describes a task, paired with an input that
provides further context.
Write a response that appropriately completes the request.
### Instruction:
{}
### Input:
{}
### Response:
{}"""
EOS_TOKEN = tokenizer.eos_token
def formatting_prompts_func(examples):
instructions = examples["instruction"]
inputs = examples["input"]
outputs = examples["output"]
texts = []
for instruction, input, output in zip(instructions, inputs, outputs):
# Must add EOS_TOKEN, otherwise your generation will go on forever!
text = alpaca_prompt.format(instruction, input, output) + EOS_TOKEN
texts.append(text)
return { "text" : texts, }
pass
from datasets import load_dataset
dataset = load_dataset("yahma/alpaca-cleaned", split = "train")
dataset = dataset.map(formatting_prompts_func, batched = True,)
Opdel nu dataene i tog- og evaldata. Jeg har taget små evaldata, da større evaldata bremser træningen.
dataset_dict = dataset.train_test_split(test_size=0.004)
Konfigurer WandB
Konfigurer nu vægte og skævheder i din nuværende kørselstid.
# @title wandb init
import wandb
wandb.login()
Angiv API-nøgle for at logge på WandB, når du bliver bedt om det.
Opsæt miljøvariabler.
%env WANDB_WATCH=all
%env WANDB_SILENT=true
Togmodel
Indtil videre har vi indlæst 4-bit modellen, oprettet LoRA-konfigurationen, forberedt datasættet og konfigureret WandB. Næste trin er at træne modellen på dataene. Til det skal vi definere en træner fra Trl-biblioteket. Vi vil bruge SFTraineren fra Trl. Men før det, initialiser WandB og definer passende træningsargumenter.
import os
from trl import SFTTrainer
from transformers import TrainingArguments
from transformers.utils import logging
import wandb
logging.set_verbosity_info()
project_name = "tiny-llama"
entity = "wandb"
# os.environ["WANDB_LOG_MODEL"] = "checkpoint"
wandb.init(project=project_name, name = "tiny-llama-unsloth-sft")
Træningsargumenter
args = TrainingArguments(
per_device_train_batch_size = 2,
per_device_eval_batch_size=2,
gradient_accumulation_steps = 4,
evaluation_strategy="steps",
warmup_ratio = 0.1,
num_train_epochs = 1,
learning_rate = 2e-5,
fp16 = not torch.cuda.is_bf16_supported(),
bf16 = torch.cuda.is_bf16_supported(),
optim = "adamw_8bit",
weight_decay = 0.1,
lr_scheduler_type = "linear",
seed = 3407,
output_dir = "outputs",
report_to="wandb", # enable logging to W&B
# run_name="tiny-llama-alpaca-run", # name of the W&B run (optional)
logging_steps=1, # how often to log to W&B
logging_strategy = 'steps',
save_total_limit=2,
)
Dette er vigtigt for træningen. For at holde GPU-forbruget lavt, skal du holde antallet af tog-, eval-batch- og gradientakkumulerende trin lavt. Logging_steps er antallet af trin, før metrics logges til WandB.
Initialiser nu SFTTrainer.
trainer = SFTTrainer(
model = model,
tokenizer = tokenizer,
train_dataset = dataset_dict["train"],
eval_dataset=dataset_dict["test"],
dataset_text_field = "text",
max_seq_length = max_seq_length,
dataset_num_proc = 2,
packing = True, # Packs short sequences together to save time!
args = args,
)
Start nu træningen.
trainer_stats = trainer.train()
wandb.finish()
Under træningsløbet vil WandB spore trænings- og evalmålingerne. Du besøger det givne dashboard-link og ser det i realtid.
Dette er et skærmbillede fra min løbetur på en Colab notesbog.
Træningshastigheden vil afhænge af flere faktorer, herunder trænings- og evaldatastørrelserne, tog- og evalbatchstørrelsen og antallet af epoker. Hvis du støder på problemer med GPU-brug, kan du prøve at reducere batch- og gradientakkumuleringstrinstørrelserne. Togets batchstørrelse = batch_size_per_device * gradient_accumulation_steps. Og antallet af optimeringstrin = samlede træningsdata/batchstørrelse. Du kan lege med parametrene og se, hvilke der virker bedst.
Du kan visualisere trænings- og evalueringstabet af din træning på WandB-dashboardet.
Togtab
Eval tab
Afslutning
Du kan gemme LoRA-adapterne lokalt eller skubbe dem til HuggingFace Repository.
model.save_pretrained("lora_model") # Local saving
# model.push_to_hub("your_name/lora_model", token = "...") # Online saving
Du kan også indlæse den gemte model fra disken og bruge den til at konkludere.
if False:
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "lora_model", # YOUR MODEL YOU USED FOR TRAINING
max_seq_length = max_seq_length,
dtype = dtype,
load_in_4bit = load_in_4bit,
)
inputs = tokenizer(
[
alpaca_prompt.format(
"capital of France?", # instruction
"", # input
"", # output - leave this blank for a generation!
)
]*1, return_tensors = "pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens = 64, use_cache = True)
tokenizer.batch_decode(outputs)
Til streaming af modelsvar.
from transformers import TextStreamer
text_streamer = TextStreamer(tokenizer)
_ = model.generate(**inputs, streamer = text_streamer, max_new_tokens = 64)
Så det hele handlede om at finjustere en Tiny-Llama-model med WandB-logning.
Her er den Colab notesbog for det samme.
Konklusion
Små LLM'er kan være fordelagtige til implementering på computerbegrænset hardware, såsom personlige computere, mobiltelefoner og andre wearables osv. Finjustering gør det muligt for disse modeller at yde bedre på downstream-opgaver. I denne artikel lærte vi, hvordan man finjusterer en basissprogmodel på et datasæt.
Nøgleforsøg
- Finjustering er processen med at få en præ-trænet model til at tilpasse sig en specifik ny opgave.
- Tiny-Llama er en LLM med kun 1.1 milliarder parametre og trænes på 3 billioner tokens.
- Der er forskellige måder at finjustere LLM'er på, som LoRA og QLoRA.
- Unsloth er en open source-platform, der giver CUDA-optimerede LLM'er til at fremskynde finjustering af LLM'er.
- Weights and Biases (WandB) er et værktøj til sporing og lagring af ML-eksperimenter.
Ofte stillede spørgsmål
A. Finjustering, i forbindelse med maskinlæring, især deep learning, er en teknik, hvor man tager en fortrænet model og tilpasser den til en ny, specifik opgave.
A. Det er muligt at finjustere mindre LLM'er gratis på Colab over Tesla T4 GPU'en med QLoRA.
A. Finjustering forbedrer i høj grad LLM's evne til at udføre downstream-opgaver, såsom rollespil, kodegenerering osv.
A. Tiny-Llama trænet på 3 billioner tokens er en LLM med 1.1B parametre. Modellen adopterer den originale Llama-2-arkitektur.
A. Unsloth er et open source-værktøj, der giver hurtigere og mere effektiv finjustering af LLM ved at optimere GPU-kerner med Triton.
Mediet vist i denne artikel ejes ikke af Analytics Vidhya og bruges efter forfatterens skøn.
Relaterede
- SEO Powered Content & PR Distribution. Bliv forstærket i dag.
- PlatoData.Network Vertical Generative Ai. Styrk dig selv. Adgang her.
- PlatoAiStream. Web3 intelligens. Viden forstærket. Adgang her.
- PlatoESG. Kulstof, CleanTech, Energi, Miljø, Solenergi, Affaldshåndtering. Adgang her.
- PlatoHealth. Bioteknologiske og kliniske forsøgs intelligens. Adgang her.
- Kilde: https://www.analyticsvidhya.com/blog/2024/02/fine-tuning-a-tiny-llama-model-with-unsloth/
- :har
- :er
- :ikke
- :hvor
- $OP
- 1
- 11
- 12
- 15 %
- 16
- 1b
- 258
- 32
- 7
- 8
- a
- A100
- I stand
- Om
- Konto
- akkumulering
- nøjagtighed
- tilpasse
- tilpasning
- tilføje
- Alle
- tillader
- også
- beløb
- an
- analytics
- Analyse Vidhya
- ,
- enhver
- api
- app
- Indløs
- Anvendelse
- passende
- passende
- arkitektur
- ER
- argumenter
- omkring
- artikel
- AS
- At
- auto
- avatars
- b
- bund
- baseret
- BE
- været
- før
- jf. nedenstående
- gavnlig
- fordele
- BEDSTE
- Bedre
- skævhed
- fordomme
- Billion
- Bit
- bits
- blank
- blogathon
- kortvarigt
- bringe
- men
- by
- CAN
- kapaciteter
- kapacitet
- kapital
- tilfælde
- Boligtype
- chatte
- Vælg
- klasse
- kode
- kompakt
- sammenlignelig
- fuldføre
- Fuldender
- computere
- begreber
- Konfiguration
- konfigureret
- forbruger
- Forbruger hardware
- sammenhæng
- samtaler
- skabe
- oprettet
- afgørende
- Nuværende
- For øjeblikket
- skik
- Dash
- instrumentbræt
- data
- datasæt
- dedikeret
- dyb
- dyb læring
- definere
- afhænge
- afhænger
- indsætte
- implementering
- Derivater
- beskriver
- Detektion
- dialoger
- forskellige
- diskretion
- do
- ned
- tidligere
- Edge
- Effektiv
- effektivitet
- effektiv
- andet
- fremkomsten
- muliggøre
- møde
- Engine (Motor)
- Forbedrer
- nok
- enhed
- Miljø
- epoker
- især
- væsentlig
- etc.
- Ether (ETH)
- evaluering
- eksempel
- eksempler
- eksperimenter
- udforske
- faktorer
- FAIL
- falsk
- langt
- hurtigere
- få
- færre
- Flyde
- flydende
- følger
- Til
- format
- Fransk vin
- Gratis
- fra
- yderligere
- Gemini
- generelle formål
- generation
- få
- Git
- given
- giver
- Go
- GPU
- GPU'er
- stor
- Hardware
- Have
- link.
- Høj
- højere
- hold
- Hvordan
- How To
- Men
- HTTPS
- KrammerFace
- i
- if
- redskaber
- importere
- vigtigt
- Forbedre
- in
- Herunder
- indgang
- indgange
- installere
- i stedet
- anvisninger
- beregnet
- ind
- involverer
- spørgsmål
- IT
- jpg
- Holde
- holde
- Nøgle
- viden
- Kumar
- Sprog
- stor
- større
- Leads
- LÆR
- lærte
- læring
- Forlade
- mindre
- Lets
- Bibliotek
- ligesom
- rampelyset
- lineær
- LINK
- Llama
- llm
- belastning
- lastning
- lokale
- lokalt
- log
- logget
- logning
- off
- Lav
- lavere
- maskine
- machine learning
- lave
- Making
- administrere
- manuel
- max-bredde
- Medier
- Hukommelse
- nævnte
- metoder
- Metrics
- ML
- Mobil
- mobiltelefoner
- model
- modeller
- mere
- mere effektiv
- mest
- flere
- skal
- my
- navn
- Behov
- Ny
- næste
- Ingen
- notesbog
- nummer
- of
- tit
- ældre
- on
- online
- kun
- open source
- OpenAI
- optimering
- optimeret
- optimering
- or
- original
- OS
- Andet
- Ellers
- vores
- ud
- output
- udgange
- i løbet af
- ejede
- Packs
- parret
- parameter
- parametre
- del
- passerer
- udføre
- udfører
- personale
- Personlige computere
- telefoner
- billede
- perron
- plato
- Platon Data Intelligence
- PlatoData
- Leg
- Punkt
- Populær
- mulig
- Precision
- Forbered
- forberedt
- behandle
- produktion
- proprietære
- giver
- offentliggjort
- Skub ud
- Spørgsmål og svar
- kvalitet
- R
- rangerer
- realtid
- reducere
- reducere
- reduktion
- frigivet
- Repository
- anmode
- Kræver
- forskning
- svar
- reaktioner
- afkast
- roller
- RTX
- Kør
- samme
- Gem
- gemt
- besparelse
- skalering
- Videnskab
- se
- frø
- Vælg
- sæt
- Kort
- vist
- underskrive
- siden
- Størrelse
- størrelser
- bremser
- lille
- mindre
- specifikke
- hastighed
- delt
- står
- starte
- Trin
- Steps
- streaming
- Kamp
- væsentlig
- sådan
- support
- Understøtter
- Tag
- taget
- Opgaver
- opgaver
- teknik
- teknikker
- Tesla
- prøve
- tekst
- tekstgenerering
- end
- at
- deres
- Them
- derefter
- Der.
- Disse
- de
- ting
- denne
- Gennem
- tid
- til
- sammen
- token
- Tokens
- også
- tog
- værktøj
- værktøjer
- fakkel
- I alt
- spor
- Sporing
- Tog
- uddannet
- Kurser
- transformers
- trillion
- Triton
- sand
- prøv
- opdatering
- us
- Brug
- brug
- anvendte
- Værdier
- udgave
- via
- Besøg
- Visualiser
- var
- Vej..
- måder
- we
- wearables
- web
- WebP
- vægt
- GODT
- var
- Hvad
- Hvad er
- hvornår
- som
- mens
- vilje
- med
- virker
- skriver
- dig
- Din
- zephyrnet