Fine-tuning di Llama 3 e utilizzo in locale: guida passo passo

Capire Llama 3

Meta ha rilasciato una nuova serie di large language model (LLM) chiamata Llama 3, una collezione di modelli text-to-text pre-addestrati e ottimizzati con istruzioni.

Llama 3 è un modello linguistico auto-regressivo che utilizza un’architettura transformer ottimizzata. Sia i modelli pre-addestrati sia quelli instruction-tuned sono disponibili con 8B e 70B parametri e una lunghezza di contesto di 8K token.

Llama 3 8B è l’LLM più apprezzato su Hugging Face. La sua versione instruction-tuned supera Gemma 7B-It di Google e Mistral 7B Instruct in varie metriche di performance. La versione instruction-tuned da 70B ha superato Gemini Pro 1.5 e Claude Sonnet nella maggior parte delle metriche di performance:

Fonte: Meta Llama 3

Meta ha addestrato Llama 3 su un nuovo mix di dati pubblicamente disponibili online, con oltre 15 trilioni di token. Il modello 8B ha un knowledge cutoff a marzo 2023, mentre il 70B ha un cutoff a dicembre 2023. I modelli usano la Grouped-Query Attention (GQA), che riduce la larghezza di banda della memoria e migliora l’efficienza.

I modelli Llama 3 sono stati rilasciati con una licenza commerciale personalizzata. Per accedervi, devi compilare un modulo con nome, affiliazione ed email e accettare termini e condizioni. Se usi email diverse su piattaforme come Kaggle e Hugging Face, potresti dover compilare il modulo più volte.

Puoi saperne di più su Llama 3 in questo articolo: Che cos’è Llama 3?.

1. Fine-tuning di Llama 3

Per questo tutorial faremo il fine-tuning del modello Llama 3 8B-Chat usando il dataset ruslanmv/ai-medical-chatbot. Il dataset contiene 250k dialoghi tra paziente e medico. Useremo i Notebook di Kaggle per accedere a questo modello e a GPU gratuite.

Configurazione

Prima di avviare il Notebook su Kaggle, compila il modulo di download di Meta con la tua email di Kaggle, poi vai alla pagina del modello Llama 3 su Kaggle e accetta l’accordo. L’approvazione può richiedere da uno a due giorni.

Ora segui questi passaggi:

1. Avvia un nuovo Notebook su Kaggle e aggiungi il modello Llama 3 cliccando su + Add Input, selezionando l’opzione Models e premendo il pulsante + accanto al modello Llama 3. Poi seleziona framework, variante e versione corretti e aggiungi il modello.

2. Vai alle Session options e seleziona GPU P100 come acceleratore.

3. Genera i token di Hugging Face e Weights & Biases e crea i Kaggle Secrets. Puoi creare e attivare i Kaggle Secrets andando su Add-ons > Secrets > Add un nuovo secret.

4. Inizia la sessione Kaggle installando tutti i pacchetti Python necessari.

%%capture
%pip install -U transformers 
%pip install -U datasets 
%pip install -U accelerate 
%pip install -U peft 
%pip install -U trl 
%pip install -U bitsandbytes 
%pip install -U wandb

5. Importa le librerie Python necessarie per caricare dataset, modello e tokenizer ed eseguire il fine-tuning.

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    HfArgumentParser,
    TrainingArguments,
    pipeline,
    logging,
)
from peft import (
    LoraConfig,
    PeftModel,
    prepare_model_for_kbit_training,
    get_peft_model,
)
import os, torch, wandb
from datasets import load_dataset
from trl import SFTTrainer, setup_chat_format

6. Tracceremo il processo di training con Weights & Biases e salveremo il modello ottimizzato su Hugging Face; per farlo dobbiamo effettuare il login sia su Hugging Face Hub sia su Weights & Biases usando la chiave API.

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")

login(token = hf_token)

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Llama 3 8B on Medical Dataset', 
    job_type="training", 
    anonymous="allow"
)

7. Imposta le variabili per modello base, dataset e nuovo modello. Caricheremo il modello base da Kaggle e il dataset da Hugging Face Hub, quindi salveremo il nuovo modello.

base_model = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"
dataset_name = "ruslanmv/ai-medical-chatbot"
new_model = "llama-3-8b-chat-doctor"

8. Imposta il tipo di dati e l’implementazione dell’attenzione.

torch_dtype = torch.float16
attn_implementation = "eager"

Caricare modello e tokenizer

In questa parte caricheremo il modello da Kaggle. Tuttavia, per limiti di memoria non possiamo caricare l’intero modello. Quindi lo carichiamo con precisione a 4 bit.

Il nostro obiettivo in questo progetto è ridurre l’uso di memoria e velocizzare il processo di fine-tuning.

# QLoRA config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch_dtype,
    bnb_4bit_use_double_quant=True,
)

# Load model
model = AutoModelForCausalLM.from_pretrained(
    base_model,
    quantization_config=bnb_config,
    device_map="auto",
    attn_implementation=attn_implementation
)

Carica il tokenizer e poi configura modello e tokenizer per i compiti di conversazione. Per impostazione predefinita, viene usato il template chatml di OpenAI, che converte l’input in un formato tipo chat.

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model)
model, tokenizer = setup_chat_format(model, tokenizer)

Aggiungere l’adapter al layer

Eseguire il fine-tuning dell’intero modello richiede molto tempo; per migliorare i tempi di training, collegheremo un adapter layer con pochi parametri, rendendo l’intero processo più veloce ed efficiente in termini di memoria.

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=['up_proj', 'down_proj', 'gate_proj', 'k_proj', 'q_proj', 'v_proj', 'o_proj']
)
model = get_peft_model(model, peft_config)

Caricare il dataset

Per caricare e pre-processare il dataset, facciamo quanto segue:

1. Carichiamo il dataset ruslanmv/ai-medical-chatbot, lo mescoliamo e selezioniamo solo le prime 1000 righe. Questo ridurrà significativamente il tempo di training.

2. Formattiamo il template della chat per renderlo conversazionale. Combiniamo le domande del paziente e le risposte del medico in una colonna "text".

3. Mostriamo un esempio dalla colonna text (la colonna “text” ha un formato tipo chat con token speciali).

#Importing the dataset
dataset = load_dataset(dataset_name, split="all")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo

def format_chat_template(row):
    row_json = [{"role": "user", "content": row["Patient"]},
               {"role": "assistant", "content": row["Doctor"]}]
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

dataset = dataset.map(
    format_chat_template,
    num_proc=4,
)

dataset['text'][3]

4. Suddividiamo il dataset in training set e validation set.

dataset = dataset.train_test_split(test_size=0.1)

Compilare e addestrare il modello

Impostiamo gli iperparametri del modello in modo da poterlo eseguire su Kaggle. Puoi approfondire ogni iperparametro leggendo il tutorial Fine-Tuning di Llama 2.

Eseguiamo il fine-tuning per un’epoca e registriamo le metriche con Weights & Biases.

training_arguments = TrainingArguments(
    output_dir=new_model,
    per_device_train_batch_size=1,
    per_device_eval_batch_size=1,
    gradient_accumulation_steps=2,
    optim="paged_adamw_32bit",
    num_train_epochs=1,
    evaluation_strategy="steps",
    eval_steps=0.2,
    logging_steps=1,
    warmup_steps=10,
    logging_strategy="steps",
    learning_rate=2e-4,
    fp16=False,
    bf16=False,
    group_by_length=True,
    report_to="wandb"
)

Ora configuriamo un trainer per supervised fine-tuning (SFT) e forniamo dataset di training e valutazione, configurazione LoRA, argomenti di training, tokenizer e modello. Manteniamo max_seq_length a 512 per evitare di superare la memoria GPU durante il training.

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    peft_config=peft_config,
    max_seq_length=512,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)

Avviamo il processo di fine-tuning eseguendo il codice seguente.

trainer.train()

Sia la training loss sia la validation loss sono diminuite. Considera di addestrare il modello per tre epoche sull’intero dataset per risultati migliori.

Valutazione del modello

Quando termini la sessione su Weights & Biases, verranno generati lo storico dell’esecuzione e il riepilogo.

wandb.finish()
model.config.use_cache = True

Le metriche di performance del modello sono anche salvate sotto il nome del progetto specifico nel tuo account Weights & Biases.

Valutiamo il modello su una query di esempio di un paziente per verificare che sia stato ottimizzato correttamente.

Per generare una risposta, dobbiamo convertire i messaggi in formato chat, passarli al tokenizer, fornire l’input al modello e poi decodificare i token generati per visualizzare il testo.

messages = [
    {
        "role": "user",
        "content": "Hello doctor, I have bad acne. How do I get rid of it?"
    }
]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, 
                                       add_generation_prompt=True)

inputs = tokenizer(prompt, return_tensors='pt', padding=True, 
                   truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=150, 
                         num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

print(text.split("assistant")[1])

Si scopre che possiamo ottenere risultati medi anche con una sola epoca.

Salvataggio del file del modello

Ora salveremo l’adapter ottimizzato e lo caricheremo su Hugging Face Hub. Le API dell’Hub creeranno automaticamente il repository e archivieranno il file dell’adapter.

trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)

Come si vede, il nostro file adapter salvato è significativamente più piccolo del modello base.

Infine, salveremo il notebook con il file dell’adapter per unirlo al modello base in un nuovo notebook.

Per salvare il Notebook di Kaggle, clicca il pulsante Save Version in alto a destra, seleziona il tipo di versione Quick Save, apri le impostazioni avanzate, seleziona Always save output when creating a Quick Save, quindi premi Save.

Se riscontri problemi durante l’esecuzione del codice, consulta questo Notebook su Kaggle: Fine-tuning di Llama 3 8B su dataset medico.

Abbiamo effettuato il fine-tuning del modello usando la GPU. Puoi anche imparare a fare il fine-tuning degli LLM con le TPU seguendo il tutorial Fine-tuning ed inferenza sul modello Gemma di Google con TPU.

Se vuoi imparare a fare il fine-tuning di altri modelli, dai un’occhiata a questo Mistral 7B Tutorial: guida passo passo all’uso e al fine-tuning di Mistral 7B.

2. Unione di Llama 3

Per usare il modello ottimizzato in locale, dobbiamo prima unire l’adapter al modello base e poi salvare il modello completo.

Configurazione

Segui questi passaggi:

1. Crea un nuovo Notebook su Kaggle e installa tutti i pacchetti Python necessari. Assicurati di usare la GPU come acceleratore.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peft
%pip install -U trl

2. Accedi a Hugging Face Hub usando i Kaggle Secrets. Questo ci aiuterà a caricare facilmente il modello completo ottimizzato.

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

3. Aggiungi il modello Llama 3 8B Chat e il Notebook di Kaggle con il fine-tuning che abbiamo appena salvato. Possiamo aggiungere i Notebook alla sessione attuale proprio come si aggiungono dataset e modelli.

Aggiungere il Notebook alla sessione Kaggle ci permetterà di accedere ai file di output. Nel nostro caso, si tratta del file adapter del modello.

4. Imposta le variabili con il percorso del modello base e dell’adapter.

base_model = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"
new_model = "/kaggle/input/fine-tune-llama-3-8b-on-medical-dataset/llama-3-8b-chat-doctor/"

Unire il modello base con l’adapter

Per prima cosa caricheremo tokenizer e modello base usando la libreria transformers. Poi imposteremo il formato chat con la libreria trl. Infine, caricheremo e uniremo l’adapter al modello base usando la libreria PEFT.

La funzione merge_and_unload() ci aiuterà a unire i pesi dell’adapter con il modello base e a usarlo come modello standalone.

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from peft import PeftModel
import torch
from trl import setup_chat_format
# Reload tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(base_model)

base_model_reload = AutoModelForCausalLM.from_pretrained(
        base_model,
        return_dict=True,
        low_cpu_mem_usage=True,
        torch_dtype=torch.float16,
        device_map="auto",
        trust_remote_code=True,
)

base_model_reload, tokenizer = setup_chat_format(base_model_reload, tokenizer)

# Merge adapter with base model
model = PeftModel.from_pretrained(base_model_reload, new_model)

model = model.merge_and_unload()

Inferenza del modello

Per verificare che il modello sia stato unito correttamente, eseguiremo una semplice inferenza usando pipeline della libreria transformers. Convertiremo il messaggio con il template chat e poi forniremo un prompt alla pipeline. La pipeline è stata inizializzata con modello, tokenizer e tipo di task.

Nota a margine: puoi impostare device_map su "auto" se vuoi usare più GPU.

messages = [{"role": "user", "content": "Hello doctor, I have bad acne. How do I get rid of it?"}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)

outputs = pipe(prompt, max_new_tokens=120, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
print(outputs[0]["generated_text"])

Il nostro modello ottimizzato funziona come previsto dopo l’unione.

Salvataggio e caricamento del modello unito

Ora salveremo tokenizer e modello usando la funzione save_pretrained().

model.save_pretrained("llama-3-8b-chat-doctor")
tokenizer.save_pretrained("llama-3-8b-chat-doctor")

I file del modello sono salvati in formato safetensors e la dimensione totale è di circa 16 GB.

Possiamo caricare tutti i file su Hugging Face Hub usando la funzione push_to_hub().

model.push_to_hub("llama-3-8b-chat-doctor", use_temp_dir=False)
tokenizer.push_to_hub("llama-3-8b-chat-doctor", use_temp_dir=False)

Infine, possiamo salvare il Notebook di Kaggle come fatto in precedenza.

Usare il Notebook Kaggle Fine Tuned Adapter to fully model ti aiuterà a risolvere eventuali problemi legati all’esecuzione del codice in autonomia.

3. Conversione del modello in Llama.cpp GGUF

Non possiamo usare i file safetensors in locale perché la maggior parte dei chatbot locali non li supporta. Invece, li convertiremo nel formato di file GGUF di llama.cpp.

Configurazione

Avvia una nuova sessione di Notebook su Kaggle e aggiungi il Notebook Fine Tuned Adapter to the full model.

Clona il repository llama.cpp e installa il framework llama.cpp usando il comando make come mostrato di seguito.

Nota: il comando seguente funziona solo per il Notebook di Kaggle. Potresti dover modificare alcune cose per eseguirlo su altre piattaforme o in locale.

%cd /kaggle/working
!git clone --depth=1 https://github.com/ggerganov/llama.cpp.git
%cd /kaggle/working/llama.cpp
!sed -i 's|MK_LDFLAGS   += -lcuda|MK_LDFLAGS   += -L/usr/local/nvidia/lib64 -lcuda|' Makefile
!LLAMA_CUDA=1 conda run -n base make -j > /dev/null

Conversione da Safetensors a formato GGUF

Esegui il seguente comando in una cella del Notebook di Kaggle per convertire il modello nel formato GGUF.

Lo script convert-hf-to-gguf.py richiede una directory del modello in input, una directory per il file di output e il tipo di output.

!python convert-hf-to-gguf.py /kaggle/input/fine-tuned-adapter-to-full-model/llama-3-8b-chat-doctor/ \
    --outfile /kaggle/working/llama-3-8b-chat-doctor.gguf \
    --outtype f16

Nel giro di pochi minuti, il modello viene convertito e salvato in locale. Possiamo poi salvare il notebook per conservare il file.

Se riscontri problemi nell’esecuzione del codice sopra, consulta il Notebook Kaggle HF LLM to GGUF.

4. Quantizzazione del modello GGUF

I laptop comuni non hanno abbastanza RAM e memoria GPU per caricare l’intero modello, quindi dobbiamo quantizzare il modello GGUF, riducendo il modello da 16 GB a circa 4-5 GB.

Configurazione

Avvia una nuova sessione di Notebook su Kaggle e aggiungi il Notebook HF LLM to GGUF.

Poi installa llama.cpp eseguendo il seguente comando in una cella del Notebook di Kaggle.

%cd /kaggle/working
!git clone --depth=1 https://github.com/ggerganov/llama.cpp.git
%cd /kaggle/working/llama.cpp
!sed -i 's|MK_LDFLAGS   += -lcuda|MK_LDFLAGS   += -L/usr/local/nvidia/lib64 -lcuda|' Makefile
!LLAMA_CUDA=1 conda run -n base make -j > /dev/null

Quantizzazione

Lo script di quantizzazione richiede una directory del modello GGUF, una directory di output e un metodo di quantizzazione. Stiamo convertendo il modello usando il metodo Q4_K_M.

%cd /kaggle/working/

!./llama.cpp/llama-quantize /kaggle/input/hf-llm-to-gguf/llama-3-8b-chat-doctor.gguf llama-3-8b-chat-doctor-Q4_K_M.gguf Q4_K_M

La dimensione del modello è diminuita sensibilmente da 15317,05 MB a 4685,32 MB.

Caricamento del file del modello su Hugging Face

Per caricare il singolo file su Hugging Face Hub, procederemo così:

1. Accedi a Hugging Face Hub usando la chiave API.
2. Crea l’oggetto API.
3. Carica il file fornendo percorso locale, percorso nel repo, ID del repo e tipo di repo.

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
from huggingface_hub import HfApi
user_secrets = UserSecretsClient()
hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

api = HfApi()
api.upload_file(
    path_or_fileobj="/kaggle/working/llama-3-8b-chat-doctor-Q4_K_M.gguf",
    path_in_repo="llama-3-8b-chat-doctor-Q4_K_M.gguf",
    repo_id="kingabzpro/llama-3-8b-chat-doctor",
    repo_type="model",
)

Il nostro modello è stato caricato correttamente sul server remoto, come mostrato di seguito.

Se riscontri ancora problemi, fai riferimento al Notebook Kaggle GGUF to Quantize, che contiene tutto il codice e l’output.

Se cerchi un modo più semplice per convertire e quantizzare il tuo modello, visita questo Space su Hugging Face e fornisci l’Hub Model Id.

5. Utilizzo del modello ottimizzato in locale

Per usare il modello GGUF in locale, devi scaricarlo e importarlo nell’applicazione Jan.

Scaricare il modello da Hugging Face

Per scaricare il modello, dobbiamo:

1. Andare al nostro repository su Hugging Face.

2. Cliccare sulla scheda Files.

3. Cliccare sul file del modello quantizzato con estensione GGUF.

4. Cliccare sul pulsante download.

Il download del file in locale richiederà alcuni minuti.

Installare l’applicazione Jan

Scarica e installa l’applicazione Jan da Jan AI.

Ecco come si presenta all’avvio l’applicazione Jan per Windows:

Caricare il modello ottimizzato in Jan

Per aggiungere il modello all’applicazione Jan, dobbiamo importare il file GGUF quantizzato.

Apri il menu Hub e clicca su Import Model, come mostrato sotto. Fornisci il percorso del file scaricato di recente, e il gioco è fatto.

Vai al menu Thread e seleziona il modello ottimizzato.

Usare il modello ottimizzato in Jan

Prima di usare il modello, dobbiamo personalizzarlo per visualizzare correttamente la risposta. Per prima cosa, modifichiamo il template del Prompt nella sezione Model Parameters.

<|im_start|>system
{system_message}<|im_end|>
<|im_start|>user
{prompt}<|im_end|>
<|im_start|>assistant

Aggiungiamo il token Stop e impostiamo i max token a 512 nei parametri di inferenza.

<endofstring>, Best, Regards, Thanks,-->

Iniziamo a scrivere le query e il “medico” risponderà di conseguenza.

Il nostro modello ottimizzato funziona perfettamente in locale.

Questo modello funziona con GPT4ALL, Llama.cpp, Ollama e molte altre applicazioni di AI locali. Per imparare a usarle, consulta questo tutorial su come eseguire LLM in locale.

Conclusione

Effettuare il fine-tuning del modello Llama 3 su un dataset personalizzato e usarlo in locale apre molte possibilità per creare applicazioni innovative. I potenziali casi d’uso spaziano da soluzioni di conversazione private e personalizzate a chatbot specifici per dominio, classificazione del testo, traduzione linguistica, question answering, sistemi di raccomandazione personalizzati e persino applicazioni per la sanità e l’automazione del marketing.

Con i framework Ollama e Langchain, costruire la tua applicazione di AI è più accessibile che mai e richiede solo poche righe di codice. Per farlo, segui il tutorial LlamaIndex: un framework dati per applicazioni basate su Large Language Models (LLM).

In questo tutorial, abbiamo imparato a fare il fine-tuning di Llama 3 8B Chat su un dataset medico. Abbiamo visto come unire l’adapter al modello base, convertirlo nel formato GGUF e quantizzarlo per l’uso in locale su un’applicazione chatbot Jan.

Se vuoi saperne di più, dai un’occhiata a questo skill track di quattro corsi su Developing Large Language Models.