Fine-tuning di Llama 3.1 per la classificazione del testo

Prima di iniziare, una nota: quando si affrontano casi d’uso di IA in ambito sanitario, è estremamente importante essere consapevoli dei potenziali esiti dannosi per i pazienti. L’esempio qui sotto, pur essendo completo, è pensato esclusivamente per illustrare il fine-tuning su un dataset reale. Se stai perseguendo casi d’uso di IA nella sanità o in altri domini sensibili, ti consigliamo vivamente di leggere la nostra guida all’Etica dell’IA.

In questo tutorial, conosceremo i modelli Llama 3.1 e faremo il fine-tuning del modello Llama-3.1-8b-It per l’analisi del sentiment sul dataset di salute mentale. Il nostro obiettivo è personalizzare il modello in modo che possa prevedere lo stato di salute mentale del paziente a partire dal testo. Fonderemo anche l’adapter con il modello base e salveremo il modello completo sull’hub di Hugging Face. 

Impareremo a conoscere i modelli Llama 3.1, come accedervi su Kaggle e come utilizzare la libreria Transformers per eseguire l’inferenza del modello. Faremo anche il fine-tuning del modello Llama-3.1-8b-It sul dataset di classificazione per la salute mentale. Infine, uniremo l’adapter salvato con il modello base e pubblicheremo il modello completo su Hugging Face Hub.

Se sei alle prime armi, puoi approfondire la teoria dietro il fine-tuning leggendo il nostro articolo Guida introduttiva al fine-tuning degli LLM. 

Immagine dell’autore

Presentazione di Llama 3.1

Llama 3.1 è l’ultima serie di modelli linguistici di grandi dimensioni (LLM) multilingue sviluppati da Meta AI, che spingono oltre i confini della comprensione e generazione del linguaggio. È disponibile in tre dimensioni: 8B, 70B e 405B parametri.

I modelli Llama 3.1 si basano su un’architettura di language model auto-regressiva con transformer ottimizzati e possono essere perfezionati per vari task e dataset di elaborazione del linguaggio naturale. Sono addestrati su un dataset diversificato di dati online pubblicamente disponibili, supportano otto lingue (inglese, tedesco, francese, italiano, portoghese, hindi, spagnolo e thai) e offrono una lunghezza di contesto di 128k. 

I modelli Llama 3.1 sono disponibili per tutti con licenze commerciali personalizzate e richiedono informazioni minime sull’individuo per scaricare i pesi del modello.

Llama 3.1 è ottimizzato per il dialogo multilingue e ha superato Gemma 2, GPT 3.5 turbo e GPT-4o in vari benchmark, tra cui chat generale, coding, matematica, ragionamento e altro. È di gran lunga il modello open source più veloce e accurato disponibile.

Fonte: Llama 3.1 (meta.com)

Puoi saperne di più sul modello Llama 3.1 leggendo Cos’è Llama 3.1 405B di Meta? Come funziona, casi d’uso e altro.

Primi passi con Llama 3.1

Per questo tutorial useremo Kaggle Notebook come ambiente di sviluppo perché offre GPU e TPU gratuite. Per usare il modello Llama 3.1 su un notebook Kaggle, segui questi passaggi:

1. Compila il modulo su meta.com usando lo stesso indirizzo email del tuo account Kaggle.

2. Accedi al repository del modello Meta | Llama 3.1 su Kaggle e clicca sul pulsante "access the model". Accetta tutti i termini e, dopo pochi secondi, avrai accesso al modello.

3. Avvia il notebook Kaggle con i modelli Llama 3.1 cliccando sul pulsante "Code" disponibile in alto a destra nella pagina del modello.

4. Seleziona framework, variazione e versione, poi premi il pulsante "Add Model".

5. Installa i pacchetti Python necessari nel notebook Kaggle usando il seguente comando:

%pip install -U transformers accelerateOfferto da

6. Carica il modello e il tokenizer usando la libreria Transformers dalla directory locale.

7. Crea la pipeline di generazione del testo con modello, tokenizer, tipo torch e device map.

from transformers import AutoTokenizer,AutoModelForCausalLM,pipeline
import torch

base_model = "/kaggle/input/llama-3.1/transformers/8b-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,
)
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)Offerto da

8. Scrivi il messaggio e convertilo nel prompt corretto usando il chat template.

9. Esegui la pipeline usando il prompt e stampa l’output generato.

messages = [{"role": "user", "content": "What is the tallest building in the world?"}]

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"])Offerto da

La risposta è accurata e dettagliata. 

Se riscontri difficoltà nell’eseguire l’inferenza del modello, fai riferimento al Notebook Kaggle Llama 3.1 Simple Model Inference. 

Fine-tuning di Llama 3.1 per la classificazione dei disturbi mentali 

Ora dobbiamo caricare il dataset, processarlo e fare il fine-tuning del modello Llama 3.1. Confronteremo anche le prestazioni del modello prima e dopo il fine-tuning.

Se sei nuovo agli LLM, ti consiglio di seguire il corso Master Large Language Models (LLMs) Concepts prima di passare alla parte di fine-tuning del tutorial.

1. Configurazione

Per prima cosa, avvieremo il nuovo notebook Kaggle e il modello Llama 3.1 proprio come nella sezione precedente.

Quindi installeremo i pacchetti Python necessari come indicato di seguito:

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peft
%pip install -U trlOfferto da

Successivamente, aggiungiamo i dati di Sentiment Analysis for Mental Health nel notebook Kaggle.  Per farlo, clicca sul pulsante “Add Input” situato in alto a destra e incolla il link del modello nella barra di ricerca. Poi, per aggiungere il modello, clicca semplicemente sul pulsante più (+).

Terremo traccia delle prestazioni del modello usando l’API Weights and Biases. Per accedere all’API, ci serve la chiave. Imposta la chiave API in Kaggle usando Secrets e attivala, come mostrato di seguito.  

Possiamo quindi avviare il progetto Weights and Biases utilizzando la chiave API.

import wandb

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune llama-3.1-8b-it on Sentiment Analysis Dataset', 
    job_type="training", 
    anonymous="allow"
)Offerto da

Poi dobbiamo importare tutti i pacchetti e le funzioni Python necessari.

import numpy as np
import pandas as pd
import os
from tqdm import tqdm
import bitsandbytes as bnb
import torch
import torch.nn as nn
import transformers
from datasets import Dataset
from peft import LoraConfig, PeftConfig
from trl import SFTTrainer
from trl import setup_chat_format
from transformers import (AutoModelForCausalLM, 
                          AutoTokenizer, 
                          BitsAndBytesConfig, 
                          TrainingArguments, 
                          pipeline, 
                          logging)
from sklearn.metrics import (accuracy_score, 
                             classification_report, 
                             confusion_matrix)
from sklearn.model_selection import train_test_splitOfferto da

2. Caricamento e processamento del dataset

È il momento di caricare il dataset, effettuare la pulizia dei dati e rimuovere tre categorie ambigue. 

Per semplificare, rimuoveremo la categoria "Suicidal" perché Llama 3.1 ha meccanismi di sicurezza che bloccano determinate parole trigger. "Stress" non è considerato un disturbo mentale e "Personality Disorder" ha molta sovrapposizione con "Bipolar". 

Di conseguenza, rimarremo con sole quattro categorie: "Normal", "Depression", "Anxiety" e "Bipolar".

df = pd.read_csv("/kaggle/input/sentiment-analysis-for-mental-health/Combined Data.csv",index_col = "Unnamed: 0")
df.loc[:,'status'] = df.loc[:,'status'].str.replace('Bi-Polar','Bipolar')
df = df[(df.status != "Personality disorder") & (df.status != "Stress") & (df.status != "Suicidal")]
df.head()Offerto da

Per risparmiare tempo di training, faremo il fine-tuning del modello solo su 3000 campioni. Per questo, mescoleremo il dataset e selezioneremo 3000 righe. 

Poi suddivideremo il dataset in set di train, eval e test per l’addestramento e il testing del modello. 

Vogliamo anche creare la colonna “text” nei set di train ed eval usando la funzione generate_prompt, che combina i dati dalle colonne “statement” e “status”. 

Infine, creeremo la colonna “text” nel set di test usando la funzione generate_test_prompt e y_true usando la colonna “status”. La useremo per generare il report di valutazione del modello, come mostrato sotto.

# Shuffle the DataFrame and select only 3000 rows
df = df.sample(frac=1, random_state=85).reset_index(drop=True).head(3000)

# Split the DataFrame
train_size = 0.8
eval_size = 0.1

# Calculate sizes
train_end = int(train_size * len(df))
eval_end = train_end + int(eval_size * len(df))

# Split the data
X_train = df[:train_end]
X_eval = df[train_end:eval_end]
X_test = df[eval_end:]

# Define the prompt generation functions
def generate_prompt(data_point):
    return f"""
            Classify the text into Normal, Depression, Anxiety, Bipolar, and return the answer as the corresponding mental health disorder label.
text: {data_point["statement"]}
label: {data_point["status"]}""".strip()

def generate_test_prompt(data_point):
    return f"""
            Classify the text into Normal, Depression, Anxiety, Bipolar, and return the answer as the corresponding mental health disorder label.
text: {data_point["statement"]}
label: """.strip()

# Generate prompts for training and evaluation data
X_train.loc[:,'text'] = X_train.apply(generate_prompt, axis=1)
X_eval.loc[:,'text'] = X_eval.apply(generate_prompt, axis=1)

# Generate test prompts and extract true labels
y_true = X_test.loc[:,'status']
X_test = pd.DataFrame(X_test.apply(generate_test_prompt, axis=1), columns=["text"])Offerto da

A questo punto vogliamo controllare la distribuzione delle categorie nel set di train.

X_train.status.value_counts()Offerto da

Come puoi vedere qui sotto, abbiamo quasi una distribuzione uguale delle categorie "Normal" e "Depression". Il resto delle etichette è minoritario. Ciò significa che il nostro dataset è sbilanciato e il modello sarà migliore nel prevedere le etichette di maggioranza rispetto a quelle di minoranza. 

Potremmo bilanciare il dataset, ma non è l’obiettivo di questo tutorial.

status
Normal        1028
Depression     938
Anxiety        258
Bipolar        176
Name: count, dtype: int64Offerto da

Quindi, vogliamo convertire i set di train ed eval in dataset di Hugging Face.

# Convert to datasets
train_data = Dataset.from_pandas(X_train[["text"]])
eval_data = Dataset.from_pandas(X_eval[["text"]])Offerto da

Poi visualizziamo il 4° campione dalla colonna “text”.

train_data['text'][3]Offerto da

Vediamo che la colonna “text” ha un system prompt, la frase e gli status come etichette. 

3. Caricamento del modello e del tokenizer

Ora vogliamo caricare il modello Llama-3.1-8b-instruct in quantizzazione a 4 bit (quantization) per risparmiare memoria GPU. 

Caricheremo quindi il tokenizer e imposteremo il pad token id. 

base_model_name = "/kaggle/input/llama-3.1/transformers/8b-instruct/1"

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=False,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype="float16",
)

model = AutoModelForCausalLM.from_pretrained(
    base_model_name,
    device_map="auto",
    torch_dtype="float16",
    quantization_config=bnb_config, 
)

model.config.use_cache = False
model.config.pretraining_tp = 1

tokenizer = AutoTokenizer.from_pretrained(base_model_name)

tokenizer.pad_token_id = tokenizer.eos_token_idOfferto da

4. Valutazione del modello prima del fine-tuning

Qui creiamo la funzione predict, che userà la pipeline di generazione del testo per prevedere le etichette dalla colonna “text”. L’esecuzione della funzione restituirà un elenco di categorie di disturbi mentali sulla base dei vari campioni nel set di test. 

def predict(test, model, tokenizer):
    y_pred = []
    categories = ["Normal", "Depression", "Anxiety", "Bipolar"]
    
    for i in tqdm(range(len(test))):
        prompt = test.iloc[i]["text"]
        pipe = pipeline(task="text-generation", 
                        model=model, 
                        tokenizer=tokenizer, 
                        max_new_tokens=2, 
                        temperature=0.1)
        
        result = pipe(prompt)
        answer = result[0]['generated_text'].split("label:")[-1].strip()
        
        # Determine the predicted category
        for category in categories:
            if category.lower() in answer.lower():
                y_pred.append(category)
                break
        else:
            y_pred.append("none")
    
    return y_pred

y_pred = predict(X_test, model, tokenizer)Offerto da

100%|██████████| 300/300 [02:54<00:00,  1.72it/s]Offerto da

Successivamente, creiamo la funzione evaluate che userà le etichette previste e quelle vere per calcolare l’accuratezza complessiva del modello e quella per categoria, generare un report di classificazione e stampare una matrice di confusione. L’esecuzione della funzione ci darà un riepilogo dettagliato della valutazione del modello. 

def evaluate(y_true, y_pred):
    labels = ["Normal", "Depression", "Anxiety", "Bipolar"]
    mapping = {label: idx for idx, label in enumerate(labels)}
    
    def map_func(x):
        return mapping.get(x, -1)  # Map to -1 if not found, but should not occur with correct data
    
    y_true_mapped = np.vectorize(map_func)(y_true)
    y_pred_mapped = np.vectorize(map_func)(y_pred)
    
    # Calculate accuracy
    accuracy = accuracy_score(y_true=y_true_mapped, y_pred=y_pred_mapped)
    print(f'Accuracy: {accuracy:.3f}')
    
    # Generate accuracy report
    unique_labels = set(y_true_mapped)  # Get unique labels
    
    for label in unique_labels:
        label_indices = [i for i in range(len(y_true_mapped)) if y_true_mapped[i] == label]
        label_y_true = [y_true_mapped[i] for i in label_indices]
        label_y_pred = [y_pred_mapped[i] for i in label_indices]
        label_accuracy = accuracy_score(label_y_true, label_y_pred)
        print(f'Accuracy for label {labels[label]}: {label_accuracy:.3f}')
        
    # Generate classification report
    class_report = classification_report(y_true=y_true_mapped, y_pred=y_pred_mapped, target_names=labels, labels=list(range(len(labels))))
    print('\nClassification Report:')
    print(class_report)
    
    # Generate confusion matrix
    conf_matrix = confusion_matrix(y_true=y_true_mapped, y_pred=y_pred_mapped, labels=list(range(len(labels))))
    print('\nConfusion Matrix:')
    print(conf_matrix)

evaluate(y_true, y_pred)Offerto da

Llama 3.1 si è comportato in modo eccellente anche senza fine-tuning. Un’accuratezza del 79% è più che buona. Vediamo come migliora il nostro modello quando lo perfezioniamo sul dataset.

Accuracy: 0.790
Accuracy for label Normal: 0.741
Accuracy for label Depression: 0.939
Accuracy for label Anxiety: 0.556
Accuracy for label Bipolar: 0.533

Classification Report:
              precision    recall  f1-score   support

      Normal       0.92      0.74      0.82       143
  Depression       0.70      0.94      0.80       115
     Anxiety       0.68      0.56      0.61        27
     Bipolar       0.89      0.53      0.67        15

    accuracy                           0.79       300
   macro avg       0.80      0.69      0.73       300
weighted avg       0.81      0.79      0.79       300


Confusion Matrix:
[[106  33   4   0]
 [  3 108   3   1]
 [  4   8  15   0]
 [  2   5   0   8]]Offerto da

5. Costruzione del modello

Durante la costruzione del modello, iniziamo estraendo i nomi dei moduli lineari dal modello usando la libreria bits and bytes. 

Configuriamo quindi LoRA utilizzando i moduli target, il tipo di task e altri argomenti prima di impostare gli argomenti di training. Questi argomenti sono ottimizzati per il notebook Kaggle. Potresti doverli modificare se li usi in locale. 

Creeremo poi il trainer del modello usando argomenti di training, un modello, un tokenizer, una configurazione LoRA e un dataset. 

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)
modulesOfferto da

['down_proj', 'gate_proj', 'o_proj', 'v_proj', 'up_proj', 'q_proj', 'k_proj']Offerto da

output_dir="llama-3.1-fine-tuned-model"

peft_config = LoraConfig(
    lora_alpha=16,
    lora_dropout=0,
    r=64,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=modules,
)

training_arguments = TrainingArguments(
    output_dir=output_dir,                    # directory to save and repository id
    num_train_epochs=1,                       # number of training epochs
    per_device_train_batch_size=1,            # batch size per device during training
    gradient_accumulation_steps=8,            # number of steps before performing a backward/update pass
    gradient_checkpointing=True,              # use gradient checkpointing to save memory
    optim="paged_adamw_32bit",
    logging_steps=1,                         
    learning_rate=2e-4,                       # learning rate, based on QLoRA paper
    weight_decay=0.001,
    fp16=True,
    bf16=False,
    max_grad_norm=0.3,                        # max gradient norm based on QLoRA paper
    max_steps=-1,
    warmup_ratio=0.03,                        # warmup ratio based on QLoRA paper
    group_by_length=False,
    lr_scheduler_type="cosine",               # use cosine learning rate scheduler
    report_to="wandb",                  # report metrics to w&b
    eval_strategy="steps",              # save checkpoint every epoch
    eval_steps = 0.2
)

trainer = SFTTrainer(
    model=model,
    args=training_arguments,
    train_dataset=train_data,
    eval_dataset=eval_data,
    peft_config=peft_config,
    dataset_text_field="text",
    tokenizer=tokenizer,
    max_seq_length=512,
    packing=False,
    dataset_kwargs={
    "add_special_tokens": False,
    "append_concat_token": False,
    }
)Offerto da

6. Addestramento del modello

È il momento di avviare l’addestramento del modello:

trainer.train()Offerto da

Il fine-tuning del modello ha richiesto 1,5 ore e la nostra validation loss è diminuita gradualmente. Per prestazioni ancora migliori, prova ad addestrare il modello sull’intero dataset per almeno cinque epoche.

Poi concludiamo la run di Weights and Biases.

wandb.finish()
model.config.use_cache = TrueOfferto da

Potremo visualizzare il riepilogo della run, inclusi tutti i metriche necessarie sulle prestazioni del modello.

Per un riepilogo dettagliato, vai al tuo account Weights and Biases e visualizza la run nel browser. Include visualizzazioni interattive.

Possiamo quindi salvare localmente sia l’adapter del modello sia il tokenizer. Nella prossima sezione useremo questo per unire l’adapter con il modello base.

# Save trained model and tokenizer
trainer.save_model(output_dir)
tokenizer.save_pretrained(output_dir)Offerto da

7. Test del modello dopo il fine-tuning

Ora arriva la parte più cruciale. Il nostro modello si comporterà meglio dopo il fine-tuning o peggiorerà? Per scoprirlo, dobbiamo eseguire la funzione 'predict' sul set di test e poi la funzione 'evaluate' per generare un report di valutazione del modello.

y_pred = predict(X_test, model, tokenizer)
evaluate(y_true, y_pred)Offerto da

Come puoi vedere dai risultati qui sotto, c’è un enorme miglioramento delle prestazioni del modello, dal 79% al 91,3% di accuratezza. Anche i punteggi F1 sono buoni. 

100%|██████████| 300/300 [03:24<00:00,  1.47it/s]
Accuracy: 0.913
Accuracy for label Normal: 0.972
Accuracy for label Depression: 0.913
Accuracy for label Anxiety: 0.667
Accuracy for label Bipolar: 0.800

Classification Report:
              precision    recall  f1-score   support

      Normal       0.92      0.97      0.95       143
  Depression       0.93      0.91      0.92       115
     Anxiety       0.75      0.67      0.71        27
     Bipolar       1.00      0.80      0.89        15

    accuracy                           0.91       300
   macro avg       0.90      0.84      0.87       300
weighted avg       0.91      0.91      0.91       300


Confusion Matrix:
[[139   3   1   0]
 [  5 105   5   0]
 [  6   3  18   0]
 [  1   2   0  12]]Offerto da

Ora possiamo salvare il notebook Kaggle per conservare i risultati e i file del modello. Per farlo, clicchiamo sul pulsante “Save Version” in alto a destra, selezioniamo il tipo di versione “Quick Save” e scegliamo il tipo di salvataggio output “Always save output when creating a Quick Save”.

Se hai problemi con il fine-tuning del modello, fai riferimento al notebook Kaggle per ulteriore assistenza. 

Puoi anche imparare a fare il fine-tuning dei modelli Llama 3.0 seguendo la nostra guida Fine-tuning di Llama 3 e uso in locale. 

Merge e salvataggio del modello Llama 3.1 fine-tuned

In questa sezione, fonderemo l’adapter con il modello base e salveremo la versione completa sull’hub di Hugging Face. 

Per prima cosa, avviamo un nuovo notebook Kaggle con accelerazione GPU e aggiungiamo il notebook salvato per accedere ai file del modello. Possiamo anche includere altri notebook Kaggle come input, in modo simile all’aggiunta di un dataset.

Quindi installiamo i pacchetti Python necessari. 

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peftOfferto da

Poi effettuiamo il login all’API di Hugging Face hub usando la chiave API per caricare i file del nostro modello nel repository del modello su 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)Offerto da

Possiamo quindi impostare la directory del modello base e del modello fine-tuned.

base_model = "/kaggle/input/llama-3.1/transformers/8b-instruct/1"
fine_tuned_model = "/kaggle/input/fine-tune-llama-3-1-for-text-classification/llama-3.1-fine-tuned-model/"Offerto da

Quindi carichiamo tokenizer e modello base. 

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from peft import PeftModel
import torch


# 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,
)Offerto da

Uniamo il modello base con l’adapter fine-tuned, come mostrato sotto. 

# Merge adapter with base model
model = PeftModel.from_pretrained(base_model_reload, fine_tuned_model)
model = model.merge_and_unload()Offerto da

Prima di salvare il nostro modello, verifichiamo che funzioni correttamente. Crea una pipeline di generazione del testo con il modello e il tokenizer e fornisci un prompt di esempio. 

text = "I'm trapped in a storm of emotions that I can't control, and it feels like no one understands the chaos inside me"
prompt = f"""Classify the text into Normal, Depression, Anxiety, Bipolar, and return the answer as the corresponding mental health disorder label.
text: {text}
label: """.strip()

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

outputs = pipe(prompt, max_new_tokens=2, do_sample=True, temperature=0.1)
print(outputs[0]["generated_text"].split("label: ")[-1].strip())Offerto da

Il nostro modello funziona perfettamente.

DepressionOfferto da

Ora possiamo salvare localmente modello e tokenizer. 

model_dir = "Llama-3.1-8B-Instruct-Mental-Health-Classification"
model.save_pretrained(model_dir)
tokenizer.save_pretrained(model_dir)Offerto da

E quindi caricare modello e tokenizer su Hugging Face Hub.

model.push_to_hub(model_dir, use_temp_dir=False)
tokenizer.push_to_hub(model_dir, use_temp_dir=False)Offerto da

Questo creerà il repository su Hugging Face e caricherà tutti i file del modello e del tokenizer.

CommitInfo(commit_url='https://huggingface.co/kingabzpro/Llama-3.1-8B-Instruct-Mental-Health-Classification/commit/e1244abeaac159e0a48439095200a4190c2b493c', commit_message='Upload tokenizer', commit_description='', oid='e1244abeaac159e0a48439095200a4190c2b493c', pr_url=None, pr_revision=None, pr_num=None)Offerto da

Possiamo visualizzare tutti i file del modello visitando il sito di Hugging Face. 

Fonte: kingabzpro/Llama-3.1-8B-Instruct-Mental-Health-Classification · Hugging Face

Se riscontri problemi nel fondere l’adapter con il modello base, fai riferimento al notebook Kaggle.

Se trovi difficile fare il fine-tuning degli LLM, puoi seguire il tutorial Fine-tuning di GPT-4 di OpenAI: guida passo passo per imparare un modo più semplice di usare l’API di OpenAI per fare il fine-tuning del modello su qualsiasi dataset con poche righe di codice.

Considerazioni finali

Il fine-tuning del modello non si limita alla personalizzazione basata sul dataset. Possiamo perfezionare i large language model su vari task di linguistica computazionale come traduzione automatica, clustering, classificazione, domanda e risposta, embedding e altro. 

In questo tutorial, abbiamo imparato a fare il fine-tuning del modello Llama 3.1 su un dataset di classificazione della salute mentale. Questo modello può essere usato per identificare pazienti e persino dipendenti che affrontano difficoltà nella vita quotidiana.

Se ti stai chiedendo come iniziare con gli LLM e cominciare a fare fine-tuning dei modelli in autonomia, ti consigliamo di seguire lo skill track Developing Large Language Models. Con questa serie di corsi, costruirai solide basi sugli LLM, proiettandoti nel nuovo panorama guidato dall’IA.