Solitamente ci sono tre diverse fasi di addestramento per i modelli linguistici di grandi dimensioni:

1. Pre-training: In questa fase, il modello viene addestrato su un ampio corpus di dati di testo grezzo per imparare a prevedere il token o la parola successiva. Il risultato è un modello di base che ha acquisito molte conoscenze generali dal testo, ma non è ancora molto utile per compiti specifici.

2. Supervised Fine-Tuning: Per rendere il modello di base più utile, la seconda fase è il supervised fine-tuning. In questa fase, il modello viene addestrato su coppie di domande-risposte o istruzioni-risposte. L'input è una domanda o un'istruzione, e l'output è la risposta o la risposta desiderata. Questa fase consente al modello di apprendere conoscenze e capacità specifiche per il compito.

3. Preference Alignment: La terza fase opzionale è l'allineamento delle preferenze, dove il modello viene addestrato per imparare le preferenze dell'utente in termini di risposte, o per allineare il modello a determinati principi. Questo viene spesso fatto utilizzando tecniche come il Reinforcement Learning from Human Feedback (RLHF) o il Debate Policy Optimization (DPO).

L'obiettivo di questo video è di concentrarsi sulla fase di supervised fine-tuning, in particolare su come eseguire il fine-tuning del modello Llama 3.1 utilizzando la libreria Unsloth. Il video coprirà diverse tecniche di fine-tuning, come il full fine-tuning, LoRA e QLoRA, e discuterà i compromessi tra loro in termini di prestazioni e requisiti di memoria.

Ci sono tre opzioni popolari per il supervised fine-tuning:

1. Full Fine-Tuning: In questo approccio, si prende il modello originale e si aggiornano i pesi con il dataset di fine-tuning delle istruzioni. Questo darà le migliori prestazioni, ma il requisito di VRAM sarà elevato.

2. LoRA (Low-Rank Adaptation): Invece di aggiornare direttamente i pesi, si aggiungono adattatori esterni al modello. Il numero di parametri in questi adattatori esterni può essere controllato. Gli aggiornamenti dei pesi per questi adattatori vengono eseguiti in precisione a 16 bit, e poi uniti di nuovo nei pesi originali del modello. Questo approccio fornisce un addestramento rapido, ma è ancora costoso a causa delle operazioni a 16 bit.

3. QLoRA (Quantized LoRA): Questo è simile a LoRA, ma gli aggiornamenti dei pesi vengono eseguiti in precisione a 4 bit, e anche i pesi del modello vengono mantenuti a 4 bit. Questo richiede meno VRAM, ma le prestazioni potrebbero non essere così buone come LoRA o il full fine-tuning.

Unsloth supporta sia LoRA che QLoRA per il fine-tuning. Il rango degli adattatori LoRA, il LoRA alpha e il LoRA dropout sono importanti iperparametri che controllano il numero di parametri e il contributo degli adattatori ai pesi finali del modello.

Per impostare gli adattatori LoRA, ci sono alcuni parametri chiave da considerare:

1. Rank: Il rango degli adattatori LoRA controlla il numero di parametri che verranno aggiornati durante il fine-tuning. Un rango più basso significa meno parametri, il che riduce i requisiti di VRAM ma può anche limitare la capacità del modello di adattarsi. Al contrario, un rango più alto consente una maggiore flessibilità ma richiede più VRAM.

2. LoRA Alpha: Questo parametro controlla il contributo degli adattatori LoRA ai pesi finali del modello. Un valore di LoRA Alpha più alto significa che gli adattatori LoRA avranno un'influenza più forte, mentre un valore più basso significa che avranno un'influenza più debole.

3. LoRA Dropout: Questo parametro controlla il tasso di dropout applicato agli adattatori LoRA durante l'addestramento. L'aumento del tasso di dropout può aiutare a prevenire il sovradattamento, ma può anche ridurre le prestazioni del modello.

Regolando questi parametri, è possibile trovare il giusto equilibrio tra requisiti di VRAM, velocità di addestramento e prestazioni del modello per il proprio caso d'uso specifico.

Per preparare i dati per il fine-tuning, dobbiamo impostare il modello di prompt e specificare il token di fine sequenza.

Il modello di prompt è cruciale, in quanto definisce il formato dei dati di input su cui il modello verrà addestrato. Per la famiglia Llama 3.1, utilizzeremo il modello di prompt Alpaca, che include un'istruzione e un input che fornisce ulteriori contesti. Ci si aspetta che il modello generi una risposta appropriata.

# Modello di prompt Alpaca
prompt_template = "Di seguito è riportata un'istruzione che descrive un compito abbinato a un input che fornisce ulteriori contesti. Rispondi con un output pertinente.\n\nIstruzione: {instruction}\nInput: {input}\nOutput:"

Ad integrazione, dobbiamo specificare il token di fine sequenza per impedire al modello di generare testo indefinitamente. Questo è un passaggio importante che molte persone hanno riscontrato problemi quando si utilizzano le versioni quantizzate dei modelli con LamaCPP.

# Imposta il token di fine sequenza
end_token = "</s>"

Impostando il modello di prompt e il token di fine sequenza, ci assicuriamo che i dati siano correttamente formattati per il processo di fine-tuning, un passaggio cruciale per ottenere buoni risultati.

Per addestrare il modello, utilizzeremo l'SFT (Supervised Fine-Tuning) Trainer dal pacchetto TRL, creato e gestito da Hugging Face.

Prima, forniamo il nostro modello, il tokenizer e il dataset all'SFT Trainer. In questo caso, stiamo utilizzando la colonna text dal dataset, poiché abbiamo impostato il nostro modello di prompt per utilizzare questo campo.

Impostiamo anche la lunghezza massima della sequenza, che dovrebbe essere basata sugli esempi nei dati di training. Tieni presente che una lunghezza di sequenza più alta aumenterà i requisiti di VRAM.

Successivamente, configureremmo gli argomenti di training, come il dispositivo (in questo caso, una GPU T4 su Google Colab con circa 15GB di VRAM) e il numero di passaggi di training.

Infine, eseguiamo l'addestramento e possiamo osservare la diminuzione della perdita, che è un buon indicatore del progresso dell'addestramento.

L'addestramento è durato circa 8 minuti e la memoria massima riservata era di circa 8GB, pari al 53% della VRAM disponibile sulla GPU T4. Questo dimostra l'efficienza dell'approccio Unsloth, che consente il fine-tuning con un requisito di VRAM relativamente basso.

Per eseguire l'inferenza, possiamo utilizzare la classe o il metodo for_inference sulla classe FastLanguageModel. Dobbiamo fornire il modello addestrato e il prompt di input nel formato Alpaca. Possiamo anche impostare il numero massimo di token da generare.

# Esegui l'inferenza
input_prompt = alpaca_prompt(instruction, input)
output = model.for_inference(input_prompt, max_new_tokens=256)
print(output)

Per abilitare lo streaming, possiamo creare un oggetto Streamer e passarlo al metodo for_inference. Questo mostrerà le risposte un token alla volta.

# Abilita lo streaming
streamer = Streamer()
output = model.for_inference(input_prompt, max_new_tokens=256, streamer=streamer)

Con questo, puoi ora eseguire l'inferenza sul tuo modello fine-tuned e persino abilitare lo streaming per un'esperienza più interattiva.

Per salvare il modello fine-tuned e il tokenizer, puoi utilizzare la funzione save_pretrained() sul modello e sul tokenizer:

model.save_pretrained("path/to/save/model")
tokenizer.save_pretrained("path/to/save/tokenizer")

Questo salverà i pesi del modello e il tokenizer nelle directory specificate come un set di file JSON.

Per caricare il modello e il tokenizer salvati, puoi utilizzare la stessa classe FastLanguageModel e fornire le directory locali:

model = FastLanguageModel.from_pretrained("path/to/save/model")
tokenizer = FastLanguageModel.from_pretrained("path/to/save/tokenizer")

Questo caricherà il modello e il tokenizer dai file salvati.

Un'altra ottima funzionalità di Unsloth è la possibilità di salvare i modelli in formati diversi, come la precisione a virgola mobile a 16 bit per VLLM o direttamente in formato GGUF per LamaCPP. Ciò consente una facile distribuzione e integrazione con varie piattaforme e framework.

Unsloth introduce anche una nuova interfaccia utente basata su Gradio, che consente di eseguire i modelli addestrati utilizzando Unsloth e di impegnarsi in sessioni di chat interattive. Puoi clonare il repository Unsloth Studio e eseguire il notebook Colab fornito per sperimentare questa funzionalità.

Unsloth ha introdotto una nuova interfaccia di chat basata sulla libreria Radish, che consente di interagire facilmente con i modelli linguistici addestrati utilizzando Unsloth. Questa interfaccia di chat fornisce un'interfaccia utente intuitiva per chattare con i modelli ed esplorarne le capacità.

Per utilizzare l'interfaccia di chat, puoi clonare il repository Unsloth Studio ed eseguire il notebook Google Colab fornito. Questo configurerà l'ambiente necessario e avvierà l'interfaccia di chat, dove potrai iniziare a conversare con il modello linguistico.

L'interfaccia di chat supporta funzionalità come lo streaming delle risposte, consentendoti di vedere l'output del modello man mano che viene generato. Questo può essere utile per osservare il processo di pensiero del modello e il modo in cui genera le risposte.

Inoltre, l'interfaccia di chat di Unsloth ti consente di salvare e caricare i tuoi modelli fine-tuned, facilitando il proseguimento del lavoro con i tuoi modelli linguistici personalizzati. Puoi anche esportare i tuoi modelli in vari formati, come la precisione a virgola mobile a 16 bit per VLLM o il formato GGUF per LamaCPP, offrendo flessibilità nell'utilizzo e nella distribuzione dei tuoi modelli.

Complessivamente, la nuova interfaccia di chat di Unsloth è uno strumento prezioso per interagire ed esplorare le capacità dei modelli linguistici addestrati utilizzando il framework Unsloth.