Beskrivning
Efter att modellerna Llama och Mistral släpptes tog LLM med öppen källkod rampljuset ur OpenAI. Sedan dess har flera modeller släppts baserade på Llama- och Mistral-arkitektur, som presterar i nivå med proprietära modeller som GPT-3.5 Turbo, Claude, Gemini, etc. Dessa modeller är dock för stora för att användas i konsumenthårdvara.
Men på senare tid har det dykt upp en ny klass av LLM. Dessa är LLM i parameterkategorin sub-7B. Färre parametrar gör dem tillräckligt kompakta för att köras i konsumenthårdvara samtidigt som effektiviteten är jämförbar med 7B-modellerna. Modeller som Tiny-Llama-1B, Microsofts Phi-2 och Alibabas Qwen-3b kan vara bra substitut för större modeller att köra lokalt eller installera på kanten. Samtidigt är finjustering avgörande för att få ut det bästa ur alla basmodeller för alla nedströmsuppgifter.
Här kommer vi att utforska hur man finjusterar en bas Tiny-Llama modell på en rengjord Alpaca-dataset.
Inlärningsmål
- Förstå finjustering och olika metoder för det.
- Lär dig om verktyg och tekniker för effektiv finjustering.
- Lär dig mer om WandB för att logga träningsloggar.
- Finjustera Tiny-Llama på Alpaca-datasetet i Colab.
Denna artikel publicerades som en del av Data Science Blogathon.
Innehållsförteckning
Vad är LLM Fine-Tuning?
Finjustering är processen att få en förutbildad modell att lära sig ny kunskap. Den förtränade modellen är en generell modell som tränas på en stor mängd data. Men i de flesta fall fungerar de inte som avsett, och finjustering är det mest effektiva sättet att få modellen att anpassa sig till specifika användningsfall. Till exempel bas LLM klarar sig bra i textgenerering på single-turn QA men kämpar med multi-turn konversationer som chattmodeller.
Basmodellerna behöver tränas på utskrifter av dialoger för att kunna föra flervarvssamtal. Finjustering är viktigt för att forma förtränade modeller till olika avatarer. Kvaliteten på finjusterade modeller beror på kvaliteten på data och basmodellkapacitet. Det finns flera sätt att modellera finjustering, som LoRA, QLoRA, etc.
Låt oss kort gå igenom dessa begrepp.
LoRA
LoRA står för Low-rank Adaptation, en populär finjusteringsteknik där vi väljer ett fåtal inlärningsbara parametrar istället för att uppdatera alla parametrar via en lågrankad approximation av originalviktsmatriser. LoRA-modellen kan finjusteras snabbare på mindre datorintensiv hårdvara.
QLoRA
QLoRA eller Quantized LoRA är ett steg längre än LoRA. Istället för en modell med full precision, kvantiserar den modellvikterna för att sänka flyttalsprecisionen innan LoRA appliceras. Kvantisering är processen att nedsända högre bitvärden till lägre värden. En 4-bitars kvantiseringsprocess involverar kvantisering av 16-bitars vikter till 4-bitars flytvärden.
Kvantisering av modellen leder till en avsevärd minskning av modellstorleken med jämförbar noggrannhet som den ursprungliga modellen. I QLoRA tar vi en kvantifierad modell och tillämpar LoRA på den. Modellerna kan kvantiseras på flera sätt, såsom genom llama.cpp, AWQ, bitsandbytes, etc.
Finjustera med Unsloth
Unsloth är en öppen källkodsplattform för att finjustera populära stora språkmodeller snabbare. Den stöder populära LLM, inklusive Llama-2 och Mistral, och deras derivator som Yi, Open-hermes, etc. Den implementerar anpassade triton-kärnor och en manuell back-prop-motor för att förbättra hastigheten på modellträningen.
Här kommer vi att använda Unsloth för att finjustera en bas 4-bitars kvantifierad Tiny-Llama-modell på Alpacka dataset. Modellen är kvantifierad med bitar och bytes, och kärnor är optimerade med OpenAI:s Triton.
Loggning med WandB
Inom maskininlärning är det avgörande att logga utbildnings- och utvärderingsmått. Detta ger oss en helhetsbild av tågkörningen. Vikt och fas (WandB) är ett bibliotek med öppen källkod för att visualisera och spåra maskininlärningsexperiment. Den har en dedikerad webbapp för att visualisera träningsmått i realtid. Det låter oss också hantera produktionsmodeller centralt. Vi kommer endast att använda WandB för att spåra vår finjusteringskörning av Tiny-Llama.
För att använda WandB, registrera dig för ett gratis konto och skapa ett API-nyckel.
Låt oss nu börja finjustera vår modell.
Hur finjusterar man Tiny-Llama?
Finjustering är en beräkningstung uppgift. Det kräver en maskin med 10-15 GB VRAM, eller så kan du använda Colabs kostnadsfria Tesla T4 GPU-runtime.
Installera nu Unsloth och 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
Nästa sak är att ladda den 4-bitars kvantiserade förtränade modellen 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,
)
Detta kommer att installera modellen lokalt. 4-bitars modellstorleken kommer att vara cirka 760 MB.
Ansök nu PEFT till 4-bitars 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
)
Förbered data
Nästa steg är att förbereda datamängden för finjustering. Som jag nämnde tidigare kommer vi att använda en rengjord Alpaca dataset. Detta är en rensad version av den ursprungliga Alpaca-datauppsättningen. Den följer formatet instruktion-ingång-svar. Här är ett exempel på Alpaca-data
Låt oss nu förbereda vår 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,)
Dela nu upp data i tåg- och evaldata. Jag har tagit små evaldata då större evaldata saktar ner träningen.
dataset_dict = dataset.train_test_split(test_size=0.004)
Konfigurera WandB
Konfigurera nu vikter och fördomar i din nuvarande körtid.
# @title wandb init
import wandb
wandb.login()
Ange API-nyckel för att logga in på WandB när du uppmanas.
Ställ in miljövariabler.
%env WANDB_WATCH=all
%env WANDB_SILENT=true
Tågmodell
Hittills har vi laddat 4-bitarsmodellen, skapat LoRA-konfigurationen, förberett datasetet och konfigurerat WandB. Nästa steg är att träna modellen på data. För det måste vi definiera en tränare från Trl-biblioteket. Vi kommer att använda SFTrainer från Trl. Men innan dess, initiera WandB och definiera lämpliga träningsargument.
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äningsargument
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,
)
Detta är viktigt för träningen. För att hålla GPU-användningen låg, håll nere stegen för tåg, eval batch och gradientackumulering. Loggningssteg är antalet steg innan mätvärden loggas till WandB.
Initiera 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,
)
Nu, börja träningen.
trainer_stats = trainer.train()
wandb.finish()
Under träningsloppet kommer WandB att spåra tränings- och evalmätningarna. Du besöker den givna instrumentpanelslänken och ser den i realtid.
Det här är en skärmdump från min körning på en Colab-anteckningsbok.
Träningshastigheten kommer att bero på flera faktorer, inklusive tränings- och evaldatastorlekar, tåg- och evalbatchstorlek och antalet epoker. Om du stöter på problem med GPU-användningen, försök att minska storleken på batch- och gradientackumuleringssteg. Tågets batchstorlek = batch_size_per_device * gradient_accumulation_steps. Och antalet optimeringssteg = total träningsdata/batchstorlek. Du kan leka med parametrarna och se vilken som fungerar bäst.
Du kan visualisera tränings- och utvärderingsförlusten av din träning på WandB-instrumentpanelen.
Tågförlust
Eval förlust
Inferens
Du kan spara LoRA-adaptrarna lokalt eller skicka dem till HuggingFace Repository.
model.save_pretrained("lora_model") # Local saving
# model.push_to_hub("your_name/lora_model", token = "...") # Online saving
Du kan också ladda den sparade modellen från disken och använda den för slutledning.
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)
För streaming av modellsvar.
from transformers import TextStreamer
text_streamer = TextStreamer(tokenizer)
_ = model.generate(**inputs, streamer = text_streamer, max_new_tokens = 64)
Så det här handlade om att finjustera en Tiny-Llama-modell med WandB-loggning.
Här är Colab anteckningsbok för samma.
Slutsats
Små LLM:er kan vara fördelaktiga för implementering på datorbegränsad hårdvara, såsom persondatorer, mobiltelefoner och andra bärbara enheter, etc. Finjustering gör att dessa modeller kan prestera bättre på nedströmsuppgifter. I den här artikeln lärde vi oss hur man finjusterar en basspråkmodell på en datauppsättning.
Key Takeaways
- Finjustering är processen att få en förtränad modell att anpassa sig till en specifik ny uppgift.
- Tiny-Llama är en LLM med endast 1.1 miljarder parametrar och tränas på 3 biljoner tokens.
- Det finns olika sätt att finjustera LLM, som LoRA och QLoRA.
- Unsloth är en öppen källkodsplattform som tillhandahåller CUDA-optimerade LLM:er för att påskynda finjustering av LLM:er.
- Weights and Biases (WandB) är ett verktyg för att spåra och lagra ML-experiment.
Vanliga frågor
S. Finjustering, i samband med maskininlärning, särskilt djupinlärning, är en teknik där du tar en förtränad modell och anpassar den till en ny, specifik uppgift.
S. Det är möjligt att finjustera mindre LLM:er gratis på Colab över Tesla T4 GPU med QLoRA.
S. Finjustering förbättrar avsevärt LLM:s förmåga att utföra nedströmsuppgifter, som rollspel, kodgenerering, etc.
S. Tiny-Llama tränad på 3 biljoner tokens är en LLM med 1.1B parametrar. Modellen antar den ursprungliga Llama-2-arkitekturen.
A. Unsloth är ett verktyg med öppen källkod som ger snabbare och mer effektiv finjustering av LLM genom att optimera GPU-kärnor med Triton.
Medierna som visas i den här artikeln ägs inte av Analytics Vidhya och används efter författarens gottfinnande.
Relaterad
- SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
- PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
- PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
- Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
- PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
- Källa: https://www.analyticsvidhya.com/blog/2024/02/fine-tuning-a-tiny-llama-model-with-unsloth/
- : har
- :är
- :inte
- :var
- $UPP
- 1
- 11
- 12
- 15%
- 16
- 1b
- 258
- 32
- 7
- 8
- a
- A100
- Able
- Om oss
- Konto
- ackumulering
- noggrannhet
- anpassa
- anpassning
- lägga till
- Alla
- tillåter
- också
- mängd
- an
- analytics
- Analys Vidhya
- och
- vilken som helst
- api
- app
- Ansök
- Tillämpa
- lämpligt
- lämpligt
- arkitektur
- ÄR
- argument
- runt
- Artikeln
- AS
- At
- bil
- Avatars
- b
- bas
- baserat
- BE
- varit
- innan
- nedan
- fördelaktigt
- Fördelarna
- BÄST
- Bättre
- förspänning
- förspänner
- Miljarder
- Bit
- bitar
- blank
- bloggaton
- i korthet
- föra
- men
- by
- KAN
- kapacitet
- kapacitet
- kapital
- fall
- Kategori
- chatt
- Välja
- klass
- koda
- kompakt
- jämförbar
- fullborda
- slutför
- datorer
- Begreppen
- konfiguration
- konfigurerad
- Konsumenten
- Konsumenthårdvara
- sammanhang
- konversationer
- skapa
- skapas
- avgörande
- Aktuella
- För närvarande
- beställnings
- Dash
- instrumentbräda
- datum
- datauppsättningar
- dedicerad
- djup
- djupt lärande
- definiera
- bero
- beror
- distribuera
- utplacera
- Derivat
- beskriver
- Detektering
- dialoger
- olika
- diskretion
- do
- ner
- Tidigare
- kant
- Effektiv
- effektivitet
- effektiv
- annars
- uppkomst
- möjliggöra
- råka ut för
- Motor
- Förbättrar
- tillräckligt
- enhet
- Miljö
- epoker
- speciellt
- väsentlig
- etc
- Eter (ETH)
- utvärdering
- exempel
- exempel
- experiment
- utforska
- faktorer
- MISSLYCKAS
- falsk
- långt
- snabbare
- få
- färre
- Flyta
- flytande
- följer
- För
- format
- Frankrike
- Fri
- från
- ytterligare
- tvillingarna
- generell mening
- generering
- skaffa sig
- gå
- ges
- ger
- Go
- GPU
- GPUs
- stor
- hårdvara
- Har
- här.
- Hög
- högre
- hålla
- Hur ser din drömresa ut
- How To
- Men
- HTTPS
- Kramar ansikte
- i
- if
- redskap
- importera
- med Esport
- förbättra
- in
- Inklusive
- ingång
- ingångar
- installera
- istället
- instruktioner
- avsedd
- in
- innebär
- problem
- IT
- jpg
- Ha kvar
- hålla
- Nyckel
- kunskap
- kumar
- språk
- Large
- större
- Leads
- LÄRA SIG
- lärt
- inlärning
- Lämna
- mindre
- Lets
- Bibliotek
- tycka om
- rampljuset
- linjär
- LINK
- Lama
- llm
- läsa in
- läser in
- lokal
- lokalt
- log
- inloggad
- skogsavverkning
- förlust
- Låg
- lägre
- Maskinen
- maskininlärning
- göra
- Framställning
- hantera
- manuell
- max-bredd
- Media
- Minne
- nämnts
- metoder
- Metrics
- ML
- Mobil
- mobiltelefoner
- modell
- modeller
- mer
- mer effektiv
- mest
- multipel
- måste
- my
- namn
- Behöver
- Nya
- Nästa
- Ingen
- anteckningsbok
- antal
- of
- Ofta
- äldre
- on
- nätet
- endast
- öppen källkod
- OpenAI
- optimering
- optimerad
- optimera
- or
- ursprungliga
- OS
- Övriga
- annat
- vår
- ut
- produktion
- utgångar
- över
- ägd
- förpackningar
- parade
- parameter
- parametrar
- del
- passera
- utföra
- utför
- personlig
- Personliga datorer
- telefoner
- Bild
- plattform
- plato
- Platon Data Intelligence
- PlatonData
- Spela
- Punkt
- Populära
- möjlig
- Precision
- Förbered
- beredd
- process
- Produktion
- proprietary
- ger
- publicerade
- Tryck
- Frågor och svar
- kvalitet
- R
- rangordna
- realtid
- minska
- reducerande
- reduktion
- frigörs
- Repository
- begära
- Kräver
- forskning
- respons
- svar
- avkastning
- Roll
- RTX
- Körning
- Samma
- Save
- sparade
- sparande
- skalning
- Vetenskap
- se
- frö
- välj
- in
- Kort
- visas
- signera
- eftersom
- Storlek
- storlekar
- saktar
- Small
- mindre
- specifik
- fart
- delas
- står
- starta
- Steg
- Steg
- streaming
- Kamp
- väsentlig
- sådana
- stödja
- Stöder
- Ta
- tagen
- uppgift
- uppgifter
- Tekniken
- tekniker
- Tesla
- testa
- text
- textgenerering
- än
- den där
- Smakämnen
- deras
- Dem
- sedan
- Där.
- Dessa
- de
- sak
- detta
- Genom
- tid
- till
- tillsammans
- token
- tokens
- alltför
- tog
- verktyg
- verktyg
- brännaren
- Totalt
- spår
- Spårning
- Tåg
- tränad
- Utbildning
- transformatorer
- Biljon
- Triton
- sann
- prova
- uppdatering
- us
- Användning
- användning
- Begagnade
- Värden
- version
- via
- Besök
- visualisera
- var
- Sätt..
- sätt
- we
- användbara
- webb
- webp
- vikt
- VÄL
- były
- Vad
- Vad är
- när
- som
- medan
- kommer
- med
- fungerar
- skriva
- dig
- Din
- zephyrnet