# Mantenha os módulos em precisão total

Alguns módulos perdem mais precisão do que outros quando quantizados. Manter esses módulos na precisão original consome um pouco mais de memória e pode recuperar grande parte da precisão. Isso se aplica quando você quantiza um modelo durante o carregamento. Um checkpoint pré-quantizado já registra quais módulos foram ignorados.

## Módulos ignorados por padrão

Se você não passar uma lista de exclusão, a maioria dos métodos mantém esses módulos não quantizados.

- Os embeddings de saída, geralmente `lm_head`.
- Pesos vinculados a outros pesos, como incorporações de entrada que compartilham pesos com `lm_head`.
- O último módulo do modelo.
- Módulos que o modelo lista em `_keep_in_fp32_modules`.

Alguns métodos definem seu próprio padrão. [HQQ](./hqq), [FP-Quant](./fp_quant) e [Four Over Six](./fouroversix) ignoram apenas `lm_head`. [SINQ](./sinq) ignora apenas os módulos em `_keep_in_fp32_modules`.

## Passe uma lista de saltos

Passe os nomes dos módulos para o argumento de lista de exclusão da configuração do método. O exemplo abaixo mantém o `lm_head` e as projeções de descida do MLP em bf16 com [bitsandbytes](./bitsandbytes).

```py
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    llm_int8_skip_modules=["lm_head", "mlp.down_proj"],
)
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B",
    quantization_config=quantization_config,
    device_map="auto",
)
```

> [!WARNING]
> Uma skip list substitui os módulos padrão ignorados em vez de adicioná-los a eles, embora os módulos em `_keep_in_fp32_modules` permaneçam ignorados. Inclua `lm_head` na sua lista se você ainda quiser que ele não seja quantizado. [AWQ](./awq) é a exceção e adiciona sua lista aos padrões.

O nome do argumento depende do método.

| Argumento | Métodos |
|---|---|
| `modules_to_not_convert` | A maioria dos métodos, incluindo AWQ, EETQ, FBGEMM FP8, Fine-grained FP8, Four Over Six, FP-Quant, HIGGS, Metal, MXFP4, NVFP4, Quanto, SINQ e torchao |
| `llm_int8_skip_modules` | bitsandbytes, tanto no modo de 4 bits quanto no modo de 8 bits |
| `skip_modules` | HQQ |

[GPTQ](./gptq) adota a abordagem oposta. `modules_in_block_to_quantize` lista os módulos a serem quantizados, e todo o restante no bloco permanece sem quantização.

## Corresponder aos nomes dos módulos

A maioria dos métodos compara cada entrada na lista de exclusão com os nomes completos dos módulos de `model.named_modules()`, como `model.layers.3.mlp.down_proj`. [HQQ](./hqq) é a exceção e corresponde exatamente aos nomes das camadas. Uma entrada corresponde de uma das três maneiras.

- Como sufixo. `mlp.down_proj` corresponde à projeção de descida em cada camada.
- Como um prefixo que termina em um limite de módulo. `model.layers.1` corresponde a `model.layers.1.mlp`, mas não a `model.layers.11.mlp`.
- Como uma expressão regular com o mesmo limite. `model\.layers\.(0|1)` corresponde às duas primeiras camadas.

Imprima os nomes dos módulos para encontrar as entradas corretas.

```py
for name, _ in model.named_modules():
    print(name)
```

## Escolha quais módulos pular

Pule os módulos em que o erro de arredondamento afeta mais a precisão para a menor economia de memória. Comece com os padrões, meça a precisão na sua tarefa e adicione módulos apenas se ela cair.

- `lm_head` produz os logits para todos os tokens do vocabulário, portanto, erros ali alteram diretamente qual token é selecionado. Ele é ignorado por padrão. Em modelos com vocabulários grandes, ele também é uma das camadas individuais maiores, de modo que quantizá-lo economiza memória real, desde que a precisão se mantenha.
- As camadas de roteador ou gate de MoE, como `mlp.gate` no Qwen3-MoE ou `mlp.router` no gpt-oss, decidem para quais especialistas cada token é enviado. Elas são pequenas e um erro de arredondamento pode enviar um token para o especialista errado, por isso quase sempre vale a pena ignorá-las.
- Os codificadores de visão e projetores multimodais em modelos de visão-linguagem são pequenos em comparação com o modelo de linguagem, e erros neles distorcem todos os tokens de imagem. Pule-os se a compreensão de imagens se degradar.
- As primeiras e últimas camadas do decodificador costumam ter mais outliers de ativação do que as camadas intermediárias. Pule-as quando a precisão do modelo quantizado for visivelmente pior do que em bf16.

Cada módulo que você pular permanece em sua precisão original e consome memória. Verifique se o modelo ainda cabe após adicionar à lista de exclusões.