La rivoluzione degli LLM trasformando i modelli di lingua
La rivoluzione degli LLM trasformando i modelli linguistici
Introduzione
Il mondo dei modelli di lingua ha subito un’evoluzione drammatica negli ultimi anni, in particolare con l’emergere dei Large Language Models (LLM). Questi modelli, dotati di miliardi di parametri e una profonda comprensione del linguaggio naturale, hanno svolto un ruolo fondamentale nella trasformazione del campo dell’intelligenza artificiale. Oggi esploreremo questa rivoluzione, sottolineando la transizione da LLM closed-source a LLM open-source, l’importanza del fine-tuning e lo sviluppo di tecniche efficienti di fine-tuning che sono recentemente emerse.
Obiettivi di apprendimento:
- Conoscere le differenze tra LLM closed-source e LLM open-source.
- Comprendere il fine-tuning tradizionale e il fine-tuning parametrico efficiente nei LLM.
- Esplorare diverse strategie di fine-tuning parametrico efficiente.
- Imparare a utilizzare Ludwig per il fine-tuning efficiente.
Closed-Source vs Open-Source LLMs: Scegliere l’Approccio Giusto
Il panorama dei modelli di linguaggio ha visto una dicotomia tra modelli closed-source forniti da aziende come OpenAI e varianti open-source offerte da istituzioni come Meta, Google e vari laboratori di ricerca. I LLM closed-source come ChatGPT, GPT 3.5 e GPT 4 rappresentano un punto di partenza convincente grazie alla loro infrastruttura gestita e alle capacità di prova concettuale rapida. Questi modelli offrono dataset pre-addestrati di alta qualità e non richiedono alcuna configurazione dell’infrastruttura, rendendoli un punto di ingresso facile per coloro che esplorano le capacità dei LLM.
Tuttavia, nonostante la loro accessibilità, i LLM closed-source presentano limitazioni fondamentali. Manca loro la proprietà del modello e concedono abilità di personalizzazione minime, rendendoli meno adatti per gli investimenti a lungo termine, specialmente per settori in cui la privacy dei dati e il controllo del modello sono fondamentali. Al contrario, i LLM open-source vantano un’alternativa promettente. Consentono la completa proprietà del modello, la personalizzazione e facilitano l’accesso immediato alle sviluppi innovativi nello spazio open-source. Il compromesso è il costo e la sfida di self-hosting di questi modelli.
- Core42 e Cerebras stabiliscono un nuovo punto di riferimento per i modelli di lingua arabi di grandi dimensioni con il rilascio di Jais 30B
- Hugging Face Research introduce Distil-Whisper Un modello compatto di riconoscimento del parlato che colma il divario nelle prestazioni elevate, in ambienti a bassa risorsa
- Decifrare il Potere dei Modelli Nascosti di Markov
Fine-Tuning Tradizionale Vs. Fine-Tuning Parametrico Efficiente
Il fine-tuning emerge come un processo critico per massimizzare il potenziale dei LLM, specialmente quando si considerano compiti specifici del dominio. I modelli closed-source spesso mancano della flessibilità richiesta per il fine-tuning, mentre i modelli open-source offrono un controllo completo su questo processo. Il fine-tuning consente l’adattamento dei LLM pre-addestrati a un compito specifico mediante l’aggiornamento dei pesi del modello, portando a miglioramenti delle prestazioni. È un modo per personalizzare questi modelli generali per applicazioni specializzate, ottimizzando le prestazioni per compiti unici.
Il dibattito tra il fine-tuning e modelli come Retrieval Augmented Generation (RAG) ruota attorno alla necessità di modelli adattati a compiti specifici, invece di intelligenza a uso generale. La natura open-source dei LLM consente la personalizzazione e il fine-tuning efficiente necessario per ottenere prestazioni superiori specifiche del compito.
Il fine-tuning tradizionale comporta l’aggiornamento di tutti i parametri del modello, un processo che si è dimostrato intensivo in termini di risorse, richiedente tempo e non sempre produce prestazioni ottimali specifiche del compito. Tuttavia, recenti innovazioni nel fine-tuning parametrico efficiente hanno offerto una svolta. Congelando il LLM pre-addestrato e addestrando solo un piccolo insieme di layer specifici del compito, che rappresentano meno dell’1% del peso totale del modello, il fine-tuning efficiente si dimostra sia economico in termini di risorse che più efficace.
Il passaggio al fine-tuning parametrico efficiente ha avuto un impatto significativo su come i LLM vengono adattati a compiti specifici. Concentrandosi sull’addestramento solo di un insieme minimo di layer specifici del compito, il processo diventa più conveniente dal punto di vista dei costi e più efficiente dal punto di vista del tempo. Questo approccio innovativo facilita prestazioni ottimali specifiche del compito, anche con dataset più piccoli, evidenziando il potenziale dei LLM open-source rispetto ai modelli closed-source.
Ricerche, come il paper LIMA di Meta, supportano l’idea che il fine-tuning su dataset più piccoli possa superare le prestazioni dei modelli closed-source come GPT 4. Questo concetto di fare di più con meno dati sottolinea l’efficienza e l’efficacia dei LLM open-source quando vengono adeguatamente sottoposti a fine-tuning.
Comprendere le Strategie di Addestramento Efficienti
Nel campo del sfruttamento dei modelli pre-addestrati per compiti specifici, LoRA (Low Rank Adaptation) e QLoRA (Quantized Low Rank Adaptation) sono emerse come metodologie innovative che consentono di sottoporre a fine-tuning efficace modelli di linguaggio di grandi dimensioni (LLM). Questi metodi sono fondamentali per adattare i modelli pre-addestrati a compiti specializzati, minimizzando i parametri aggiuntivi.
LoRA: Un tuffo nell’architettura
L’architettura di LoRA prevede una decomposizione a rango ridotto, che funziona suddividendo grandi matrici di peso all’interno delle architetture dei trasformatori in matrici più piccole. Nel contesto dei trasformatori, LoRA si concentra sulle proiezioni lineari di query, chiave e valore.
Di solito, queste proiezioni lineari hanno grandi matrici di peso, come ad esempio 1024 per 1024, che LoRA decomprime in matrici più piccole, come 1024 per 8 e 8 per 1024. Queste matrici più piccole si moltiplicano per produrre la dimensione originale. La compressione riduce drasticamente i parametri che possono essere sottilmente regolati, a circa la metà o l’1% dei parametri totali di LLM.
Nel contesto dell’architettura dei trasformatori, LoRA integra moduli adattatori per strati di proiezione chiave e query. Questi adattatori, costruiti tramite la decomposizione a rango ridotto, mantengono le forme originali consentendo l’inserimento negli strati trasformatore. Gli strati di base rimangono congelati mentre solo i pesi dell’adattatore sono addestrabili.
QLoRA: Adattamento quantizzato a rango ridotto
QLoRA, un’estensione di LoRA, rappresenta in modo innovativo i pesi del modello utilizzando una precisione a 4 bit anziché la rappresentazione standard a virgola mobile a 32 bit. Utilizzando valori a 4 bit, il peso di ciascun parametro viene compresso, riducendo significativamente la dimensione del modello. L’efficienza di QLoRA consente il sottoposizione a sintonizzazione fine anche per modelli colossali su piattaforme a memoria meno intensiva, come Colab.
Questo approccio di quantizzazione riduce drasticamente la memoria richiesta per la sintonizzazione fine, rendendo possibile la sintonizzazione fine di modelli grandi anche con risorse computazionali limitate, come le GPU T4.
LoRA vs. QLoRA
LoRA e QLoRA offrono percorsi diversi per la sintonizzazione fine di modelli di lingua ampia. LoRA opera principalmente tramite decomposizione a rango ridotto, consentendo la modifica efficace di modelli pre-addestrati con parametri ridotti. D’altra parte, QLoRA, la versione raffinata, introduce la quantizzazione per comprimere significativamente i pesi, riducendo così la memoria del modello. Sia LoRA che QLoRA sono fondamentali nel campo della Sintonizzazione Fine Efficientemente dei Parametri (PEFT) per i LLM.
Ludwig: Un approccio dichiarativo all’apprendimento automatico
Esplorando il panorama degli LLM open source, Ludwig emerge come un attore di primo piano. Ludwig offre un approccio dichiarativo all’apprendimento automatico, fornendo un’interfaccia accessibile per controllare e personalizzare modelli senza la necessità di codici estesi. Le configurazioni basate su YAML di Ludwig consentono agli utenti di gestire in modo efficiente diverse caratteristiche di input e compiti di output. La capacità multimodale di Ludwig gli consente di gestire diversi tipi di dati, rendendolo un versatile e user-friendly strumento nel campo degli LLM.
Unendo la facilità di utilizzo di AutoML con la flessibilità delle API a basso livello, Ludwig colma il divario, offrendo modelli personalizzabili senza la necessità di codici estesi. La sua architettura modulare semplifica ed rende accessibile l’esperimento di apprendimento profondo, fornendo agli utenti una piattaforma conveniente per esplorare il potenziale degli LLM.
Implementazione di LoRA per la sintonizzazione fine
Sfruttare LoRA comporta l’integrazione di moduli adattatori negli strati trasformatore, consentendo una sintonizzazione fine specifica mantenendo gli strati di base congelati. La decomposizione a rango ridotto di LoRA comprime i parametri di sintonizzazione fine in una piccola frazione della dimensione originale del LLM. Questo metodo aiuta ad adattare modelli pre-addestrati per adattarsi a compiti personalizzati senza alterare in modo significativo l’architettura di base.
Ludwig introduce un approccio accessibile per la configurazione della sintonizzazione fine basata su LoRA dei modelli di linguaggio. Utilizzando Ludwig, gli utenti possono configurare l’architettura del modello, definire le caratteristiche di input e output e applicare configurazioni LoRA o QLoRA tramite configurazioni basate su YAML.
Queste configurazioni semplificano il processo di implementazione della sintonizzazione fine basata su LoRA, come il tipo di modello (LLM), la selezione del modello di base e la specifica delle caratteristiche di input e output per il compito previsto.
Codice:
# Installa Ludwig e le dipendenze correlate a LLM di Ludwig.
!pip uninstall -y tensorflow –quiet
!pip install ludwig –quiet
!pip install ludwig[llm] –quiet
# Abilita il testo a capo in modo da non dover scorrere orizzontalmente e crea una funzione per svuotare la cache CUDA.
from IPython.display import HTML, display
def set_css():
display(HTML(“‘<style>
pre {
white-space: pre-wrap;
}
</style>
“‘)))
get_ipython().events.register(‘pre_run_cell’, set_css)
def clear_cache():
if torch.cuda.is_available():
torch.cuda.empty_cache()
# Setup Your HuggingFace Token
import getpass
import locale; locale.getpreferredencoding = lambda: “UTF-8”
import logging
import os
import torch
import yaml
from ludwig.api import LudwigModel
os.environ[“HUGGING_FACE_HUB_TOKEN”] = getpass.getpass(“Token:”)
assert os.environ[“HUGGING_FACE_HUB_TOKEN”]
# Import The Code Generation Dataset
from google.colab import data_table; data_table.enable_dataframe_formatter()
import numpy as np; np.random.seed(123)
import pandas as pd
df = pd.read_json(“https://raw.githubusercontent.com/sahil280114/codealpaca/master/data/code_alpaca_20k.json”)
# We’re going to create a new column called `split` where:
# 90% will be assigned a value of 0 -> train set
# 5% will be assigned a value of 1 -> validation set
# 5% will be assigned a value of 2 -> test set
# Calculate the number of rows for each split value
total_rows = len(df)
split_0_count = int(total_rows * 0.9)
split_1_count = int(total_rows * 0.05)
split_2_count = total_rows – split_0_count – split_1_count
# Create an array with split values based on the counts
split_values = np.concatenate([
np.zeros(split_0_count),
np.ones(split_1_count),
np.full(split_2_count, 2)
])
# Shuffle the array to ensure randomness
np.random.shuffle(split_values)
# Add the ‘split’ column to the DataFrame
df[‘split’] = split_values
df[‘split’] = df[‘split’].astype(int)
# For this webinar, we will just 500 rows of this dataset.
df = df.head(n=1000)
Parametri di configurazione avanzati e di ottimizzazione fine in Ludwig
Nel nostro percorso di esplorazione di Ludwig e delle sue capacità nei compiti di elaborazione del linguaggio naturale, abbiamo compreso l’essenza dell’ottimizzazione fine e il suo impatto significativo sui modelli. Ora, approfondiamo ulteriormente i dettagli della configurazione avanzata e i parametri di ottimizzazione fine offerti da Ludwig.
La vera potenza di un modello emerge non solo dalla sua architettura, ma anche dal processo di ottimizzazione fine che lo modella per soddisfare le nostre esigenze. Come già accennato, l’efficacia dell’ottimizzazione fine dipende dal guidare il modello nella giusta direzione. Un modo per raggiungere questo obiettivo è fornire prompt specifici e dati avvolti in questi prompt.
Immaginate un mondo in cui alimentiamo il modello con un prompt, lo abbiniamo a istruzioni e contesti specifici e lasciamo che accada la magia. Il prompt funge da guida, orientando la comprensione del modello del compito che deve svolgere. Ed è qui che entrano in gioco le funzionalità avanzate di Ludwig.
Codice:
qlora_fine_tuning_config = yaml.safe_load(
“””
model_type: llm
base_model: meta-llama/Llama-2-7b-hf
input_features:
– name: instruction
type: text
output_features:
– name: output
type: text
prompt:
template: >-
Sotto è presente un’istruzione che descrive un compito, abbinata a un input che può fornire ulteriori contesti. Scrivi una risposta che completi correttamente la richiesta.
### Istruzione: {instruction}
### Input: {input}
### Risposta:
generazione:
temperatura: 0.1
max_new_tokens: 512
adattatore:
tipo: lora
quantizzazione:
bit: 4
preprocessing:
global_max_sequence_length: 512
split:
tipo: casuale
probabilità:
– 0,9 # train
– 0,05 # val
– 0,05 # test
allenatore:
tipo: finetune
epoche: 1
dimensione_batch: 1
dimensione_batch_valutazione: 2
passi_accumulazione_gradiente: 16
tasso_apprendimento: 0,0004
programma_tasso_apprendimento:
frazione_riscaldamento: 0,03
““”
)
modello = ModelloLudwig(config=qlora_fine_tuning_config, livello_registrazione=logging.INFO)
risultati = modello.addestra(dataset=df)
Controlla il codice completo qui – Ludwig: Ottimizzazione fine di Llama-2-7b
Dopo l’ottimizzazione fine, inferenza ed output del modello
Dopo un’ottimizzazione fine meticolosa, è ora il momento di osservare il modello in azione e osservare le sue capacità di inferenza. Questa fase è dove si mette alla prova il modello producendo output basati sull’addestramento ricevuto.
Impostando i parametri, utilizzando le configurazioni YAML e definendo aspetti chiave come adattatori, quantizzazione e specifiche relative all’addestramento, Ludwig fornisce un ambiente facile da usare ma robusto per modellare il modello secondo le proprie preferenze.
Inoltre, non si può sottovalutare l’importanza di monitorare il processo di ottimizzazione fine e comprendere le implicazioni sulla memoria. Ad esempio, l’utilizzo dell’adattatore LoRA insieme alla quantizzazione riduce significativamente l’uso della memoria, rendendo il processo più efficiente e pratico.
Dopo l’ottimizzazione fine, l’inferenza diventa il punto focale. Il modello, ora pronto per affrontare i compiti assegnati, genera output basati sui prompt forniti. Tuttavia, le sfumature risiedono nel fatto che questi modelli sono auto-regressivi, il che significa che producono un token alla volta. Il processo di inferenza, sebbene lento a causa della generazione e del calcolo dei token, fornisce una visione delle capacità del modello.
Gli output dell’inferenza potrebbero non essere perfetti, soprattutto se il numero di epoche per l’ottimizzazione fine è limitato. Tuttavia, modificando i parametri come la configurazione di generazione (temperatura, massimo dei nuovi token, ecc.), gli output possono essere modificati, migliorando così le risposte del modello.
Conclusione
L’evoluzione del LLM da modelli closed-source a open-source sottolinea il ruolo dell’ottimizzazione fine delle funzionalità avanzate di Ludwig nella creazione di modelli linguistici adattabili ed efficienti. Il futuro promette LLM personalizzati e diversificati nonostante i dati limitati. Mentre continuiamo ad esplorare il mondo dei modelli linguistici, gli sviluppi open-source del LLM plasmeranno non solo il futuro dell’IA, ma offriranno anche opportunità rivoluzionarie in diversi settori, aprendo la strada a applicazioni innovative e soluzioni su misura. La collaborazione e i contributi open-source apriranno la strada a un approccio più completo, accessibile ed efficiente alla modellazione del linguaggio.
Punti chiave:
- I modelli closed-source offrono un accesso facile ma un’adozione limitata; i modelli open-source consentono la personalizzazione ma richiedono un’autoospitalità, bilanciando l’accessibilità e il controllo.
- Modificare i LLM pre-addestrati tramite ottimizzazione fine migliora le prestazioni per compiti specifici, trovando un equilibrio tra modelli ad uso generale e orientati ai compiti.
- L’approccio dichiarativo di Ludwig semplifica la personalizzazione del modello e l’impostazione dei parametri di ottimizzazione fine, ottimizzando il processo di ottimizzazione fine per ottenere migliori output del modello.
Domande frequenti
Informazioni sull’autore: Arnav Garg
Arnav Garg, Senior Machine Learning Engineer presso Predibase, è la tua guida in questo viaggio. È un esperto di apprendimento automatico applicato e addestramento su larga scala, con un’attenzione particolare alle ottimizzazioni dell’ottimizzazione fine. L’esperienza di Arnav si estende all’addestramento distribuito su larga scala e alla creazione di meccanismi di affidabilità per un addestramento efficace ed economico.
Pagina DataHour: https://community.analyticsvidhya.com/c/datahour/efficient-fine-tuning-of-llms-on-single-t4-gpu-using-ludwig
LinkedIn: https://www.linkedin.com/in/arnavgarg/
</style>
