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, FP-Quant e Four Over Six ignoram apenas lm_head. 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.

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",
)

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 é a exceção e adiciona sua lista aos padrões.

O nome do argumento depende do método.

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 é 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.

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.