Introductie
Nadat de Llama- en Mistral-modellen waren uitgebracht, haalden de open-source LLM's de schijnwerpers uit OpenAI. Sindsdien zijn er meerdere modellen uitgebracht op basis van de Llama- en Mistral-architectuur, die vergelijkbaar zijn met eigen modellen zoals GPT-3.5 Turbo, Claude, Gemini, enz. Deze modellen zijn echter te groot om in consumentenhardware te worden gebruikt.
Maar de laatste tijd is er een nieuwe klasse van LLM's ontstaan. Dit zijn de LLM's in de parametercategorie sub-7B. Door minder parameters zijn ze compact genoeg om in consumentenhardware te draaien, terwijl de efficiëntie vergelijkbaar blijft met die van de 7B-modellen. Modellen als Tiny-Llama-1B, Microsoft's Phi-2 en Alibaba's Qwen-3b kunnen geweldige vervangers zijn voor grotere modellen om lokaal te draaien of op edge te implementeren. Tegelijkertijd is verfijning van cruciaal belang om het beste uit elk basismodel te halen voor alle vervolgtaken.
Hier zullen we onderzoeken hoe u een basis kunt verfijnen Tiny-Llama-model op een schoongemaakte Alpaca-dataset.
leerdoelen
- Begrijp de fijnafstelling en de verschillende methoden ervan.
- Leer meer over tools en technieken voor efficiënte afstemming.
- Leer meer over WandB voor het loggen van trainingslogboeken.
- Verfijn Tiny-Llama op de Alpaca-dataset in Colab.
Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.
Inhoudsopgave
Wat is LLM-finetuning?
Fine-tuning is het proces waarbij een vooraf getraind model nieuwe kennis leert. Het vooraf getrainde model is een model voor algemene doeleinden dat is getraind op een grote hoeveelheid gegevens. In de meeste gevallen presteren ze echter niet zoals bedoeld, en verfijning is de meest effectieve manier om het model aan te passen aan specifieke gebruikssituaties. Basis bijvoorbeeld LLM's doen het goed bij het genereren van tekst op single-turn QA, maar hebben moeite met multi-turn gesprekken zoals chatmodellen.
De basismodellen moeten worden getraind op transcripties van dialogen om multi-turn gesprekken te kunnen voeren. Verfijning is essentieel om vooraf getrainde modellen in verschillende avatars te vormen. De kwaliteit van verfijnde modellen hangt af van de kwaliteit van de gegevens en de mogelijkheden van het basismodel. Er zijn meerdere manieren om fijnafstemming te modelleren, zoals LoRA, QLoRA, enz.
Laten we deze concepten kort doornemen.
LoRA
LoRA staat voor Low-rank Adaptation, een populaire verfijningstechniek waarbij we een paar trainbare parameters selecteren in plaats van alle parameters bij te werken via een lage benadering van de originele gewichtsmatrices. Het LoRA-model kan sneller worden verfijnd op minder rekenintensieve hardware.
QLoRA
QLoRA of Quantized LoRA is een stap verder dan de LoRA. In plaats van een model met volledige precisie, kwantiseert het de modelgewichten om de drijvende-kommaprecisie te verlagen voordat LoRA wordt toegepast. Kwantisering is het proces waarbij hogere bitwaarden naar lagere waarden worden omgezet. Een 4-bit kwantiseringsproces omvat het kwantiseren van de 16-bit gewichten naar 4-bit float-waarden.
Het kwantificeren van het model leidt tot een substantiële verkleining van de modelomvang met een nauwkeurigheid die vergelijkbaar is met die van het originele model. Bij QLoRA nemen we een gekwantiseerd model en passen we LoRA daarop toe. De modellen kunnen op meerdere manieren worden gekwantiseerd, zoals via llama.cpp, AWQ, bitsandbytes, enz.
Fijnafstemming met Unsloth
Unsloth is een open-sourceplatform waarmee u populaire grote taalmodellen sneller kunt verfijnen. Het ondersteunt populaire LLM's, waaronder Llama-2 en Mistral, en hun afgeleiden zoals Yi, Open-hermes, enz. Het implementeert aangepaste triton-kernels en een handmatige back-prop-engine om de snelheid van de modeltraining te verbeteren.
Hier zullen we de Unsloth gebruiken om een 4-bits gekwantiseerd Tiny-Llama-basismodel op de Alpaca gegevensset. Het model is gekwantiseerd met bits en bytes, en kernels zijn geoptimaliseerd met Triton van OpenAI.
Loggen met WandB
Bij machine learning is het van cruciaal belang om trainings- en evaluatiegegevens vast te leggen. Hierdoor krijgen we een compleet beeld van de treinrit. Gewichten en afwijkingen (WandB) is een open-sourcebibliotheek voor het visualiseren en volgen van machine learning-experimenten. Het heeft een speciale web-app voor het in realtime visualiseren van trainingsstatistieken. Ook kunnen we productiemodellen centraal beheren. We zullen WandB alleen gebruiken om onze Tiny-Llama-verfijningsrun te volgen.
Om WandB te gebruiken, meldt u zich aan voor een gratis account en maakt u een API sleutel.
Laten we nu beginnen met het verfijnen van ons model.
Hoe Tiny-Llama verfijnen?
Het nauwkeurig afstemmen is een rekenintensieve taak. Er is een machine met 10-15 GB VRAM voor nodig, of je kunt de gratis Tesla T4 GPU-runtime van Colab gebruiken.
Installeer nu Unsloth en 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
Het volgende is het laden van het 4-bits gekwantiseerde, vooraf getrainde model met 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,
)
Hiermee wordt het model lokaal geïnstalleerd. De grootte van het 4-bits model zal ongeveer 760 MB zijn.
Solliciteer nu PEFT naar het 4-bit Tiny-Llama-model.
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
)
Bereid gegevens voor
De volgende stap is het voorbereiden van de dataset voor verfijning. Zoals ik eerder al zei, zullen we een gereinigde gebruiken Alpaca-gegevensset. Dit is een opgeschoonde versie van de originele Alpaca-dataset. Het volgt het instructie-invoer-antwoordformaat. Hier is een voorbeeld van Alpaca-gegevens
Laten we nu onze gegevens voorbereiden.
@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,)
Splits nu de gegevens in trein- en evaluatiegegevens. Ik heb kleine evaluatiegegevens genomen omdat grotere evaluatiegegevens de training vertragen.
dataset_dict = dataset.train_test_split(test_size=0.004)
Configureer WandB
Configureer nu Weights and Biases in uw huidige runtime.
# @title wandb init
import wandb
wandb.login()
Geef de API-sleutel op om in te loggen bij WandB wanneer daarom wordt gevraagd.
Omgevingsvariabelen instellen.
%env WANDB_WATCH=all
%env WANDB_SILENT=true
Treinmodel
Tot nu toe hebben we het 4-bits model geladen, de LoRA-configuratie gemaakt, de dataset voorbereid en WandB geconfigureerd. De volgende stap is het trainen van het model op de gegevens. Daarvoor moeten we een trainer uit de Trl-bibliotheek definiëren. We gebruiken de SFTrainer van Trl. Maar initialiseer daarvoor WandB en definieer de juiste trainingsargumenten.
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")
Trainingsargumenten
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,
)
Dit is belangrijk voor de training. Om het GPU-gebruik laag te houden, moet u de stappen voor het verzamelen van treinen, evaluatiebatches en gradiënten laag houden. De logging_steps is het aantal stappen voordat statistieken worden vastgelegd in WandB.
Initialiseer nu de 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,
)
Begin nu met de training.
trainer_stats = trainer.train()
wandb.finish()
Tijdens de trainingsrun houdt WandB de trainings- en evaluatiegegevens bij. U bezoekt de gegeven dashboardlink en ziet deze in realtime.
Dit is een screenshot van mijn run op een Colab-notebook.
De trainingssnelheid is afhankelijk van meerdere factoren, waaronder de gegevensgrootte van de training en evaluatie, de batchgrootte van de trein en evaluatie en het aantal tijdperken. Als u GPU-gebruiksproblemen ondervindt, probeer dan de stapgroottes van batch- en gradiëntaccumulatie te verkleinen. De batchgrootte van de trein = batch_size_per_device * gradiënt_accumulatie_stappen. En het aantal optimalisatiestappen = totale trainingsgegevens/batchgrootte. Je kunt met de parameters spelen en zien welke beter werkt.
Op het WandB dashboard kun je het trainings- en evaluatieverlies van je training visualiseren.
Trein verlies
Eval verlies
Inferenties
U kunt de LoRA-adapters lokaal opslaan of naar de HuggingFace Repository pushen.
model.save_pretrained("lora_model") # Local saving
# model.push_to_hub("your_name/lora_model", token = "...") # Online saving
U kunt het opgeslagen model ook van de schijf laden en voor gevolgtrekkingen gebruiken.
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)
Voor het streamen van modelreacties.
from transformers import TextStreamer
text_streamer = TextStreamer(tokenizer)
_ = model.generate(**inputs, streamer = text_streamer, max_new_tokens = 64)
Dit ging dus allemaal over het verfijnen van een Tiny-Llama-model met WandB-logboekregistratie.
Hier is de Colab-notitieblok voor het zelfde.
Conclusie
Kleine LLM's kunnen nuttig zijn bij implementatie op computerbeperkte hardware, zoals personal computers, mobiele telefoons en andere wearables, enz. Dankzij de fijnafstemming kunnen deze modellen beter presteren bij downstream-taken. In dit artikel hebben we geleerd hoe u een basistaalmodel op een dataset kunt verfijnen.
Key Takeaways
- Fine-tuning is het proces waarbij een vooraf getraind model wordt aangepast aan een specifieke nieuwe taak.
- Tiny-Llama is een LLM met slechts 1.1 miljard parameters en is getraind op 3 biljoen tokens.
- Er zijn verschillende manieren om LLM's te verfijnen, zoals LoRA en QLoRA.
- Unsloth is een open-sourceplatform dat voor CUDA geoptimaliseerde LLM's biedt om het verfijnen van LLM's te versnellen.
- Weights and Biases (WandB) is een hulpmiddel voor het volgen en opslaan van ML-experimenten.
Veelgestelde Vragen / FAQ
A. In de context van machinaal leren, en vooral deep learning, is verfijning een techniek waarbij je een vooraf getraind model gebruikt en dit aanpast aan een nieuwe, specifieke taak.
A. Het is mogelijk om kleinere LLM's gratis te verfijnen op Colab via de Tesla T4 GPU met QLoRA.
A. Door het afstemmen wordt het vermogen van LLM om downstream-taken uit te voeren, zoals rollenspellen, het genereren van code, enz. enorm vergroot.
A. Tiny-Llama getraind op 3 biljoen tokens is een LLM met 1.1 miljard parameters. Het model neemt de originele Llama-2-architectuur over.
A. Unsloth is een open-sourcetool die snellere en efficiëntere LLM-fijnafstemming biedt door GPU-kernels te optimaliseren met Triton.
De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt.
Verwant
- Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
- PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
- PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
- PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
- Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
- Bron: https://www.analyticsvidhya.com/blog/2024/02/fine-tuning-a-tiny-llama-model-with-unsloth/
- : heeft
- :is
- :niet
- :waar
- $UP
- 1
- 11
- 12
- 15%
- 16
- 1b
- 258
- 32
- 7
- 8
- a
- A100
- in staat
- Over
- Account
- ophoping
- nauwkeurigheid
- aanpassen
- aanpassing
- toevoegen
- Alles
- toestaat
- ook
- bedragen
- an
- analytics
- Analytics Vidhya
- en
- elke
- api
- gebruiken
- Solliciteer
- Het toepassen van
- passend
- op gepaste wijze
- architectuur
- ZIJN
- argumenten
- rond
- dit artikel
- AS
- At
- auto
- Avatars
- b
- baseren
- gebaseerde
- BE
- geweest
- vaardigheden
- onder
- heilzaam
- betekent
- BEST
- Betere
- vooringenomenheid
- vooroordelen
- Miljard
- Beetje
- stukjes
- blanco
- blogathon
- kort
- brengen
- maar
- by
- CAN
- mogelijkheden
- bekwaamheid
- hoofdstad
- gevallen
- Categorie
- de chat
- Kies
- klasse
- code
- compact
- vergelijkbaar
- compleet
- voltooit
- computers
- concepten
- Configuratie
- geconfigureerd
- consument
- Consumentenhardware
- verband
- conversaties
- en je merk te creëren
- aangemaakt
- cruciaal
- Actueel
- Op dit moment
- gewoonte
- Dash
- dashboards
- gegevens
- datasets
- toegewijd aan
- deep
- diepgaand leren
- bepalen
- afhangen
- afhankelijk
- implementeren
- het inzetten
- Derivaten
- beschrijft
- Opsporing
- dialogen
- anders
- goeddunken
- do
- beneden
- Vroeger
- rand
- effectief
- doeltreffendheid
- doeltreffend
- anders
- opkomst
- in staat stellen
- ontmoeting
- Motor
- Verbetert
- genoeg
- entiteit
- Milieu
- tijdperken
- vooral
- essentieel
- etc
- Ether (ETH)
- evaluatie
- voorbeeld
- voorbeelden
- experimenten
- Verken
- factoren
- FAIL
- vals
- ver
- sneller
- weinig
- minder
- Vlotter
- drijvend
- volgt
- Voor
- formaat
- Frankrijk
- Gratis
- oppompen van
- verder
- Gemini
- voor algemeen gebruik
- generatie
- krijgen
- Git
- gegeven
- geeft
- Go
- Kopen Google Reviews
- GPU
- GPU's
- groot
- Hardware
- Hebben
- hier
- Hoge
- hoger
- houden
- Hoe
- How To
- Echter
- HTTPS
- KnuffelenGezicht
- i
- if
- gereedschap
- importeren
- belangrijk
- verbeteren
- in
- Inclusief
- invoer
- ingangen
- installeren
- verkrijgen in plaats daarvan
- instructies
- bestemde
- in
- gaat
- problemen
- IT
- jpg
- Houden
- houden
- sleutel
- kennis
- kumar
- taal
- Groot
- groter
- Leads
- LEARN
- geleerd
- leren
- Verlof
- minder
- Laten we
- Bibliotheek
- als
- schijnwerpers
- lineair
- LINK
- Lama
- lm
- laden
- het laden
- lokaal
- plaatselijk
- inloggen
- ingelogd
- logging
- uit
- Laag
- te verlagen
- machine
- machine learning
- maken
- maken
- beheer
- handboek
- max-width
- Media
- Geheugen
- vermeld
- methoden
- Metriek
- ML
- Mobile
- mobieltjes
- model
- modellen
- meer
- efficiënter
- meest
- meervoudig
- Dan moet je
- my
- naam
- Noodzaak
- New
- volgende
- Geen
- notitieboekje
- aantal
- of
- vaak
- ouder
- on
- online.
- Slechts
- open source
- OpenAI
- optimalisatie
- geoptimaliseerde
- optimaliseren
- or
- origineel
- OS
- Overige
- anders-
- onze
- uit
- uitgang
- uitgangen
- over
- eigendom
- Packs
- gepaarde
- parameter
- parameters
- deel
- passeren
- uitvoeren
- uitvoerend
- persoonlijk
- Persoonlijke computers
- telefoons
- beeld
- platform
- Plato
- Plato gegevensintelligentie
- PlatoData
- Spelen
- punt
- Populair
- mogelijk
- precisie
- Voorbereiden
- bereid
- productie
- gepatenteerd
- biedt
- gepubliceerde
- Duwen
- Q & A
- kwaliteit
- R
- rangschikken
- real-time
- verminderen
- vermindering
- reductie
- uitgebracht
- bewaarplaats
- te vragen
- vereist
- onderzoek
- antwoord
- reacties
- terugkeer
- Rol
- RTX
- lopen
- dezelfde
- Bespaar
- gered
- besparing
- scaling
- Wetenschap
- zien
- zaad
- kiezen
- reeks
- Bermuda's
- getoond
- teken
- sinds
- Maat
- maten
- vertraagt
- Klein
- kleinere
- specifiek
- snelheid
- spleet
- staat
- begin
- Stap voor
- Stappen
- streaming
- wezenlijk
- dergelijk
- ondersteuning
- steunen
- Nemen
- ingenomen
- Taak
- taken
- techniek
- technieken
- Tesla
- proef
- tekst
- tekst generatie
- neem contact
- dat
- De
- hun
- Ze
- harte
- Er.
- Deze
- ze
- ding
- dit
- Door
- niet de tijd of
- naar
- samen
- teken
- tokens
- ook
- nam
- tools
- tools
- fakkel
- Totaal
- spoor
- Tracking
- Trainen
- getraind
- Trainingen
- transformers
- Triljoen
- Triton
- waar
- proberen
- bijwerken
- us
- Gebruik
- .
- gebruikt
- Values
- versie
- via
- Bezoek
- visualiseren
- was
- Manier..
- manieren
- we
- wearables
- web
- webp
- gewicht
- GOED
- waren
- Wat
- Wat is
- wanneer
- welke
- en
- wil
- Met
- Bedrijven
- schrijven
- u
- Your
- zephyrnet