# Quatro sobre seis

[Four Over Six](https://github.com/mit-han-lab/fouroversix) é uma biblioteca para realizar quantização FP4 rápida e precisa, especialmente com o formato NVFP4 em GPUs NVIDIA Blackwell. Nosso método escala adaptativamente os blocos NVFP4 para 4 ou 6, a fim de reduzir o erro de quantização em valores próximos do máximo em cada bloco, conforme descrito em nosso [preprint](https://arxiv.org/abs/2512.02010).

![Four Over Six visual explanation](https://github.com/mit-han-lab/fouroversix/raw/main/assets/four-over-six.png)

Nossa implementação é mais eficiente em GPUs NVIDIA Blackwell. No entanto, você pode executar o Four Over Six em hardware mais antigo e até em CPUs, sem nenhuma alteração de código, pois, nesses casos, nosso framework faz automaticamente o fallback para uma implementação que realiza a simulação com multiplicação de matrizes em FP32.

Para quantizar um modelo para NVFP4 com 4/6, você pode carregar seu modelo da seguinte forma:

```python
from transformers import AutoModelForCausalLM, FourOverSixConfig

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-8B",
    device_map="auto",
    quantization_config=FourOverSixConfig(),
)
```

Suportamos diversas opções de quantização comumente usadas durante a quantização NVFP4, incluindo a transformada aleatória de Hadamard, escalonamento em blocos 2D, entradas transpostas e arredondamento estocástico, conforme descrito em nosso [pré-impresso](https://arxiv.org/abs/2512.02010). Essas opções podem ser utilizadas definindo a opção apropriada no `FourOverSixConfig` passado acima. Camadas individuais podem receber opções de quantização personalizadas definindo `module_config_overrides`, ou serem excluídas da quantização definindo `modules_to_not_convert`, conforme mostrado abaixo.

## Treinamento

A nossa camada linear quantizada contém uma implementação do passo de retropropagação, de modo que muitos modelos podem ser treinados com poucas modificações. Certifique-se de definir `keep_master_weights` como `True` e de excluir camadas da quantização conforme necessário (frequentemente é importante manter as últimas camadas de uma rede em alta precisão):

```python
from transformers import AutoModelForCausalLM, FourOverSixConfig

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-8B",
    device_map="auto",
    quantization_config=FourOverSixConfig(
        keep_master_weights=True,
        modules_to_not_convert=[
            "lm_head",
            "model.layers.34.self_attn.q_proj",
            "model.layers.34.self_attn.k_proj",
            "model.layers.34.self_attn.v_proj",
            # Add more layers here, e.g. self_attn.o_proj, MLP layers
        ],
    ),
)
```