GPTQ

O projeto GPT-QModel (pacote Python gptqmodel) implementa o algoritmo GPTQ, uma técnica de quantização pós-treino em que cada linha da matriz de pesos é quantizada de forma independente para encontrar uma versão dos pesos que minimize o erro. Esses pesos são quantizados para int4, mas são restaurados para fp16 em tempo real durante a inferência. Isso pode economizar 4x o uso de memória, pois os pesos int4 são desquantizados em um kernel fundido, em vez da memória global da GPU. A inferência também é mais rápida, pois uma largura de bits menor leva menos tempo para se comunicar.

O AutoGPTQ não é mais suportado no Transformers. Instale o GPT-QModel em vez disso.

Instale primeiro o Accelerate, o Transformers e o Optimum.

pip install --upgrade accelerate optimum transformers

Em seguida, execute o comando abaixo para instalar o GPT-QModel.

pip install gptqmodel --no-build-isolation

Crie uma classe GPTQConfig e defina o número de bits para quantização, um conjunto de dados para calibrar os pesos para a quantização e um tokenizador para preparar o conjunto de dados.

from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig

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

Você pode passar seu próprio conjunto de dados como uma lista de strings, mas é altamente recomendável usar o mesmo conjunto de dados do artigo 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)

Carregue um modelo para quantizar e passe GPTQConfig para from_pretrained(). Defina device_map="auto" para descarregar automaticamente o modelo para a CPU, ajudando a caber o modelo na memória, e permitindo que os módulos do modelo sejam movidos entre a CPU e a GPU para a quantização.

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

Se você estiver ficando sem memória porque um conjunto de dados é grande demais (o offloading para o disco não é suportado), tente passar o parâmetro max_memory para alocar a quantidade de memória a ser usada no seu dispositivo (GPU e CPU).

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

Dependendo do seu hardware, pode levar algum tempo para quantizar um modelo do zero. Pode levar cerca de 5 minutos para quantizar o modelo facebook/opt-350m em uma GPU do Google Colab de nível gratuito, mas levará cerca de 4 horas para quantizar um modelo com 175 bilhões de parâmetros em uma NVIDIA A100. Antes de quantizar um modelo, é uma boa ideia verificar no Hub se uma versão quantizada com GPTQ do modelo já existe.

Depois que um modelo é quantizado, você pode usar push_to_hub() para enviar o modelo e o tokenizer para o Hub, onde ele pode ser facilmente compartilhado e acessado. Isso salva o GPTQConfig.

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

save_pretrained() salva um modelo quantizado localmente. Se o modelo foi quantizado com o parâmetro device_map, certifique-se de mover o modelo inteiro para uma GPU ou CPU antes de salvá-lo. O exemplo abaixo salva o modelo em uma 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")

Recarregue um modelo quantizado com from_pretrained() e defina device_map="auto" para distribuir automaticamente o modelo em todas as GPUs disponíveis, carregando-o mais rápido sem usar mais memória do que o necessário.

from transformers import AutoModelForCausalLM

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

Marlin

Marlin é um kernel CUDA GPTQ exclusivo para 4 bits, altamente otimizado para a arquitetura de GPU NVIDIA A100 (Ampere). O carregamento, a desquantização e a execução dos pesos após a desquantização são altamente paralelizados, oferecendo uma melhoria substancial na inferência em comparação com o kernel CUDA GPTQ original. O Marlin está disponível apenas para inferência quantizada e não suporta quantização de modelos.

A inferência Marlin pode ser ativada com o parâmetro backend em 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 é o backend ativamente mantido para GPTQ em Transformers. Originalmente, foi um fork de AutoGPTQ, mas desde então divergiu com melhorias significativas, como quantização mais rápida, menor uso de memória e padrões mais precisos.

O GPT-QModel fornece quantização assimétrica, que pode potencialmente reduzir os erros de quantização em comparação com a quantização simétrica. Ele não é compatível com checkpoints legados do AutoGPTQ, e nem todos os kernels (Marlin) suportam quantização assimétrica.

O GPT-QModel também oferece suporte mais amplo aos modelos de LLM mais recentes, a modelos multimodais (Qwen2-VL e Ovis1.6-VL), a plataformas (Linux, macOS, Windows 11) e a hardware (AMD ROCm, Apple Silicon, CPUs Intel/AMD e GPUs Intel Datacenter Max/Arc, entre outros).

Os kernels Marlin também foram atualizados para GPUs A100, e outros kernels foram atualizados para incluir auto-padding para modelos legados e modelos com características de entrada/saída não uniformes.

Recursos

Execute a quantização GPTQ com PEFT no notebook para uma experiência prática.