# Quantização

As técnicas de quantização reduzem os custos de memória e computacionais ao representar pesos e ativações com tipos de dados de menor precisão, como inteiros de 8 bits (int8). Isso permite carregar modelos maiores que normalmente não caberiam na memória e acelerar a inferência. O Transformers suporta os algoritmos de quantização AWQ e GPTQ e suporta quantização de 8 bits e 4 bits com bitsandbytes.

Técnicas de quantização que não são suportadas no Transformers podem ser adicionadas com a classe `HfQuantizer`.

Aprenda como quantizar modelos no guia de [Quantização](../quantization/overview).

## QuantoConfig[[transformers.QuantoConfig]]

#### transformers.QuantoConfig[[transformers.QuantoConfig]]

```python
transformers.QuantoConfig(weights = 'int8', activations = None, modules_to_not_convert: list | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1021)

**Parâmetros:**

weights (`str`, *opcional*, padrão `"int8"`) : O dtype de destino para os pesos após a quantização. Os valores suportados são ("float8","int8","int4","int2")

activations (`str`, *opcional*) : O dtype de destino para as ativações após a quantização. Os valores suportados são (None,"int8","float8")

modules_to_not_convert (`list`, *opcional*, padrão `None`) : A lista de módulos que não devem ser quantizados, útil para quantizar modelos que exigem explicitamente que alguns módulos permaneçam em sua precisão original (por exemplo, o codificador do Whisper, o codificador do Llava, as camadas de gate do Mixtral).

Esta é uma classe wrapper sobre todos os atributos e recursos possíveis com os quais você pode interagir em um modelo que foi carregado usando `quanto`.

#### post_init[[transformers.QuantoConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1049)

Verificador de segurança que os argumentos estão corretos

## AqlmConfig[[transformers.AqlmConfig]]

#### transformers.AqlmConfig[[transformers.AqlmConfig]]

```python
transformers.AqlmConfig(in_group_size: int = 8, out_group_size: int = 1, num_codebooks: int = 1, nbits_per_codebook: int = 16, linear_weights_not_to_quantize: list[str] | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L865)

**Parâmetros:**

in_group_size (`int`, *opcional*, padrão 8) : O tamanho do grupo ao longo da dimensão de entrada.

out_group_size (`int`, *opcional*, padrão 1) : O tamanho do grupo ao longo da dimensão de saída. É recomendável usar sempre 1.

num_codebooks (`int`, *opcional*, padrão 1) : Número de codebooks para o procedimento de Quantização Aditiva.

nbits_per_codebook (`int`, *opcional*, padrão 16) : Número de bits que codificam um único vetor de codebook. O tamanho dos codebooks é 2**nbits_per_codebook.

linear_weights_not_to_quantize (`Optional[list[str]]`, *opcional*) : Lista dos caminhos completos dos parâmetros de peso de `nn.Linear` que não devem ser quantizados.

kwargs (`dict[str, Any]`, *opcional*) : Parâmetros adicionais a partir dos quais o objeto de configuração será inicializado.

Esta é uma classe wrapper sobre os parâmetros de `aqlm`.

#### post_init[[transformers.AqlmConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L902)

Verificador de segurança que garante que os argumentos estão corretos — também substitui alguns argumentos do tipo NoneType pelos seus valores padrão.

## VptqConfig[[transformers.VptqConfig]]

#### transformers.VptqConfig[[transformers.VptqConfig]]

```python
transformers.VptqConfig(enable_proxy_error: bool = False, config_for_layers: dict = {}, shared_layer_config: dict = {}, modules_to_not_convert: list | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L980)

**Parâmetros:**

enable_proxy_error (`bool`, *opcional*, padrão `False`) : calcula o erro de proxy para cada camada

config_for_layers (`Dict`, *opcional*, padrão `{}`) : parâmetros de quantização para cada camada

shared_layer_config (`Dict`, *opcional*, padrão `{}`) : parâmetros de quantização compartilhados entre as camadas

modules_to_not_convert (`list`, *opcional*, padrão `None`) : A lista de módulos que não devem ser quantizados, útil para quantizar modelos que exigem explicitamente que alguns módulos permaneçam em sua precisão original (por exemplo, o codificador do Whisper, o codificador do Llava, as camadas de gate do Mixtral).

kwargs (`dict[str, Any]`, *opcional*) : Parâmetros adicionais a partir dos quais o objeto de configuração será inicializado.

Esta é uma classe wrapper sobre os parâmetros de `vptq`.

#### post_init[[transformers.VptqConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1010)

Verificador de segurança que os argumentos estão corretos

## AwqConfig[[transformers.AwqConfig]]

#### transformers.AwqConfig[[transformers.AwqConfig]]

```python
transformers.AwqConfig(bits: int = 4, group_size: int = 128, zero_point: bool = True, backend: AwqBackend = <AwqBackend.AUTO: 'auto'>, modules_to_not_convert: list | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L799)

**Parâmetros:**

bits (`int`, *opcional*, padrão 4) : O número de bits para quantização.

group_size (`int`, *opcional*, padrão 128) : O tamanho do grupo a ser usado para quantização. O valor recomendado é 128 e -1 usa quantização por coluna.

zero_point (`bool`, *opcional*, padrão `True`) : Se deve usar quantização com ponto zero.

backend (`AwqBackend`, *opcional*, padrão `AwqBackend.AUTO`) : O backend de quantização.

modules_to_not_convert (`list`, *opcional*, padrão `None`) : A lista de módulos que não devem ser quantizados, útil para quantizar modelos que exigem explicitamente que alguns módulos permaneçam em sua precisão original (por exemplo, o encoder do Whisper, o encoder do Llava, as camadas de gate do Mixtral). Observe que não é possível quantizar diretamente com o transformers; consulte a documentação do `AutoAWQ` para quantizar modelos do HF.

Esta é uma classe wrapper sobre todos os atributos e recursos possíveis com os quais você pode interagir em um modelo que foi carregado usando a quantização awq da biblioteca `auto-awq`, com base no backend auto_awq.

## EetqConfig[[transformers.EetqConfig]]

#### transformers.EetqConfig[[transformers.EetqConfig]]

```python
transformers.EetqConfig(weights: str = 'int8', modules_to_not_convert: list | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1062)

**Parâmetros:**

weights (`str`, *opcional*, padrão `"int8"`) : O dtype de destino para os pesos. O único valor suportado é "int8"

modules_to_not_convert (`list`, *opcional*, padrão `None`) : A lista de módulos que não devem ser quantizados, útil para quantizar modelos que exigem explicitamente que alguns módulos permaneçam em sua precisão original.

Esta é uma classe wrapper que abrange todos os atributos e recursos possíveis com os quais você pode interagir em um modelo carregado usando `eetq`.

#### post_init[[transformers.EetqConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1086)

Verificador de segurança que os argumentos estão corretos

## GPTQConfig[[transformers.GPTQConfig]]

#### transformers.GPTQConfig[[transformers.GPTQConfig]]

```python
transformers.GPTQConfig(bits: int, tokenizer: Any = None, dataset: list[str] | str | None = None, group_size: int = 128, damp_percent: float = 0.1, desc_act: bool = False, act_group_aware: bool = True, sym: bool = True, true_sequential: bool = True, format: str = 'gptq', meta: dict[str, typing.Any] | None = None, backend: str | None = None, model_seqlen: int | None = None, block_name_to_quantize: str | None = None, module_name_preceding_first_block: list[str] | None = None, batch_size: int = 1, pad_token_id: int | None = None, max_input_length: int | None = None, cache_block_outputs: bool = True, modules_in_block_to_quantize: list[list[str]] | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L617)

**Parâmetros:**

bits (`int`) : O número de bits para quantizar, os valores suportados são (2, 3, 4, 8).

tokenizer (`str` ou `PreTrainedTokenizerBase`, *opcional*) : O tokenizer usado para processar o conjunto de dados. Você pode passar: - Um objeto de tokenizer personalizado. - Uma string, o *model id* de um tokenizer predefinido hospedado em um repositório de modelos no huggingface.co. - Um caminho para um *diretório* contendo os arquivos de vocabulário necessários para o tokenizer, por exemplo, salvos usando o método [save_pretrained()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained), por exemplo, `./my_model_directory/`.

dataset (`Union[list[str]]`, *opcional*) : O conjunto de dados usado para quantização. Você pode fornecer seu próprio conjunto de dados em uma lista de strings ou simplesmente usar os conjuntos de dados originais utilizados no artigo GPTQ ['wikitext2','c4','c4-new']

group_size (`int`, *opcional*, padrão 128) : O tamanho do grupo a ser usado para quantização. O valor recomendado é 128 e -1 usa quantização por coluna.

damp_percent (`float`, *opcional*, padrão 0.1) : A porcentagem da diagonal média da Hessiana a ser usada para amortecimento. O valor recomendado é 0.1.

desc_act (`bool`, *opcional*, padrão `False`) : Se deve quantizar as colunas em ordem decrescente de tamanho de ativação. Definir como False pode acelerar significativamente a inferência, mas a perplexidade pode ficar ligeiramente pior. Também conhecido como act-order.

act_group_aware (`bool`, *opcional*, padrão `True`) : Usa GAR (ordem de ativação com consciência de grupo) durante a quantização. Tem impacto positivo mensurável na qualidade da quantização. Aplicável apenas quando `desc_act = False`. Será forçado a `False` quando `desc_act = True`.

sym (`bool`, *opcional*, padrão `True`) : Se deve usar quantização simétrica.

true_sequential (`bool`, *opcional*, padrão `True`) : Se deve realizar a quantização sequencial mesmo dentro de um único bloco Transformer. Em vez de quantizar o bloco inteiro de uma vez, realizamos a quantização camada por camada. Como resultado, cada camada passa por quantização usando entradas que já passaram pelas camadas quantizadas anteriormente.

format (`str`, *opcional*, padrão `"gptq"`) : formato de peso GPTQ. `gptq` (v1) é suportado pelo gptqmodel. `gptq_v2` é exclusivo do gptqmodel.

meta (`dict[str, any]`, *opcional*) : Propriedades, como tooling:version, que não contribuem diretamente para a quantização ou para a inferência quantizada são armazenadas em meta. Ou seja, `meta.quantizer`: ["optimum:_version_", "gptqmodel:_version_"]

backend (`str`, *opcional*) : Controla qual kernel usar. Os valores válidos para gptqmodel são `auto`, `auto_trainable` e outros. Ref backends do gptqmodel: https://github.com/ModelCloud/GPTQModel/blob/main/gptqmodel/utils/backend.py

model_seqlen (`int`, *opcional*) : O comprimento máximo da sequência que o modelo pode aceitar.

block_name_to_quantize (`str`, *opcional*) : O nome do bloco do transformers a ser quantizado. Se for None, inferiremos o nome do bloco usando padrões comuns (por exemplo, model.layers)

module_name_preceding_first_block (`list[str]`, *opcional*) : As camadas que antecedem o primeiro bloco Transformer.

batch_size (`int`, *opcional*, padrão 1) : O tamanho do lote usado ao processar o conjunto de dados

pad_token_id (`int`, *opcional*) : O id do token de padding. Necessário para preparar o conjunto de dados quando `batch_size` > 1.

max_input_length (`int`, *opcional*) : O comprimento máximo da entrada. Isso é necessário para inicializar um buffer que depende do comprimento máximo esperado da entrada. É específico para o backend exllama com act-order.

cache_block_outputs (`bool`, *opcional*, padrão `True`) : Se deve armazenar em cache as saídas dos blocos para reutilizá-las como entradas do bloco subsequente.

modules_in_block_to_quantize (`list[list[str]]`, *opcional*) : Lista de listas de nomes de módulos a serem quantizados no bloco especificado. Este argumento é útil para excluir certos módulos lineares da quantização. O bloco a ser quantizado pode ser especificado definindo `block_name_to_quantize`. Cada lista será quantizada sequencialmente. Se não for definido, todas as camadas lineares serão quantizadas. Exemplo: `modules_in_block_to_quantize =[["self_attn.k_proj", "self_attn.v_proj", "self_attn.q_proj"], ["self_attn.o_proj"]]`. Neste exemplo, primeiro quantizaremos as camadas q, k e v simultaneamente, pois são independentes. Em seguida, quantizaremos a camada `self_attn.o_proj` com as camadas q, k e v já quantizadas. Dessa forma, obteremos melhores resultados, pois isso reflete a entrada real que `self_attn.o_proj` receberá quando o modelo for quantizado.

Esta é uma classe wrapper sobre todos os atributos e recursos possíveis com os quais você pode interagir com um modelo carregado usando a API `optimum` para quantização GPTQ, com base no backend gptqmodel.

#### from_dict_optimum[[transformers.GPTQConfig.from_dict_optimum]]

```python
from_dict_optimum(config_dict)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L788)

Obter a classe compatível com o dicionário de configuração gptq do optimum

#### post_init[[transformers.GPTQConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L738)

Verificador de segurança que os argumentos estão corretos

#### to_dict_optimum[[transformers.GPTQConfig.to_dict_optimum]]

```python
to_dict_optimum()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L782)

Obter um dicionário compatível para a configuração gptq do optimum

## BitsAndBytesConfig[[transformers.BitsAndBytesConfig]]

#### transformers.BitsAndBytesConfig[[transformers.BitsAndBytesConfig]]

```python
transformers.BitsAndBytesConfig(load_in_8bit = False, load_in_4bit = False, llm_int8_threshold = 6.0, llm_int8_skip_modules = None, llm_int8_enable_fp32_cpu_offload = False, llm_int8_has_fp16_weight = False, bnb_4bit_compute_dtype = None, bnb_4bit_quant_type = 'fp4', bnb_4bit_use_double_quant = False, bnb_4bit_quant_storage = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L390)

**Parâmetros:**

load_in_8bit (`bool`, *opcional*, padrão `False`) : Este sinalizador é usado para habilitar a quantização de 8 bits com LLM.int8().

load_in_4bit (`bool`, *opcional*, padrão `False`) : Este sinalizador é usado para habilitar a quantização de 4 bits, substituindo as camadas Linear por camadas FP4/NF4 do `bitsandbytes`.

llm_int8_threshold (`float`, *opcional*, padrão 6.0) : Este parâmetro corresponde ao limiar de outliers para a detecção de outliers, conforme descrito no artigo `LLM.int8() : 8-bit Matrix Multiplication for Transformers at Scale`: https://huggingface.co/papers/2208.07339 Qualquer valor de estado oculto que esteja acima deste limiar será considerado um outlier e a operação sobre esses valores será executada em fp16. Os valores geralmente seguem uma distribuição normal, ou seja, a maioria dos valores está na faixa [-3.5, 3.5], mas existem alguns outliers sistemáticos excepcionais que possuem uma distribuição muito diferente em modelos grandes. Esses outliers frequentemente estão no intervalo [-60, -6] ou [6, 60]. A quantização Int8 funciona bem para valores de magnitude ~5, mas, além disso, há uma penalidade de desempenho significativa. Um bom limiar padrão é 6, mas um limiar menor pode ser necessário para modelos mais instáveis (modelos pequenos, fine-tuning).

llm_int8_skip_modules (`list[str]`, *opcional*) : Uma lista explícita dos módulos que não queremos converter em 8 bits. Isso é útil para modelos como o Jukebox, que possui várias cabeças em diferentes posições e não necessariamente na última posição. Por exemplo, para modelos `CausalLM`, o último `lm_head` é mantido em seu `dtype` original.

llm_int8_enable_fp32_cpu_offload (`bool`, *opcional*, padrão `False`) : Esta flag é usada para casos de uso avançados e para usuários que conhecem esse recurso. Se você deseja dividir seu modelo em diferentes partes e executar algumas partes em int8 na GPU e outras em fp32 na CPU, pode usar esta flag. Isso é útil para descarregar modelos grandes, como `google/flan-t5-xxl`. Observe que as operações em int8 não serão executadas na CPU.

llm_int8_has_fp16_weight (`bool`, *opcional*, padrão `False`) : Este sinalizador executa o LLM.int8() com pesos principais de 16 bits. Isso é útil para fine-tuning, pois os pesos não precisam ser convertidos de volta para o passo de retropropagação.

bnb_4bit_compute_dtype (`torch.dtype` ou str, *opcional*, padrão `torch.float32`) : Define o tipo de cálculo, que pode ser diferente do tipo de entrada. Por exemplo, as entradas podem ser fp32, mas o cálculo pode ser definido como bf16 para ganhos de velocidade.

bnb_4bit_quant_type (`str`,  *opcional*, padrão `"fp4"`) : Define o tipo de dados de quantização nas camadas bnb.nn.Linear4Bit. As opções são os tipos de dados FP4 e NF4, especificados por `fp4` ou `nf4`.

bnb_4bit_use_double_quant (`bool`, *opcional*, padrão `False`) : Esta flag é usada para quantização aninhada, na qual as constantes de quantização da primeira quantização são quantizadas novamente.

bnb_4bit_quant_storage (`torch.dtype` ou str, *opcional*, padrão `torch.uint8`) : Define o tipo de armazenamento para empacotar os parâmetros quantizados de 4 bits.

kwargs (`dict[str, Any]`, *opcional*) : Parâmetros adicionais a partir dos quais o objeto de configuração será inicializado.

Esta é uma classe wrapper sobre todos os atributos e recursos possíveis com os quais você pode interagir em um modelo carregado usando `bitsandbytes`.

Atualmente, apenas a quantização `LLM.int8()`, `FP4` e `NF4` é suportada. Se mais métodos forem adicionados ao `bitsandbytes`, mais argumentos serão adicionados a esta classe.

#### is_quantizable[[transformers.BitsAndBytesConfig.is_quantizable]]

```python
is_quantizable()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L551)

Retorna `True` se o modelo for quantizável, `False` caso contrário.

#### post_init[[transformers.BitsAndBytesConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L521)

Verificador de segurança que garante que os argumentos estão corretos — também substitui alguns argumentos do tipo NoneType pelos seus valores padrão.

#### quantization_method[[transformers.BitsAndBytesConfig.quantization_method]]

```python
quantization_method()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L557)

Este método retorna o método de quantização usado para o modelo. Se o modelo não for quantizável, ele retorna `None`.

#### to_diff_dict[[transformers.BitsAndBytesConfig.to_diff_dict]]

```python
to_diff_dict()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L588)

**Retorna:** `dict[str, Any]`

Dicionário de todos os atributos que compõem esta instância de configuração,

Remove todos os atributos de config que correspondem aos atributos padrão de config para melhorar a legibilidade e serializa para um dicionário Python.

## HfQuantizer[[transformers.quantizers.HfQuantizer]]

#### transformers.quantizers.HfQuantizer[[transformers.quantizers.HfQuantizer]]

```python
transformers.quantizers.HfQuantizer(quantization_config: QuantizationConfigMixin, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L74)

Classe abstrata do quantizador do HuggingFace. Atualmente, suporta a quantização de modelos de transformers do HF para inferência e/ou quantização. Esta classe é usada apenas em transformers.PreTrainedModel.from_pretrained e ainda não pode ser facilmente utilizada fora do escopo desse método.

Attributes quantization_config (`transformers.utils.quantization_config.QuantizationConfigMixin`): A configuração de quantização que define os parâmetros de quantização do seu modelo que você deseja quantizar. requires_calibration (`bool`): Se o método de quantização requer calibrar o modelo antes de usá-lo.

#### adjust_max_memory[[transformers.quantizers.HfQuantizer.adjust_max_memory]]

```python
adjust_max_memory(max_memory: dict)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L148)

ajuste o argumento max_memory de infer_auto_device_map() se for necessária memória extra para a quantização

#### dequantize[[transformers.quantizers.HfQuantizer.dequantize]]

```python
dequantize(model, dtype = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L239)

Potencialmente desquantize o modelo para recuperar o modelo original, com alguma perda de precisão / desempenho. Observe que nem todos os esquemas de quantização suportam isso.

#### get_load_operations[[transformers.quantizers.HfQuantizer.get_load_operations]]

```python
get_load_operations()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L323)

Classes de Op que carregam os tensors serializados, por exemplo, `{"deserialize": Mxfp4Deserialize, "dequantize": Mxfp4Dequantize}`. A desserialização constrói os parâmetros de um módulo, portanto, ela é executada apenas nos conversores gerais. A desquantização também é executada antes das ops dos conversores do modelo, por exemplo, antes de um merge por expert.

#### get_new_dtype[[transformers.quantizers.HfQuantizer.get_new_dtype]]

```python
get_new_dtype(converter, param, dtype: torch.dtype | None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L134)

Isso ocorre no momento da materialização, quando o tensor é enviado do disco para o dispositivo. `dtype` para converter o tensor do checkpoint pré-quantizado `param`. Se esse parâmetro não estiver quantizado (tipo float), usamos o `dtype` de entrada que vem do `nn.Module` inicializado.

Se o método de quantização tiver um `Deserializer` ou `Dequantizer` (função de carregamento), retornamos None para que seja tratado por eles.

#### get_state_dict_and_metadata[[transformers.quantizers.HfQuantizer.get_state_dict_and_metadata]]

```python
get_state_dict_and_metadata(model)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L290)

Obtém o state dict e os metadados. Útil quando precisamos modificar um pouco o state dict devido à quantização

#### get_weight_conversions[[transformers.quantizers.HfQuantizer.get_weight_conversions]]

```python
get_weight_conversions()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L331)

Retorna o carregamento a ser executado em qualquer parâmetro que não corresponder aos conversores do modelo

#### param_needs_quantization[[transformers.quantizers.HfQuantizer.param_needs_quantization]]

```python
param_needs_quantization(model: PreTrainedModel, param_name: str, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L152)

Verifique se um determinado parâmetro precisa ser quantizado.

#### postprocess_model[[transformers.quantizers.HfQuantizer.postprocess_model]]

```python
postprocess_model(model: PreTrainedModel, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L207)

**Parâmetros:**

model (`~transformers.PreTrainedModel`) : O modelo a ser quantizado

kwargs (`dict`, *opcional*) : Os argumentos de palavra-chave que são passados para `_process_model_after_weight_loading`.

Faça o pós-processamento do modelo após o carregamento dos pesos. Certifique-se de sobrescrever o método abstrato `_process_model_after_weight_loading`.

#### preprocess_model[[transformers.quantizers.HfQuantizer.preprocess_model]]

```python
preprocess_model(model: PreTrainedModel, dtype = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L184)

**Parâmetros:**

model (`~transformers.PreTrainedModel`) : O modelo a ser quantizado

kwargs (`dict`, *opcional*) : Os argumentos de palavra-chave que são passados ao `_process_model_before_weight_loading`.

Definindo atributos do modelo e/ou convertendo o modelo antes do carregamento dos pesos. Neste ponto, o modelo deve estar inicializado no dispositivo meta, para que você possa manipular livremente a estrutura do modelo a fim de substituir módulos in-place. Certifique-se de sobrescrever o método abstrato `_process_model_before_weight_loading`.

#### remove_quantization_config[[transformers.quantizers.HfQuantizer.remove_quantization_config]]

```python
remove_quantization_config(model)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L227)

Remova a configuração de quantização do modelo.

#### update_attn_implementation[[transformers.quantizers.HfQuantizer.update_attn_implementation]]

```python
update_attn_implementation(config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L177)

Visualiza o `attn_implementation` solicitado antes de o modelo ser construído, para que um quantizador possa definir um valor padrão.

#### update_device_map[[transformers.quantizers.HfQuantizer.update_device_map]]

```python
update_device_map(device_map: dict[str, typing.Any] | None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L112)

**Parâmetros:**

device_map (`Union[dict, str]`, *opcional*) : O device_map que é passado pelo método `from_pretrained`.

Substitua este método se você deseja substituir o device map existente por um novo. Por exemplo, para bitsandbytes, como `accelerate` é um requisito obrigatório, se nenhum device_map for passado, o device_map será definido como `"auto"``

#### update_dtype[[transformers.quantizers.HfQuantizer.update_dtype]]

```python
update_dtype(dtype: torch.dtype)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L100)

**Parâmetros:**

dtype (`torch.dtype`) : O dtype de entrada que é passado em `from_pretrained`

Alguns métodos de quantização exigem que o dtype do modelo seja definido explicitamente para um dtype de destino. Você precisa sobrescrever este método caso queira garantir que esse comportamento seja preservado

#### update_parallel_plan[[transformers.quantizers.HfQuantizer.update_parallel_plan]]

```python
update_parallel_plan(model, plan: dict)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L166)

Atualiza `model.tp_plan` ou `model.ep_plan` (os planos completos, mesclados a partir da configuração e de todas as subconfigurações) para levar em consideração as chaves personalizadas do quantizador, como 'inv_scale'

#### update_weight_conversions[[transformers.quantizers.HfQuantizer.update_weight_conversions]]

```python
update_weight_conversions(weight_conversions, model)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L341)

Faz com que os conversores do modelo (do mapeamento de conversão) carreguem os nomes serializados. Os parâmetros do modelo decidem, por exemplo, para uma mesclagem de `experts.*.gate_proj.weight` em `experts.gate_up_proj`:
- `experts.gate_up_proj_scale_inv` é um parâmetro: uma cópia mescla `experts.*.gate_proj.weight_scale_inv` nele
- caso contrário, o conversor também coleta `experts.*.gate_proj.weight_scale_inv`, a operação de desquantização é executada primeiro

#### validate_environment[[transformers.quantizers.HfQuantizer.validate_environment]]

```python
validate_environment(*args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L158)

Este método é usado para verificar possíveis conflitos com os argumentos passados em `from_pretrained`. Você precisa defini-lo para todos os quantizadores futuros que forem integrados ao transformers. Se nenhuma verificação explícita for necessária, basta não retornar nada.

## HiggsConfig[[transformers.HiggsConfig]]

#### transformers.HiggsConfig[[transformers.HiggsConfig]]

```python
transformers.HiggsConfig(bits: int = 4, p: int = 2, modules_to_not_convert: list[str] | None = None, hadamard_size: int = 512, group_size: int = 256, tune_metadata: dict[str, typing.Any] | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1315)

**Parâmetros:**

bits (int, *opcional*, padrão 4) : Número de bits a serem usados para quantização. Pode ser 2, 3 ou 4. O padrão é 4.

p (int, *opcional*, padrão 2) : Dimensão da grade de quantização. 1 e 2 são suportados. 2 é sempre melhor na prática. O padrão é 2.

modules_to_not_convert (`list`, *opcional*, padrão ["lm_head"]) : Lista de camadas lineares que não devem ser quantizadas.

hadamard_size (int, *opcional*, padrão 512) : Tamanho de Hadamard para o método HIGGS. O padrão é 512. A dimensão de entrada das matrizes é preenchida até esse valor. Reduzir esse valor para menos de 512 diminuirá a qualidade da quantização.

group_size (int, *opcional*, padrão 256) : Tamanho do grupo para o método HIGGS. Pode ser 64, 128 ou 256. Diminuir esse valor tem pouco impacto no desempenho. O padrão é 256. Deve ser um divisor de hadamard_size.

tune_metadata ('dict', *opcional*, padrão {}) : Metadados por módulo (formas de bloco de gemm, metadados de GPU, etc.) para salvar os resultados de ajuste de kernel. O padrão é um dicionário vazio. É definido automaticamente durante o ajuste.

HiggsConfig é uma classe de configuração para quantização usando o método HIGGS.

#### post_init[[transformers.HiggsConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1356)

Verificador de segurança que garante que os argumentos estão corretos — também substitui alguns argumentos do tipo NoneType pelos seus valores padrão.

## HqqConfig[[transformers.HqqConfig]]

#### transformers.HqqConfig[[transformers.HqqConfig]]

```python
transformers.HqqConfig(nbits: int = 4, group_size: int = 64, view_as_float: bool = False, axis: int | None = None, dynamic_config: dict | None = None, skip_modules: list = ['lm_head'], **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L277)

**Parâmetros:**

nbits (`int`, *opcional*, padrão 4) : Número de bits. Os valores suportados são (8, 4, 3, 2, 1).

group_size (`int`, *opcional*, padrão 64) : Valor do tamanho do grupo. Os valores suportados são quaisquer valores divisíveis por weight.shape[axis]).

view_as_float (`bool`, *opcional*, padrão `False`) : Exibe o peso quantizado como float (usado em treinamento distribuído) se definido como `True`.

axis (`Optional[int]`, *opcional*) : Eixo ao longo do qual o agrupamento é realizado. Os valores suportados são 0 ou 1.

dynamic_config (dict, *opcional*) : Parâmetros para configuração dinâmica. A chave é a etiqueta de nome da camada e o valor é uma configuração de quantização. Se definido, cada camada especificada pelo seu id usará sua configuração de quantização dedicada.

skip_modules (`list[str]`, *opcional*, padrão `['lm_head']`) : Lista de camadas `nn.Linear` para ignorar.

kwargs (`dict[str, Any]`, *opcional*) : Parâmetros adicionais a partir dos quais o objeto de configuração será inicializado.

Este é um wrapper em torno do BaseQuantizeConfig do hqq.

#### from_dict[[transformers.HqqConfig.from_dict]]

```python
from_dict(config: dict)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L342)

Override from_dict, used in AutoQuantizationConfig.from_dict in quantizers/auto.py

#### post_init[[transformers.HqqConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L337)

Verificador de segurança que garante que os argumentos estão corretos — também substitui alguns argumentos do tipo NoneType pelos seus valores padrão.

#### to_diff_dict[[transformers.HqqConfig.to_diff_dict]]

```python
to_diff_dict()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L367)

**Retorna:** `dict[str, Any]`

Dicionário de todos os atributos que compõem esta instância de configuração,

Remove todos os atributos de config que correspondem aos atributos padrão de config para melhorar a legibilidade e serializa para um dicionário Python.

## MetalConfig[[transformers.MetalConfig]]

#### transformers.MetalConfig[[transformers.MetalConfig]]

```python
transformers.MetalConfig(bits: int = 4, group_size: int = 64, modules_to_not_convert: list | None = None, dequantize: bool = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1825)

Classe de configuração para quantização afim Metal direcionada a dispositivos Apple Silicon (MPS).

Esse método de quantização usa os kernels Metal `mlx-quantization-metal-kernels` do Hugging Face Hub para executar quantização afim (escalas + qbiases) com largura de bits e tamanho de grupo configuráveis. Os pesos quantizados são empacotados em tensores `uint32` e a passagem direta usa kernels Metal de desquantização + matmul fundidos.

## Mxfp4Config[[transformers.Mxfp4Config]]

#### transformers.Mxfp4Config[[transformers.Mxfp4Config]]

```python
transformers.Mxfp4Config(modules_to_not_convert: list | None = None, dequantize: bool = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1791)

**Parâmetros:**

modules_to_not_convert (`list`, *opcional*, padrão `None`) : A lista de módulos que não devem ser quantizados, útil para quantizar modelos que exigem explicitamente que alguns módulos permaneçam em sua precisão original.

dequantize (`bool`, *opcional*, padrão `False`) : Se devemos desquantizar o modelo para a precisão bf16 ou não

Esta é uma classe wrapper sobre todos os atributos e recursos possíveis com os quais você pode interagir em um modelo que foi carregado usando quantização mxfp4.

## NVFP4Config[[transformers.NVFP4Config]]

#### transformers.NVFP4Config[[transformers.NVFP4Config]]

```python
transformers.NVFP4Config(modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L2067)

**Parâmetros:**

modules_to_not_convert (`list[str]`, *opcional*) : Padrões de nomes de módulos que devem permanecer na sua precisão original.

kwargs (`dict[str, Any]`, *opcional*) : Valores adicionais são ignorados e reportados por meio do logger do Transformers.

Configuração para quantização de pesos NVFP4 em tempo real.

## FbgemmFp8Config[[transformers.FbgemmFp8Config]]

#### transformers.FbgemmFp8Config[[transformers.FbgemmFp8Config]]

```python
transformers.FbgemmFp8Config(activation_scale_ub: float = 1200.0, modules_to_not_convert: list | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1284)

**Parâmetros:**

activation_scale_ub (`float`, *opcional*, padrão 1200.0) : O limite superior da escala de ativação. Isso é usado ao quantizar a ativação de entrada.

modules_to_not_convert (`list`, *opcional*, padrão `None`) : A lista de módulos que não devem ser quantizados, útil para quantizar modelos que exigem explicitamente que alguns módulos permaneçam em sua precisão original.

Esta é uma classe wrapper que abrange todos os atributos e recursos possíveis com os quais você pode interagir em um modelo carregado usando quantização fp8 do fbgemm.

## CompressedTensorsConfig[[transformers.CompressedTensorsConfig]]

#### transformers.CompressedTensorsConfig[[transformers.CompressedTensorsConfig]]

```python
transformers.CompressedTensorsConfig(config_groups: dict[str, typing.Union[ForwardRef('QuantizationScheme'), list[str]]] | None = None, format: str = 'dense', quantization_status: QuantizationStatus = 'initialized', kv_cache_scheme: typing.Optional[ForwardRef('QuantizationArgs')] = None, global_compression_ratio: float | None = None, ignore: list[str] | None = None, quant_method: str = 'compressed-tensors', run_compressed: bool | None = None, dequantize: bool = False, use_optimized_inference: bool = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1095)

**Parâmetros:**

config_groups (`typing.dict[str, typing.Union[ForwardRef('QuantizationScheme'), typing.list[str]]]`, *opcional*) : dicionário que mapeia o nome do grupo para uma definição de esquema de quantização

format (`str`, *opcional*, padrão `"dense"`) : formato em que os pesos são armazenados, por exemplo, `dense`, `float-quantized` ou `pack-quantized`

quantization_status (`QuantizationStatus`, *opcional*, padrão `"initialized"`) : status do modelo no ciclo de vida da quantização, ou seja, 'initialized', 'calibration', 'frozen'

kv_cache_scheme (`typing.Union[QuantizationArgs, NoneType]`, *opcional*) : especifica a quantização do cache de kv. Se for None, o cache de kv não é quantizado.

global_compression_ratio (`typing.Union[float, NoneType]`, *opcional*) : porcentagem de compressão do modelo em float de 0 a 1

ignore (`typing.Union[typing.list[str], NoneType]`, *opcional*) : nomes ou tipos de camadas que não devem ser quantizados, suporta regex prefixado por 're:'

quant_method (`str`, *opcional*, padrão `"compressed-tensors"`) : não substitua, deve ser compressed-tensors

run_compressed (`bool`, *opcional*) : descontinuado, use `dequantize` em vez disso. Seu único efeito é definir `dequantize` para o seu oposto, `run_compressed=False` significando `dequantize=True`.

dequantize (`bool`, *opcional*, padrão `False`) : quando `True`, os pesos quantizados são desquantizados de volta para o dtype do modelo (por exemplo, BF16) no momento do carregamento, o que é necessário para o ajuste fino ou para salvar o modelo em seu dtype original. Quando `False`, os pesos são mantidos em sua forma comprimida e o compressed-tensors os descomprime na primeira passagem de frente.

use_optimized_inference (`bool`, *opcional*, padrão `False`) : quando `True`, as camadas para as quais temos kernels mantêm seus pesos quantizados e são executadas por meio desses kernels (atualmente W8A8 FP8, em CUDA SM89+, XPU ou MPS com torch >= 2.15). Somente para inferência e opt-in: sem ele, o modelo segue pela rota regular de compressed-tensors. Ignorado quando `dequantize=True`.

Esta é uma classe de encapsulamento que gerencia as opções de configuração de quantização do compressed-tensors. Ela é um encapsulamento de `compressed_tensors.QuantizationConfig`

#### from_dict[[transformers.CompressedTensorsConfig.from_dict]]

```python
from_dict(config_dict, return_unused_kwargs = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1192)

**Parâmetros:**

config_dict (`dict[str, Any]`) : Dicionário que será usado para instanciar o objeto de configuração.

return_unused_kwargs (`bool`,*opcional*, padrão `False`) : Indica se deve ou não retornar uma lista de argumentos de palavra-chave não utilizados. Usado no método `from_pretrained` da classe `PreTrainedModel`.

kwargs (`dict[str, Any]`) : Parâmetros adicionais a partir dos quais inicializar o objeto de configuração.

**Retorna:** `QuantizationConfigMixin`

O objeto de configuração instanciado a partir desses parâmetros.

Instancia um [CompressedTensorsConfig](/docs/transformers/main/pt/main_classes/quantization#transformers.CompressedTensorsConfig) a partir de um dicionário Python de parâmetros. Opcionalmente, desembrulha quaisquer args da quantization_config aninhada

#### to_dict[[transformers.CompressedTensorsConfig.to_dict]]

```python
to_dict()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1217)

Configuração de quantização a ser adicionada ao config.json

Serializa esta instância em um dicionário Python. Retorna: `dict[str, Any]`: Dicionário de todos os atributos que compõem esta instância de configuração.

#### to_diff_dict[[transformers.CompressedTensorsConfig.to_diff_dict]]

```python
to_diff_dict()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1232)

**Retorna:** `dict[str, Any]`

Dicionário de todos os atributos que compõem esta instância de configuração,

Remove todos os atributos de config que correspondem aos atributos padrão de config para melhorar a legibilidade e serializa para um dicionário Python.

## TorchAoConfig[[transformers.TorchAoConfig]]

#### transformers.TorchAoConfig[[transformers.TorchAoConfig]]

```python
transformers.TorchAoConfig(quant_type: AOBaseConfig, modules_to_not_convert: list | None = None, include_input_output_embeddings: bool = False, untie_embedding_weights: bool = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1460)

**Parâmetros:**

quant_type (`AOBaseConfig`) : uma instância de `AOBaseConfig` do torchao que especifica o tipo de quantização, por exemplo, `Int4WeightOnlyConfig(group_size=32)`, `Int8WeightOnlyConfig()`, `Int8DynamicActivationInt8WeightConfig()`, `Float8WeightOnlyConfig()`, etc.

modules_to_not_convert (`list`, *opcional*, padrão `None`) : A lista de módulos que não devem ser quantizados, útil para quantizar modelos que exigem explicitamente que alguns módulos permaneçam em sua precisão original.

include_input_output_embeddings (`bool`, *opcional*, padrão `False`) : Indica se a incorporação (embedding) deve ser incluída na quantização ou não. Se essa flag estiver definida, a incorporação de entrada também será removida da lista module_not_to_convert.

untie_embedding_weights (`bool`, *opcional*, padrão `False`) : Se deve desvincular os pesos ao quantizar pesos de incorporação de entrada que estão vinculados a outros pesos.

Classe de configuração para técnicas de quantização/esparcidade do torchao.

Exemplo:

```python
from torchao.quantization import Int4WeightOnlyConfig

quantization_config = TorchAoConfig(Int4WeightOnlyConfig(group_size=32))
model = AutoModelForCausalLM.from_pretrained(
    model_id, device_map="cuda", torch_dtype=torch.bfloat16, quantization_config=quantization_config
)
```

#### from_dict[[transformers.TorchAoConfig.from_dict]]

```python
from_dict(config_dict, return_unused_kwargs = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1543)

Crie uma configuração a partir de um dicionário.

#### get_apply_tensor_subclass[[transformers.TorchAoConfig.get_apply_tensor_subclass]]

```python
get_apply_tensor_subclass()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1529)

Retorne a configuração de quantização a ser aplicada.

#### post_init[[transformers.TorchAoConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1511)

Valide a configuração e defina os padrões.

#### to_dict[[transformers.TorchAoConfig.to_dict]]

```python
to_dict()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1533)

Converte a configuração em um dicionário.

## BitNetQuantConfig[[transformers.BitNetQuantConfig]]

#### transformers.BitNetQuantConfig[[transformers.BitNetQuantConfig]]

```python
transformers.BitNetQuantConfig(modules_to_not_convert: list | None = None, linear_class: str = 'bitlinear', quantization_mode: str = 'offline', use_rms_norm: bool = False, rms_norm_eps: float | None = 1e-06, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1563)

**Parâmetros:**

modules_to_not_convert (`Optional[List]`, *opcional*) : Opcionalmente, fornece uma lista de caminhos completos dos parâmetros de peso de `nn.Linear` que não devem ser quantizados. O valor padrão é None.

linear_class (`str`, *opcional*, padrão `"bitlinear"`) : O tipo de classe linear a ser usado. Pode ser `bitlinear` ou `autobitlinear`.

quantization_mode (`str`, *opcional*, padrão `"offline"`) : O modo de quantização a ser utilizado. Pode ser `online` ou `offline`. No modo `online`, os parâmetros de quantização dos pesos são calculados dinamicamente durante cada passagem de frente (por exemplo, com base nos valores atuais dos pesos). Isso permite se adaptar a alterações nos pesos durante o treinamento (Quantization-Aware Training - QAT). No modo `offline`, os parâmetros de quantização são pré-calculados *antes* da inferência. Esses parâmetros são então fixados e carregados no modelo quantizado. Isso geralmente resulta em menor sobrecarga de tempo de execução em comparação com a quantização online.

use_rms_norm (`bool`, *opcional*, padrão `False`) : Indica se a RMSNorm deve ser aplicada às ativações antes da quantização. Isso corresponde à abordagem do artigo original do BitNet de normalizar as ativações antes da quantização/empacotamento.

rms_norm_eps (`float`, *opcional*, padrão 1e-06) : O valor de epsilon usado na camada RMSNorm para estabilidade numérica.

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave adicionais que podem ser usados por backends de quantização específicos ou versões futuras.

Classe de configuração para aplicar a quantização BitNet.

#### post_init[[transformers.BitNetQuantConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1612)

Verificador de segurança que os argumentos estão corretos

## SpQRConfig[[transformers.SpQRConfig]]

#### transformers.SpQRConfig[[transformers.SpQRConfig]]

```python
transformers.SpQRConfig(bits: int = 3, beta1: int = 16, beta2: int = 16, shapes: dict[str, int] | None = None, modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1619)

**Parâmetros:**

bits (`int`, *opcional*, padrão 3) : Especifica a contagem de bits para os pesos e os zero-points e escalas de primeira ordem. Atualmente, apenas bits = 3 é suportado.

beta1 (`int`, *opcional*, padrão 16) : Largura do tile SpQR. Atualmente, apenas beta1 = 16 é suportado.

beta2 (`int`, *opcional*, padrão 16) : Altura do tile SpQR. Atualmente, apenas beta2 = 16 é suportado.

shapes (`Optional`, *opcional*) : Um dicionário contendo a forma de cada objeto. Precisamos disso porque é impossível deduzir o tamanho exato dos parâmetros apenas a partir de bits, beta1, beta2.

modules_to_not_convert (`Optional[list[str]]`, *opcional*) : Opcionalmente, fornece uma lista de caminhos completos dos parâmetros de peso de `nn.Linear` que não devem ser quantizados. O valor padrão é None.

kwargs (`dict[str, Any]`, *opcional*) : Parâmetros adicionais a partir dos quais o objeto de configuração será inicializado.

Esta é uma classe de envoltório para os parâmetros do `spqr`. Consulte a publicação original para mais detalhes.

#### post_init[[transformers.SpQRConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1660)

Verificador de segurança que garante que os argumentos estão corretos — também substitui alguns argumentos do tipo NoneType pelos seus valores padrão.

## FineGrainedFP8Config[[transformers.FineGrainedFP8Config]]

#### transformers.FineGrainedFP8Config[[transformers.FineGrainedFP8Config]]

```python
transformers.FineGrainedFP8Config(activation_scheme: str = 'dynamic', weight_block_size: tuple = (128, 128), dequantize: bool = False, modules_to_not_convert: list | None = None, modules_to_convert: list | None = None, scale_fmt: str = 'float', expert_dtype: str = 'fp8', **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1682)

**Parâmetros:**

activation_scheme (`str`, *opcional*, padrão `"dynamic"`) : O esquema usado para ativação; o padrão e o único esquema suportado por enquanto é "dynamic".

weight_block_size (`typing.tuple[int, int]`, *opcional*, padrão `(128, 128)`) : O tamanho dos blocos de pesos para quantização, o padrão é (128, 128).

dequantize (`bool`, *opcional*, padrão `False`) : Se deve desquantizar o modelo durante o carregamento.

modules_to_not_convert (`list`, *opcional*) : Uma lista de nomes de módulos que não devem ser convertidos durante a quantização.

modules_to_convert (`list`, *opcional*) : Uma lista de nomes de módulos adicionais, como tabelas de incorporação, que devem ser convertidos durante a quantização.

scale_fmt (`str`, *opcional*, padrão `"float"`) : dtype de armazenamento das escalas de peso por bloco: `"float"` (fp32, estilo V3) ou `"ue8m0"` (1 byte `torch.float8_e8m0fnu`, estilo V4).

expert_dtype (`str`, *opcional*, padrão `"fp8"`) : Formato dos pesos dos especialistas do MoE: `"fp8"` ou `"fp4"` para os especialistas FP4-packed do DeepSeek-V4.

FineGrainedFP8Config é uma classe de configuração para quantização FP8 de grão fino, usada principalmente para modelos deepseek.

#### post_init[[transformers.FineGrainedFP8Config.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1729)

Verificador de segurança que os argumentos estão corretos

## QuarkConfig[[transformers.QuarkConfig]]

#### transformers.QuarkConfig[[transformers.QuarkConfig]]

```python
transformers.QuarkConfig(**kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1749)

## FourOverSixConfig[[transformers.FourOverSixConfig]]

#### transformers.FourOverSixConfig[[transformers.FourOverSixConfig]]

```python
transformers.FourOverSixConfig(activation_dtype: str | None = None, activation_scale_rule: str | None = None, dtype: str = 'nvfp4', gradient_dtype: str | None = None, gradient_scale_rule: str | None = None, keep_master_weights: bool = False, matmul_backend: str | None = None, output_dtype: str | None = 'bfloat16', quantize_backend: str | None = None, scale_rule: str = 'mse', weight_dtype: str | None = None, weight_scale_2d: bool = False, weight_scale_rule: str | None = None, module_config_overrides: dict[str, dict[str, typing.Any]] | None = None, modules_to_not_convert: list[str] | None = ['lm_head'], **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1869)

**Parâmetros:**

activation_dtype (`str`, *opcional*) : Tipo de dados a ser usado ao quantizar os tensores de ativação. Se não for fornecido, `dtype` é usado.

activation_scale_rule (`str`, *opcional*) : Regra de escala a ser usada ao selecionar uma escala para blocos em tensores de ativação. Se não for fornecida, `scale_rule` é usada.

dtype (`str`, padrão "nvfp4", *opcional*, padrão `"nvfp4"`) : O tipo de dados a ser usado para os pesos, ativações e tensores da camada. Pode ser `"nvfp4"` ou `"mxfp4"`.

gradient_dtype (`str`, *opcional*) : Tipo de dados a ser usado ao quantizar os tensores de gradiente. Se não for fornecido, `dtype` é usado.

gradient_scale_rule (`str`, *opcional*) : Regra de escala a ser usada ao selecionar uma escala para blocos em tensores de gradiente. Se não for fornecida, `scale_rule` é usada.

keep_master_weights (`bool`, padrão False, *opcional*, padrão `False`) : Se deve manter os pesos mestres. Se `True`, os pesos de alta precisão são mantidos o tempo todo e os pesos são quantizados online em cada passagem de frente. Isso é útil para treinamento quantizado.

matmul_backend (`str`, *opcional*) : O backend a ser usado para multiplicações de matrizes. Pode ser `"cutlass"` ou `"pytorch"`. Se não for fornecido, o CUTLASS será usado se estiver disponível e o PyTorch será usado caso contrário.

output_dtype (`str`, *opcional*, padrão `"bfloat16"`) : O tipo de dados a ser usado para a saída da camada. Pode ser `"bfloat16"` ou `"float16"`.

quantize_backend (`str`, *opcional*) : O backend a ser usado para quantização. Pode ser `"cuda"`, `"triton"` ou `"pytorch"`. Se não for fornecido, o backend mais rápido será selecionado com base no seu ambiente e nas opções suportadas por cada backend. Normalmente, `"cuda"` será usado para inferência, `"triton"` será usado para treinamento e `"pytorch"` será usado em dispositivos não-CUDA.

scale_rule (`str`, padrão "mse", *opcional*, padrão `"mse"`) : Regra a ser usada ao selecionar as escalas dos blocos. Pode ser `"mse"`, `"mae"` ou `"abs_max"` para Four Over Six, `"static_6"` para quantização NVFP4 padrão, ou `"static_4"` para escalar todos os blocos para um valor máximo de 4.

weight_dtype (`str`, *opcional*) : Tipo de dados a ser usado ao quantizar os tensores de pesos. Se não for fornecido, `dtype` é usado.

weight_scale_2d (`bool`, padrão False, *opcional*, padrão `False`) : Se deve calcular fatores de escala nos tensores de peso em blocos 2D. Isso deve ser feito durante o treinamento.

weight_scale_rule (`str`, *opcional*) : Regra de escala a ser usada ao selecionar uma escala para blocos em tensores de peso. Se não for fornecida, `scale_rule` é usada.

module_config_overrides (`dict[str, dict[str, Any]]`, *opcional*) : Um dicionário de substituições de configuração específicas de módulo. As chaves devem ser nomes de módulos e os valores devem ser dicionários contendo a configuração de quantização para aquele módulo. Isso pode ser usado para substituir a configuração padrão de módulos específicos.

modules_to_not_convert (`list[str]`, *opcional*, padrão `['lm_head']`) : A lista de módulos a serem excluídos da quantização. Por padrão, o `lm_head` é excluído.

Esta é uma classe wrapper que contém todas as opções para quantização com `fouroversix`. Em resumo, Four Over Six é uma modificação da quantização NVFP4 que escala adaptativamente o maior valor em cada bloco de 16 valores FP4 para 4 ou 6. A seleção de uma escala de 6 utiliza a faixa completa de valores FP4, mas a seleção de uma escala de 4 permite uma distribuição mais uniforme do erro de quantização. Consulte a publicação original para mais detalhes: https://arxiv.org/abs/2512.02010.

## FPQuantConfig[[transformers.FPQuantConfig]]

#### transformers.FPQuantConfig[[transformers.FPQuantConfig]]

```python
transformers.FPQuantConfig(forward_dtype: str = 'nvfp4', forward_method: str = 'abs_max', backward_dtype: str = 'bf16', store_master_weights: bool = False, hadamard_group_size: int | None = None, pseudoquantization: bool = False, transform_init: str = 'hadamard', modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1371)

**Parâmetros:**

forward_dtype (`str`, *opcional*, padrão `"nvfp4"`) : O dtype a ser usado para a passagem direta.

forward_method (`str`, *opcional*, padrão `"abs_max"`) : A escala a ser usada para a passagem direta. Pode ser `"abs_max"` ou `"quest"`. `"abs_max"` é melhor para PTQ, `"quest"` é melhor para QAT.

backward_dtype (`str`, *opcional*, padrão `"bf16"`) : O dtype a ser usado para a passagem reversa.

store_master_weights (`bool`, *opcional*, padrão `False`) : Se as pesos mestres devem ser armazenados. Necessário para QAT sobre pesos de camada.

hadamard_group_size (`int`, *opcional*) : O tamanho do grupo para a transformada de hadamard antes da quantização para `"quest"` corresponde ao tamanho do grupo do MXFP4 (32). Se `None`, será definido como 16 para `"nvfp4"` e 32 para `"mxfp4"`.

pseudoquantization (`bool`, *opcional*, padrão `False`) : Se deve usar pseudo-quantização baseada em Triton. É obrigatório para GPUs que não são Blackwell. Não oferece nenhum ganho de velocidade. Para fins de depuração.

transform_init (`str`, *opcional*, padrão `"hadamard"`) : um método para inicializar a matriz de pré-processamento. Pode ser `"hadamard"`, `"identity"` ou `"gsr"`.

modules_to_not_convert (`list`, *opcional*) : A lista de módulos que não devem ser quantizados, útil para quantizar modelos que exigem explicitamente que alguns módulos permaneçam em sua precisão original.

FPQuantConfig é uma classe de configuração para quantização usando o método FPQuant.

#### post_init[[transformers.FPQuantConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1418)

Verificador de segurança que garante que os argumentos estão corretos — também substitui alguns argumentos do tipo NoneType pelos seus valores padrão.

## AutoRoundConfig[[transformers.AutoRoundConfig]]

#### transformers.AutoRoundConfig[[transformers.AutoRoundConfig]]

```python
transformers.AutoRoundConfig(bits: int = 4, group_size: int = 128, sym: bool = True, backend: str = 'auto', **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L208)

**Parâmetros:**

bits (`int`, *opcional*, padrão 4) : O número de bits para quantização, os valores suportados são (2, 3, 4, 5, 6, 7, 8).

group_size (`int`, *opcional*, padrão 128) : Valor de group-size

sym (`bool`, *opcional*, padrão `True`) : Se a quantização é simétrica ou não

backend (`str`, *opcional*, padrão `"auto"`) : O backend de inferência. Por padrão, o AutoRound seleciona um backend compatível com base no dispositivo, nas configurações de quantização e nas bibliotecas instaladas. Consulte [Especificar backend de inferência](https://github.com/intel/auto-round/blob/main/docs/step_by_step.md#specify-inference-backend) para todas as opções de backend.

Esta é uma classe wrapper sobre todos os atributos e recursos possíveis com os quais você pode interagir em um modelo que foi carregado com quantização AutoRound.

#### post_init[[transformers.AutoRoundConfig.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L239)

Verificador de segurança que os argumentos estão corretos.

## SinqConfig[[transformers.SinqConfig]]

#### transformers.SinqConfig[[transformers.SinqConfig]]

```python
transformers.SinqConfig(nbits: int = 4, group_size: int = 64, tiling_mode: str = '1D', method: str = 'sinq', modules_to_not_convert: list[str] | None = None, **kwargs: Any)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1964)

**Parâmetros:**

nbits (`int`, padrão 4) : Bits de quantização para os pesos.

group_size (`int`, padrão 64) : Tamanho do grupo usado na quantização de pesos SINQ (deve ser múltiplo de 8).

tiling_mode (`str`, padrão "1D") : Modo de tiling para SINQ (geralmente "1D"; "2D" se suportado pelo seu backend).

method (`str`, padrão "sinq") : "sinq" – SINQ apenas de pesos, sem calibração "asinq" – A-SINQ (sensível a ativações), não suportado no Hugging Face. Consulte o repositório oficial do SINQ.

modules_to_not_convert (`list[str]`, *opcional*) : Lista de nomes/prefixos de módulos para manter em precisão total.

- ****kwargs** : Argumentos extras do usuário (mantidos em `_extra_kwargs` para ida e volta).

Configuração de quantização para SINQ / A-SINQ.

Passe isso para:

AutoModel.from_pretrained(..., quantization_config=SinqConfig(...))

## GgufConfig[[transformers.GgufConfig]]

#### transformers.GgufConfig[[transformers.GgufConfig]]

```python
transformers.GgufConfig(gguf_file: str | None = None, dequantize: bool = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L2087)

**Parâmetros:**

gguf_file (`str`, *opcional*) : caminho para o arquivo `.gguf` que contém os pesos. Pode ser omitido quando o nome é especificado por meio de `from_pretrained(..., gguf_file=...)`, que preenche esse valor.

dequantize (`bool`, *opcional*, padrão `False`) : Desempacota todos os pesos no momento do carregamento para um modelo denso simples. Sempre correto, mas abre mão da economia de memória; esse também é o recurso de fallback automático quando não há kernel de matmul disponível para os tipos de quantização do arquivo.

Carregue um checkpoint quantizado GGUF com seus pesos mantidos em blocos GGUF.