I Large Language Model (LLM) sono componenti fondamentali delle moderne applicazioni di intelligenza artificiale, soprattutto per l’elaborazione del linguaggio naturale. Hanno il potenziale per elaborare e comprendere in modo efficiente il linguaggio umano, con applicazioni che vanno dagli assistenti virtuali e la traduzione automatica al riassunto di testi e alle domande e risposte.
Librerie come LangChain facilitano l’implementazione di applicazioni IA end-to-end come quelle citate sopra. Il nostro tutorial Introduzione a LangChain per Data Engineering & Data Applications offre una panoramica su ciò che puoi fare con LangChain, inclusi i problemi che LangChain risolve, con esempi di casi d’uso sui dati.
Questo articolo spiega l’intero processo di addestramento di un large language model, dalla configurazione dell’ambiente all’implementazione finale, usando Pytorch 2.0.1, un framework di deep learning dinamico e flessibile che consente un’implementazione del modello semplice e chiara.
Prerequisiti
Per trarre il massimo da questo contenuto, è importante avere dimestichezza con la programmazione in Python, una comprensione di base dei concetti di deep learning e dei transformer, e familiarità con il framework Pytorch. Il codice sorgente completo sarà disponibile su GitHub.
Prima di passare all’implementazione principale, dobbiamo installare e importare le librerie rilevanti. Inoltre, è importante notare che lo script di addestramento è ispirato a questo repository di Hugging Face.
Installazione delle librerie
Il processo di installazione è descritto di seguito:
Per prima cosa, usiamo l’istruzione %%bash per eseguire i comandi di installazione in un’unica cella come comando bash in Jupyter Notebook.
- Trl: usata per addestrare modelli linguistici transformer con reinforcement learning.
- Peft utilizza metodi di fine-tuning efficienti in termini di parametri (PEFT) per abilitare un’adattabilità efficiente del modello pre-addestrato.
- Torch: una libreria open source per il machine learning ampiamente utilizzata.
- Datasets: usata per facilitare il download e il caricamento di molti dataset di machine learning comuni.
Transformers: una libreria sviluppata da Hugging Face che include migliaia di modelli pre-addestrati per una varietà di attività testuali come classificazione, riepilogo e traduzione.
%%bash
pip -q install trl
pip -q install peft
pip -q install torch
pip -q install datasets
pip -q install transformers
Ora, questi moduli possono essere importati come segue:
import torch
from trl import SFTTrainer
from datasets import load_dataset
from peft import LoraConfig, get_peft_model, prepare_model_for_int8_training
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArgumentsCaricamento e preparazione dei dati
Per questa illustrazione useremo il dataset alpaca, liberamente disponibile su Hugging Face. Il dataset ha tre colonne principali: instruction, input e output. Queste colonne sono combinate per generare una colonna di testo finale.
L’istruzione per caricare il dataset è riportata di seguito fornendo il nome del dataset di interesse, ovvero tatsu-lab/alpaca:
train_dataset = load_dataset("tatsu-lab/alpaca", split="train")
print(train_dataset)Possiamo vedere che i dati risultanti sono in un dizionario con due chiavi:
- Features: contiene le colonne principali dei dati
- Num_rows: corrisponde al numero totale di righe nei dati
Struttura di train_dataset
Le prime cinque righe possono essere visualizzate con l’istruzione seguente. Prima, converti il dizionario in un dataframe pandas, poi visualizza le righe.
pandas_format = train_dataset.to_pandas()
display(pandas_format.head())
Prime cinque righe di train_dataset
Per una migliore visualizzazione, stampiamo le informazioni sulle prime tre righe; prima però dobbiamo installare la libreria textwrap per impostare a 50 il numero massimo di parole per riga. La prima istruzione di stampa separa ciascun blocco con 15 trattini.
import textwrap
for index in range(3):
print("---"*15)
print("Instruction:
{}".format(textwrap.fill(pandas_format.iloc[index]["instruction"],
width=50)))
print("Output:
{}".format(textwrap.fill(pandas_format.iloc[index]["output"],
width=50)))
print("Text:
{}".format(textwrap.fill(pandas_format.iloc[index]["text"],
width=50)))
Dettagli delle prime tre righe
Addestramento del modello
Prima di procedere con l’addestramento del modello, dobbiamo impostare alcuni prerequisiti:
- Modello pre-addestrato: useremo il modello pre-addestrato Salesforce/xgen-7b-8k-base, disponibile su Hugging Face. Salesforce ha addestrato questa serie di LLM da 7B chiamati XGen-7B con attenzione densa standard su sequenze fino a 8K per fino a 1,5T token.
- Tokenizer: serve per i compiti di tokenizzazione sui dati di addestramento. Il codice per caricare il modello pre-addestrato e il tokenizer è il seguente:
pretrained_model_name = "Salesforce/xgen-7b-8k-base"
model = AutoModelForCausalLM.from_pretrained(pretrained_model_name, torch_dtype=torch.bfloat16)
tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name, trust_remote_code=True)Configurazione dell’addestramento
L’addestramento richiede alcuni argomenti e configurazioni; di seguito sono definiti i due oggetti di configurazione importanti: un’istanza di TrainingArguments, un’istanza del modello LoraConfig e infine il modello SFTTrainer.
TrainingArguments
Serve a definire i parametri per l’addestramento del modello.
In questo scenario specifico, iniziamo definendo la destinazione in cui verrà memorizzato il modello addestrato usando l’attributo output_dir, prima di definire ulteriori iperparametri come il metodo di ottimizzazione, il learning rate, il numero di epoche e altro.
model_training_args = TrainingArguments(
output_dir="xgen-7b-8k-base-fine-tuned",
per_device_train_batch_size=4,
optim="adamw_torch",
logging_steps=80,
learning_rate=2e-4,
warmup_ratio=0.1,
lr_scheduler_type="linear",
num_train_epochs=1,
save_strategy="epoch"
)LoRAConfig
Gli argomenti principali usati in questo scenario sono il rango della matrice di trasformazione a bassa dimensione in LoRA, impostato a 16. Poi, il fattore di scalatura per i parametri aggiuntivi in LoRA è impostato a 32.
Inoltre, il rapporto di dropout è 0,05, il che significa che il 5% delle unità di input verrà ignorato durante l’addestramento. Infine, poiché ci occupiamo di causal language modeling, il task viene inizializzato con l’attributo CAUSAL_LM.
SFTTrainer
Serve ad addestrare il modello usando i dati di training, il tokenizer e informazioni aggiuntive come i modelli sopra.
Poiché stiamo usando il campo text dei dati di training, è importante dare un’occhiata alla distribuzione per aiutare a impostare il numero massimo di token in una data sequenza.
import matplotlib.pyplot as plt
pandas_format['text_length'] = pandas_format['text'].apply(len)
plt.figure(figsize=(10,6))
plt.hist(pandas_format['text_length'], bins=50, alpha=0.5, color='g')
plt.title('Distribution of Length of Text')
plt.xlabel('Length of Text')
plt.ylabel('Frequency')
plt.grid(True)
plt.show()
Distribuzione della lunghezza della colonna text
In base all’osservazione sopra, possiamo vedere che la maggior parte dei testi ha una lunghezza compresa tra 0 e 1000. Inoltre, come mostrato sotto, solo il 4,5% dei documenti testuali ha una lunghezza superiore a 1024.
mask = pandas_format['text_length'] > 1024
percentage = (mask.sum() / pandas_format['text_length'].count()) * 100
print(f"The percentage of text documents with a length greater than 1024 is: {percentage}%")
Quindi impostiamo a 1024 il numero massimo di token nella sequenza, in modo che qualsiasi testo più lungo venga troncato.
SFT_trainer = SFTTrainer(
model=model,
train_dataset=train_dataset,
dataset_text_field="text",
max_seq_length=1024,
tokenizer=tokenizer,
args=model_training_args,
packing=True,
peft_config=lora_peft_config,
)Esecuzione dell’addestramento
Con tutti i prerequisiti a posto, ora possiamo eseguire il processo di addestramento del modello come segue:
tokenizer.pad_token = tokenizer.eos_token
model.resize_token_embeddings(len(tokenizer))
model = prepare_model_for_int8_training(model)
model = get_peft_model(model, lora_peft_config)
training_args = model_training_args
trainer = SFT_trainer
trainer.train()È importante sottolineare che questo addestramento viene eseguito in un ambiente cloud con GPU, il che rende l’intero processo più veloce. Tuttavia, l’addestramento su un computer locale richiederebbe più tempo per essere completato.
Il nostro blog, Pro e contro dell’uso degli LLM nel cloud rispetto all’esecuzione in locale, fornisce considerazioni chiave per scegliere la strategia di distribuzione ottimale per gli LLM
Vediamo cosa succede nello snippet di codice sopra:
- tokenizer.pad_token = tokenizer.eos_token: imposta il token di padding uguale al token di fine frase.
- model.resize_token_embeddings(len(tokenizer)): ridimensiona il layer di embedding dei token del modello per farlo corrispondere alla lunghezza del vocabolario del tokenizer.
- model = prepare_model_for_int8_training(model): prepara il modello all’addestramento con precisione INT8, probabilmente effettuando una quantizzazione.
- model = get_peft_model(model, lora_peft_config): adatta il modello dato in base alla configurazione PEFT.
- training_args = model_training_args: assegna gli argomenti di addestramento predefiniti a training_args.
- trainer = SFT_trainer: assegna l’istanza di SFTTrainer alla variabile trainer.
- trainer.train(): avvia il processo di addestramento del modello secondo le specifiche fornite.
Conclusione
Questo articolo ha fornito una guida chiara su come addestrare un large language model con PyTorch. A partire dalla preparazione del dataset, ha illustrato i passaggi per predisporre i prerequisiti, configurare il trainer e, infine, eseguire il processo di addestramento.
Sebbene abbia utilizzato uno specifico dataset e un modello pre-addestrato, il processo dovrebbe essere in gran parte lo stesso per qualsiasi altra opzione compatibile. Ora che sai come addestrare un LLM, puoi sfruttare queste conoscenze per addestrare altri modelli sofisticati per vari task di NLP.
Dai un’occhiata alla nostra guida su come creare applicazioni LLM con LangChain per esplorare ulteriormente la potenza dei large language model. Oppure, se devi ancora approfondire i concetti dei large language model, consulta il nostro corso per proseguire nell’apprendimento.
