# 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 la memoria y acelerar la inferencia.

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

## PipelineQuantizationConfig[[diffusers.PipelineQuantizationConfig]]

#### diffusers.PipelineQuantizationConfig[[diffusers.PipelineQuantizationConfig]]

```python
diffusers.PipelineQuantizationConfig(quant_backend: str = None, quant_kwargs: dict[str, str | float | int | dict] = None, components_to_quantize: list[str] | str | None = None, quant_mapping: dict[str, DiffQuantConfigMixin | 'TransformersQuantConfigMixin'] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/pipe_quant_config.py#L34)

**Parámetros:**

quant_backend (`str`) : Backend de cuantización que se utilizará. Al usar esta opción, asumimos que el backend está disponible tanto para `diffusers` como para `transformers`.

quant_kwargs (`dict`) : Parámetros para inicializar la clase del backend de cuantización.

components_to_quantize (`list`) : Componentes de un pipeline que se van a cuantizar.

quant_mapping (`dict`) : Mapeo que define las especificaciones de cuantización que se usarán para los componentes del pipeline. Al usar este argumento, no se espera que los usuarios proporcionen `quant_backend`, `quant_kawargs` y `components_to_quantize`.

Clase de configuración que se utiliza al aplicar cuantización sobre la marcha en [from_pretrained()](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained).

## BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]

#### diffusers.BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]

```python
diffusers.BFLQuantizationConfig(compute_dtype: 'torch.dtype' | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L427)

**Parámetros:**

compute_dtype (`torch.dtype`, por defecto `torch.bfloat16`) : El dtype de las activaciones y de las capas no cuantizadas. Los dispositivos sin kernels fusionados de FP8 o NVFP4 descuantizan los pesos a este dtype en cada pasada hacia adelante.

Config para cargar puntos de control cuantizados con los esquemas `fp8r` y `nvfp4` de Black Forest Labs.

Ambos esquemas se leen desde el punto de control a través de `~FromSingleFileMixin.from_single_file`; no se admite la cuantización de un modelo sobre la marcha. Una capa lineal se cuantiza cuando su peso viene acompañado de tensores de escala:

- `fp8r`: `weight` es `float8_e4m3fn` con forma `[N, K]` y `weight_scale` es una escala fp32 por fila `[N]`.
- `nvfp4`: `weight` es `uint8` con forma `[N, K/2]` (dos valores E2M1 por byte), `weight_scale` es una escala de bloque `float8_e4m3fn` `[N, K/16]`, y `weight_scale_2` y `input_scale` son escalares fp32 que almacenan la escala global de pesos y la escala de activaciones calibrada (el layout NVFP4 de ModelOpt).

## BitsAndBytesConfig[[diffusers.BitsAndBytesConfig]]

#### diffusers.BitsAndBytesConfig[[diffusers.BitsAndBytesConfig]]

```python
diffusers.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/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L171)

**Parámetros:**

load_in_8bit (`bool`, *opcional*, por defecto `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) : Esto 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 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 de los valores están en el rango [-3.5, 3.5], pero existen algunos atípicos sistemáticos excepcionales que están distribuidos de manera muy diferente en los modelos grandes. Estos atípicos suelen estar en el intervalo [-60, -6] o [6, 60]. La cuantización Int8 funciona bien para valores de magnitud ~5, pero más allá de eso, hay un penalización significativa en el rendimiento. Un buen umbral predeterminado es 6, pero 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, para los modelos `CausalLM`, la última `lm_head` se suele mantener 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 partes 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*, por defecto `"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*, por defecto `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`.

Esto reemplaza a `load_in_8bit` o `load_in_4bit`, por lo que ambas opciones son mutuamente excluyentes.

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[[diffusers.BitsAndBytesConfig.is_quantizable]]

```python
is_quantizable()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L343)

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

#### post_init[[diffusers.BitsAndBytesConfig.post_init]]

```python
post_init()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L313)

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

#### quantization_method[[diffusers.BitsAndBytesConfig.quantization_method]]

```python
quantization_method()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L349)

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[[diffusers.BitsAndBytesConfig.to_diff_dict]]

```python
to_diff_dict()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L380)

**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 serializa a un diccionario de Python.

## GGUFQuantizationConfig[[diffusers.GGUFQuantizationConfig]]

#### diffusers.GGUFQuantizationConfig[[diffusers.GGUFQuantizationConfig]]

```python
diffusers.GGUFQuantizationConfig(compute_dtype: 'torch.dtype' | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L404)

**Parámetros:**

compute_dtype : (`torch.dtype`, por defecto `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.

Esta es una clase de configuración para técnicas de cuantización GGUF.

## NunchakuLiteQuantizationConfig[[diffusers.NunchakuLiteQuantizationConfig]]

#### diffusers.NunchakuLiteQuantizationConfig[[diffusers.NunchakuLiteQuantizationConfig]]

```python
diffusers.NunchakuLiteQuantizationConfig(compute_dtype: 'torch.dtype' | str | None = None, svdq_w4a4: dict[str, Any] | None = None, awq_w4a16: dict[str, Any] | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L451)

**Parámetros:**

compute_dtype (`torch.dtype`, por defecto `torch.bfloat16`) : dtype de tiempo de ejecución utilizado por los búferes de punto flotante en los módulos cuantizados.

svdq_w4a4 (`dict`, *opcional*) : Configuración explícita de destino SVDQ W4A4 con `precision`, `group_size`, `rank` y `targets`.

awq_w4a16 (`dict`, *opcional*) : Configuración explícita de destino AWQ W4A16 con `precision`, `group_size` y `targets`.

Configuración para cargar puntos de control de Nunchaku Lite.

El soporte de Nunchaku Lite en Diffusers carga puntos de control precuantizados. Para crear un punto de control compatible, use [`diffuse-compressor`](https://github.com/rootonchair/diffuse-compressor) para elegir o adaptar una configuración objetivo para la arquitectura del modelo, cuantizar y exportar el transformer, y empaquetarlo como un pipeline de Diffusers con la compacta `quantization_config` almacenada en `config.json`.

El state dict exportado debe coincidir exactamente con la arquitectura del modelo Diffusers de destino. Los checkpoints cuantizados con proyecciones QKV fusionadas no se cargarán en una configuración de modelo que espere módulos de proyección Q, K y V separados.

Ejemplo de configuración compacta de `config.json`:

```json
{
  "_class_name": "ErnieImageTransformer2DModel",
  "quantization_config": {
    "quant_method": "nunchaku_lite",
    "compute_dtype": "bfloat16",
    "svdq_w4a4": {
      "precision": "nvfp4",
      "group_size": 16,
      "rank": 32,
      "targets": ["layers.0.self_attention.to_q"]
    },
    "awq_w4a16": {
      "precision": "int4",
      "group_size": 64,
      "targets": ["final_linear"]
    }
  }
}
```

## QuantoConfig[[diffusers.QuantoConfig]]

#### diffusers.QuantoConfig[[diffusers.QuantoConfig]]

```python
diffusers.QuantoConfig(weights_dtype: str = 'int8', modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L669)

**Parámetros:**

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

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

`QuantoConfig` está obsoleto y se eliminará en la versión 1.0.0. Considere cambiar a uno de los otros backends de cuantización compatibles, como [BitsAndBytesConfig](/docs/diffusers/v0.43.0/es/api/quantization#diffusers.BitsAndBytesConfig) o [TorchAoConfig](/docs/diffusers/v0.43.0/es/api/quantization#diffusers.TorchAoConfig).

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

#### post_init[[diffusers.QuantoConfig.post_init]]

```python
post_init()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L703)

Verificador de seguridad que los argumentos son correctos

## SDNQConfig[[diffusers.SDNQConfig]]

#### diffusers.SDNQConfig[[diffusers.SDNQConfig]]

```python
diffusers.SDNQConfig(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L981)

**Parámetros:**

weights_dtype (`str`, *opcional*, valor predeterminado `"int8"`) : El dtype objetivo para los pesos después de la cuantización, p. ej. `"int8"`, `"uint4"`, `"float8_e4m3fn"`. Consulte `sdnq.common.accepted_weight_dtypes` para todos los valores admitidos.

group_size (`int`, *opcional*, valor predeterminado `0`) : Cuántos elementos de un tensor comparten el mismo grupo de cuantización. `0` selecciona automáticamente en función de `weights_dtype`, `-1` deshabilita el agrupamiento y utiliza la cuantización por fila.

use_svd (`bool`, *opcional*, valor predeterminado `False`) : Si se aplica el algoritmo SVDQuant sobre la cuantización SDNQ.

use_quantized_matmul (`bool`, *opcional*, valor predeterminado `False`) : Si se debe usar matmul cuantizado INT8 / FP8 / FP16 en la pasada hacia adelante en lugar de BF16 / FP16.

modules_to_not_convert (`list`, *opcional*, valor predeterminado `None`) : La lista de módulos que se omitirán durante la cuantización.

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se reenvían a `sdnq.SDNQConfig` (p. ej. `quantized_matmul_dtype`, `svd_rank`, `use_hadamard`, `quant_conv`, `quant_embedding`, `modules_dtype_dict`).

Clase de configuración para SDNQ (SD.Next Quantization).

La biblioteca `sdnq` incluye su propia configuración y cuantizador compatibles con diffusers; esta clase es una fábrica delgada que delega en ellos para que los puntos de control con `quant_method="sdnq"` se carguen de forma nativa con diffusers. Todos los argumentos se reenvían a `sdnq.SDNQConfig`. Requiere la biblioteca `sdnq`: `pip install sdnq`.

Referencia: https://github.com/Disty0/sdnq

## TorchAoConfig[[diffusers.TorchAoConfig]]

#### diffusers.TorchAoConfig[[diffusers.TorchAoConfig]]

```python
diffusers.TorchAoConfig(quant_type: 'AOBaseConfig', modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L572)

**Parámetros:**

quant_type (`AOBaseConfig`) : Una instancia de una subclase de `AOBaseConfig` que especifica el tipo de cuantización. Consulte la [documentación de torchao](https://docs.pytorch.org/ao/main/api_ref_quantization.html#inference-apis-for-quantize) para las clases de configuración disponibles (p. ej. `Int4WeightOnlyConfig`, `Int8WeightOnlyConfig`, `Float8WeightOnlyConfig`, `Float8DynamicActivationFloat8WeightConfig`, etc.).

modules_to_not_convert (`list[str]`, *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 de configuración para técnicas de cuantización/escasez de torchao.

Ejemplo:
```python
from diffusers import FluxTransformer2DModel, TorchAoConfig
from torchao.quantization import Int8WeightOnlyConfig

quantization_config = TorchAoConfig(Int8WeightOnlyConfig())
transformer = FluxTransformer2DModel.from_pretrained(
    "black-forest-labs/Flux.1-Dev",
    subfolder="transformer",
    quantization_config=quantization_config,
    torch_dtype=torch.bfloat16,
)
```

#### from_dict[[diffusers.TorchAoConfig.from_dict]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L637)

Crear una configuración a partir de un diccionario.

#### get_apply_tensor_subclass[[diffusers.TorchAoConfig.get_apply_tensor_subclass]]

```python
get_apply_tensor_subclass()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L659)

Cree el método de cuantización apropiado en función de la configuración.

#### to_dict[[diffusers.TorchAoConfig.to_dict]]

```python
to_dict()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L623)

Convierte la configuración en un diccionario.

## DiffusersQuantizer[[diffusers.DiffusersQuantizer]]

#### diffusers.DiffusersQuantizer[[diffusers.DiffusersQuantizer]]

```python
diffusers.DiffusersQuantizer(quantization_config: QuantizationConfigMixin, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L34)

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

Attributes quantization_config (`diffusers.quantizers.quantization_config.QuantizationConfigMixin`): La configuración de cuantización que define los parámetros de cuantización de tu modelo que deseas cuantizar. modules_to_not_convert (`list[str]`, *opcional*): La lista de nombres de módulos que no se deben convertir al cuantizar el modelo. required_packages (`list[str]`, *opcional*): La lista de paquetes pip requeridos para instalar antes de usar el cuantizador requires_calibration (`bool`): Si el método de cuantización requiere calibrar el modelo antes de usarlo.

#### adjust_max_memory[[diffusers.DiffusersQuantizer.adjust_max_memory]]

```python
adjust_max_memory(max_memory: dict[str, int | str])
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L133)

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

#### adjust_target_dtype[[diffusers.DiffusersQuantizer.adjust_target_dtype]]

```python
adjust_target_dtype(torch_dtype: torch.dtype)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L91)

**Parámetros:**

torch_dtype (`torch.dtype`, *opcional*) : El torch_dtype que se utiliza para calcular el device_map.

Sobrescriba este método si desea ajustar la variable `target_dtype` utilizada en `from_pretrained` para calcular el device_map en caso de que el device_map sea un `str`. Por ejemplo, para bitsandbytes forzamos la configuración de `target_dtype` a `torch.int8` y para 4 bits pasamos un enum personalizado `accelerate.CustomDtype.int4`.

#### check_if_quantized_param[[diffusers.DiffusersQuantizer.check_if_quantized_param]]

```python
check_if_quantized_param(model: ModelMixin, param_value: torch.Tensor, param_name: str, state_dict: dict[str, typing.Any], **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L137)

verifica si un componente de state_dict cargado forma parte de un parámetro cuantizado + algunas validaciones; solo está definido para los métodos de cuantización que requieren crear nuevos parámetros para la cuantización.

#### check_quantized_param_shape[[diffusers.DiffusersQuantizer.check_quantized_param_shape]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L157)

verifica si el parámetro cuantizado tiene la forma esperada.

#### create_quantized_param[[diffusers.DiffusersQuantizer.create_quantized_param]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L151)

toma los componentes necesarios de state_dict y crea el parámetro cuantizado.

#### dequantize[[diffusers.DiffusersQuantizer.dequantize]]

```python
dequantize(model)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L219)

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

#### get_cuda_warm_up_factor[[diffusers.DiffusersQuantizer.get_cuda_warm_up_factor]]

```python
get_cuda_warm_up_factor()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L232)

El factor que se utilizará en `caching_allocator_warmup` para obtener el número de bytes que se preasignarán para calentar cuda. Un factor de 2 significa que se asignan todos los bytes del modelo vacío (ya que se asigna en fp16), un factor de 4 significa que se asigna la mitad de la memoria de los pesos que residen en el modelo vacío, etc...

#### get_special_dtypes_update[[diffusers.DiffusersQuantizer.get_special_dtypes_update]]

```python
get_special_dtypes_update(model, torch_dtype: torch.dtype)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L113)

**Parámetros:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : El modelo a cuantizar

torch_dtype (`torch.dtype`) : El dtype pasado en el método `from_pretrained`.

devuelve los dtypes de los módulos que no están cuantizados; se utiliza para el cálculo de device_map en caso de que se pase un str como device_map. El método utilizará `modules_to_not_convert`, que se modifica en `_process_model_before_weight_loading`. Los modelos de `diffusers` aún no tienen ningún atributo `modules_to_not_convert`, pero esto podría cambiar pronto en el futuro.

#### postprocess_model[[diffusers.DiffusersQuantizer.postprocess_model]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L206)

**Parámetros:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : El modelo 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[[diffusers.DiffusersQuantizer.preprocess_model]]

```python
preprocess_model(model: ModelMixin, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L190)

**Parámetros:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : El modelo 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`.

#### update_device_map[[diffusers.DiffusersQuantizer.update_device_map]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L79)

**Parámetros:**

device_map (`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 device_map, el device_map se establece en `"auto"``

#### update_missing_keys[[diffusers.DiffusersQuantizer.update_missing_keys]]

```python
update_missing_keys(model, missing_keys: list[str], prefix: str)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L103)

**Parámetros:**

missing_keys (`list[str]`, *opcional*) : La lista de claves ausentes en el punto de control en comparación con el diccionario de estado del modelo

Sobrescribe este método si deseas ajustar `missing_keys`.

#### update_torch_dtype[[diffusers.DiffusersQuantizer.update_torch_dtype]]

```python
update_torch_dtype(torch_dtype: torch.dtype)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L68)

**Parámetros:**

torch_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

#### validate_environment[[diffusers.DiffusersQuantizer.validate_environment]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L163)

Este método se utiliza para verificar posibles conflictos con los argumentos que se pasan en `from_pretrained`. Debes definirlo para todos los cuantificadores futuros que se integren con diffusers. Si no se necesita una comprobación explícita, simplemente no devuelvas nada.