Alleggerire LLMs con AutoGPTQ e transformers

LLMs più leggeri con AutoGPTQ e transformers

I modelli di linguaggio di grandi dimensioni hanno dimostrato straordinarie capacità nella comprensione e generazione di testi simili a quelli umani, rivoluzionando le applicazioni in vari ambiti. Tuttavia, le esigenze che pongono sull’hardware dei consumatori per l’addestramento e il dispiegamento sono diventate sempre più difficili da soddisfare.

🤗 La missione principale di Hugging Face è democratizzare il buon apprendimento automatico e ciò include rendere i modelli di grandi dimensioni accessibili il più possibile per tutti. Nello stesso spirito della nostra collaborazione bitsandbytes, abbiamo appena integrato la libreria AutoGPTQ in Transformers, rendendo possibile per gli utenti quantizzare ed eseguire modelli con precisione di 8, 4, 3 o anche 2 bit utilizzando l’algoritmo GPTQ (Frantar et al. 2023). C’è una degradazione trascurabile dell’accuratezza con una quantizzazione a 4 bit, con una velocità di inferenza comparabile alla base fp16 per dimensioni di batch ridotte. Si noti che il metodo GPTQ differisce leggermente dai metodi di quantizzazione post-addestramento proposti da bitsandbytes in quanto richiede il passaggio di un set di dati di calibrazione.

Questa integrazione è disponibile sia per le GPU Nvidia che per le GPU AMD con tecnologia RoCm.

Indice

  • Risorse
  • Un breve riassunto del paper GPTQ
  • Libreria AutoGPTQ – la libreria completa per sfruttare efficientemente GPTQ per i modelli di linguaggio di grandi dimensioni
  • Supporto nativo dei modelli GPTQ in 🤗 Transformers
  • Quantizzazione dei modelli con la libreria Optimum
  • Esecuzione di modelli GPTQ tramite Inferenza di Generazione di Testo
  • Perfezionare modelli quantizzati con PEFT
  • Spazio per il miglioramento
    • Modelli supportati
  • Conclusione e parole finali
  • Ringraziamenti

Risorse

Questo articolo e questa versione includono diverse risorse per iniziare con la quantizzazione GPTQ:

  • Articolo originale
  • Notebook di utilizzo di base su Google Colab – Questo notebook mostra come quantizzare il tuo modello Transformers con il metodo GPTQ, come eseguire inferenza e come effettuare il fine-tuning con il modello quantizzato.
  • Documentazione sull’integrazione di Transformers
  • Documentazione sull’integrazione di Optimum
  • I repository di Bloke con modelli GPTQ compatibili.

Un breve riassunto del paper GPTQ

I metodi di quantizzazione di solito appartengono a una delle due categorie:

  1. Quantizzazione post-addestramento (PTQ): quantizziamo un modello pre-addestrato utilizzando risorse moderate, come un set di dati di calibrazione e alcune ore di calcolo.
  2. Addestramento consapevole della quantizzazione (QAT): la quantizzazione viene eseguita prima dell’addestramento o del successivo fine-tuning.

GPTQ rientra nella categoria PTQ ed è particolarmente interessante per i modelli massicci, per i quali l’addestramento completo del modello o anche il fine-tuning possono essere molto costosi.

In particolare, GPTQ adotta uno schema di quantizzazione misto int4/fp16 in cui i pesi sono quantizzati come int4 mentre le attivazioni rimangono in float16. Durante l’inferenza, i pesi vengono dequantizzati al volo e il calcolo effettivo viene eseguito in float16.

I vantaggi di questo schema sono doppi:

  • Risparmi di memoria vicini a x4 per la quantizzazione int4, poiché la dequantizzazione avviene vicino all’unità di calcolo in un kernel fuso e non nella memoria globale della GPU.
  • Potenziamento potenziale grazie al tempo risparmiato sulla comunicazione dei dati dovuto alla minore larghezza di bit utilizzata per i pesi.

Il paper GPTQ affronta il problema della compressione strato per strato:

Dato uno strato lll con matrice dei pesi WlW_{l}Wl​ e input dello strato XlX_{l}Xl​, vogliamo trovare una versione quantizzata del peso W^l\hat{W}_{l}W^l​ per minimizzare l’errore quadratico medio (MSE):

W^l∗=argminWl^∥WlX−W^lX∥22{\hat{W}_{l}}^{*} = argmin_{\hat{W_{l}}} \|W_{l}X-\hat{W}_{l}X\|^{2}_{2}W^l​∗=argminWl​^​​∥Wl​X−W^l​X∥22​

Una volta risolto questo per ogni livello, è possibile ottenere una soluzione al problema globale combinando le soluzioni per ciascun livello.

Per risolvere questo problema di compressione layer-wise, l’autore utilizza il framework Optimal Brain Quantization (Frantar et al 2022). Il metodo OBQ parte dall’osservazione che l’equazione sopra può essere scritta come la somma degli errori quadratici, su ciascuna riga di WlW_{l}Wl​.

∑i=0drow∥Wl[i,:]X−W^l[i,:]X∥22 \sum_{i=0}^{d_{row}} \|W_{l[i,:]}X-\hat{W}_{l[i,:]}X\|^{2}_{2} ∑i=0drow​​∥Wl[i,:]​X−W^l[i,:]​X∥22​

Ciò significa che possiamo quantizzare ogni riga indipendentemente. Questo è chiamato quantizzazione per canale. Per ogni riga Wl[i,:]W_{l[i,:]}Wl[i,:]​, OBQ quantizza un peso alla volta, aggiornando sempre tutti i pesi non ancora quantizzati, al fine di compensare l’errore causato dalla quantizzazione di un singolo peso. L’aggiornamento dei pesi selezionati ha una formula a forma chiusa, che utilizza le matrici Hessiane.

Il paper GPTQ migliora questo framework introducendo una serie di ottimizzazioni che riducono la complessità dell’algoritmo di quantizzazione mantenendo l’accuratezza del modello.

Rispetto a OBQ, il passo di quantizzazione stesso è anche più veloce con GPTQ: per quantizzare un modello BERT (336M) con OBQ ci vogliono 2 ore di GPU, mentre con GPTQ, un modello Bloom (176B) può essere quantizzato in meno di 4 ore di GPU.

Per saperne di più sull’algoritmo esatto e sui diversi benchmark su perplexity e speedup, consulta il paper originale.

La libreria AutoGPTQ – la libreria completa per sfruttare efficientemente GPTQ per LLM

La libreria AutoGPTQ consente agli utenti di quantizzare i modelli 🤗 Transformers utilizzando il metodo GPTQ. Mentre gli sforzi paralleli della comunità come GPTQ-for-LLaMa, Exllama e llama.cpp implementano metodi di quantizzazione strettamente per l’architettura Llama, AutoGPTQ ha guadagnato popolarità grazie alla sua copertura completa di una vasta gamma di architetture di trasformatori.

Dato che la libreria AutoGPTQ ha una maggiore copertura dei modelli di trasformatori, abbiamo deciso di fornire un’API integrata 🤗 Transformers per rendere la quantizzazione LLM più accessibile a tutti. Al momento abbiamo integrato le opzioni di ottimizzazione più comuni, come i kernel CUDA. Per opzioni più avanzate come i kernel Triton o la compatibilità con l’attenzione fusa, consulta la libreria AutoGPTQ.

Supporto nativo dei modelli GPTQ in 🤗 Transformers

Dopo aver installato la libreria AutoGPTQ e optimum (pip install optimum), eseguire modelli GPTQ in Transformers è ora semplice come:

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("TheBloke/Llama-2-7b-Chat-GPTQ", torch_dtype=torch.float16, device_map="auto")

Consulta la documentazione di Transformers per saperne di più su tutte le funzionalità.

La nostra integrazione AutoGPTQ ha molti vantaggi:

  • I modelli quantizzati sono serializzabili e possono essere condivisi nell’Hub.
  • GPTQ riduce drasticamente i requisiti di memoria per eseguire LLM, mentre la latenza di inferenza è paragonabile all’inferenza FP16.
  • AutoGPTQ supporta i kernel Exllama per una vasta gamma di architetture.
  • L’integrazione offre il supporto nativo RoCm per le GPU AMD.
  • È disponibile il fintuning con PEFT.

Puoi controllare sull’Hub se il tuo modello preferito è già stato quantizzato. TheBloke, uno dei principali contributori di Hugging Face, ha quantizzato molti modelli con AutoGPTQ e li ha condivisi nell’Hugging Face Hub. Abbiamo lavorato insieme per assicurarci che questi repository funzionino immediatamente con la nostra integrazione.

Questo è un campione di benchmark per il caso di dimensione batch = 1. Il benchmark è stato eseguito su una singola GPU NVIDIA A100-SXM4-80GB. Abbiamo utilizzato una lunghezza di prompt di 512 e generato esattamente 512 nuovi token. La prima riga è il valore di base fp16 non quantizzato, mentre le altre righe mostrano il consumo di memoria e le prestazioni utilizzando diversi kernel AutoGPTQ.

È disponibile qui un benchmark più completo e riproducibile.

Quantizzare modelli con la libreria Optimum

Per integrare in modo trasparente AutoGPTQ in Transformers, abbiamo utilizzato una versione minimalista dell’API di AutoGPTQ disponibile in Optimum, il toolkit di Hugging Face per l’ottimizzazione dell’addestramento e dell’inferenza. Seguendo questo approccio, abbiamo ottenuto un’integrazione semplice con Transformers, consentendo alle persone di utilizzare l’API di Optimum se desiderano quantizzare i propri modelli! Consulta la documentazione di Optimum se desideri quantizzare i tuoi LLM personali.

La quantizzazione dei modelli di 🤗 Transformers con il metodo GPTQ può essere fatta in poche righe:

from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig

model_id = "facebook/opt-125m"
tokenizer = AutoTokenizer.from_pretrained(model_id)
quantization_config = GPTQConfig(bits=4, dataset = "c4", tokenizer=tokenizer)

model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto", quantization_config=quantization_config)

La quantizzazione di un modello può richiedere molto tempo. Nota che per un modello da 175B, sono necessarie almeno 4 ore di GPU se si utilizza un dataset grande (ad esempio, `”c4″`). Come menzionato in precedenza, molti modelli GPTQ sono già disponibili nell’Hugging Face Hub, il che evita la necessità di quantizzare un modello da soli nella maggior parte dei casi di utilizzo. Tuttavia, è anche possibile quantizzare un modello utilizzando il proprio dataset appropriato per il dominio specifico su cui si sta lavorando.

Esecuzione di modelli GPTQ tramite l’inferenza di generazione di testo

In parallelo all’integrazione di GPTQ in Transformers, il supporto di GPTQ è stato aggiunto alla libreria Text-Generation-Inference (TGI), che mira a servire modelli di lingua di grandi dimensioni in produzione. GPTQ può ora essere utilizzato insieme a funzionalità come il batching dinamico, l’attenzione paginata e l’attenzione flash per una vasta gamma di architetture.

A titolo di esempio, questa integrazione consente di servire un modello da 70B su una singola GPU A100-80GB! Ciò non è possibile utilizzando un checkpoint fp16 in quanto supera la memoria GPU disponibile.

Puoi scoprire di più sull’utilizzo di GPTQ in TGI nella documentazione.

Si noti che il kernel integrato in TGI non scala molto bene con batch size più grandi. Sebbene questo approccio risparmi memoria, ci si aspettano rallentamenti con batch size più grandi.

Affina modelli quantizzati con PEFT

Non è possibile allenare ulteriormente un modello quantizzato utilizzando i metodi regolari. Tuttavia, sfruttando la libreria PEFT, è possibile allenare adattatori in cima! Per farlo, congeliamo tutti gli strati del modello quantizzato e aggiungiamo gli adattatori addestrabili. Ecco alcuni esempi su come utilizzare PEFT con un modello GPTQ: notebook colab e script di fine-tuning.

Spazio per miglioramenti

La nostra integrazione di AutoGPTQ già porta benefici impressionanti a un costo ridotto in termini di qualità della previsione. C’è ancora spazio per miglioramenti, sia nelle tecniche di quantizzazione che nelle implementazioni del kernel.

Innanzitutto, mentre AutoGPTQ si integra (per quanto ne sappiamo) con il kernel W4A16 più performante (pesi come int4, attivazioni come fp16) dell’implementazione exllama, c’è una buona possibilità che il kernel possa essere ancora migliorato. Ci sono state altre implementazioni promettenti da Kim et al. e dal MIT Han Lab che sembrano promettenti. Inoltre, dai benchmark interni, sembra che non esista ancora un kernel W4A16 open-source performante scritto in Triton, che potrebbe essere una direzione da esplorare.

Sul lato della quantizzazione, sottolineiamo ancora una volta che questo metodo quantizza solo i pesi. Sono state proposte altre approcci per la quantizzazione di LLM che possono quantizzare sia i pesi che le attivazioni a un costo ridotto in termini di qualità della previsione, come LLM-QAT, dove può essere utilizzato un regime misto int4/int8, oltre alla quantizzazione della cache chiave-valore. Uno dei vantaggi principali di questa tecnica è la possibilità di utilizzare l’aritmetica intera effettiva per il calcolo, ad esempio con i Tensor Core di Nvidia che supportano il calcolo int8. Tuttavia, per quanto ne sappiamo, non esistono kernel di quantizzazione W4A8 open-source disponibili, ma potrebbe essere un’interessante direzione da esplorare.

Sul lato del kernel, progettare kernel performanti W4A16 per batch di dimensioni più grandi rimane una sfida aperta.

Modelli supportati

In questa implementazione iniziale, sono supportati solo modelli di grandi dimensioni di modelli linguistici con un’architettura di solo decoder o solo encoder. Questo potrebbe sembrare un po’ restrittivo, ma comprende la maggior parte degli LLM all’avanguardia come Llama, OPT, GPT-Neo, GPT-NeoX.

Al momento non sono supportati modelli molto grandi di visione, audio e multimodali.

Conclusioni e parole finali

In questo post, abbiamo presentato l’integrazione della libreria AutoGPTQ in Transformers, rendendo possibile quantizzare gli LLM con il metodo GPTQ per renderli accessibili a chiunque nella comunità e consentire loro di creare strumenti e applicazioni interessanti con gli LLM.

Questa integrazione è disponibile sia per GPU Nvidia che per GPU AMD alimentate da RoCm, il che rappresenta un enorme passo avanti verso la democratizzazione dei modelli quantizzati per architetture GPU più ampie.

La collaborazione con il team di AutoGPTQ è stata molto proficua e siamo molto grati per il loro supporto e il loro lavoro su questa libreria.

Speriamo che questa integrazione renda più facile per tutti utilizzare gli LLM nelle loro applicazioni e non vediamo l’ora di vedere cosa costruirete con essa!

Non perdete le risorse utili condivise sopra per una migliore comprensione dell’integrazione e per iniziare rapidamente con la quantizzazione GPTQ.

  • Documento originale
  • Notebook Google Colab per l’uso di base: questo notebook mostra come quantizzare il modello dei transformer con il metodo GPTQ, come fare inferenza e come fare il fine-tuning con il modello quantizzato.
  • Documentazione sull’integrazione di Transformers
  • Documentazione sull’integrazione di Optimum
  • Repository di The Bloke con modelli GPTQ compatibili.

Ringraziamenti

Vogliamo ringraziare William per il suo supporto e il suo lavoro sulla fantastica libreria AutoGPTQ e per il suo aiuto nell’integrazione. Vogliamo anche ringraziare TheBloke per il suo lavoro nella quantizzazione di molti modelli con AutoGPTQ e per averli condivisi sul Hub e per il suo aiuto nell’integrazione. Vogliamo inoltre ringraziare qwopqwop200 per i suoi continui contributi alla libreria AutoGPTQ e per il suo lavoro nell’estendere la libreria per la CPU che verrà rilasciata nelle prossime versioni di AutoGPTQ.

Infine, vorremmo ringraziare Pedro Cuenca per il suo aiuto nella stesura di questo post.