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

Di recente, il campo dei Large Language Model (LLM) sta cambiando rapidamente. I nuovi LLM vengono progettati per essere più piccoli e intelligenti, il che li rende meno costosi e più semplici da usare rispetto ai modelli più grandi. 

Con il rilascio di Llama 3.2, abbiamo ora accesso a modelli più piccoli, come le varianti 1B e 3B. Sebbene questi modelli più compatti possano non eguagliare l’accuratezza dei modelli più grandi in compiti generali, possono essere sottoposti a fine-tuning per ottenere prestazioni eccellenti in aree specifiche, come la classificazione delle emozioni nelle interazioni di assistenza clienti. Questa capacità consente loro di sostituire potenzialmente i modelli tradizionali in questi domini.

In questo tutorial esploreremo le capacità dei modelli vision e lightweight di Llama 3.2. Impareremo come accedere al modello Llama 3.2 3B, fare fine-tuning su un dataset di assistenza clienti e successivamente unirlo ed esportarlo sull’hub di Hugging Face. Infine, convertiremo il modello in formato GGUF e lo useremo in locale con l’applicazione Jan.

Se sei nuovo all’AI, ti consigliamo vivamente di seguire il percorso di competenze AI Fundamentals e conoscere le basi di ChatGPT, LLM, generative AI e altro.

Immagine dell’autore

Presentazione di Llama 3.2

La famiglia di modelli open source Llama 3.2 ha due varianti: i modelli lightweight e i modelli vision. I modelli vision eccellono nel ragionamento su immagini e nel collegare visione e linguaggio, mentre i modelli lightweight sono adatti alla generazione di testo multilingue e al tool calling per dispositivi edge.

Modelli lightweight

Il modello lightweight ha due varianti più piccole: 1B e 3B. Questi modelli sono efficaci nella generazione di testo multilingue e nei compiti di tool calling. Sono piccoli, il che significa che possono girare su un dispositivo garantendo che i dati non lascino mai il dispositivo e offrendo generazione di testo ad alta velocità con un basso costo computazionale.

Per creare questi modelli leggeri ed efficienti, Llama 3.2 utilizza tecniche di pruning e knowledge distillation. Il pruning riduce la dimensione del modello mantenendo le prestazioni, mentre la knowledge distillation usa reti più grandi per trasferire conoscenza a quelle più piccole, migliorandone il rendimento.

Il modello 3B supera altri modelli come Gemma 2 (2,6B) e Phi 3.5-mini in compiti come il follow-the-instruction, la sintesi, la riscrittura di prompt e l’uso di strumenti.

Fonte: Llama 3.2: rivoluzionare l’edge AI e la visione con modelli aperti e personalizzabili

Modelli vision

I modelli vision sono disponibili in due varianti: 11B e 90B. Questi modelli sono progettati per supportare il ragionamento su immagini. L’11B e il 90B possono comprendere e interpretare documenti, grafici e diagrammi ed eseguire compiti come image captioning e visual grounding. Queste capacità avanzate sono state rese possibili integrando encoder di immagini pre-addestrati con modelli linguistici tramite pesi adapter composti da layer di cross-attention.

Rispetto a Claude 3 Haiku e GPT-4o mini, i modelli vision di Llama 3.2 hanno eccelso nel riconoscimento di immagini e in vari compiti di comprensione visiva, rendendoli strumenti solidi per applicazioni di AI multimodale.

Fonte: Llama 3.2: rivoluzionare l’edge AI e la visione con modelli aperti e personalizzabili

Puoi approfondire casi d’uso, benchmark, Llama Guard 3 e l’architettura dei modelli Llama 3.2 leggendo il nostro ultimo blog, Llama 3.2 Guide: How It Works, Use Cases & More.

Accesso ai modelli Lightweight di Llama 3.2 su Kaggle

Anche se il modello Llama 3.2 è gratuito e open source, devi comunque accettare termini e condizioni e compilare il modulo sul sito web. 

Per ottenere l’accesso all’ultimo modello Llama 3.2 sulla piattaforma Kaggle:

1. Vai sul sito llama.com e compila il modulo con le tue informazioni. Seleziona sia i modelli lightweight sia i modelli vision. 

Fonte: Download Llama

2. Vai alla pagina del modello Meta | Llama 3.2 e fai clic sul pulsante “Submit Form”. 

Fonte: Meta | Llama 3.2 | Kaggle

3. Accetta tutti i termini e le condizioni e premi il pulsante “Submit”. 

Fonte: Meta | Llama 3.2 | Kaggle

4. Attendi qualche minuto finché non vedi l’opzione per scaricare o creare un nuovo notebook. Seleziona la scheda Transformers e la variante del modello, poi fai clic su “+ New Notebook”.

5. Il notebook Kaggle verrà avviato con l’ultimo modello Llama. Per farlo funzionare, basta cambiare l’acceleratore in “GPU T4 x2”.

6. Aggiorna i pacchetti Python Transformers e Accelerate. 

%%capture
%pip install -U transformers accelerate

7. Carica tokenizer e modello usando il pacchetto Transformers. Invece di fornire il link al repository del modello su Hugging Face, specifichiamo la directory locale in cui si trova il modello.

from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, TextStreamer
import torch


base_model = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"

tokenizer = AutoTokenizer.from_pretrained(base_model)

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

8. Imposta pad_token_id per evitare messaggi di avviso.

if tokenizer.pad_token_id is None:
    tokenizer.pad_token_id = tokenizer.eos_token_id
if model.config.pad_token_id is None:
    model.config.pad_token_id = model.config.eos_token_id

9. Crea la pipeline di generazione del testo con modello e tokenizer. 

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)

10. Esegui la pipeline con un prompt personalizzato. Nel nostro caso, chiediamo informazioni su Vincent van Gogh.

messages = [{"role": "user", "content": "Who is Vincent van Gogh?"}]

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

outputs = pipe(prompt, max_new_tokens=120, do_sample=True)

print(outputs[0]["generated_text"])

La risposta è piuttosto accurata. 

11. Forniamo istruzioni di sistema per vedere se riesce a comprendere e seguire prompt complessi. Mostreremo i risultati in HTML unendo il codice Markdown. 

from IPython.display import Markdown, display

messages = [
    {
        "role": "system",
        "content": "You are a skilled Python developer specializing in database management and optimization.",
    },
    {
        "role": "user",
        "content": "I'm experiencing a sorting issue in my database. Could you please provide Python code to help resolve this problem?",
    },
]

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

outputs = pipe(prompt, max_new_tokens=512, do_sample=True)

display(
    Markdown(
            outputs[0]["generated_text"].split(
                "<|start_header_id|>assistant<|end_header_id|>"
            )[1]
        )
    )

Il risultato è molto accurato. Il modello si comporta piuttosto bene nonostante abbia solo 3 miliardi di parametri.

Se riscontri difficoltà ad accedere ai modelli lightweight di Llama 3.2, consulta il notebook Accessing the Llama 3.2 Lightweight Models.

Accesso ai modelli Vision di Llama 3.2 su Kaggle

Accedere al modello Vision è semplice e non devi preoccuparti della memoria GPU, perché in questa guida useremo più GPU. 

1. Invia il modulo sulla pagina del modello Meta | Llama 3.2 Vision. Accetta tutti i termini e fai clic sul pulsante “Submit”. 

Fonte: Meta | Llama 3.2 Vision | Kaggle

2. Scorri in basso, seleziona la scheda Transformer e la variante del modello vision, poi fai clic su “+ New Notebook”.

Fonte: Meta | Llama 3.2 Vision | Kaggle

3. Assicurati di usare “GPU T4 x2” come acceleratore. 
4. Aggiorna i pacchetti Python Transformers e Accelerate.

%%capture
%pip install -U transformers accelerate

5. Carica l’elaboratore di immagini e il modello Llama 3.2 vision. 

import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor

base_model = "/kaggle/input/llama-3.2-vision/transformers/11b-vision-instruct/1"

processor = AutoProcessor.from_pretrained(base_model)

model = MllamaForConditionalGeneration.from_pretrained(
    base_model,
    low_cpu_mem_usage=True,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

Come si vede, usa quasi 25 GB di memoria GPU. Sarà impossibile eseguirlo su un laptop o sulla versione gratuita di Google Colab.

6. Carica l’immagine. Le abbiamo passato l’immagine di copertina del tutorial: OpenAI o1-preview Tutorial: Building a Machine Learning Project.
7. Scrivi il messaggio e convertilo in un prompt usando un template di chat. Scrivi il messaggio e convertilo in un prompt usando un template di chat. 
8. Elabora sia immagine che testo e passali al modello per generare la risposta. 

import requests
from PIL import Image

url = "https://media.datacamp.com/cms/google/ad_4nxcz-j3ir2begccslzay07rqfj5ttakp2emttn0x6nkygls5ywl0unospj2s0-mrwpdtmqjl1fagh6pvkkjekqey_kwzl6qnodf143yt66znq0epflvx6clfoqw41oeoymhpz6qrlb5ajer4aeniogbmtwtd.png"
image = Image.open(requests.get(url, stream=True).raw)

messages = [
    {"role": "user", "content": [
        {"type": "image"},
        {"type": "text", "text": "Describe the tutorial feature image."}
    ]}
]
input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(image, input_text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=120)
print(processor.decode(output[0]))

Otteniamo così una descrizione dettagliata dell’immagine. È piuttosto accurata. 

Se riscontri problemi nell’esecuzione del codice sopra, fai riferimento al notebook Kaggle Accessing the Llama 3.2 Vision Models.

Fine-tuning di Llama 3.2 3B Instruct

In questa sezione impareremo a fare fine-tuning del modello Llama 3.2 3B Instruct usando la libreria Transformers su un dataset di assistenza clienti. Useremo Kaggle per accedere a GPU gratuite e ottenere più RAM rispetto a Colab. 

1. Configurazione

Avvia un nuovo notebook su Kaggle e imposta le variabili d’ambiente. Useremo l’API di Hugging Face per salvare il modello e Weights & Biases per monitorarne le prestazioni.

Installa e aggiorna 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

Carica i pacchetti e le funzioni Python che useremo durante il processo di fine-tuning e valutazione.

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

Accedi alla CLI di Hugging Face 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)

Accedi a Weights & Biases usando la chiave API e crea un nuovo progetto. 

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Llama 3.2 on Customer Support Dataset', 
    job_type="training", 
    anonymous="allow"
)

Imposta le variabili per modello base, dataset e nome del nuovo modello. Le useremo in più punti del progetto, quindi è meglio definirle all’inizio per evitare confusione.

base_model = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"
new_model = "llama-3.2-3b-it-Ecommerce-ChatBot"
dataset_name = "bitext/Bitext-customer-support-llm-chatbot-training-dataset"

2. Caricamento del modello e del tokenizer

Imposta il tipo di dato e l’implementazione dell’attenzione.

# Set torch dtype and attention implementation
if torch.cuda.get_device_capability()[0] >= 8:
    !pip install -qqq flash-attn
    torch_dtype = torch.bfloat16
    attn_implementation = "flash_attention_2"
else:
    torch_dtype = torch.float16
    attn_implementation = "eager"

Carica modello e tokenizer indicando la directory locale del modello. Anche se il modello è piccolo, caricarlo interamente e fare fine-tuning richiederà tempo. Invece, lo caricheremo con quantizzazione a 4 bit.

# 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
)

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)

3. Caricamento ed elaborazione del dataset

Caricheremo il dataset Bitext-customer-support-llm-chatbot dall’hub di Hugging Face. È un dataset sintetico ibrido che useremo per creare il nostro chatbot di assistenza clienti personalizzato.

Caricheremo, mescoleremo e selezioneremo solo 1000 campioni. Facciamo fine-tuning su un sottoinsieme ridotto per minimizzare i tempi di training, ma puoi sempre usare l’intero modello.

Poi creeremo la colonna "text" usando istruzioni di sistema, richieste utente e risposte dell’assistente. Infine, convertiremo la risposta JSON nel formato chat.

#Importing the dataset
dataset = load_dataset(dataset_name, split="train")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo
instruction = """You are a top-rated customer service agent named John. 
    Be polite to customers and answer all their questions.
    """
def format_chat_template(row):
    
    row_json = [{"role": "system", "content": instruction },
               {"role": "user", "content": row["instruction"]},
               {"role": "assistant", "content": row["response"]}]
    
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

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

Come si vede, abbiamo combinato la richiesta del cliente e la risposta dell’assistente in un formato chat. 

dataset['text'][3]

4. Configurazione del modello

Estrai il nome dei layer lineari dal modello. 

import bitsandbytes as bnb

def find_all_linear_names(model):
    cls = bnb.nn.Linear4bit
    lora_module_names = set()
    for name, module in model.named_modules():
        if isinstance(module, cls):
            names = name.split('.')
            lora_module_names.add(names[0] if len(names) == 1 else names[-1])
    if 'lm_head' in lora_module_names:  # needed for 16 bit
        lora_module_names.remove('lm_head')
    return list(lora_module_names)

modules = find_all_linear_names(model)

Usa il nome del modulo lineare per creare l’adapter LoRA. Faremo fine-tuning solo dell’adapter LoRA e lasceremo invariato il resto del modello per risparmiare memoria e velocizzare l’addestramento. 

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=modules
)
model, tokenizer = setup_chat_format(model, tokenizer)
model = get_peft_model(model, peft_config)

Configuriamo gli iperparametri del modello per eseguirlo nell’ambiente Kaggle. Puoi capire ogni iperparametro consultando il tutorial Fine-Tuning Llama 2 e modificarli per ottimizzare il training sul tuo sistema.

#Hyperparamter
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,
    eval_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 imposteremo un trainer per supervised fine-tuning (SFT) e forniremo dataset di training e valutazione, configurazione LoRA, argomenti di training, tokenizer e modello. 

# Setting sft parameters
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,
)

5. Addestramento del modello

Avvia il processo di training e monitora le metriche di loss su training e validazione. 

trainer.train()

La training loss è diminuita gradualmente. Un buon segno. 

La cronologia dettagliata dell’esecuzione viene generata quando terminiamo la run di Weights & Biases. 

wandb.finish()

Puoi sempre visitare la dashboard di Weights & Biases per analizzare a fondo le metriche del modello.

6. Inferenza del modello

Per testare il modello sottoposto a fine-tuning, gli forniremo un prompt di esempio dal dataset. 

messages = [{"role": "system", "content": instruction},
    {"role": "user", "content": "I bought the same item twice, cancel order {{Order Number}}"}]

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_new_tokens=150, num_return_sequences=1)

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

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

Il modello con fine-tuning ha adottato lo stile e ha fornito una risposta accurata.

7. Salvataggio di tokenizer e modello

Salva il modello con fine-tuning in locale e pubblicalo anche sull’hub di Hugging Face. La funzione push_to_hub creerà un nuovo repository del modello e invierà i file al tuo repository su Hugging Face. 

# Save the fine-tuned model
trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)

Fonte: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot

Per fare fine-tuning dei modelli Llama 3 più grandi, dai un’occhiata al tutorial Fine-Tuning Llama 3.1 per la classificazione del testo. Questo tutorial è molto popolare e ti aiuterà a utilizzare gli LLM sull’intero task. 

8. Salvataggio del notebook

Fai clic sul pulsante "Save Version" in alto a destra, seleziona l’opzione di salvataggio rapido e cambia l’opzione per salvare l’output in modo da salvare il file del modello e tutto il codice.

Dai un’occhiata al notebook Kaggle Fine-tune Llama 3.2 on Customer Support per il codice sorgente, i risultati e l’output. 

Questa è una guida ricca di codice. Se cerchi una guida no-code o low-code per il fine-tuning degli LLM, dai un’occhiata a LlaMA-Factory WebUI Beginner's Guide: Fine-Tuning LLMs. 

Unione ed esportazione di Llama 3.2 con fine-tuning 

Creeremo un nuovo notebook e aggiungeremo il notebook salvato in precedenza per accedere all’adapter LoRA con fine-tuning, così da evitare problemi di memoria. 

Assicurati di aver aggiunto anche il modello base "Llama 3.2 3B Instruct".

Installa e aggiorna tutti i pacchetti Python necessari. 

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

Accedi alla CLI di Hugging Face per inviare il modello unito all’hub di Hugging Face. 

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)

Fornisci il percorso del modello base e dell’adapter LoRA con fine-tuning. Li useremo per caricare il modello base e unirlo con l’adapter.

# Model
base_model_url = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"
new_model_url = "/kaggle/input/fine-tune-llama-3-2-on-customer-support/llama-3.2-3b-it-Ecommerce-ChatBot/"

Carica tokenizer e modello completo. 

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

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

Applica il formato chat a modello e tokenizer. Quindi unisci il modello base con l’adapter LoRA.

# Merge adapter with base model
base_model_reload, tokenizer = setup_chat_format(base_model_reload, tokenizer)
model = PeftModel.from_pretrained(base_model_reload, new_model_url)

model = model.merge_and_unload()

Per verificare che il modello sia stato unito correttamente, passagli un prompt di esempio e genera la risposta. 

instruction = """You are a top-rated customer service agent named John. 
    Be polite to customers and answer all their questions.
    """

messages = [{"role": "system", "content": instruction},
    {"role": "user", "content": "I have to see what payment payment modalities are accepted"}]

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_new_tokens=150, num_return_sequences=1)

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

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

Come si vede, il nostro modello con fine-tuning funziona perfettamente. 

Salva tokenizer e modello in locale. 

new_model = "llama-3.2-3b-it-Ecommerce-ChatBot"

model.save_pretrained(new_model)
tokenizer.save_pretrained(new_model)

Invia tokenizer e modello unito al repository di Hugging Face.

model.push_to_hub(new_model, use_temp_dir=False)
tokenizer.push_to_hub(new_model, use_temp_dir=False)

Dopo qualche minuto, potrai vedere tutti i file del modello con i metadati nel tuo repository su Hugging Face.

Fonte: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot

Puoi anche consultare il codice sorgente nel notebook Kaggle Merging and Exporting Fine-tuned Llama 3.2 per saperne di più sull’unione e il caricamento del modello sull’hub di Hugging Face.

Il passo successivo in questo progetto è convertire il modello completo in formato GGUF e poi quantizzarlo. Dopo di che, puoi usarlo in locale con la tua app di chat preferita come Jan, Msty o GPT4ALL. Segui la guida Fine-Tuning Llama 3 and Using It Locally per imparare a convertire tutti gli LLM in formato GGUF e usarli in locale sul tuo laptop.

Conversione del modello unito in formato GGUF

Per usare il modello con fine-tuning in locale, dobbiamo prima convertirlo in formato GGUF. Perché? Perché è il formato di llama.cpp ed è accettato da tutte le applicazioni desktop di chatbot. 

Convertire il modello unito nel formato llama.ccp è piuttosto semplice. Dobbiamo solo andare su GGUF My Repo su Hugging Face Hub. Accedi con l’account Hugging Face. Digita il link al repository del modello con fine-tuning “kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot” e premi il pulsante “Submit”. 

Fonte: GGUF My Repo

Nel giro di pochi secondi, la versione quantizzata del modello verrà creata in un nuovo repository su Hugging Face. 

Fonte: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot-Q4_K_M-GGUF

Fai clic sulla scheda “Files” e scarica solo il file GGUF. 

Fonte: llama-3.2-3b-it-ecommerce-chatbot-q4_k_m.gguf

Uso del modello con fine-tuning in locale

Useremo l’applicazione chatbot Jan per usare in locale il nostro modello con fine-tuning. Vai sul sito ufficiale, jan.ai, per scaricare e installare l’applicazione. 

Fonte: Jan

Clicca sulle impostazioni, seleziona il menu “My Models” e premi il pulsante “Import Model”. Quindi indica la directory locale del modello. 

Vai al menu chat e seleziona il modello con fine-tuning, come mostrato sotto.

Fai clic sulla scheda “Assistant” nel pannello a destra e digita il system prompt.

System prompt: “You are a top-rated customer service agent named John. Be polite to customers and answer all their questions.”

Clicca sulla scheda “Model”, accanto a “Assistant”, e cambia il token di stop in “<|eot_id|>”.

È fatta. Non ti resta che chiedere all’AI di assistenza clienti il problema che stai affrontando. 

Prompt: “How do I order multiple items from the same vendor?”

La risposta è stata accurata e velocissima—quasi 102 token al secondo.

Conclusione

Fare fine-tuning di LLM più piccoli consente di risparmiare sui costi e migliorare i tempi di inferenza. Con dati sufficienti, puoi incrementare le prestazioni del modello su determinati compiti fino a livelli vicini a GPT-4-mini. In breve, il futuro dell’AI prevede l’uso di più LLM piccoli in una griglia con una relazione master-slave. 

Il modello master riceverà il prompt iniziale e deciderà quale modello specializzato utilizzare per generare le risposte. Questo ridurrà il tempo di calcolo, migliorerà i risultati e abbasserà i costi operativi.

In questo tutorial abbiamo visto Llama 3.2 e come accedervi su Kaggle. Abbiamo anche imparato a fare fine-tuning del modello leggero Llama 3.2 sul dataset di assistenza clienti, in modo che impari a rispondere con uno stile specifico e a fornire informazioni accurate per il dominio. Poi abbiamo unito l’adapter LoRA con il modello base e caricato il modello completo su Hugging Face Hub. Infine, abbiamo convertito il modello unito in formato GGUF e lo abbiamo usato in locale sul laptop con l’applicazione chatbot Jan.

Segui il nostro corso interattivo Working with Hugging Face per imparare a usare lo strumento e fare fine-tuning dei modelli.