AutoGPTQ
v0.7.1: patch release
El desarrollo de Autogptq se ha detenido. Cambie a GPTQMODEL como reemplazo de entrega.
Un paquete de cuantización LLM fácil de usar con API fáciles de usar, basado en el algoritmo GPTQ (cuantificación de solo peso).
use_marlin=True al cargar modelos.auto-gptq integrado, por lo que ahora ejecutar y capacitar a los modelos GPTQ puede estar más disponible para todos. ¡Vea este blog y sus recursos para más detalles!Para más historias, por favor, recurra aquí
El resultado se genera utilizando este script, el tamaño del lote de la entrada es 1, la estrategia de decodificación es la búsqueda del haz y hace cumplir el modelo para generar 512 tokens, la métrica de velocidad es tokens/s (cuanto más grande, mejor).
El modelo cuantificado se carga utilizando la configuración que puede ganar la velocidad de inferencia más rápida.
| modelo | GPU | num_beams | FP16 | GPTQ-INT4 |
|---|---|---|---|---|
| Llama-7b | 1xa100-40g | 1 | 18.87 | 25.53 |
| Llama-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 |
Para comparación de perplejidad, puede recurrir aquí y aquí
AutoGPTQ está disponible solo en Linux y Windows. Puede instalar la última versión estable de AutoGPTQ de PIP con ruedas pre-construidas:
| Versión de plataforma | Instalación | Construido contra 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 se puede instalar con la dependencia de Triton con pip install auto-gptq[triton] --no-build-isolation para poder usar el backend de Triton (actualmente solo admite Linux, sin cuantificación de 3 bits).
Para AutoGPTQ más antiguo, consulte la tabla de instalación de versiones anteriores.
En los sistemas NVIDIA, AutoGPTQ no admite Maxwell o GPU más bajas.
Clon el código fuente:
git clone https://github.com/PanQiWei/AutoGPTQ.git && cd AutoGPTQ Se requieren algunos paquetes para construir desde la fuente: pip install numpy gekko pandas .
Luego, instale localmente desde la fuente:
pip install -vvv --no-build-isolation -e . Puede establecer BUILD_CUDA_EXT=0 para deshabilitar la construcción de la extensión de Pytorch, pero esto se desaconseja mucho ya que AutoGPTQ luego recurre a una implementación lenta de Python.
Como último recurso, si el comando anterior falla, puede probar python setup.py install .
Para instalar desde la fuente para AMD GPUS de soporte ROCM, especifique la variable de entorno ROCM_VERSION . Ejemplo:
ROCM_VERSION=5.6 pip install -vvv --no-build-isolation -e . La compilación se puede acelerar especificando la variable PYTORCH_ROCM_ARCH (referencia) para construir un solo dispositivo de destino, por ejemplo gfx90a para dispositivos de la serie MI200.
Para los sistemas ROCM, los paquetes rocsparse-dev , hipsparse-dev , rocthrust-dev , rocblas-dev Y hipblas-dev se requieren para construir.
Aviso: asegúrese de estar en cometer 65C2E15 o posterior
Para instalar desde la fuente para Intel Gaudi 2 HPUS, establezca la variable de entorno BUILD_CUDA_EXT=0 para deshabilitar la construcción de la extensión CUDA Pytorch. Ejemplo:
BUILD_CUDA_EXT=0 pip install -vvv --no-build-isolation -e .Observe que Intel Gaudi 2 usa un núcleo optimizado tras la inferencia y requiere
BUILD_CUDA_EXT=0en máquinas no uda.
ADVERTENCIA: Esto es solo una muestra del uso de API básicas en AutoGpTQ, que usa solo una muestra para cuantificar un modelo mucho pequeño, la calidad del modelo cuantificado que usa tales pequeñas muestras puede no ser buena.
A continuación se muestra un ejemplo para el uso más simple de auto_gptq para cuantificar un modelo e inferencia después de la cuantización:
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" ])Para las características más avanzadas de la cuantización del modelo, haga referencia a este 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" ]
] Después de esto, puede usar OPTGPTQForCausalLM.from_pretrained y otros métodos como se muestra en BASIC.
Puede usar tareas definidas en auto_gptq.eval_tasks para evaluar el rendimiento del modelo en una tarea específica de flujo descendente antes y después de la cuantificación.
¿Las tareas predefinidas respaldan todos los modelos de idioma causal implementado? transformadores y en este proyecto.
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
)
)
) Los tutoriales proporcionan orientación paso a paso para integrar auto_gptq con su propio proyecto y algunos principios de las mejores prácticas.
Los ejemplos proporcionan muchos scripts de ejemplo para usar auto_gptq de diferentes maneras.
Puede usar
model.config.model_typepara comparar con la tabla a continuación para verificar si el modelo que usa es compatible conauto_gptq.Por ejemplo, Model_Type de
WizardLM,vicunaygpt4allson todosllama, por lo tanto, todos están respaldados porauto_gptq.
| tipo de modelo | cuantificación | inferencia | Peft-Lora | PEFT-ADA-Lora | peft-adaption_prompt |
|---|---|---|---|---|---|
| floración | ✅ | ✅ | ✅ | ✅ | |
| GPT2 | ✅ | ✅ | ✅ | ✅ | |
| GPT_NEOX | ✅ | ✅ | ✅ | ✅ | ✅ Requerir esta rama de Peft |
| GPTJ | ✅ | ✅ | ✅ | ✅ | ✅ Requerir esta rama de Peft |
| llama | ✅ | ✅ | ✅ | ✅ | ✅ |
| musgo | ✅ | ✅ | ✅ | ✅ | ✅ Requerir esta rama de Peft |
| optar | ✅ | ✅ | ✅ | ✅ | |
| gpt_bigcode | ✅ | ✅ | ✅ | ✅ | |
| Codegen | ✅ | ✅ | ✅ | ✅ | |
| Falcon (refinedwebmodel/refinedweb) | ✅ | ✅ | ✅ | ✅ |
Actualmente, auto_gptq admite: LanguageModelingTask , SequenceClassificationTask y TextSummarizationTask ; ¡Más tareas llegarán pronto!
Las pruebas se pueden ejecutar con:
pytest tests/ -s
AutoGPTQ predeterminado es usar Exllamav2 Int4*FP16 Kernel para la multiplicación de matriz.
Marlin es un kernel INT4 * FP16 optimizado se propuso recientemente en https://github.com/ist-deslab/marlin. Esto se integra en AutoGPTQ al cargar un modelo con use_marlin=True . Este núcleo está disponible solo en dispositivos con capacidad de cómputo 8.0 u 8.6 (GPU de amperios).
