# FP-Quant

[FP-Quant](https://github.com/IST-DASLab/FP-Quant) é uma família de algoritmos de quantização projetada para a geração Blackwell de GPUs da Nvidia. O objetivo é permitir a quantização pós-treino (PTQ) e o treinamento consciente de quantização (QAT) eficientes de LLMs nos [tipos de dados MXFP4 e NVFP4](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf).

Esta integração acompanha o pré-impresso do pré-impresso [**Bridging the Gap Between Promise and Performance for Microscaling FP4 Quantization**](https://arxiv.org/abs/2509.23202).

Atualmente, apenas o QAT é suportado com `pseudoquantization=True`. Os modelos podem ser quantizados em tempo de execução com `quantization_config=FPQuantConfig()`:

```python
from transformers import AutoModelForCausalLM, AutoTokenizer, FPQuantConfig
import torch

model = AutoModelForCausalLM.from_pretrained(
    "qwen/Qwen3-8B",
    quantization_config=FPQuantConfig(),
    device_map="auto",
    dtype=torch.bfloat16,
)
```

ou pré-processado com GPTQ para melhor qualidade (veja [FP Format Quantization Harness](https://github.com/IST-DASLab/FP-Quant)).

Você pode escolher entre MXFP4 e NVFP4 com `FPQuantConfig(forward_dtype="mxfp4")`. O NVFP4 oferece melhor qualidade, mas usa um pouco mais de memória.

Uma **GPU de geração Blackwell é necessária** para executar os kernels. O suporte em tempo de execução para FP-Quant é implementado por meio da biblioteca [QuTLASS](https://github.com/IST-DASLab/qutlass) e de uma interface leve do PyTorch, a lib [`fp_quant`](https://github.com/IST-DASLab/FP-Quant/tree/master/inference_lib). Recomendamos instalar a primeira **a partir do código-fonte** e a segunda com `pip install fp_quant`.

Usuários **sem uma GPU de geração Blackwell** podem usar o método com `quantization_config=FPQuantConfig(pseudoquantization=True)` sem precisar instalar o [QuTLASS](https://github.com/IST-DASLab/qutlass). Isso não proporcionará aceleração, mas emulará totalmente o efeito da quantização.

> [!TIP]
> Encontre modelos pré-quantizados com FP-Quant na [coleção](https://huggingface.co/collections/ISTA-DASLab/fp-quant-6877c186103a21d3a02568ee) oficial do ISTA-DASLab.

## torch.compile

O FP-Quant é totalmente compatível com [torch.compile](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html).

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, FPQuantConfig

model = AutoModelForCausalLM.from_pretrained(
    "qwen/Qwen3-8B",
    quantization_config=FPQuantConfig(),
    device_map="auto",
    dtype=torch.bfloat16,
)

model.forward = torch.compile(model.forward, mode="max-autotune", fullgraph=True)
```

## Acelerações

O FP-Quant atualmente apresenta o melhor desempenho para o processamento com tamanhos de lote muito grandes.

Veja o [README do QuTLASS](https://github.com/IST-DASLab/qutlass/blob/main/README.md) para mais informações sobre acelerações.