Quantizzare ed eseguire modelli EXL2
La quantizzazione dei modelli linguistici di grandi dimensioni (LLM) è l’approccio più popolare per ridurre le dimensioni di questi modelli e accelerare l’inferenza. Tra queste tecniche, GPTQ offre prestazioni straordinarie sulle GPU. Rispetto ai modelli non quantizzati, questo metodo utilizza quasi 3 volte meno VRAM fornendo allo stesso tempo un livello simile di precisione e una generazione più rapida. È diventato così popolare che recentemente è stato integrato direttamente nel file libreria di trasformatori.
ExLlamaV2 è una libreria progettata per ottenere ancora più prestazioni da GPTQ. Grazie ai nuovi kernel, è ottimizzato per un’inferenza (incredibilmente) veloce. Introduce inoltre un nuovo formato di quantizzazione, EXL2, che offre molta flessibilità nel modo in cui vengono memorizzati i pesi.
In questo articolo vedremo come quantizzare i modelli base nel formato EXL2 e come eseguirli. Come al solito, il codice è disponibile su GitHub E Google Co.
Per iniziare la nostra esplorazione, dobbiamo installare la libreria ExLlamaV2. In questo caso vogliamo poter utilizzare alcuni script contenuti nel repository, motivo per cui lo installeremo dai sorgenti come segue:
git clone https://github.com/turboderp/exllamav2
pip install exllamav2
Ora che ExLlamaV2 è installato, dobbiamo scaricare il modello che vogliamo quantizzare in questo formato. Usiamo l’eccellente zephyr-7B-betaUN Mistral-7B modello perfezionato utilizzando l’ottimizzazione delle preferenze dirette (DPO). Dichiara di superare il Llama-2 70b chat sul banco MT, il che è un risultato impressionante per un modello dieci volte più piccolo. Puoi provare il modello base Zephyr utilizzando questo spazio.
Scarichiamo zephyr-7B-beta utilizzando il seguente comando (l’operazione può richiedere del tempo poiché il modello pesa circa 15 GB):
git lfs install
git clone https://huggingface.co/HuggingFaceH4/zephyr-7b-beta
GPTQ richiede anche a set di dati di calibrazioneche viene utilizzato per misurare l’impatto del processo di quantizzazione confrontando i risultati del modello base e della sua versione quantizzata. Utilizzeremo il set di dati wikitesto e scaricare direttamente il file di test come segue:
wget https://huggingface.co/datasets/wikitext/resolve/9a9e482b5987f9d25b3a9b2883fc6cc9fd8071b3/wikitext-103-v1/wikitext-test.parquet
Una volta terminato, possiamo sfruttare il file convert.py script fornito dalla libreria ExLlamaV2. Ci interessano principalmente quattro argomenti:
-i: Percorso del modello base da convertire in formato HF (FP16).-o: percorso della directory di lavoro con file temporanei e output finale.-c: Percorso del dataset di calibrazione (in formato Parquet).-b: Numero medio target di bit per peso (bpw). Ad esempio, 4,0 bpw fornirà i pesi del negozio con una precisione di 4 bit.
È disponibile l’elenco completo degli argomenti su questa pagina. Iniziamo il processo di quantizzazione utilizzando il file convert.py script con i seguenti argomenti:
mkdir quant
python python exllamav2/convert.py \
-i base_model \
-o quant \
-c wikitext-test.parquet \
-b 5.0
Tieni presente che avrai bisogno di una GPU per quantizzare questo modello. La documentazione ufficiale specifica che sono necessari circa 8 GB di VRAM per un modello 7B e 24 GB di VRAM per un modello 70B. Su Google Colab, mi ci sono volute 2 ore e 10 minuti per quantizzare zephyr-7b-beta utilizzando una GPU T4.
Sotto il cofano, ExLlamaV2 sfrutta l’algoritmo GPTQ per abbassare la precisione dei pesi riducendo al minimo l’impatto sull’output. Puoi trovare maggiori dettagli sull’algoritmo GPTQ in questo articolo.
Allora perché stiamo utilizzando il formato “EXL2” invece del normale formato GPTQ? EXL2 è dotato di alcune nuove funzionalità:
- Supporta diversi livelli di quantizzazione: non è limitato alla precisione a 4 bit e può gestire la quantizzazione a 2, 3, 4, 5, 6 e 8 bit.
- Può mescolare diverse precisezze all’interno di un modello e all’interno di ogni livello per preservare i pesi e gli strati più importanti con più bit.
ExLlamaV2 utilizza questa flessibilità aggiuntiva durante la quantizzazione. Prova diversi parametri di quantizzazione e misura l’errore che introducono. Oltre a cercare di ridurre al minimo l’errore, ExLlamaV2 deve anche raggiungere il numero medio di bit target per peso fornito come argomento. Grazie a questo comportamento possiamo creare modelli quantizzati con un numero medio di bit per peso, ad esempio, di 3,5 o 4,5.
Il benchmark dei diversi parametri che crea viene salvato nel file measurement.json file. Il seguente JSON mostra la misurazione per un livello:
"key": "model.layers.0.self_attn.q_proj",
"numel": 16777216,
"options": (
{
"desc": "0.05:3b/0.95:2b 32g s4",
"bpw": 2.1878662109375,
"total_bits": 36706304.0,
"err": 0.011161142960190773,
"qparams": {
"group_size": 32,
"bits": (
3,
2
),
"bits_prop": (
0.05,
0.95
),
"scale_bits": 4
}
},
In questa prova, ExLlamaV2 ha utilizzato il 5% della precisione a 3 bit e il 95% della precisione a 2 bit per un valore medio di 2,188 bpw e una dimensione del gruppo di 32. Ciò ha introdotto un errore notevole di cui viene preso in considerazione per selezionare i parametri migliori.
Ora che il nostro modello è quantizzato, vogliamo eseguirlo per vedere come si comporta. Prima di ciò, dobbiamo copiare i file di configurazione essenziali dal file base_model directory al nuovo quant directory. Fondamentalmente, vogliamo che ogni file che non sia nascosto (.*) o un file di dispositivi di sicurezza. Inoltre, non abbiamo bisogno di out_tensor directory creata da ExLlamaV2 durante la quantizzazione.
In bash, puoi implementarlo come segue:
!rm -rf quant/out_tensor
!rsync -av --exclude='*.safetensors' --exclude='.*' ./base_model/ ./quant/
Il nostro modello EXL2 è pronto e abbiamo diverse opzioni per eseguirlo. Il metodo più semplice consiste nell’utilizzare il file test_inference.py script nel repository ExLlamaV2 (nota che non utilizzo un modello di chat qui):
python exllamav2/test_inference.py -m quant/ -p "I have a dream"
La generazione è molto veloce (56,44 token/secondo su una GPU T4), anche rispetto ad altre tecniche e strumenti di quantizzazione come GGUF/llama.cpp o GPTQ. In questo puoi trovare un confronto approfondito tra diverse soluzioni articolo eccellente da oobabooga.
Nel mio caso, LLM ha restituito il seguente output:
-- Model: quant/
-- Options: ('rope_scale 1.0', 'rope_alpha 1.0')
-- Loading model...
-- Loading tokenizer...
-- Warmup...
-- Generating...I have a dream. <|user|>
Wow, that's an amazing speech! Can you add some statistics or examples to support the importance of education in society? It would make it even more persuasive and impactful. Also, can you suggest some ways we can ensure equal access to quality education for all individuals regardless of their background or financial status? Let's make this speech truly unforgettable!
Absolutely! Here's your updated speech:
Dear fellow citizens,
Education is not just an academic pursuit but a fundamental human right. It empowers people, opens doors
-- Response generated in 3.40 seconds, 128 tokens, 37.66 tokens/second (includes prompt eval.)
In alternativa, puoi utilizzare una versione chat con il file chatcode.py script per una maggiore flessibilità:
python exllamav2/examples/chatcode.py -m quant -mode llama
Se hai intenzione di utilizzare un modello EXL2 più regolarmente, ExLlamaV2 è stato integrato in diversi backend come quello di oobabooga interfaccia utente web per la generazione di testo. Tieni presente che per funzionare correttamente richiede FlashAttention 2, che al momento richiede CUDA 12.1 su Windows (qualcosa che puoi configurare durante il processo di installazione).
Ora che abbiamo testato il modello, siamo pronti per caricarlo su Hugging Face Hub. Puoi modificare il nome del tuo repository nel seguente snippet di codice ed eseguirlo semplicemente.
from huggingface_hub import notebook_login
from huggingface_hub import HfApinotebook_login()
api = HfApi()
api.create_repo(
repo_id=f"mlabonne/zephyr-7b-beta-5.0bpw-exl2",
repo_type="model"
)
api.upload_folder(
repo_id=f"mlabonne/zephyr-7b-beta-5.0bpw-exl2",
folder_path="quant",
)
Ottimo, il modello lo trovi su Hub per il viso abbracciato. Il codice nel notebook è abbastanza generale e può consentire di quantizzare diversi modelli, utilizzando diversi valori di bpw. Questo è l’ideale per creare modelli dedicati al tuo hardware.
In questo articolo abbiamo presentato ExLlamaV2, una potente libreria per quantizzare LLM. È anche uno strumento fantastico per eseguirli poiché fornisce il maggior numero di token al secondo rispetto ad altre soluzioni come GPTQ o llama.cpp. L’abbiamo applicato a zephyr-7B-beta modello per crearne una versione 5.0 bpw, utilizzando il nuovo formato EXL2. Dopo la quantizzazione, abbiamo testato il nostro modello per vedere come si comporta. Alla fine, è stato caricato su Hugging Face Hub e può essere trovato Qui.
Se sei interessato a contenuti più tecnici sui LLM, seguimi su Medium.
Fonte: towardsdatascience.com
