FP8 de granularidade fina

A quantização FP8 de granularidade fina quantiza os pesos e as ativações para fp8.

• Os pesos são quantizados para 8 bits para cada bloco 2D (weight_block_size=(128, 128)).
• As ativações são quantizadas para 8 bits para cada grupo por token. O valor do grupo corresponde aos pesos no canal de entrada (128 por padrão).

A quantização FP8 permite o suporte a DeepSeek-V3 e DeepSeek-R1.

Você precisa de uma GPU com Compute Capability>=9 (H100) e instalar uma versão do PyTorch compatível com a versão do CUDA da sua GPU.

Instale o Accelerate e atualize para a versão mais recente do PyTorch.

pip install --upgrade accelerate torch

Crie uma classe FineGrainedFP8Config e passe-a para from_pretrained() para quantizá-la. Por padrão, os pesos são carregados em precisão completa (torch.float32), independentemente do tipo de dados real em que os pesos estão armazenados. Defina dtype="auto" para carregar os pesos no tipo de dados definido no arquivo config.json do modelo, carregando automaticamente o tipo de dados mais otimizado em termos de memória.

from transformers import FineGrainedFP8Config, AutoModelForCausalLM, AutoTokenizer

model_name = "meta-llama/Meta-Llama-3-8B"
quantization_config = FineGrainedFP8Config()
quantized_model = AutoModelForCausalLM.from_pretrained(model_name, dtype="auto", device_map="auto", quantization_config=quantization_config)

tokenizer = AutoTokenizer.from_pretrained(model_name)
input_text = "What are we having for dinner?"
input_ids = tokenizer(input_text, return_tensors="pt").to(quantized_model.device.type)

output = quantized_model.generate(**input_ids, max_new_tokens=10)
print(tokenizer.decode(output[0], skip_special_tokens=True))

Use save_pretrained() para salvar o modelo quantizado e recarregue-o com from_pretrained().

quant_path = "/path/to/save/quantized/model"
quantized_model.save_pretrained(quant_path)
model = AutoModelForCausalLM.from_pretrained(quant_path, device_map="auto")

Caminho rápido do DeepGEMM

Em GPUs Hopper (SM90+) e Blackwell (SM100+), cada linear FP8 é despachado automaticamente para os kernels DeepGEMM de kernels-community/deep-gemm quando weight_block_size=(128, 128) e activation_scheme="dynamic". O DeepGEMM é de 3 a 6 vezes mais rápido que o fallback Triton. Instale ou atualize o pacote kernels para habilitá-lo.

pip install -U kernels

O DeepGEMM compila seus kernels em tempo de execução (JIT) usando o nvcc do sistema, portanto, é necessário ter o toolkit CUDA completo instalado. Uma instalação apenas de tempo de execução (bibliotecas CUDA sem o nvcc) não funcionará. A versão mínima do toolkit depende do hardware: 12.3 ou posterior no Hopper (SM90) e 12.9 ou posterior no Blackwell (SM100).

O Transformers localiza o toolkit verificando CUDA_HOME, em seguida CUDA_PATH, depois nvcc no seu PATH e, por fim, /usr/local/cuda. Defina CUDA_HOME para a raiz do toolkit caso o nvcc não seja detectado.

Se o kernel não puder ser carregado (faltando kernels, GPU não suportada, ausência do toolkit CUDA ou um nvcc mais antigo que a versão exigida), o Transformers registra um aviso uma única vez e recorre ao kernel finegrained-fp8 do Triton. A quantização estática de ativação permanece sempre no caminho do Triton.

Para forçar o fallback do Triton mesmo quando o DeepGEMM está disponível, defina TRANSFORMERS_DISABLE_DEEPGEMM_LINEAR=1. Isso afeta apenas o despacho linear FP8 e deixa o backend de especialistas "deepgemm" intacto, que você alterna com set_experts_implementation().

Para os especialistas de MoE, o caminho DeepGEMM é opcional. Passe experts_implementation="deepgemm" (ou "deepgemm_megamoe" em Blackwell) no momento do carregamento para rotear as multiplicações de matrizes dos especialistas pelo DeepGEMM. Consulte o guia Backends de especialistas para o conjunto completo de opções.

Formato de escala UE8M0

Os checkpoints no estilo DeepSeek V4 armazenam as escalas de pesos FP8 no formato empacotado float8_e8m0fnu em vez de float32. Esses checkpoints são pré-quantizados e definem scale_fmt="ue8m0" em sua configuração de quantização. Tanto os kernels DeepGEMM quanto os kernels Triton leem escalas UE8M0, de modo que esses checkpoints funcionam em qualquer um dos caminhos.

No Blackwell (SM100+), os kernels de especialistas do DeepGEMM suportam apenas escalas UE8M0. Um checkpoint com escalas float32 simples (scale_fmt="float") gera um ValueError. Use um checkpoint com scale_fmt="ue8m0" ou execute os especialistas com grouped_mm ou batched_mm, que suportam escalas float32 diretamente. O Hopper (SM90+) suporta escalas float32 no caminho do DeepGEMM sem conversão. Consulte o guia Experts backends para as opções de backend de especialistas.