AutoGPTQ
v0.7.1: patch release
Le développement AutogptQ s'est arrêté. Veuillez passer à GPTQMODEL en remplacement d'allumage.
Un package de quantification LLM facile à utiliser avec des API conviviales, basée sur l'algorithme GPTQ (quantification en poids uniquement).
use_marlin=True lors du chargement des modèles.auto-gptq , donc maintenant les modèles GPTQ en cours d'exécution peuvent être plus disponibles pour tout le monde! Voir ce blog et ce sont des ressources pour plus de détails!Pour plus d'histoires, veuillez vous tourner ici
Le résultat est généré à l'aide de ce script, la taille du lot de l'entrée est de 1, la stratégie de décodage est la recherche de faisceau et applique le modèle pour générer 512 jetons, la métrique de vitesse est des jetons / s (plus, le plus grand, mieux c'est).
Le modèle quantifié est chargé à l'aide de la configuration qui peut gagner la vitesse d'inférence la plus rapide.
| modèle | GPU | num_beams | FP16 | gptq-Int4 |
|---|---|---|---|---|
| lama-7b | 1xa100-40g | 1 | 18.87 | 25,53 |
| lama-7b | 1xa100-40g | 4 | 68.79 | 91.30 |
| Moss-moon 16b | 1xa100-40g | 1 | 12.48 | 15.25 |
| Moss-moon 16b | 1xa100-40g | 4 | Oom | 42.67 |
| Moss-moon 16b | 2xa100-40g | 1 | 06.83 | 06.78 |
| Moss-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 |
Pour la comparaison de la perplexité, vous pouvez vous tourner ici et ici
AutogptQ est disponible sur Linux et Windows uniquement. Vous pouvez installer la dernière version stable d'AutogptQ à partir de PIP avec des roues prédéfinies:
| Version de la plate-forme | Installation | Construit contre 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 peut être installé avec la dépendance Triton avec pip install auto-gptq[triton] --no-build-isolation afin de pouvoir utiliser le backend Triton (ne prend actuellement en charge que Linux, pas de quantification 3 bits).
Pour l'ancien AutogptQ, veuillez vous référer au tableau d'installation des versions précédentes.
Sur les systèmes NVIDIA, AutoGPTQ ne prend pas en charge les GPU maxwell ou inférieurs.
Clone le code source:
git clone https://github.com/PanQiWei/AutoGPTQ.git && cd AutoGPTQ Quelques packages sont nécessaires pour construire à partir de la source: pip install numpy gekko pandas .
Ensuite, installez-vous localement à partir de la source:
pip install -vvv --no-build-isolation -e . Vous pouvez définir BUILD_CUDA_EXT=0 pour désactiver le bâtiment d'extension Pytorch, mais cela est fortement découragé car AutoGPTQ se replie alors sur une implémentation de python lente.
En dernier recours, si la commande ci-dessus échoue, vous pouvez essayer python setup.py install .
Pour installer à partir de Source pour les GPU AMD prenant en charge le ROCM, veuillez spécifier la variable d'environnement ROCM_VERSION . Exemple:
ROCM_VERSION=5.6 pip install -vvv --no-build-isolation -e . La compilation peut être accélérée en spécifiant la variable PYTORCH_ROCM_ARCH (référence) afin de construire pour un seul dispositif cible, par exemple gfx90a pour les appareils de la série MI200.
Pour les systèmes ROCM, les packages rocsparse-dev , hipsparse-dev , rocthrust-dev , rocblas-dev et hipblas-dev sont nécessaires pour construire.
Remarque: Assurez-vous que vous êtes dans la validation 65C2E15 ou plus tard
Pour installer à partir de Source pour Intel Gaudi 2 HPUS, définissez la variable d'environnement BUILD_CUDA_EXT=0 pour désactiver la construction de l'extension CUDA Pytorch. Exemple:
BUILD_CUDA_EXT=0 pip install -vvv --no-build-isolation -e .Notez qu'Intel Gaudi 2 utilise un noyau optimisé lors de l'inférence et nécessite
BUILD_CUDA_EXT=0sur les machines non cuda.
AVERTISSEMENT: Ce n'est qu'une vitrine de l'utilisation des API de base dans AutoGPTQ, qui utilise un seul échantillon pour quantifier un modèle très petit, la qualité du modèle quantifié utilisant de si petits échantillons peut ne pas être bon.
Vous trouverez ci-dessous un exemple pour l'utilisation la plus simple d' auto_gptq pour quantifier un modèle et une inférence après la quantification:
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" ])Pour des fonctionnalités plus avancées de la quantification du modèle, veuillez référence à ce script
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" ]
] Après cela, vous pouvez utiliser OPTGPTQForCausalLM.from_pretrained et d'autres méthodes comme indiqué dans Basic.
Vous pouvez utiliser des tâches définies dans auto_gptq.eval_tasks pour évaluer les performances du modèle sur une tâche spécifique en baisse avant et après la quantification.
Les tâches prédéfinies prennent en charge tous les modèles de langue causale implémentés dans? Transformers et dans ce projet.
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
)
)
) Les tutoriels fournissent des conseils étape par étape pour intégrer auto_gptq à votre propre projet et quelques principes de meilleure pratique.
Les exemples fournissent de nombreux exemples de scripts pour utiliser auto_gptq de différentes manières.
Vous pouvez utiliser
model.config.model_typepour comparer avec le tableau ci-dessous pour vérifier si le modèle que vous utilisez est pris en charge parauto_gptq.Par exemple, Model_Type de
WizardLM,vicunaetgpt4allsont tousllama, donc ils sont tous pris en charge parauto_gptq.
| type de modèle | quantification | inférence | peft-lora | peft-ada-lora | peft-adaption_prompt |
|---|---|---|---|---|---|
| floraison | ✅ | ✅ | ✅ | ✅ | |
| gpt2 | ✅ | ✅ | ✅ | ✅ | |
| gpt_neox | ✅ | ✅ | ✅ | ✅ | ✅Réquérir cette branche PEFT |
| gptj | ✅ | ✅ | ✅ | ✅ | ✅Réquérir cette branche PEFT |
| lama | ✅ | ✅ | ✅ | ✅ | ✅ |
| mousse | ✅ | ✅ | ✅ | ✅ | ✅Réquérir cette branche PEFT |
| opter | ✅ | ✅ | ✅ | ✅ | |
| gpt_bigcode | ✅ | ✅ | ✅ | ✅ | |
| Codegen | ✅ | ✅ | ✅ | ✅ | |
| Falcon (raffinéwwebmodel / raffiné) | ✅ | ✅ | ✅ | ✅ |
Actuellement, auto_gptq prend en charge: LanguageModelingTask , SequenceClassificationTask et TextSummarizationTask ; Plus de tâches viendront bientôt!
Les tests peuvent être effectués avec:
pytest tests/ -s
AutoGPTQ par défaut est en utilisant le noyau EXLLAMAV2 INT4 * FP16 pour la multiplication matricielle.
Marlin est un noyau INT4 * FP16 optimisé a récemment été proposé sur https://github.com/ist-daslab/marlin. Ceci est intégré dans autogptQ lors du chargement d'un modèle avec use_marlin=True . Ce noyau est disponible uniquement sur les appareils avec une capacité de calcul 8.0 ou 8.6 (GPU AMPERE).
