AutoGPTQ
v0.7.1: patch release
Autogptq -Entwicklung hat gestoppt. Bitte wechseln Sie als Drop-In-Austausch zu GPTQModel.
Ein benutzerfreundliches LLM-Quantisierungspaket mit benutzerfreundlichen APIs, basierend auf dem GPTQ-Algorithmus (nur Gewichtsquantisierung).
use_marlin=True beim Laden von Modellen veröffentlicht.auto-gptq integriert, sodass jetzt für alle ausgeführte GPTQ-Modelle für alle verfügbar sein können! Weitere Informationen finden Sie in diesem Blog und es sind Ressourcen!Für weitere Geschichten wenden Sie sich bitte hier an
Das Ergebnis wird unter Verwendung dieses Skripts generiert, die Stapelgröße der Eingabe ist 1, die Dekodierungsstrategie ist die Beam -Suche und erzwingt das Modell, um 512 Token zu generieren. Die Geschwindigkeitsmetrik ist Token/S (desto größer, desto besser).
Das quantisierte Modell wird unter Verwendung des Setups geladen, das die schnellste Inferenzgeschwindigkeit gewinnen kann.
| Modell | GPU | num_beams | FP16 | GPTQ-int4 |
|---|---|---|---|---|
| Lama-7b | 1xa100-40g | 1 | 18.87 | 25.53 |
| Lama-7b | 1xa100-40g | 4 | 68.79 | 91.30 |
| Moos-Moon 16b | 1xa100-40g | 1 | 12.48 | 15.25 |
| Moos-Moon 16b | 1xa100-40g | 4 | Oom | 42.67 |
| Moos-Moon 16b | 2xa100-40g | 1 | 06.83 | 06.78 |
| Moos-Moon 16b | 2xa100-40g | 4 | 13.10 | 10.80 |
| GPT-J 6b | 1xrtx3060-12g | 1 | Oom | 29,55 |
| GPT-J 6b | 1xrtx3060-12g | 4 | Oom | 47.36 |
Für Verwirrlichkeitsvergleich können Sie sich hier und hier wenden
AutoGPTQ ist nur unter Linux und Windows verfügbar. Sie können die neueste stabile Version von AutoGPTQ von PIP mit vorgefertigten Rädern installieren:
| Plattformversion | Installation | Gebaut gegen Pytorch |
|---|---|---|
| CUDA 11.8 | pip install auto-gptq --no-build-isolation --extra-index-url https://huggingface.github.io/autogptq-index/whl/cu118/ | 2.2.1+cu118 |
| CUDA 12.1 | pip install auto-gptq --no-build-isolation | 2.2.1+cu121 |
| ROCM 5.7 | pip install auto-gptq --no-build-isolation --extra-index-url https://huggingface.github.io/autogptq-index/whl/rocm573/ | 2.2.1+rocm5.7 |
AutoGPTQ kann mit der Triton-Abhängigkeit mit pip install auto-gptq[triton] --no-build-isolation , um das Triton-Backend zu verwenden (derzeit nur Linux, No 3-Bit-Quantisierung).
Für ältere AutogPTQ finden Sie die vorherige Installationstabelle der vorherigen Veröffentlichungen.
Bei NVIDIA -Systemen unterstützt AutogPTQ Maxwell oder Lower GPUs weder.
Klonen Sie den Quellcode:
git clone https://github.com/PanQiWei/AutoGPTQ.git && cd AutoGPTQ Es sind einige Pakete erforderlich, um aus Quelle zu erstellen: pip install numpy gekko pandas .
Installieren Sie dann lokal aus Quelle:
pip install -vvv --no-build-isolation -e . Sie können BUILD_CUDA_EXT=0 festlegen, um das Pytorch -Erweiterungsgebäude zu deaktivieren. Dies wird jedoch stark entmutigt , wenn autogptq dann auf eine langsame Python -Implementierung zurückfällt.
Wenn der obige Befehl fehlschlägt, können Sie python setup.py install , wenn der obige Befehl fehlschlägt.
Um von der Quelle für AMD -GPUs zu installieren, die ROCM unterstützt, geben Sie bitte die Umgebungsvariable ROCM_VERSION an. Beispiel:
ROCM_VERSION=5.6 pip install -vvv --no-build-isolation -e . Die Zusammenstellung kann beschleunigt werden, indem die Variable PYTORCH_ROCM_ARCH (Referenz) angegeben wird, um für ein einzelnes Zielgerät zu erstellen, z. B. gfx90a für Geräte der Serie MI200.
Für ROCM-Systeme sind die Pakete rocsparse-dev , hipsparse-dev , rocthrust-dev , rocblas-dev und hipblas-dev zu bauen.
Beachten Sie: Stellen Sie sicher
Um die Quelle für Intel Gaudi 2 HPUs zu installieren, setzen Sie die Umgebungsvariable BUILD_CUDA_EXT=0 um das Erstellen der CUDA -Pytorch -Erweiterung zu deaktivieren. Beispiel:
BUILD_CUDA_EXT=0 pip install -vvv --no-build-isolation -e .Beachten Sie, dass Intel Gaudi 2 nach Schluss einen optimierten Kernel verwendet und auf Nicht-Kuda-Maschinen
BUILD_CUDA_EXT=0erfordert.
WARNUNG: Dies ist nur ein Präsentieren der Verwendung von Basis -APIs in autogptq, bei dem nur eine Probe ein viel kleines Modell, die Qualität des quantisierten Modells unter Verwendung solcher kleinen Proben unter Verwendung von solcher kleinen Proben quantisieren.
Nachfolgend finden Sie ein Beispiel für die einfachste Verwendung von auto_gptq , um ein Modell und eine Inferenz nach der Quantisierung zu quantisieren:
from transformers import AutoTokenizer , TextGenerationPipeline
from auto_gptq import AutoGPTQForCausalLM , BaseQuantizeConfig
import logging
logging . basicConfig (
format = "%(asctime)s %(levelname)s [%(name)s] %(message)s" , level = logging . INFO , datefmt = "%Y-%m-%d %H:%M:%S"
)
pretrained_model_dir = "facebook/opt-125m"
quantized_model_dir = "opt-125m-4bit"
tokenizer = AutoTokenizer . from_pretrained ( pretrained_model_dir , use_fast = True )
examples = [
tokenizer (
"auto-gptq is an easy-to-use model quantization library with user-friendly apis, based on GPTQ algorithm."
)
]
quantize_config = BaseQuantizeConfig (
bits = 4 , # quantize model to 4-bit
group_size = 128 , # it is recommended to set the value to 128
desc_act = False , # set to False can significantly speed up inference but the perplexity may slightly bad
)
# load un-quantized model, by default, the model will always be loaded into CPU memory
model = AutoGPTQForCausalLM . from_pretrained ( pretrained_model_dir , quantize_config )
# quantize model, the examples should be list of dict whose keys can only be "input_ids" and "attention_mask"
model . quantize ( examples )
# save quantized model
model . save_quantized ( quantized_model_dir )
# save quantized model using safetensors
model . save_quantized ( quantized_model_dir , use_safetensors = True )
# push quantized model to Hugging Face Hub.
# to use use_auth_token=True, Login first via huggingface-cli login.
# or pass explcit token with: use_auth_token="hf_xxxxxxx"
# (uncomment the following three lines to enable this feature)
# repo_id = f"YourUserName/{quantized_model_dir}"
# commit_message = f"AutoGPTQ model for {pretrained_model_dir}: {quantize_config.bits}bits, gr{quantize_config.group_size}, desc_act={quantize_config.desc_act}"
# model.push_to_hub(repo_id, commit_message=commit_message, use_auth_token=True)
# alternatively you can save and push at the same time
# (uncomment the following three lines to enable this feature)
# repo_id = f"YourUserName/{quantized_model_dir}"
# commit_message = f"AutoGPTQ model for {pretrained_model_dir}: {quantize_config.bits}bits, gr{quantize_config.group_size}, desc_act={quantize_config.desc_act}"
# model.push_to_hub(repo_id, save_dir=quantized_model_dir, use_safetensors=True, commit_message=commit_message, use_auth_token=True)
# load quantized model to the first GPU
model = AutoGPTQForCausalLM . from_quantized ( quantized_model_dir , device = "cuda:0" )
# download quantized model from Hugging Face Hub and load to the first GPU
# model = AutoGPTQForCausalLM.from_quantized(repo_id, device="cuda:0", use_safetensors=True, use_triton=False)
# inference with model.generate
print ( tokenizer . decode ( model . generate ( ** tokenizer ( "auto_gptq is" , return_tensors = "pt" ). to ( model . device ))[ 0 ]))
# or you can also use pipeline
pipeline = TextGenerationPipeline ( model = model , tokenizer = tokenizer )
print ( pipeline ( "auto-gptq is" )[ 0 ][ "generated_text" ])Für erweiterte Funktionen der Modellquantisierung verweisen Sie bitte auf dieses Skript
from auto_gptq . modeling import BaseGPTQForCausalLM
class OPTGPTQForCausalLM ( BaseGPTQForCausalLM ):
# chained attribute name of transformer layer block
layers_block_name = "model.decoder.layers"
# chained attribute names of other nn modules that in the same level as the transformer layer block
outside_layer_modules = [
"model.decoder.embed_tokens" , "model.decoder.embed_positions" , "model.decoder.project_out" ,
"model.decoder.project_in" , "model.decoder.final_layer_norm"
]
# chained attribute names of linear layers in transformer layer module
# normally, there are four sub lists, for each one the modules in it can be seen as one operation,
# and the order should be the order when they are truly executed, in this case (and usually in most cases),
# they are: attention q_k_v projection, attention output projection, MLP project input, MLP project output
inside_layer_modules = [
[ "self_attn.k_proj" , "self_attn.v_proj" , "self_attn.q_proj" ],
[ "self_attn.out_proj" ],
[ "fc1" ],
[ "fc2" ]
] Danach können Sie OPTGPTQForCausalLM.from_pretrained und andere Methoden verwenden, wie in Basic gezeigt.
Sie können Aufgaben verwenden, die in auto_gptq.eval_tasks definiert sind, um die Leistung des Modells vor und nach der Quantisierung auf eine bestimmte Down-Stream-Aufgabe zu bewerten.
Die vordefinierten Aufgaben unterstützen alle kausalsprachigen Modelle in? Transformatoren und in diesem Projekt.
from functools import partial
import datasets
from transformers import AutoTokenizer , AutoModelForCausalLM , GenerationConfig
from auto_gptq import AutoGPTQForCausalLM , BaseQuantizeConfig
from auto_gptq . eval_tasks import SequenceClassificationTask
MODEL = "EleutherAI/gpt-j-6b"
DATASET = "cardiffnlp/tweet_sentiment_multilingual"
TEMPLATE = "Question:What's the sentiment of the given text? Choices are {labels}. n Text: {text} n Answer:"
ID2LABEL = {
0 : "negative" ,
1 : "neutral" ,
2 : "positive"
}
LABELS = list ( ID2LABEL . values ())
def ds_refactor_fn ( samples ):
text_data = samples [ "text" ]
label_data = samples [ "label" ]
new_samples = { "prompt" : [], "label" : []}
for text , label in zip ( text_data , label_data ):
prompt = TEMPLATE . format ( labels = LABELS , text = text )
new_samples [ "prompt" ]. append ( prompt )
new_samples [ "label" ]. append ( ID2LABEL [ label ])
return new_samples
# model = AutoModelForCausalLM.from_pretrained(MODEL).eval().half().to("cuda:0")
model = AutoGPTQForCausalLM . from_pretrained ( MODEL , BaseQuantizeConfig ())
tokenizer = AutoTokenizer . from_pretrained ( MODEL )
task = SequenceClassificationTask (
model = model ,
tokenizer = tokenizer ,
classes = LABELS ,
data_name_or_path = DATASET ,
prompt_col_name = "prompt" ,
label_col_name = "label" ,
** {
"num_samples" : 1000 , # how many samples will be sampled to evaluation
"sample_max_len" : 1024 , # max tokens for each sample
"block_max_len" : 2048 , # max tokens for each data block
# function to load dataset, one must only accept data_name_or_path as input
# and return datasets.Dataset
"load_fn" : partial ( datasets . load_dataset , name = "english" ),
# function to preprocess dataset, which is used for datasets.Dataset.map,
# must return Dict[str, list] with only two keys: [prompt_col_name, label_col_name]
"preprocess_fn" : ds_refactor_fn ,
# truncate label when sample's length exceed sample_max_len
"truncate_prompt" : False
}
)
# note that max_new_tokens will be automatically specified internally based on given classes
print ( task . run ())
# self-consistency
print (
task . run (
generation_config = GenerationConfig (
num_beams = 3 ,
num_return_sequences = 3 ,
do_sample = True
)
)
) Tutorials bieten Schritt-für-Schritt-Anleitungen zur Integration auto_gptq in Ihr eigenes Projekt und einige Best-Practice-Prinzipien.
Beispiele geben zahlreiche Beispielskripte an, um auto_gptq auf unterschiedliche Weise zu verwenden.
Sie können
model.config.model_typeverwenden, um mit der folgenden Tabelle zu vergleichen, um zu überprüfen, ob das von Ihnen verwendete Modell vonauto_gptqunterstützt wird.Zum Beispiel sind model_type von
WizardLM,vicunaundgpt4allallellama, daher werden sie alle vonauto_gptqunterstützt.
| Modelltyp | Quantisierung | Schlussfolgerung | Peft-Lora | Peft-ada-lora | pft-adaption_prompt |
|---|---|---|---|---|---|
| blühen | ✅ | ✅ | ✅ | ✅ | |
| gpt2 | ✅ | ✅ | ✅ | ✅ | |
| gpt_neox | ✅ | ✅ | ✅ | ✅ | ✅ ✅ diesen PEFT -Zweig entsteht |
| gptj | ✅ | ✅ | ✅ | ✅ | ✅ ✅ diesen PEFT -Zweig entsteht |
| Lama | ✅ | ✅ | ✅ | ✅ | ✅ |
| Moos | ✅ | ✅ | ✅ | ✅ | ✅ ✅ diesen PEFT -Zweig entsteht |
| opt | ✅ | ✅ | ✅ | ✅ | |
| GPT_BIGCODE | ✅ | ✅ | ✅ | ✅ | |
| Codegen | ✅ | ✅ | ✅ | ✅ | |
| Falcon (REFINEDWebmodel/REFINEDWEB) | ✅ | ✅ | ✅ | ✅ |
Derzeit unterstützt auto_gptq : LanguageModelingTask , SequenceClassificationTask und TextSummarizationTask ; Weitere Aufgaben werden bald kommen!
Tests können mit: durchgeführt werden:
pytest tests/ -s
Autogptq standardmäßig mit exllamav2 int4*fp16 kernel zur matrix multiplication.
Marlin ist ein optimierter INT4 * FP16-Kernel wurde kürzlich unter https://github.com/ist-daslab/marlin vorgeschlagen. Dies ist in autogptq integriert, wenn ein Modell mit use_marlin=True geladen wird. Dieser Kernel ist nur auf Geräten mit Rechnungsfähigkeit 8.0 oder 8.6 (Ampere -GPUs) erhältlich.
