Introduzione
Dopo il rilascio dei modelli Llama e Mistral, gli LLM open source hanno tolto le luci della ribalta da OpenAI. Da allora, sono stati rilasciati più modelli basati sull'architettura Llama e Mistral, con prestazioni alla pari con modelli proprietari come GPT-3.5 Turbo, Claude, Gemini, ecc. Tuttavia, questi modelli sono troppo grandi per essere utilizzati nell'hardware consumer.
Ma ultimamente è emersa una nuova classe di LLM. Questi sono gli LLM nella categoria dei parametri sub-7B. Meno parametri li rendono sufficientemente compatti da poter essere utilizzati su hardware consumer mantenendo un'efficienza paragonabile ai modelli 7B. Modelli come Tiny-Llama-1B, Phi-2 di Microsoft e Qwen-3b di Alibaba possono essere ottimi sostituti di modelli più grandi da eseguire localmente o implementare on edge. Allo stesso tempo, la messa a punto è fondamentale per ottenere il meglio da qualsiasi modello di base per qualsiasi attività successiva.
Qui esploreremo come mettere a punto una base Modello Tiny-Llama su un set di dati Alpaca pulito.
obiettivi formativi
- Comprendere la messa a punto e i diversi metodi per eseguirla.
- Scopri gli strumenti e le tecniche per un'ottimizzazione efficiente.
- Ulteriori informazioni su WandB per la registrazione dei registri di formazione.
- Ottimizza Tiny-Llama sul set di dati Alpaca in Colab.
Questo articolo è stato pubblicato come parte di Blogathon sulla scienza dei dati.
Sommario
Che cos'è la messa a punto LLM?
Il fine tuning è il processo attraverso il quale un modello pre-addestrato apprende nuove conoscenze. Il modello pre-addestrato è un modello generico addestrato su una grande quantità di dati. Tuttavia, nella maggior parte dei casi, non funzionano come previsto e la messa a punto è il modo più efficace per adattare il modello a casi d’uso specifici. Ad esempio, base LLM ottengono buoni risultati nella generazione di testo nel QA a turno singolo, ma hanno difficoltà con le conversazioni a più turni come i modelli di chat.
I modelli base devono essere addestrati sulle trascrizioni dei dialoghi per essere in grado di sostenere conversazioni a più turni. La messa a punto è essenziale per modellare i modelli pre-addestrati in avatar diversi. La qualità dei modelli ottimizzati dipende dalla qualità dei dati e dalle funzionalità del modello di base. Esistono diversi modi per ottimizzare il modello, come LoRA, QLoRA, ecc.
Esaminiamo brevemente questi concetti.
LORA
LoRA sta per Low-rank Adaptation, una tecnica popolare di fine tuning in cui selezioniamo alcuni parametri addestrabili invece di aggiornare tutti i parametri tramite un'approssimazione di basso rango delle matrici di peso originali. Il modello LoRA può essere ottimizzato più velocemente su hardware meno intensivo di calcolo.
QLoRA
QLoRA o Quantized LoRA è un passo avanti rispetto a LoRA. Invece di un modello a precisione completa, quantizza i pesi del modello per ridurre la precisione in virgola mobile prima di applicare LoRA. La quantizzazione è il processo di downcasting dei valori di bit più alti a valori più bassi. Un processo di quantizzazione a 4 bit comporta la quantizzazione dei pesi a 16 bit in valori float a 4 bit.
La quantizzazione del modello porta a una sostanziale riduzione delle dimensioni del modello con una precisione paragonabile al modello originale. In QLoRA, prendiamo un modello quantizzato e gli applichiamo LoRA. I modelli possono essere quantizzati in diversi modi, ad esempio tramite llama.cpp, AWQ, bitsandbytes, ecc.
Ottimizzazione con Unsloth
Unsloth è una piattaforma open source per ottimizzare più rapidamente i modelli linguistici di grandi dimensioni più diffusi. Supporta LLM popolari, inclusi Llama-2 e Mistral, e i loro derivati come Yi, Open-hermes, ecc. Implementa kernel Triton personalizzati e un motore di back-prop manuale per migliorare la velocità di addestramento del modello.
Qui utilizzeremo Unsloth per mettere a punto un modello Tiny-Llama quantizzato a 4 bit base sul Alpaca set di dati. Il modello è quantizzato con bit e byte e i kernel sono ottimizzati con Triton di OpenAI.
Registrazione con WandB
Nell'apprendimento automatico, è fondamentale registrare le metriche di formazione e valutazione. Questo ci dà un quadro completo della corsa del treno. Pesi e pregiudizi (WandB) è una libreria open source per la visualizzazione e il monitoraggio degli esperimenti di machine learning. Dispone di un'app Web dedicata per visualizzare le metriche di allenamento in tempo reale. Ci consente inoltre di gestire centralmente i modelli di produzione. Utilizzeremo WandB solo per tracciare la nostra corsa di messa a punto di Tiny-Llama.
Per utilizzare WandB, registrati per un account gratuito e crea un Chiave API.
Ora iniziamo a mettere a punto il nostro modello.
Come mettere a punto Tiny-Llama?
La messa a punto è un compito impegnativo dal punto di vista computazionale. Richiede una macchina con 10-15 GB di VRAM oppure puoi utilizzare il runtime gratuito della GPU Tesla T4 di Colab.
Ora installa Unsloth e 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
La prossima cosa da fare è caricare il modello pre-addestrato quantizzato a 4 bit con 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,
)
Questo installerà il modello localmente. La dimensione del modello a 4 bit sarà di circa 760 MB.
Ora applica PEFT al modello Tiny-Llama a 4 bit.
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
)
Prepara i dati
Il passo successivo è preparare il set di dati per la messa a punto. Come ho detto prima, useremo un pulito Set di dati sull'alpaca. Questa è una versione pulita del set di dati Alpaca originale. Segue il formato istruzione-input-risposta. Ecco un esempio di dati Alpaca
Ora prepariamo i nostri dati.
@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,)
Ora dividi i dati in dati di treno e di valutazione. Ho preso dati di valutazione piccoli poiché dati di valutazione più grandi rallentano l'addestramento.
dataset_dict = dataset.train_test_split(test_size=0.004)
Configura WandB
Ora configura pesi e bias nel tuo runtime corrente.
# @title wandb init
import wandb
wandb.login()
Fornire la chiave API per accedere a WandB quando richiesto.
Configura le variabili di ambiente.
%env WANDB_WATCH=all
%env WANDB_SILENT=true
Modello di treno
Finora abbiamo caricato il modello a 4 bit, creato la configurazione LoRA, preparato il set di dati e configurato WandB. Il passaggio successivo è addestrare il modello sui dati. Per questo dobbiamo definire un trainer dalla libreria Trl. Utilizzeremo il SFTrainer di Trl. Ma prima, inizializza WandB e definisci gli argomenti di training appropriati.
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")
Argomenti di formazione
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,
)
Questo è importante per la formazione. Per mantenere basso l'utilizzo della GPU, mantieni bassi i passaggi di accumulo di treno, batch di valutazione e gradiente. logging_steps è il numero di passaggi prima che i parametri vengano registrati su WandB.
Ora inizializza 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,
)
Ora inizia la formazione.
trainer_stats = trainer.train()
wandb.finish()
Durante l'esecuzione dell'addestramento, WandB monitorerà le metriche di addestramento e valutazione. Visiti il collegamento della dashboard indicato e lo vedi in tempo reale.
Questo è uno screenshot della mia corsa su un notebook Colab.
La velocità di addestramento dipenderà da molteplici fattori, tra cui le dimensioni dei dati di addestramento e valutazione, le dimensioni del batch di formazione e valutazione e il numero di epoche. Se riscontri problemi di utilizzo della GPU, prova a ridurre le dimensioni dei passaggi di accumulo di batch e gradienti. La dimensione del batch del treno = batch_size_per_device * gradient_accumulation_steps. E il numero di passaggi di ottimizzazione = dati di addestramento totali/dimensione batch. Puoi giocare con i parametri e vedere quale funziona meglio.
Puoi visualizzare la perdita di formazione e valutazione della tua formazione sulla dashboard di WandB.
Perdita del treno
Perdita di valutazione
Inferenza
Puoi salvare gli adattatori LoRA localmente o inviarli al repository HuggingFace.
model.save_pretrained("lora_model") # Local saving
# model.push_to_hub("your_name/lora_model", token = "...") # Online saving
È inoltre possibile caricare il modello salvato dal disco e utilizzarlo per l'inferenza.
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)
Per lo streaming delle risposte del modello.
from transformers import TextStreamer
text_streamer = TextStreamer(tokenizer)
_ = model.generate(**inputs, streamer = text_streamer, max_new_tokens = 64)
Quindi, si trattava di mettere a punto un modello Tiny-Llama con la registrazione WandB.
Ecco il Quaderno Colab per lo stesso.
Conclusione
I piccoli LLM possono essere utili per la distribuzione su hardware con limitazioni di calcolo, come personal computer, telefoni cellulari e altri dispositivi indossabili, ecc. La regolazione fine consente a questi modelli di funzionare meglio nelle attività downstream. In questo articolo abbiamo imparato come ottimizzare un modello linguistico di base su un set di dati.
Punti chiave
- Il fine tuning è il processo attraverso il quale un modello pre-addestrato si adatta a un nuovo compito specifico.
- Tiny-Llama è un LLM con solo 1.1 miliardi di parametri ed è addestrato su 3 trilioni di token.
- Esistono diversi modi per ottimizzare gli LLM, come LoRA e QLoRA.
- Unsloth è una piattaforma open source che fornisce LLM ottimizzati per CUDA per accelerare la messa a punto dei LLM.
- Weights and Biases (WandB) è uno strumento per monitorare e archiviare esperimenti ML.
Domande frequenti
R. Il fine tuning, nel contesto dell'apprendimento automatico, in particolare del deep learning, è una tecnica in cui si prende un modello pre-addestrato e lo si adatta a un compito nuovo e specifico.
R. È possibile ottimizzare gratuitamente LLM più piccoli su Colab sulla GPU Tesla T4 con QLoRA.
R. La messa a punto migliora notevolmente la capacità di LLM di eseguire attività a valle, come giochi di ruolo, generazione di codice, ecc.
R. Tiny-Llama addestrato su 3 trilioni di token è un LLM con parametri da 1.1 miliardi. Il modello adotta l'architettura originale Llama-2.
R. Unsloth è uno strumento open source che fornisce una messa a punto LLM più rapida ed efficiente ottimizzando i kernel GPU con Triton.
I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e vengono utilizzati a discrezione dell'autore.
Leggi Anche
- Distribuzione di contenuti basati su SEO e PR. Ricevi amplificazione oggi.
- PlatoData.Network Generativo verticale Ai. Potenzia te stesso. Accedi qui.
- PlatoAiStream. Intelligenza Web3. Conoscenza amplificata. Accedi qui.
- PlatoneESG. Carbonio, Tecnologia pulita, Energia, Ambiente, Solare, Gestione dei rifiuti. Accedi qui.
- Platone Salute. Intelligence sulle biotecnologie e sulle sperimentazioni cliniche. Accedi qui.
- Fonte: https://www.analyticsvidhya.com/blog/2024/02/fine-tuning-a-tiny-llama-model-with-unsloth/
- :ha
- :È
- :non
- :Dove
- $ SU
- 1
- 11
- 12
- 15%
- 16
- 1b
- 258
- 32
- 7
- 8
- a
- A100
- capace
- Chi siamo
- Il mio account
- accumulazione
- precisione
- adattare
- adattamento
- aggiungere
- Tutti
- consente
- anche
- quantità
- an
- analitica
- Analisi Vidhya
- ed
- in qualsiasi
- api
- App
- APPLICA
- AMMISSIONE
- opportuno
- appropriatamente
- architettura
- SONO
- argomenti
- in giro
- articolo
- AS
- At
- auto
- avatars
- b
- base
- basato
- BE
- stato
- prima
- sotto
- benefico
- vantaggi
- MIGLIORE
- Meglio
- pregiudizio
- pregiudizi
- Miliardo
- Po
- bit
- vuoto
- blogathon
- brevemente
- portare
- ma
- by
- Materiale
- funzionalità
- capacità
- capitale
- casi
- Categoria
- chiacchierare
- Scegli
- classe
- codice
- compatto
- paragonabile
- completamento di una
- Completa
- computer
- concetti
- Configurazione
- configurato
- Consumer
- Hardware di consumo
- contesto
- Conversazioni
- creare
- creato
- cruciale
- Corrente
- Attualmente
- costume
- Dash
- cruscotto
- dati
- dataset
- dedicato
- deep
- apprendimento profondo
- definire
- dipendere
- dipende
- schierare
- distribuzione
- Derivati
- descrive
- rivelazione
- dialoghi
- diverso
- discrezione
- do
- giù
- In precedenza
- bordo
- Efficace
- efficienza
- efficiente
- altro
- emersione
- enable
- incontrare
- motore
- Migliora
- abbastanza
- entità
- Ambiente
- epoche
- particolarmente
- essential
- eccetera
- Etere (ETH)
- valutazione
- esempio
- Esempi
- esperimenti
- esplora
- Fattori
- FAIL
- falso
- lontano
- più veloce
- pochi
- meno
- galleggiante
- galleggiante
- segue
- Nel
- formato
- Francia
- Gratis
- da
- ulteriormente
- Gemini
- scopo generale
- ELETTRICA
- ottenere
- Idiota
- dato
- dà
- Go
- GPU
- GPU
- grande
- Hardware
- Avere
- qui
- Alta
- superiore
- tenere
- Come
- Tutorial
- Tuttavia
- HTTPS
- abbracciare il viso
- i
- if
- attrezzi
- importare
- importante
- competenze
- in
- Compreso
- ingresso
- Ingressi
- install
- invece
- istruzioni
- destinato
- ai miglioramenti
- comporta
- sicurezza
- IT
- jpg
- mantenere
- conservazione
- Le
- conoscenze
- Kumar
- Lingua
- grandi
- superiore, se assunto singolarmente.
- Leads
- IMPARARE
- imparato
- apprendimento
- Lasciare
- meno
- Consente di
- Biblioteca
- piace
- ribalta
- lineare
- LINK
- Lama
- lm
- caricare
- Caricamento in corso
- locale
- a livello locale
- ceppo
- registrati
- registrazione
- spento
- Basso
- inferiore
- macchina
- machine learning
- make
- Fare
- gestire
- Manuale
- max-width
- Media
- Memorie
- menzionato
- metodi
- Metrica
- ML
- Mobile
- cellulari
- modello
- modelli
- Scopri di più
- più efficiente
- maggior parte
- multiplo
- devono obbligatoriamente:
- my
- Nome
- Bisogno
- New
- GENERAZIONE
- Nessuna
- taccuino
- numero
- of
- di frequente
- maggiore
- on
- online
- esclusivamente
- open source
- OpenAI
- ottimizzazione
- ottimizzati
- ottimizzazione
- or
- i
- OS
- Altro
- altrimenti
- nostro
- su
- produzione
- uscite
- ancora
- Di proprietà
- Pacchetti
- accoppiato
- parametro
- parametri
- parte
- passare
- eseguire
- esecuzione
- cronologia
- Computer personale
- telefoni
- immagine
- piattaforma
- Platone
- Platone Data Intelligence
- PlatoneDati
- Giocare
- punto
- Popolare
- possibile
- Precisione
- Preparare
- preparato
- processi
- Produzione
- proprio
- fornisce
- pubblicato
- Spingi
- Domande e risposte
- qualità
- R
- classifica
- tempo reale
- ridurre
- riducendo
- riduzione
- rilasciato
- deposito
- richiesta
- richiede
- riparazioni
- risposta
- risposte
- ritorno
- Ruolo
- rtx
- Correre
- stesso
- Risparmi
- salvato
- risparmio
- scala
- Scienze
- vedere
- seme
- select
- set
- Corti
- mostrato
- segno
- da
- Taglia
- Dimensioni
- rallenta
- piccole
- inferiore
- specifico
- velocità
- dividere
- si
- inizia a
- step
- Passi
- Streaming
- Lotta
- sostanziale
- tale
- supporto
- supporti
- Fai
- preso
- Task
- task
- per l'esame
- tecniche
- Tesla
- test
- testo
- generazione di testo
- di
- che
- I
- loro
- Li
- poi
- Là.
- Strumenti Bowman per analizzare le seguenti finiture:
- di
- cosa
- questo
- Attraverso
- tempo
- a
- insieme
- token
- Tokens
- pure
- ha preso
- strumenti
- torcia
- Totale
- pista
- Tracking
- Treni
- allenato
- Training
- trasformatori
- Trilione
- tritone
- vero
- prova
- aggiornamento
- us
- Impiego
- uso
- utilizzato
- Valori
- versione
- via
- Visita
- visualizzare
- Prima
- Modo..
- modi
- we
- indossabili
- sito web
- WebP
- peso
- WELL
- sono stati
- Che
- Che cosa è l'
- quando
- quale
- while
- volere
- con
- lavori
- scrivere
- Tu
- Trasferimento da aeroporto a Sharm
- zefiro