# 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](https://hf.co/papers/2412.19437) e DeepSeek-R1.

    

> [!TIP]
> 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.

```bash
pip install --upgrade accelerate torch
```

Crie uma classe [FineGrainedFP8Config](/docs/transformers/main/pt/main_classes/quantization#transformers.FineGrainedFP8Config) e passe-a para [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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.

```py
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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.save_pretrained) para salvar o modelo quantizado e recarregue-o com [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained).

```py
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](https://github.com/deepseek-ai/DeepGEMM) de [kernels-community/deep-gemm](https://huggingface.co/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](https://github.com/huggingface/kernels) para habilitá-lo.

```bash
pip install -U kernels
```

O DeepGEMM compila seus kernels em tempo de execução (JIT) com 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).

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 se `nvcc` não for descoberto.

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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](../experts_interface) 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](../experts_interface) para as opções de backend de especialistas.