Hugging Face's logo

Diffusers documentation

Cuantización

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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.

Aprende a cuantizar modelos en la guía de Cuantización.

PipelineQuantizationConfig

clase diffusers.PipelineQuantizationConfig

< >

( quant_backend: str = Nonequant_kwargs: dict[str, str | float | int | dict] = Nonecomponents_to_quantize: list[str] | str | None = Nonequant_mapping: dict[str, DiffQuantConfigMixin | 'TransformersQuantConfigMixin'] = None )

Parámetros

  • quant_backend (str) — Backend de cuantización que se utilizará. Al usar esta opción, se asume 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 a utilizar 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().

BFLQuantizationConfig

clase diffusers.BFLQuantizationConfig

< >

( compute_dtype: 'torch.dtype' | None = None )

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 contienen la escala global de pesos y la escala de activaciones calibrada (el diseño NVFP4 de ModelOpt).

BitsAndBytesConfig

clase diffusers.BitsAndBytesConfig

< >

( load_in_8bit = Falseload_in_4bit = Falsellm_int8_threshold = 6.0llm_int8_skip_modules = Nonellm_int8_enable_fp32_cpu_offload = Falsellm_int8_has_fp16_weight = Falsebnb_4bit_compute_dtype = Nonebnb_4bit_quant_type = 'fp4'bnb_4bit_use_double_quant = Falsebnb_4bit_quant_storage = None**kwargs )

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) — Corresponde al umbral de valores atípicos para la detección de outliers, 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 outlier 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 outliers sistemáticos excepcionales que están distribuidos de manera muy diferente en los modelos grandes. Estos outliers 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, fine-tuning).
  • 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 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 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 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) — Establece el tipo de cálculo, que puede ser diferente del 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 inicializar 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

< >

( )

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

post_init

< >

( )

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

quantization_method

< >

( )

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

< >

( ) → dict[str, Any]

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.

GGUFQuantizationConfig

clase diffusers.GGUFQuantizationConfig

< >

( compute_dtype: 'torch.dtype' | None = None )

Parámetros

  • compute_dtype — (torch.dtype, por defecto torch.float32): 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

clase diffusers.NunchakuLiteQuantizationConfig

< >

( compute_dtype: 'torch.dtype' | str | None = Nonesvdq_w4a4: dict[str, Any] | None = Noneawq_w4a16: dict[str, Any] | None = None**kwargs )

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 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:

{
  "_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

clase diffusers.QuantoConfig

< >

( weights_dtype: str = 'int8'modules_to_not_convert: list[str] | None = None**kwargs )

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 ha sido 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 admitidos, como BitsAndBytesConfig o 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

< >

( )

Verificador de seguridad que los argumentos son correctos

SDNQConfig

clase diffusers.SDNQConfig

< >

( *args**kwargs )

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) — Número de elementos de un tensor que 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 se 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

clase diffusers.TorchAoConfig

< >

( quant_type: 'AOBaseConfig'modules_to_not_convert: list[str] | None = None**kwargs )

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 para ver 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:

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

< >

( config_dictreturn_unused_kwargs = False**kwargs )

Crear una configuración a partir de un diccionario.

get_apply_tensor_subclass

< >

( )

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

to_dict

< >

( )

Convierte la configuración en un diccionario.

DiffusersQuantizer

clase diffusers.DiffusersQuantizer

< >

( quantization_config: QuantizationConfigMixin**kwargs )

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.

Atributos 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 de 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

< >

( max_memory: dict )

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

adjust_target_dtype

< >

( torch_dtype: torch.dtype )

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

< >

( model: ModelMixinparam_value: torch.Tensorparam_name: strstate_dict: dict**kwargs )

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

check_quantized_param_shape

< >

( *args**kwargs )

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

create_quantized_param

< >

( *args**kwargs )

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

dequantize

< >

( model )

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

< >

( )

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

< >

( modeltorch_dtype: torch.dtype )

Parámetros

  • model (~diffusers.models.modeling_utils.ModelMixin) — El modelo que se va 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

< >

( model: ModelMixin**kwargs )

Parámetros

  • model (~diffusers.models.modeling_utils.ModelMixin) — 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

< >

( model: ModelMixin**kwargs )

Parámetros

  • model (~diffusers.models.modeling_utils.ModelMixin) — El modelo que se va a cuantizar
  • kwargs (dict, opcional) — Los argumentos de palabra clave que se pasan a _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

< >

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

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

< >

( modelmissing_keys: listprefix: str )

Parámetros

  • missing_keys (list[str], opcional) — La lista de claves que faltan en el punto de control en comparación con el state dict del modelo

Sobrescribe este método si deseas ajustar missing_keys.

update_torch_dtype

< >

( torch_dtype: torch.dtype )

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 quieres asegurarte de que se preserve ese comportamiento

validate_environment

< >

( *args**kwargs )

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.

Update on GitHub

←Salidas Inferencia remota→