ExLlamaV2: Det hurtigste bibliotek til at køre LLM’er

Kvantiser og kør EXL2-modeller

Quantizing Large Language Models (LLM’er) er den mest populære tilgang til at reducere størrelsen af ​​disse modeller og fremskynde inferens. Blandt disse teknikker leverer GPTQ fantastisk ydeevne på GPU’er. Sammenlignet med ikke-kvantiserede modeller bruger denne metode næsten 3 gange mindre VRAM, mens den giver et tilsvarende niveau af nøjagtighed og hurtigere generering. Det blev så populært, at det for nylig er blevet direkte integreret i transformatorbiblioteket.

ExLlamaV2 er et bibliotek designet til at presse endnu mere ydeevne ud af GPTQ. Takket være nye kerner er det optimeret til (brasende) hurtige slutninger. Det introducerer også et nyt kvantiseringsformat, EXL2, som giver en masse fleksibilitet til, hvordan vægte opbevares.

I denne artikel vil vi se, hvordan man kvantiserer basismodeller i EXL2-formatet, og hvordan man kører dem. Som sædvanlig er koden tilgængelig på GitHub og Google Colab.

For at starte vores udforskning skal vi installere ExLlamaV2-biblioteket. I dette tilfælde ønsker vi at være i stand til at bruge nogle scripts indeholdt i repoen, hvorfor vi vil installere det fra kilden som følger:

git clone https://github.com/turboderp/exllamav2
pip install exllamav2

Nu hvor ExLlamaV2 er installeret, skal vi downloade den model, vi ønsker at kvantisere i dette format. Lad os bruge den fremragende zephyr-7B-beta, en Mistral-7B-model finjusteret ved hjælp af Direct Preference Optimization (DPO). Det hævder at overgå Llama-2 70b chat på MT-bænken, hvilket er et imponerende resultat for en model, der er ti gange mindre. Du kan prøve basis Zephyr-modellen ved at bruge denne plads.

Vi downloader zephyr-7B-beta ved hjælp af følgende kommando (dette kan tage et stykke tid, da modellen er omkring 15 GB):

git lfs install
git clone https://huggingface.co/HuggingFaceH4/zephyr-7b-beta

GPTQ kræver også en kalibreringsdatasæt, som bruges til at måle virkningen af ​​kvantiseringsprocessen ved at sammenligne output fra basismodellen og dens kvantiserede version. Vi vil bruge wikitext-datasættet og direkte downloade testfilen som følger:

wget https://huggingface.co/datasets/wikitext/resolve/9a9e482b5987f9d25b3a9b2883fc6cc9fd8071b3/wikitext-103-v1/wikitext-test.parquet

Når det er gjort, kan vi udnytte convert.py script leveret af ExLlamaV2-biblioteket. Vi er mest optaget af fire argumenter:

• -i: Grundmodellens vej til konvertering i HF-format (FP16).
• -o: Sti til arbejdsmappen med midlertidige filer og endelig output.
• -c: Sti til kalibreringsdatasættet (i parketformat).
• -b: Mål gennemsnitligt antal bits pr. vægt (bpw). For eksempel vil 4,0 bpw give butiksvægte i 4-bit præcision.

Den komplette liste over argumenter er tilgængelig på denne side. Lad os starte kvantiseringsprocessen ved hjælp af convert.py script med følgende argumenter:

mkdir quant
python python exllamav2/convert.py \
-i base_model \
-o quant \
-c wikitext-test.parquet \
-b 5.0

Bemærk, at du skal bruge en GPU for at kvantisere denne model. Den officielle dokumentation specificerer, at du skal bruge cirka 8 GB VRAM for en 7B-model og 24 GB VRAM for en 70B-model. På Google Colab tog det mig 2 timer og 10 minutter at kvantificere zephyr-7b-beta ved hjælp af en T4 GPU.

Under motorhjelmen udnytter ExLlamaV2 GPTQ-algoritmen til at sænke vægtens præcision og samtidig minimere indvirkningen på outputtet. Du kan finde flere detaljer om GPTQ-algoritmen i denne artikel.

Så hvorfor bruger vi “EXL2”-formatet i stedet for det almindelige GPTQ-format? EXL2 kommer med et par nye funktioner:

• Det understøtter forskellige niveauer af kvantisering: den er ikke begrænset til 4-bit præcision og kan håndtere 2, 3, 4, 5, 6 og 8-bit kvantisering.
• Det kan blande forskellige præcisioner inden for en model og inden for hvert lag for at bevare de vigtigste vægte og lag med flere bits.

ExLlamaV2 bruger denne ekstra fleksibilitet under kvantisering. Den prøver forskellige kvantiseringsparametre og måler den fejl, de introducerer. Udover at forsøge at minimere fejlen, skal ExLlamaV2 også opnå det gennemsnitlige antal bits pr. vægt, der er angivet som et argument. Takket være denne adfærd kan vi skabe kvantiserede modeller med et gennemsnitligt antal bits pr. vægt på f.eks. 3,5 eller 4,5.

Benchmark for forskellige parametre, den opretter, gemmes i measurement.json fil. Følgende JSON viser målingen for et lag:

"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
}
},

I dette forsøg brugte ExLlamaV2 5% af 3-bit og 95% af 2-bit præcision til en gennemsnitlig værdi på 2.188 bpw og en gruppestørrelse på 32. Dette introducerede en mærkbar fejl, der tages i betragtning for at vælge de bedste parametre.

Nu hvor vores model er kvantificeret, vil vi køre den for at se, hvordan den klarer sig. Før det skal vi kopiere væsentlige konfigurationsfiler fra base_model mappe til den nye quant vejviser. Grundlæggende vil vi have hver fil, der ikke er skjult (.*) eller en sikkerhedsfil. Derudover har vi ikke brug for out_tensor mappe, der blev oprettet af ExLlamaV2 under kvantisering.

I bash kan du implementere dette som følger:

!rm -rf quant/out_tensor
!rsync -av --exclude='*.safetensors' --exclude='.*' ./base_model/ ./quant/

Vores EXL2-model er klar, og vi har flere muligheder for at køre den. Den mest ligetil metode består i at bruge test_inference.py script i ExLlamaV2-repoen (bemærk, at jeg ikke bruger en chatskabelon her):

python exllamav2/test_inference.py -m quant/ -p "I have a dream"

Generationen er meget hurtig (56,44 tokens/sekund på en T4 GPU), selv sammenlignet med andre kvantiseringsteknikker og værktøjer som GGUF/llama.cpp eller GPTQ. Du kan finde en dybdegående sammenligning mellem forskellige løsninger i denne fremragende artikel fra oobabooga.

I mit tilfælde returnerede LLM følgende 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.)

Alternativt kan du bruge en chatversion med chat.py script for mere fleksibilitet:

python exllamav2/examples/chat.py -m quant -mode llama

Hvis du planlægger at bruge en EXL2-model mere regelmæssigt, er ExLlamaV2 blevet integreret i flere backends som oobaboogas tekstgenererings-web-UI. Bemærk at det kræver FlashAttention 2 at arbejde så effektivt som muligt, hvilket kræver CUDA 12.1 på Windows i øjeblikket (noget du kan konfigurere under installationsprocessen).

Nu hvor vi har testet modellen, er vi klar til at uploade den til Hugging Face Hub. Du kan ændre navnet på din repo i følgende kodestykke og blot køre det.

from huggingface_hub import notebook_login
from huggingface_hub import HfApi
notebook_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",
)

Fantastisk, modellen kan findes på Hugging Face Hub. Koden i notesbogen er ret generel og kan give dig mulighed for at kvantisere forskellige modeller ved at bruge forskellige værdier af bpw. Dette er ideelt til at skabe modeller dedikeret til din hardware.

I denne artikel præsenterede vi ExLlamaV2, et kraftfuldt bibliotek til at kvantisere LLM’er. Det er også et fantastisk værktøj til at køre dem, da det giver det højeste antal tokens pr. sekund sammenlignet med andre løsninger som GPTQ eller llama.cpp. Vi anvendte den på zephyr-7B-beta-modellen for at skabe en 5.0 bpw-version af den ved hjælp af det nye EXL2-format. Efter kvantisering testede vi vores model for at se, hvordan den klarer sig. Endelig blev den uploadet til Hugging Face Hub og kan findes her.

Hvis du er interesseret i mere teknisk indhold omkring LLM’er, så følg mig på Medium.