GPTQ

El proyecto GPT-QModel (paquete de Python gptqmodel) implementa el algoritmo GPTQ, una técnica de cuantización posterior al entrenamiento en la que cada fila de la matriz de pesos se cuantiza de forma independiente para encontrar una versión de los pesos que minimice el error. Estos pesos se cuantizan a int4, pero se restauran a fp16 sobre la marcha durante la inferencia. Esto puede ahorrar un 4x en el uso de memoria porque los pesos int4 se descuantizan en un kernel fusionado en lugar de en la memoria global de la GPU. La inferencia también es más rápida porque una menor anchura de bits requiere menos tiempo para comunicarse.

AutoGPTQ ya no se admite en Transformers. Instala GPT-QModel en su lugar.

Instale primero Accelerate, Transformers y Optimum.

pip install --upgrade accelerate optimum transformers

Luego, ejecute el siguiente comando para instalar GPT-QModel.

pip install gptqmodel --no-build-isolation

Cree una clase GPTQConfig y establezca el número de bits a los que cuantizar, un conjunto de datos para calibrar los pesos para la cuantización y un tokenizador para preparar el conjunto de datos.

from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig

tokenizer = AutoTokenizer.from_pretrained("facebook/opt-125m")
gptq_config = GPTQConfig(bits=4, dataset="c4", tokenizer=tokenizer)

Puede pasar su propio conjunto de datos como una lista de cadenas, pero se recomienda encarecidamente usar el mismo conjunto de datos del artículo de GPTQ.

dataset = ["gptqmodel is an easy-to-use model quantization library with user-friendly apis, based on the GPTQ algorithm."]
gptq_config = GPTQConfig(bits=4, dataset=dataset, tokenizer=tokenizer)

Cargue un modelo para cuantizar y pase GPTQConfig a from_pretrained(). Establezca device_map="auto" para descargar automáticamente el modelo a la CPU y ayudar a que quepa en la memoria, y permita que los módulos del modelo se muevan entre la CPU y la GPU para la cuantización.

quantized_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m", device_map="auto", quantization_config=gptq_config)

Si se queda sin memoria porque un conjunto de datos es demasiado grande (no se admite el descargado en disco), intente pasar el parámetro max_memory para asignar la cantidad de memoria que se usará en su dispositivo (GPU y CPU).

quantized_model = AutoModelForCausalLM.from_pretrained(
    "facebook/opt-125m",
    device_map="auto",
    max_memory={0: "30GiB", 1: "46GiB", "cpu": "30GiB"},
    quantization_config=gptq_config
)

Dependiendo de tu hardware, puede llevar algo de tiempo cuantizar un modelo desde cero. Puede tardar unos 5 minutos en cuantizar el modelo facebook/opt-350m en una GPU de Google Colab de nivel gratuito, pero tardará unas 4 horas en cuantizar un modelo de 175 mil millones de parámetros en una NVIDIA A100. Antes de cuantizar un modelo, es buena idea comprobar en el Hub si ya existe una versión cuantizada con GPTQ del modelo.

Una vez que un modelo está cuantizado, puedes usar push_to_hub() para subir el modelo y el tokenizador al Hub, donde se puede compartir y acceder fácilmente. Esto guarda la GPTQConfig.

quantized_model.push_to_hub("opt-125m-gptq")
tokenizer.push_to_hub("opt-125m-gptq")

save_pretrained() guarda un modelo cuantizado localmente. Si el modelo se cuantizó con el parámetro device_map, asegúrate de mover el modelo completo a una GPU o CPU antes de guardarlo. El ejemplo siguiente guarda el modelo en una CPU.

quantized_model.save_pretrained("opt-125m-gptq")
tokenizer.save_pretrained("opt-125m-gptq")

# if quantized with device_map set
quantized_model.to("cpu")
quantized_model.save_pretrained("opt-125m-gptq")

Recargue un modelo cuantizado con from_pretrained() y establezca device_map="auto" para distribuir automáticamente el modelo en todas las GPUs disponibles, lo que permite cargarlo más rápido sin usar más memoria de la necesaria.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("{your_username}/opt-125m-gptq", device_map="auto")

Marlin

Marlin es un kernel CUDA GPTQ exclusivo de 4 bits, altamente optimizado para la arquitectura de GPU NVIDIA A100 (Ampere). La carga, la descuantización y la ejecución de los pesos después de la descuantización están altamente paralelizados, lo que ofrece una mejora sustancial en la inferencia en comparación con el kernel CUDA GPTQ original. Marlin solo está disponible para inferencia cuantizada y no admite la cuantización de modelos.

La inferencia de Marlin se puede activar con el parámetro backend en GPTQConfig.

from transformers import AutoModelForCausalLM, GPTQConfig

model = AutoModelForCausalLM.from_pretrained("{your_username}/opt-125m-gptq", device_map="auto", quantization_config=GPTQConfig(bits=4, backend="marlin"))

GPT-QModel

GPT-QModel es el backend activamente mantenido para GPTQ en Transformers. Originalmente se bifurcó de AutoGPTQ, pero desde entonces ha divergido con mejoras significativas, como una cuantización más rápida, un menor uso de memoria y valores predeterminados más precisos.

GPT-QModel ofrece cuantización asimétrica, lo que puede reducir los errores de cuantización en comparación con la cuantización simétrica. No es compatible hacia atrás con los puntos de control (checkpoints) heredados de AutoGPTQ, y no todos los núcleos (kernels) (Marlin) admiten la cuantización asimétrica.

GPT-QModel también ofrece un soporte más amplio para los últimos modelos de LLM, modelos multimodales (Qwen2-VL y Ovis1.6-VL), plataformas (Linux, macOS, Windows 11) y hardware (AMD ROCm, Apple Silicon, CPUs de Intel/AMD, y GPUs Intel Datacenter Max/Arc, entre otros).

Los kernels de Marlin también se han actualizado para las GPU A100, y otros kernels se han actualizado para incluir auto-padding para modelos heredados y modelos con características de entrada/salida no uniformes.

Recursos

Ejecuta la cuantización GPTQ con el cuaderno de PEFT para una experiencia práctica.