# Cuantización

Las técnicas de cuantización reducen los costos de memoria y de cómputo al representar los pesos y las activaciones con tipos de datos de menor precisión, como enteros de 8 bits (int8). Esto permite cargar modelos más grandes que normalmente no cabrían en memoria y acelerar la inferencia. Transformers admite los algoritmos de cuantización AWQ y GPTQ, y soporta la cuantización de 8 bits y 4 bits con bitsandbytes.

Las técnicas de cuantización que no están soportadas en Transformers se pueden añadir con la clase `HfQuantizer`.

Aprende a cuantizar modelos en la guía de [Cuantización](../quantization/overview).

## QuantoConfig[[transformers.QuantoConfig]]

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

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

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

**Parámetros:**

weights (`str`, *opcional*, valor predeterminado `"int8"`) : El dtype objetivo para los pesos después de la cuantización. Los valores admitidos son ("float8","int8","int4","int2")

activations (`str`, *opcional*) : El dtype objetivo para las activaciones después de la cuantización. Los valores admitidos son (None,"int8","float8")

modules_to_not_convert (`list`, *opcional*, valor predeterminado `None`) : La lista de módulos que no se deben cuantizar, útil para cuantizar modelos que requieren explícitamente que algunos módulos se mantengan en su precisión original (p. ej., el codificador de Whisper, el codificador de Llava, las capas de puerta de Mixtral).

Esta es una clase envoltorio sobre todos los atributos y características posibles con los que puedes trabajar un modelo que se ha cargado usando `quanto`.

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

```python
post_init()
```

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

Verificador de seguridad que los argumentos son correctos

## 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)
```

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

**Parámetros:**

in_group_size (`int`, *opcional*, valor predeterminado 8) : El tamaño del grupo a lo largo de la dimensión de entrada.

out_group_size (`int`, *opcional*, valor predeterminado 1) : El tamaño del grupo a lo largo de la dimensión de salida. Se recomienda usar siempre 1.

num_codebooks (`int`, *opcional*, valor predeterminado: 1) : Número de libros de códigos para el procedimiento de Cuantización Aditiva.

nbits_per_codebook (`int`, *opcional*, valor predeterminado: 16) : Número de bits que codifican un vector de codebook individual. El tamaño de los codebooks es 2**nbits_per_codebook.

linear_weights_not_to_quantize (`Optional[list[str]]`, *opcional*) : Lista de rutas completas de los parámetros de peso de `nn.Linear` que no deben cuantizarse.

kwargs (`dict[str, Any]`, *opcional*) : Parámetros adicionales a partir de los cuales se inicializa el objeto de configuración.

Esta es una clase envoltorio sobre los parámetros de `aqlm`.

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

```python
post_init()
```

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

Comprobador de seguridad que verifica que los argumentos sean correctos; también reemplaza algunos argumentos de tipo NoneType con sus valores predeterminados.

## 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)
```

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

**Parámetros:**

enable_proxy_error (`bool`, *opcional*, valor predeterminado `False`) : calcular el error de proxy para cada capa

config_for_layers (`Dict`, *opcional*, valor predeterminado `{}`) : parámetros de cuantización para cada capa

shared_layer_config (`Dict`, *opcional*, valor predeterminado `{}`) : parámetros de cuantización compartidos entre capas

modules_to_not_convert (`list`, *opcional*, valor predeterminado `None`) : La lista de módulos que no se deben cuantizar, útil para cuantizar modelos que requieren explícitamente que algunos módulos se mantengan en su precisión original (p. ej., el codificador de Whisper, el codificador de Llava, las capas de puerta de Mixtral).

kwargs (`dict[str, Any]`, *opcional*) : Parámetros adicionales a partir de los cuales se inicializa el objeto de configuración.

Esta es una clase envoltorio sobre los parámetros de `vptq`.

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

```python
post_init()
```

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

Verificador de seguridad que los argumentos son correctos

## 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)
```

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

**Parámetros:**

bits (`int`, *opcional*, valor predeterminado: 4) : El número de bits a los que cuantizar.

group_size (`int`, *opcional*, valor predeterminado 128) : El tamaño de grupo que se utilizará para la cuantización. El valor recomendado es 128 y -1 utiliza cuantización por columna.

zero_point (`bool`, *opcional*, valor predeterminado `True`) : Si se debe usar la cuantización de punto cero.

backend (`AwqBackend`, *opcional*, valor predeterminado `AwqBackend.AUTO`) : El backend de cuantización.

modules_to_not_convert (`list`, *opcional*, valor predeterminado `None`) : La lista de módulos que no se deben cuantizar, útil para cuantizar modelos que requieren explícitamente que algunos módulos se mantengan en su precisión original (p. ej., el codificador de Whisper, el codificador de Llava, las capas de puerta de Mixtral). Ten en cuenta que no se puede cuantizar directamente con transformers; consulta la documentación de `AutoAWQ` para cuantizar modelos de HF.

Esta es una clase envoltorio sobre todos los atributos y funciones posibles con los que puedes trabajar un modelo que se ha cargado usando la cuantización awq de la biblioteca `auto-awq` que depende del backend auto_awq.

## EetqConfig[[transformers.EetqConfig]]

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

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

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

**Parámetros:**

weights (`str`, *opcional*, valor predeterminado `"int8"`) : El dtype objetivo para los pesos. El único valor admitido es "int8"

modules_to_not_convert (`list`, *opcional*, valor predeterminado `None`) : La lista de módulos que no se deben cuantizar, útil para cuantizar modelos que requieren explícitamente que algunos módulos se mantengan en su precisión original.

Esta es una clase envoltorio sobre todos los atributos y características posibles con los que puedes trabajar un modelo que se ha cargado usando `eetq`.

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

```python
post_init()
```

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

Verificador de seguridad que los argumentos son correctos

## 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)
```

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

**Parámetros:**

bits (`int`) : El número de bits a los que cuantizar; los valores admitidos son (2, 3, 4, 8).

tokenizer (`str` o `PreTrainedTokenizerBase`, *opcional*) : El tokenizador utilizado para procesar el conjunto de datos. Puede pasar: - Un objeto de tokenizador personalizado. - Una cadena, el *model id* de un tokenizador predefinido alojado en un repositorio de modelos en huggingface.co. - Una ruta a un *directorio* que contenga los archivos de vocabulario requeridos por el tokenizador, por ejemplo, guardados mediante el método [save_pretrained()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained), p. ej., `./my_model_directory/`.

dataset (`Union[list[str]]`, *opcional*) : El conjunto de datos utilizado para la cuantización. Puede proporcionar su propio conjunto de datos en una lista de cadenas o simplemente utilizar los conjuntos de datos originales empleados en el artículo de GPTQ ['wikitext2','c4','c4-new']

group_size (`int`, *opcional*, valor predeterminado 128) : El tamaño de grupo que se utilizará para la cuantización. El valor recomendado es 128 y -1 utiliza cuantización por columna.

damp_percent (`float`, *opcional*, valor predeterminado 0.1) : El porcentaje de la diagonal media de la hessiana que se utilizará para el amortiguamiento. El valor recomendado es 0.1.

desc_act (`bool`, *opcional*, valor predeterminado `False`) : Si se cuantizan las columnas en orden de tamaño de activación decreciente. Establecerlo en False puede acelerar significativamente la inferencia, pero la perplejidad puede empeorar ligeramente. También conocido como act-order.

act_group_aware (`bool`, *opcional*, valor predeterminado `True`) : Utiliza GAR (group aware activation order) durante la cuantización. Tiene un impacto positivo medible en la calidad de la cuantización. Solo es aplicable cuando `desc_act = False`. Se forzará a `False` cuando `desc_act = True`.

sym (`bool`, *opcional*, valor predeterminado `True`) : Si se debe usar cuantización simétrica.

true_sequential (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe realizar la cuantización secuencial incluso dentro de un solo bloque Transformer. En lugar de cuantizar el bloque completo de una sola vez, se realiza una cuantización capa por capa. Como resultado, cada capa se cuantiza utilizando entradas que han pasado por las capas cuantizadas previamente.

format (`str`, *opcional*, valor predeterminado `"gptq"`) : formato de pesos GPTQ. `gptq` (v1) es compatible con gptqmodel. `gptq_v2` es exclusivo de gptqmodel.

meta (`dict[str, any]`, *opcional*) : Las propiedades que no contribuyen directamente a la cuantización o a la inferencia cuantizada, como tooling:version, se almacenan en meta. Por ejemplo, `meta.quantizer`: ["optimum:_version_", "gptqmodel:_version_"]

backend (`str`, *opcional*) : Controla qué kernel se debe usar. Los valores válidos para gptqmodel son `auto`, `auto_trainable` y más. Ref backends de gptqmodel: https://github.com/ModelCloud/GPTQModel/blob/main/gptqmodel/utils/backend.py

model_seqlen (`int`, *opcional*) : La longitud máxima de secuencia que puede aceptar el modelo.

block_name_to_quantize (`str`, *opcional*) : El nombre del bloque de transformers que se debe cuantizar. Si es None, se inferirá el nombre del bloque utilizando patrones comunes (p. ej. model.layers).

module_name_preceding_first_block (`list[str]`, *opcional*) : Las capas que preceden al primer bloque de Transformer.

batch_size (`int`, *opcional*, valor predeterminado 1) : El tamaño del lote utilizado al procesar el conjunto de datos

pad_token_id (`int`, *opcional*) : El id del token de relleno. Necesario para preparar el conjunto de datos cuando `batch_size` > 1.

max_input_length (`int`, *opcional*) : La longitud máxima de la entrada. Esto es necesario para inicializar un búfer que depende de la longitud máxima de entrada esperada. Es específico del backend exllama con act-order.

cache_block_outputs (`bool`, *opcional*, valor predeterminado `True`) : Si se deben cachear las salidas de los bloques para reutilizarlas como entradas del bloque siguiente.

modules_in_block_to_quantize (`list[list[str]]`, *opcional*) : Lista de listas de nombres de módulos a cuantizar en el bloque especificado. Este argumento es útil para excluir ciertos módulos lineales de la cuantización. El bloque a cuantizar se puede especificar configurando `block_name_to_quantize`. Cuantizaremos cada lista de forma secuencial. Si no se configura, cuantizaremos todas las capas lineales. Ejemplo: `modules_in_block_to_quantize =[["self_attn.k_proj", "self_attn.v_proj", "self_attn.q_proj"], ["self_attn.o_proj"]]`. En este ejemplo, primero cuantizaremos las capas q, k y v simultáneamente, ya que son independientes. A continuación, cuantizaremos la capa `self_attn.o_proj` con las capas q, k y v ya cuantizadas. De esta manera, obtendremos mejores resultados, ya que refleja la entrada real que recibirá `self_attn.o_proj` cuando el modelo esté cuantizado.

Esta es una clase envoltorio sobre todos los atributos y funciones posibles con los que puedes trabajar un modelo que se ha cargado mediante la API de `optimum` para la cuantización GPTQ, que se basa en el backend gptqmodel.

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

```python
from_dict_optimum(config_dict)
```

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

Obtener la clase compatible con el diccionario de configuración gptq de optimum

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

```python
post_init()
```

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

Verificador de seguridad que los argumentos son correctos

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

```python
to_dict_optimum()
```

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

Obtener un diccionario compatible para la configuración de gptq de 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)
```

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

**Parámetros:**

load_in_8bit (`bool`, *opcional*, valor predeterminado `False`) : Esta bandera se utiliza para habilitar la cuantización de 8 bits con LLM.int8().

load_in_4bit (`bool`, *opcional*, valor predeterminado `False`) : Esta bandera se utiliza para habilitar la cuantización de 4 bits reemplazando las capas Linear con capas FP4/NF4 de `bitsandbytes`.

llm_int8_threshold (`float`, *opcional*, valor predeterminado 6.0) : Este parámetro corresponde al umbral de atípicos para la detección de atípicos, tal como se describe en el artículo `LLM.int8() : 8-bit Matrix Multiplication for Transformers at Scale`: https://huggingface.co/papers/2208.07339 Cualquier valor de los estados ocultos que supere este umbral se considerará un atípico y la operación sobre esos valores se realizará en fp16. Los valores suelen estar distribuidos de forma normal, es decir, la mayoría se encuentran en el rango [-3.5, 3.5], pero en los modelos grandes existen algunos atípicos sistemáticos excepcionales con una distribución muy diferente. Estos atípicos suelen encontrarse en el intervalo [-60, -6] o [6, 60]. La cuantización Int8 funciona bien para valores de magnitud ~5, pero más allá de ese punto se incurre en un penalización significativa de rendimiento. Un umbral predeterminado adecuado es 6, aunque podría ser necesario un umbral más bajo para modelos más inestables (modelos pequeños, ajuste fino).

llm_int8_skip_modules (`list[str]`, *opcional*) : Una lista explícita de los módulos que no queremos convertir a 8 bits. Esto es útil para modelos como Jukebox, que tiene varias cabezas en diferentes lugares y no necesariamente en la última posición. Por ejemplo, en los modelos `CausalLM`, la última `lm_head` se mantiene en su `dtype` original.

llm_int8_enable_fp32_cpu_offload (`bool`, *opcional*, valor predeterminado `False`) : Esta bandera se utiliza para casos de uso avanzados y para usuarios que conocen esta función. Si deseas dividir tu modelo en diferentes partes y ejecutar algunas en int8 en la GPU y otras en fp32 en la CPU, puedes usar esta bandera. Esto es útil para descargar modelos grandes, como `google/flan-t5-xxl`. Ten en cuenta que las operaciones en int8 no se ejecutarán en la CPU.

llm_int8_has_fp16_weight (`bool`, *opcional*, valor predeterminado `False`) : Esta bandera ejecuta LLM.int8() con pesos principales de 16 bits. Esto es útil para el ajuste fino, ya que los pesos no tienen que convertirse de ida y vuelta para la propagación inversa.

bnb_4bit_compute_dtype (`torch.dtype` o str, *opcional*, valor predeterminado `torch.float32`) : Esto establece el tipo de cálculo, que puede ser diferente al tipo de entrada. Por ejemplo, las entradas pueden ser fp32, pero el cálculo puede configurarse en bf16 para obtener mejoras de velocidad.

bnb_4bit_quant_type (`str`,  *opcional*, valor predeterminado `"fp4"`) : Esto establece el tipo de datos de cuantización en las capas bnb.nn.Linear4Bit. Las opciones son los tipos de datos FP4 y NF4, que se especifican con `fp4` o `nf4`.

bnb_4bit_use_double_quant (`bool`, *opcional*, valor predeterminado `False`) : Esta bandera se utiliza para la cuantización anidada, donde las constantes de cuantización de la primera cuantización se cuantizan nuevamente.

bnb_4bit_quant_storage (`torch.dtype` o str, *opcional*, valor predeterminado `torch.uint8`) : Esto establece el tipo de almacenamiento para empaquetar los parámetros cuantizados de 4 bits.

kwargs (`dict[str, Any]`, *opcional*) : Parámetros adicionales a partir de los cuales se inicializa el objeto de configuración.

Esta es una clase envoltorio sobre todos los atributos y funciones posibles con los que puedes trabajar un modelo que se ha cargado usando `bitsandbytes`.

Actualmente solo admite la cuantización `LLM.int8()`, `FP4` y `NF4`. Si se añaden más métodos a `bitsandbytes`, se añadirán más argumentos a esta clase.

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

```python
is_quantizable()
```

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

Devuelve `True` si el modelo es cuantizable, `False` en caso contrario.

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

```python
post_init()
```

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

Comprobador de seguridad que verifica que los argumentos sean correctos; también reemplaza algunos argumentos de tipo NoneType con sus valores predeterminados.

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

```python
quantization_method()
```

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

Este método devuelve el método de cuantización utilizado para el modelo. Si el modelo no es cuantizable, devuelve `None`.

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

```python
to_diff_dict()
```

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

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

Diccionario de todos los atributos que componen esta instancia de configuración,

Elimina todos los atributos de config que corresponden a los atributos de la configuración predeterminada, para mejorar la legibilidad, y los serializa en un diccionario de Python.

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

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

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

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

Clase abstracta del cuantizador de HuggingFace. Por ahora, admite la cuantización de modelos de transformers de HF para inferencia y/o cuantización. Esta clase se utiliza únicamente en transformers.PreTrainedModel.from_pretrained y aún no se puede utilizar fácilmente fuera del ámbito de ese método.

Attributes quantization_config (`transformers.utils.quantization_config.QuantizationConfigMixin`): La configuración de cuantización que define los parámetros de cuantización del modelo que deseas cuantizar. requires_calibration (`bool`): Indica si el método de cuantización requiere calibrar el modelo antes de usarlo.

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

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

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

ajustar el argumento max_memory de infer_auto_device_map() si se necesita memoria adicional para la cuantización

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

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

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

Descomprimir el modelo para recuperar el modelo original, con cierta pérdida de precisión / rendimiento. Tenga en cuenta que no todos los esquemas de cuantización admiten esta operación.

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

```python
get_load_operations()
```

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

Clases de operaciones que cargan los tensores serializados, p. ej. `{"deserialize": Mxfp4Deserialize, "dequantize": Mxfp4Dequantize}`. La deserialización construye los parámetros de un módulo, por lo que solo se ejecuta en los conversores generales. La descuantización también se ejecuta antes de las operaciones de los conversores del modelo, p. ej. antes de una fusión por experto.

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

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

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

Esto ocurre en el momento de la materialización, cuando el tensor se envía desde el disco al dispositivo. `dtype` para convertir el tensor del checkpoint pre-cuantizado `param`. Si ese parámetro no está cuantizado (tipo float), se utiliza el `dtype` de entrada que proviene del `nn.Module` inicializado.

Si el método de cuantización tiene un `Deserializer` o un `Dequantizer` (función de carga), devolvemos None para que lo gestionen ellos.

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

```python
get_state_dict_and_metadata(model)
```

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

Obtener el state dict y los metadatos. Útil cuando necesitamos modificar un poco el state dict debido a la cuantización

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

```python
get_weight_conversions()
```

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

Devuelve la carga a realizar en cualquier parámetro que no coincida con los conversores del modelo

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

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

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

Comprueba si un parámetro dado necesita ser cuantizado.

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

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

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

**Parámetros:**

model (`~transformers.PreTrainedModel`) : El modelo que se va a cuantizar

kwargs (`dict`, *opcional*) : Los argumentos de palabra clave que se pasan a `_process_model_after_weight_loading`.

Post-procesa el modelo después de cargar los pesos. Asegúrate de sobrescribir el método abstracto `_process_model_after_weight_loading`.

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

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

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

**Parámetros:**

model (`~transformers.PreTrainedModel`) : El modelo que se va a cuantizar

kwargs (`dict`, *opcional*) : Los argumentos de palabra clave que se pasan junto con `_process_model_before_weight_loading`.

Establecer atributos del modelo y/o convertir el modelo antes de cargar los pesos. En este punto, el modelo debe estar inicializado en el dispositivo meta, por lo que puedes manipular libremente el esqueleto del modelo para reemplazar módulos in situ. Asegúrate de sobrescribir el método abstracto `_process_model_before_weight_loading`.

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

```python
remove_quantization_config(model)
```

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

Elimine la configuración de cuantización del modelo.

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

```python
update_attn_implementation(config)
```

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

Ve el `attn_implementation` solicitado antes de que se construya el modelo, por lo que un cuantizador puede establecerlo de forma predeterminada.

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

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

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

**Parámetros:**

device_map (`Union[dict, str]`, *opcional*) : El device_map que se pasa a través del método `from_pretrained`.

Sobrescriba este método si desea pasar un mapa de dispositivos para reemplazar el mapa de dispositivos existente. Por ejemplo, para bitsandbytes, ya que `accelerate` es un requisito obligatorio, si no se pasa un device_map, el device_map se establece en `"auto"``

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

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

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

**Parámetros:**

dtype (`torch.dtype`) : El dtype de entrada que se pasa en `from_pretrained`

Algunos métodos de cuantización requieren establecer explícitamente el dtype del modelo a un dtype objetivo. Debes sobrescribir este método si deseas asegurarte de que se preserve ese comportamiento

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

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

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

Actualiza `model.tp_plan` o `model.ep_plan` (los planes completos, fusionados desde la configuración y todas las subconfiguraciones) para tener en cuenta las claves personalizadas del cuantizador, como 'inv_scale'

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

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

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

Hace que los conversores del modelo (de la conversión de mapeo) carguen los nombres serializados. Los parámetros del modelo deciden, por ejemplo, para una fusión de `experts.*.gate_proj.weight` en `experts.gate_up_proj`:
- `experts.gate_up_proj_scale_inv` es un parámetro: una copia fusiona `experts.*.gate_proj.weight_scale_inv` en él
- en caso contrario, el convertidor también recopila `experts.*.gate_proj.weight_scale_inv`, la operación de descuantización se ejecuta primero

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

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

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

Este método se utiliza para verificar posibles conflictos con los argumentos que se pasan en `from_pretrained`. Debe definirse para todos los cuantizadores futuros que se integren con transformers. Si no se necesita ninguna comprobación explícita, simplemente no devuelva 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)
```

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

**Parámetros:**

bits (int, *opcional*, valor predeterminado 4) : Número de bits a utilizar para la cuantización. Puede ser 2, 3 o 4. El valor predeterminado es 4.

p (int, *opcional*, valor predeterminado 2) : Dimensión de la cuadrícula de cuantización. Se admiten 1 y 2. En la práctica, 2 siempre es mejor. El valor predeterminado es 2.

modules_to_not_convert (`list`, *opcional*, por defecto ["lm_head"]) : Lista de capas lineales que no deben cuantizarse.

hadamard_size (int, *opcional*, valor predeterminado 512) : Tamaño de Hadamard para el método HIGGS. El valor predeterminado es 512. La dimensión de entrada de las matrices se rellena hasta este valor. Reducir este valor por debajo de 512 disminuirá la calidad de la cuantización.

group_size (int, *opcional*, valor predeterminado 256) : Tamaño de grupo para el método HIGGS. Puede ser 64, 128 o 256. Disminuirlo apenas afecta el rendimiento. El valor predeterminado es 256. Debe ser un divisor de hadamard_size.

tune_metadata ('dict', *opcional*, valor predeterminado {}) : Metadatos a nivel de módulo (formas de bloques gemm, metadatos de GPU, etc.) para guardar los resultados del ajuste de kernels. El valor predeterminado es un diccionario vacío. Se establece automáticamente durante el ajuste.

HiggsConfig es una clase de configuración para la cuantización mediante el método HIGGS.

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

```python
post_init()
```

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

Comprobador de seguridad que verifica que los argumentos sean correctos; también reemplaza algunos argumentos de tipo NoneType con sus valores predeterminados.

## 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)
```

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

**Parámetros:**

nbits (`int`, *opcional*, valor predeterminado: 4) : Número de bits. Los valores admitidos son (8, 4, 3, 2, 1).

group_size (`int`, *opcional*, valor predeterminado: 64) : Valor de group-size. Los valores admitidos son cualquier valor divisible por weight.shape[axis]).

view_as_float (`bool`, *opcional*, valor predeterminado `False`) : Si se establece en `True`, muestra el peso cuantizado como float (se utiliza en entrenamiento distribuido).

axis (`Optional[int]`, *opcional*) : Eje a lo largo del cual se realiza el agrupamiento. Los valores admitidos son 0 o 1.

dynamic_config (dict, *opcional*) : Parámetros para la configuración dinámica. La clave es la etiqueta de nombre de la capa y el valor es una configuración de cuantización. Si se establece, cada capa especificada por su id utilizará su configuración de cuantización dedicada.

skip_modules (`list[str]`, *opcional*, valor predeterminado `['lm_head']`) : Lista de capas `nn.Linear` que se deben omitir.

kwargs (`dict[str, Any]`, *opcional*) : Parámetros adicionales a partir de los cuales se inicializa el objeto de configuración.

Este es un envoltorio alrededor de BaseQuantizeConfig de hqq.

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

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

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

Sobrescribir from_dict, que se utiliza en AutoQuantizationConfig.from_dict en quantizers/auto.py

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

```python
post_init()
```

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

Comprobador de seguridad que verifica que los argumentos sean correctos; también reemplaza algunos argumentos de tipo NoneType con sus valores predeterminados.

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

```python
to_diff_dict()
```

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

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

Diccionario de todos los atributos que componen esta instancia de configuración,

Elimina todos los atributos de config que corresponden a los atributos de la configuración predeterminada, para mejorar la legibilidad, y los serializa en un diccionario de 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)
```

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

Clase de configuración para la cuantización afín de Metal dirigida a dispositivos Apple Silicon (MPS).

Este método de cuantización utiliza los kernels Metal de `mlx-quantization-metal-kernels` del Hugging Face Hub para realizar una cuantización afín (escalas + qbiases) con ancho de bits y tamaño de grupo configurables. Los pesos cuantizados se empaquetan en tensores `uint32` y la pasada hacia adelante utiliza kernels Metal fusionados de decuantización + matmul.

## Mxfp4Config[[transformers.Mxfp4Config]]

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

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

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

**Parámetros:**

modules_to_not_convert (`list`, *opcional*, valor predeterminado `None`) : La lista de módulos que no se deben cuantizar, útil para cuantizar modelos que requieren explícitamente que algunos módulos se mantengan en su precisión original.

dequantize (`bool`, *opcional*, valor predeterminado `False`) : Si descuantizamos el modelo a precisión bf16 o no

Esta es una clase envoltorio sobre todos los atributos y características posibles con los que puedes trabajar un modelo que se ha cargado usando cuantización mxfp4.

## NVFP4Config[[transformers.NVFP4Config]]

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

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

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

**Parámetros:**

modules_to_not_convert (`list[str]`, *opcional*) : Patrones de nombres de módulos que deben mantener su precisión original.

kwargs (`dict[str, Any]`, *opcional*) : Los valores adicionales se ignoran y se informan a través del registro de Transformers.

Configuración para la cuantización de pesos NVFP4 sobre la marcha.

## FbgemmFp8Config[[transformers.FbgemmFp8Config]]

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

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

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

**Parámetros:**

activation_scale_ub (`float`, *opcional*, valor predeterminado 1200.0) : Límite superior de la escala de activación. Se utiliza al cuantizar la activación de entrada.

modules_to_not_convert (`list`, *opcional*, valor predeterminado `None`) : La lista de módulos que no se deben cuantizar, útil para cuantizar modelos que requieren explícitamente que algunos módulos se mantengan en su precisión original.

Esta es una clase envoltorio sobre todos los atributos y funciones posibles con los que puedes trabajar un modelo que se ha cargado usando cuantización fp8 de 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)
```

[Fuente](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*) : diccionario que mapea el nombre de un grupo a una definición de esquema de cuantización

format (`str`, *opcional*, valor predeterminado `"dense"`) : formato en el que se almacenan los pesos, p. ej. `dense`, `float-quantized` o `pack-quantized`

quantization_status (`QuantizationStatus`, *opcional*, valor predeterminado `"initialized"`) : estado del modelo en el ciclo de vida de la cuantización, es decir, 'initialized', 'calibration', 'frozen'

kv_cache_scheme (`typing.Union[QuantizationArgs, NoneType]`, *opcional*) : especifica la cuantización de la caché kv. Si es None, la caché kv no se cuantiza.

global_compression_ratio (`typing.Union[float, NoneType]`, *opcional*) : porcentaje de compresión del modelo como float entre 0 y 1

ignore (`typing.Union[typing.list[str], NoneType]`, *opcional*) : nombres o tipos de capas que no se deben cuantizar, admite expresiones regulares con el prefijo 're:'

quant_method (`str`, *opcional*, por defecto `"compressed-tensors"`) : no se debe sobrescribir, debe ser compressed-tensors

run_compressed (`bool`, *opcional*) : obsoleto, use `dequantize` en su lugar. Su único efecto es establecer `dequantize` en su opuesto, `run_compressed=False` lo que significa `dequantize=True`.

dequantize (`bool`, *opcional*, valor predeterminado `False`) : cuando es `True`, los pesos cuantizados se descuantizan al tipo de datos del modelo (p. ej., BF16) en el momento de la carga, lo cual es lo que se necesita para el ajuste fino o para guardar el modelo en su tipo de datos original. Cuando es `False`, los pesos se mantienen en su forma comprimida y compressed-tensors los descomprime en la primera pasada hacia adelante.

use_optimized_inference (`bool`, *opcional*, valor predeterminado `False`) : cuando es `True`, las capas para las que tenemos kernels conservan sus pesos cuantizados y se ejecutan a través de esos kernels (actualmente W8A8 FP8, en CUDA SM89+, XPU o MPS con torch >= 2.15). Solo para inferencia y de activación opcional: sin esta opción, el modelo se procesa a través de la ruta regular de compressed-tensors. Se ignora cuando `dequantize=True`.

Esta es una clase envoltorio que gestiona las opciones de configuración de cuantización de compressed-tensors. Es un envoltorio alrededor de `compressed_tensors.QuantizationConfig`

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

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

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

**Parámetros:**

config_dict (`dict[str, Any]`) : Diccionario que se utilizará para instanciar el objeto de configuración.

return_unused_kwargs (`bool`,*opcional*, valor predeterminado `False`) : Indica si se debe devolver una lista de argumentos de palabra clave no utilizados. Se utiliza en el método `from_pretrained` de `PreTrainedModel`.

kwargs (`dict[str, Any]`) : Parámetros adicionales a partir de los cuales se inicializa el objeto de configuración.

**Devuelve:** `QuantizationConfigMixin`

El objeto de configuración instanciado a partir de esos parámetros.

Instancia un [CompressedTensorsConfig](/docs/transformers/main/es/main_classes/quantization#transformers.CompressedTensorsConfig) a partir de un diccionario de Python de parámetros. Opcionalmente, extrae cualquier argumento de la quantization_config anidada

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

```python
to_dict()
```

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

Configuración de cuantización que se añadirá a config.json

Serializa esta instancia en un diccionario de Python. Devuelve: `dict[str, Any]`: Diccionario de todos los atributos que componen esta instancia de configuración.

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

```python
to_diff_dict()
```

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

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

Diccionario de todos los atributos que componen esta instancia de configuración,

Elimina todos los atributos de config que corresponden a los atributos de la configuración predeterminada, para mejorar la legibilidad, y los serializa en un diccionario de 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)
```

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

**Parámetros:**

quant_type (`AOBaseConfig`) : una instancia de `AOBaseConfig` de torchao que especifica el tipo de cuantización, p. ej. `Int4WeightOnlyConfig(group_size=32)`, `Int8WeightOnlyConfig()`, `Int8DynamicActivationInt8WeightConfig()`, `Float8WeightOnlyConfig()`, etc.

modules_to_not_convert (`list`, *opcional*, valor predeterminado `None`) : La lista de módulos que no se deben cuantizar, útil para cuantizar modelos que requieren explícitamente que algunos módulos se mantengan en su precisión original.

include_input_output_embeddings (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe incluir el embedding en la cuantización o no. Si se establece esta bandera, el embedding de entrada también se eliminará de la lista module_not_to_convert.

untie_embedding_weights (`bool`, *opcional*, valor predeterminado `False`) : Si se deben desvincular los pesos al cuantizar los pesos de la incrustación de entrada que están vinculados a otros pesos.

Clase de configuración para técnicas de cuantización/escasez de torchao.

Ejemplo:

```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)
```

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

Crear una configuración a partir de un diccionario.

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

```python
get_apply_tensor_subclass()
```

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

Devuelve la configuración de cuantización a aplicar.

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

```python
post_init()
```

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

Validar la configuración y establecer los valores predeterminados.

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

```python
to_dict()
```

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

Convierte la configuración en un diccionario.

## 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)
```

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

**Parámetros:**

modules_to_not_convert (`Optional[List]`, *opcional*) : Opcionalmente, proporciona una lista de rutas completas de los parámetros de peso de `nn.Linear` que no deben cuantizarse. El valor predeterminado es None.

linear_class (`str`, *opcional*, valor predeterminado `"bitlinear"`) : El tipo de clase lineal a utilizar. Puede ser `bitlinear` o `autobitlinear`.

quantization_mode (`str`, *opcional*, valor predeterminado `"offline"`) : El modo de cuantización a utilizar. Puede ser `online` o `offline`. En el modo `online`, los parámetros de cuantización de los pesos se calculan dinámicamente durante cada pasada hacia adelante (por ejemplo, en función de los valores actuales de los pesos). Esto permite adaptarse a los cambios en los pesos durante el entrenamiento (Quantization-Aware Training - QAT). En el modo `offline`, los parámetros de cuantización se calculan con antelación *antes* de la inferencia. Estos parámetros se fijan y se cargan en el modelo cuantizado. Esto generalmente resulta en una menor sobrecarga de tiempo de ejecución en comparación con la cuantización en línea.

use_rms_norm (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe aplicar RMSNorm a las activaciones antes de la cuantización. Esto coincide con el enfoque del artículo original de BitNet de normalizar las activaciones antes de la cuantización/empaquetado.

rms_norm_eps (`float`, *opcional*, valor predeterminado 1e-06) : El valor de epsilon utilizado en la capa RMSNorm para la estabilidad numérica.

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que pueden ser utilizados por backends de cuantización específicos o versiones futuras.

Clase de configuración para aplicar la cuantización BitNet.

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

```python
post_init()
```

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

Verificador de seguridad que los argumentos son correctos

## 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)
```

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

**Parámetros:**

bits (`int`, *opcional*, valor predeterminado 3) : Especifica el número de bits para los pesos y los puntos cero y escalas de primer orden. Actualmente solo se admite bits = 3.

beta1 (`int`, *opcional*, valor predeterminado 16) : Ancho de la tesela de SpQR. Actualmente solo se admite beta1 = 16.

beta2 (`int`, *opcional*, valor predeterminado 16) : Altura de la tesela de SpQR. Actualmente solo se admite beta2 = 16.

shapes (`Optional`, *optional*) : Un diccionario que contiene la forma de cada objeto. Necesitamos esto porque es imposible deducir el tamaño exacto de los parámetros solo a partir de bits, beta1, beta2.

modules_to_not_convert (`Optional[list[str]]`, *opcional*) : Opcionalmente, proporciona una lista de rutas completas de los parámetros de peso de `nn.Linear` que no deben cuantizarse. El valor predeterminado es None.

kwargs (`dict[str, Any]`, *opcional*) : Parámetros adicionales a partir de los cuales se inicializa el objeto de configuración.

Esta es una clase envoltorio sobre los parámetros de `spqr`. Consulte la publicación original para más detalles.

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

```python
post_init()
```

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

Comprobador de seguridad que verifica que los argumentos sean correctos; también reemplaza algunos argumentos de tipo NoneType con sus valores predeterminados.

## 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)
```

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

**Parámetros:**

activation_scheme (`str`, *opcional*, valor predeterminado `"dynamic"`) : El esquema utilizado para la activación; el valor predeterminado y el único esquema compatible por ahora es "dynamic".

weight_block_size (`typing.tuple[int, int]`, *opcional*, valor predeterminado `(128, 128)`) : El tamaño de los bloques de pesos para la cuantización, el valor predeterminado es (128, 128).

dequantize (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe descuantizar el modelo durante la carga.

modules_to_not_convert (`list`, *opcional*) : Una lista de nombres de módulos que no deben convertirse durante la cuantización.

modules_to_convert (`list`, *opcional*) : Una lista de nombres de módulos adicionales, como tablas de incrustación, que deben convertirse durante la cuantización.

scale_fmt (`str`, *opcional*, valor predeterminado `"float"`) : dtype de almacenamiento de las escalas de pesos por bloque: `"float"` (fp32, estilo V3) o `"ue8m0"` (1 byte `torch.float8_e8m0fnu`, estilo V4).

expert_dtype (`str`, *opcional*, valor predeterminado `"fp8"`) : Formato de los pesos de los expertos MoE: `"fp8"`, o `"fp4"` para los expertos empaquetados en FP4 de DeepSeek-V4.

FineGrainedFP8Config es una clase de configuración para la cuantización FP8 de grano fino, utilizada principalmente para los modelos deepseek.

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

```python
post_init()
```

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

Verificador de seguridad que los argumentos son correctos

## QuarkConfig[[transformers.QuarkConfig]]

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

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

[Fuente](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)
```

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

**Parámetros:**

activation_dtype (`str`, *opcional*) : Tipo de datos a utilizar al cuantizar los tensores de activación. Si no se proporciona, se utiliza `dtype`.

activation_scale_rule (`str`, *opcional*) : Regla de escalado a utilizar al seleccionar una escala para los bloques en los tensores de activación. Si no se proporciona, se utiliza `scale_rule`.

dtype (`str`, predeterminado "nvfp4", *opcional*, predeterminado a `"nvfp4"`) : El tipo de datos que se usará para los pesos, las activaciones y los tensores de la capa. Puede ser `"nvfp4"` o `"mxfp4"`.

gradient_dtype (`str`, *opcional*) : Tipo de datos a utilizar al cuantizar los tensores de gradiente. Si no se proporciona, se utiliza `dtype`.

gradient_scale_rule (`str`, *opcional*) : Regla de escalado que se utilizará al seleccionar una escala para los bloques en los tensores de gradiente. Si no se proporciona, se utiliza `scale_rule`.

keep_master_weights (`bool`, por defecto False, *opcional*, por defecto `False`) : Indica si se deben conservar los pesos maestros. Si es `True`, se mantienen los pesos de alta precisión en todo momento y los pesos se cuantizan en línea en cada pasada hacia adelante. Esto es útil para el entrenamiento cuantizado.

matmul_backend (`str`, *opcional*) : El backend que se usará para las multiplicaciones de matrices. Puede ser `"cutlass"` o `"pytorch"`. Si no se proporciona, se usará CUTLASS si está disponible y, en caso contrario, se usará PyTorch.

output_dtype (`str`, *opcional*, valor predeterminado `"bfloat16"`) : El tipo de datos a utilizar para la salida de la capa. Puede ser `"bfloat16"` o `"float16"`.

quantize_backend (`str`, *opcional*) : El backend que se usará para la cuantización. Puede ser `"cuda"`, `"triton"` o `"pytorch"`. Si no se especifica, se seleccionará el backend más rápido en función de su entorno y de las opciones que cada backend admite. Por lo general, `"cuda"` se usará para la inferencia, `"triton"` se usará para el entrenamiento y `"pytorch"` se usará en dispositivos que no sean de CUDA.

scale_rule (`str`, por defecto "mse", *opcional*, por defecto `"mse"`) : Regla a utilizar al seleccionar las escalas de bloque. Puede ser `"mse"`, `"mae"` o `"abs_max"` para Four Over Six, `"static_6"` para la cuantización NVFP4 predeterminada, o `"static_4"` para escalar todos los bloques a un valor máximo de 4.

weight_dtype (`str`, *opcional*) : Tipo de datos a utilizar al cuantizar los tensores de pesos. Si no se proporciona, se utiliza `dtype`.

weight_scale_2d (`bool`, por defecto False, *opcional*, por defecto `False`) : Si se deben calcular los factores de escala en los tensores de pesos en bloques 2D. Esto debe hacerse durante el entrenamiento.

weight_scale_rule (`str`, *opcional*) : Regla de escalado a utilizar al seleccionar una escala para los bloques en los tensores de pesos. Si no se proporciona, se utiliza `scale_rule`.

module_config_overrides (`dict[str, dict[str, Any]]`, *opcional*) : Un diccionario de configuraciones de reemplazo específicas de cada módulo. Las claves deben ser nombres de módulos y los valores deben ser diccionarios que contengan la configuración de cuantización para ese módulo. Esto se puede usar para reemplazar la configuración predeterminada de módulos específicos.

modules_to_not_convert (`list[str]`, *opcional*, valor predeterminado `['lm_head']`) : La lista de módulos que se excluirán de la cuantización. De forma predeterminada, se excluye `lm_head`.

Esta es una clase envoltura que contiene todas las opciones para la cuantización con `fouroversix`. En resumen, Four Over Six es una modificación de la cuantización NVFP4 que escala de forma adaptativa el valor más grande en cada bloque de 16 valores FP4 a 4 o 6. Seleccionar una escala de 6 utiliza todo el rango de valores FP4, pero seleccionar una escala de 4 permite una distribución más uniforme del error de cuantización. Consulte la publicación original para más detalles: 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)
```

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

**Parámetros:**

forward_dtype (`str`, *opcional*, valor predeterminado `"nvfp4"`) : El dtype a utilizar para la pasada hacia adelante.

forward_method (`str`, *opcional*, valor predeterminado `"abs_max"`) : La escalada a utilizar en la pasada hacia adelante. Puede ser `"abs_max"` o `"quest"`. `"abs_max"` es mejor para PTQ, `"quest"` es mejor para QAT.

backward_dtype (`str`, *opcional*, valor predeterminado `"bf16"`) : El dtype que se usará para la propagación hacia atrás.

store_master_weights (`bool`, *opcional*, valor predeterminado `False`) : Si se deben almacenar los pesos maestros. Necesario para QAT sobre los pesos de las capas.

hadamard_group_size (`int`, *opcional*) : El tamaño de grupo para la transformación de hadamard antes de la cuantización para `"quest"` coincide con el tamaño de grupo de MXFP4 (32). Si es `None`, se establecerá en 16 para `"nvfp4"` y en 32 para `"mxfp4"`.

pseudoquantization (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar la pseudo-cuantización basada en Triton. Es obligatorio para GPUs que no sean Blackwell. No ofrece ninguna mejora de velocidad. Para fines de depuración.

transform_init (`str`, *opcional*, valor predeterminado `"hadamard"`) : un método para inicializar la matriz de preprocesamiento. Puede ser `"hadamard"`, `"identity"` o `"gsr"`.

modules_to_not_convert (`list`, *opcional*) : La lista de módulos que no se deben cuantizar, útil para cuantizar modelos que requieren explícitamente que algunos módulos se mantengan en su precisión original.

FPQuantConfig es una clase de configuración para la cuantización mediante el método FPQuant.

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

```python
post_init()
```

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

Comprobador de seguridad que verifica que los argumentos sean correctos; también reemplaza algunos argumentos de tipo NoneType con sus valores predeterminados.

## AutoRoundConfig[[transformers.AutoRoundConfig]]

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

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

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

**Parámetros:**

bits (`int`, *opcional*, valor predeterminado: 4) : El número de bits a los que cuantizar; los valores admitidos son (2, 3, 4, 5, 6, 7, 8).

group_size (`int`, *opcional*, valor predeterminado 128) : Valor de group-size

sym (`bool`, *opcional*, valor predeterminado `True`) : Cuantización simétrica o no

backend (`str`, *opcional*, valor predeterminado `"auto"`) : El backend de inferencia. De forma predeterminada, AutoRound selecciona un backend compatible en función del dispositivo, la configuración de cuantización y las bibliotecas instaladas. Consulte [Especificar el backend de inferencia](https://github.com/intel/auto-round/blob/main/docs/step_by_step.md#specify-inference-backend) para ver todas las opciones de backend.

Esta es una clase envoltorio sobre todos los atributos y funciones posibles con los que puedes trabajar un modelo que se ha cargado con cuantización AutoRound.

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

```python
post_init()
```

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

Verificador de seguridad que los argumentos son correctos.

## 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)
```

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

**Parámetros:**

nbits (`int`, por defecto 4) : Bits de cuantización para los pesos.

group_size (`int`, predeterminado 64) : Tamaño de grupo utilizado en la cuantización de pesos SINQ (debe ser múltiplo de 8).

tiling_mode (`str`, predeterminado "1D") : Modo de tiling para SINQ (típicamente "1D"; "2D" si tu backend lo soporta).

method (`str`, por defecto "sinq") : "sinq" – SINQ solo de pesos sin calibración "asinq" – A-SINQ (con conciencia de activación), no compatible con Hugging Face. Consulte el repositorio oficial de SINQ.

modules_to_not_convert (`list[str]`, *opcional*) : Lista de nombres/prefijos de módulos que se deben mantener en precisión completa.

- ****kwargs** : Argumentos adicionales del usuario (se conservan en `_extra_kwargs` para el viaje de ida y vuelta).

Configuración de cuantización para SINQ / A-SINQ.

Pásalo a:

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)
```

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

**Parámetros:**

gguf_file (`str`, *opcional*) : ruta al archivo `.gguf` que contiene los pesos. Puede omitirse si se especifica mediante `from_pretrained(..., gguf_file=...)`, que lo completa.

dequantize (`bool`, *opcional*, valor predeterminado `False`) : En su lugar, descomprime cada peso en el momento de la carga en un modelo denso normal. Siempre es correcto, pero renuncia al ahorro de memoria; este también es el mecanismo de respaldo automático cuando no hay un kernel de matmul disponible para los tipos de cuantización del archivo.

Cargue un punto de control GGUF cuantizado con sus pesos en bloques GGUF.