# Exportadores

Se pueden agregar nuevos backends de exportación a Transformers mediante la herencia de `HfExporter`.

Aprende a usar los exportadores integrados en la guía [Exporters](../exporters).

## AutoHfExporter[[transformers.exporters.AutoHfExporter]]

#### transformers.exporters.AutoHfExporter[[transformers.exporters.AutoHfExporter]]

```python
transformers.exporters.AutoHfExporter()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/auto.py#L93)

La clase exportadora Auto-HF que se encarga de instanciar automáticamente el `HfExporter` correcto a partir de la `ExportConfig`.

#### from_pretrained[[transformers.exporters.AutoHfExporter.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/auto.py#L113)

Cargue una instancia de exportador desde un modelo/punto de control preentrenado que incluye una configuración de exportación.

**Aún no implementado** — marcador de posición para un flujo de trabajo de "receta de exportación" de primera clase.

La idea: los propietarios de los modelos publican un `export_config.json` (o un campo `export_config` en `config.json`) junto a sus pesos en el Hub. Ese archivo recoge la configuración que el propietario ya ha validado para su arquitectura: el formato de destino (`dynamo` / `onnx` / `executorch`), las especificaciones exactas de las formas dinámicas (p. ej. `text_ids` dinámico hasta 4096, mosaicos de imagen fijos en 448, `batch=1` para despliegue en el borde), la bandera `strict`, el opset de ONNX, el diseño de prefill frente a decode, la elección del backend de ExecuTorch y cualquier otro parámetro que hoy en día se transmite como conocimiento tácito en un README o en un cuaderno privado.

Los consumidores obtienen la exportación validada por el propietario en una sola llamada:

```python
exporter = AutoHfExporter.from_pretrained("org/model-name")
program = exporter.export(model, inputs)
```

        Se compone con el registro [*register_export_input_preparer*]: el propietario proporciona la especificación de forma mediante `export_config.json`, mientras que transformers proporciona las precomputaciones dependientes de los datos (`cu_seqlens`, ids de posición de visión, índices de ventana, …) para esa arquitectura. Juntas, cubren las dos partes difíciles de exportar nuevos modelos: conocer el contrato de forma correcto y preparar las entradas adecuadas, de modo que los usuarios aguas abajo no tengan que derivar ninguno de los dos desde cero (y no se rompan en producción si lo hacen mal).

#### supports_export_format[[transformers.exporters.AutoHfExporter.supports_export_format]]

```python
supports_export_format(export_config_dict: dict)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/auto.py#L145)

Devuelve True si el dict proporcionado describe un `export_format` que cuenta con una clase de configuración registrada y una clase de exportador registrada. Emite una advertencia con un mensaje accionable cuando el formato está completamente ausente, es desconocido o solo está registrado a medias.

## AutoExportConfig[[transformers.exporters.AutoExportConfig]]

#### transformers.exporters.AutoExportConfig[[transformers.exporters.AutoExportConfig]]

```python
transformers.exporters.AutoExportConfig()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/auto.py#L65)

La clase de configuración de exportación Auto-HF que se encarga de enrutar automáticamente a la configuración de exportación correcta a partir de una configuración de exportación almacenada en un diccionario.

## HfExporter[[transformers.exporters.HfExporter]]

#### transformers.exporters.HfExporter[[transformers.exporters.HfExporter]]

```python
transformers.exporters.HfExporter()
```

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

Clase base abstracta para todos los exportadores de Transformers.

Subclase e implementa `~HfExporter.export` para añadir un nuevo backend de exportación.

#### export[[transformers.exporters.HfExporter.export]]

```python
export(model: PreTrainedModel, sample_inputs: MutableMapping[str, torch.Tensor | Cache], config: ExportConfigMixin)
```

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

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel)): El modelo a exportar.

sample_inputs (`dict[str, torch.Tensor | Cache]`) : **Forward** kwargs — lo que pasarías a `model(**sample_inputs)`. Se usan directamente como entradas de ejemplo durante el trazado. Para una exportación de un paso de decodificación autoregresivo, esto significa que debes incluir `past_key_values`, `cache_position`, etc. Si solo tienes entradas de estilo generación, usa `~HfExporter.export_for_generation` en su lugar: ejecuta `model.generate` por ti y exporta cada etapa.

config (`ExportConfigMixin`) : Configuración específica del backend.

**Devuelve:**

Artefacto de exportación específico del backend.

Exporta el modelo y devuelve el objeto de programa específico del backend.

#### export_for_generation[[transformers.exporters.HfExporter.export_for_generation]]

```python
export_for_generation(model: PreTrainedModel, sample_inputs: MutableMapping[str, torch.Tensor | Cache], config: ExportConfigMixin | dict[str, ExportConfigMixin], generation_config: GenerationConfig | None = None, multi_token_decode: bool = False)
```

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

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel)): el modelo generativo a exportar. Debe admitir `model.generate(**sample_inputs)`.

sample_inputs (`dict[str, torch.Tensor | Cache]`) : argumentos de **Generate** — lo que se pasaría a `model.generate(**sample_inputs)` (normalmente `input_ids` + `attention_mask`, además de cualquier entrada de modalidad como `pixel_values` / `input_features` para modelos multimodales). Los argumentos de forward por etapa se capturan internamente.

config (`ExportConfigMixin` o `dict[str, ExportConfigMixin]`) : Configuración específica del backend. Pasa una única configuración para aplicarla a todos los componentes, o un `dict` con claves por nombre de componente (p. ej. `"image_encoder"`, `"language_model"`, `"lm_head"`, `"decode"`) para sobrescribir la configuración por componente; todos los nombres de componentes deben estar presentes en el dict.

generation_config ([GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig), *opcional*) : Se reenvía a la captura de `generate()` (por defecto, la del propio modelo). Pasa una con `cache_implementation="static"` para exportar contra un `StaticCache` de tamaño fijo.

multi_token_decode (`bool`, *opcional*, valor predeterminado `False`) : Indica si el componente `decode` procesa varios tokens de consulta a la vez (un eje de consulta dinámico, prefill en una caché vacía o continuación desde el pasado, según el caso) frente al paso clásico de un solo token (ver [decompose_for_generation()](/docs/transformers/main/es/main_classes/exporters#transformers.exporters.utils.decompose_for_generation)). Solo se mantiene dinámico en una exportación con forma dinámica (`config.dynamic=True`).

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

`{component_name: backend_specific_artifact}` — las mismas claves que [decompose_for_generation()](/docs/transformers/main/es/main_classes/exporters#transformers.exporters.utils.decompose_for_generation). Los valores son lo que devuelve `~HfExporter.export` para el backend concreto (`ExportedProgram`, `ONNXProgram`, `ExecutorchProgramManager`).

Descomponga un modelo generativo y exporte cada componente de forma independiente.

Envoltura fina alrededor de [decompose_for_generation()](/docs/transformers/main/es/main_classes/exporters#transformers.exporters.utils.decompose_for_generation) que llama a `~HfExporter.export` en cada par `(submodel, forward_inputs)` devuelto. Si necesitas los pares intermedios `(submodel, forward_inputs)` (para verificación, entradas personalizadas, omitir una etapa, …), llama directamente a [decompose_for_generation()](/docs/transformers/main/es/main_classes/exporters#transformers.exporters.utils.decompose_for_generation).

#### validate_environment[[transformers.exporters.HfExporter.validate_environment]]

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

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

Comprueba que `required_packages` están instalados y emite una advertencia si hay una desviación de versión respecto a `tested_versions`.

## DynamoExporter[[transformers.exporters.DynamoExporter]]

#### transformers.exporters.DynamoExporter[[transformers.exporters.DynamoExporter]]

```python
transformers.exporters.DynamoExporter()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_dynamo.py#L69)

Exportador que convierte un [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel) en un `ExportedProgram`.

Ejemplo:

```python
>>> from transformers.exporters.exporter_dynamo import DynamoExporter, DynamoConfig

>>> exporter = DynamoExporter()
>>> exported = exporter.export(model, inputs, config=DynamoConfig(dynamic=True))
>>> outputs = exported.module()(**inputs)
```

#### export[[transformers.exporters.DynamoExporter.export]]

```python
export(model: PreTrainedModel, sample_inputs: MutableMapping[str, Any], config: DynamoConfig | dict[str, Any])
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_dynamo.py#L87)

## OnnxExporter[[transformers.exporters.OnnxExporter]]

#### transformers.exporters.OnnxExporter[[transformers.exporters.OnnxExporter]]

```python
transformers.exporters.OnnxExporter()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_onnx.py#L108)

Exportador que convierte un [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel) en un `ONNXProgram` de ONNX.

Ejemplo:

```python
>>> from transformers.exporters.exporter_onnx import OnnxExporter, OnnxConfig

>>> exporter = OnnxExporter()
>>> onnx_program = exporter.export(model, inputs, config=OnnxConfig(dynamic=True))
>>> outputs = onnx_program(**inputs)  # run in-memory
>>> exporter.export(model, inputs, config=OnnxConfig(output_path="model.onnx"))  # save to disk
```

#### export[[transformers.exporters.OnnxExporter.export]]

```python
export(model: PreTrainedModel, sample_inputs: MutableMapping[str, Any], config: OnnxConfig | dict[str, Any])
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_onnx.py#L126)

## ExecutorchExporter[[transformers.exporters.ExecutorchExporter]]

#### transformers.exporters.ExecutorchExporter[[transformers.exporters.ExecutorchExporter]]

```python
transformers.exporters.ExecutorchExporter()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_executorch.py#L109)

Exportador que convierte un [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel) en un `ExecutorchProgramManager` de ExecuTorch.

Ejemplo:

```python
>>> from transformers.exporters.exporter_executorch import ExecutorchExporter, ExecutorchConfig

>>> exporter = ExecutorchExporter()
>>> et_program = exporter.export(model, inputs, config=ExecutorchConfig(backend="xnnpack"))
>>> et_program.write_to_file("model.pte")
```

#### export[[transformers.exporters.ExecutorchExporter.export]]

```python
export(model: PreTrainedModel, sample_inputs: MutableMapping[str, Any], config: ExecutorchConfig | dict[str, Any])
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_executorch.py#L126)

Exporta un modelo a ExecuTorch, aplicando la preparación del backend y parches de operaciones de torch.

## DynamoConfig[[transformers.exporters.DynamoConfig]]

#### transformers.exporters.DynamoConfig[[transformers.exporters.DynamoConfig]]

```python
transformers.exporters.DynamoConfig(export_format: ExportFormat = <ExportFormat.DYNAMO: 'dynamo'>, dynamic: bool = False, strict: bool = False, dynamic_shapes: dict[str, Any] | None = None, prefer_deferred_runtime_asserts_over_guards: bool = False, quantizer: ExportQuantizer | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/configs.py#L83)

**Parámetros:**

dynamic (*bool*, *opcional*, valor predeterminado *False*) : Indica si se debe exportar con formas dinámicas (simbólicas). Cuando *True* y *dynamic_shapes* no está establecido, todas las dimensiones de los tensores se configuran automáticamente en *Dim.AUTO*.

strict (*bool*, *opcional*, valor predeterminado *False*) : Si se habilita el modo estricto en *torch.export*. Ejecuta la trazada simbólica completa y detecta más errores, pero es más lento y tiene más probabilidades de fallar en modelos complejos.

dynamic_shapes (*dict[str, Any]*, *opcional*) : Especificaciones explícitas de forma dinámica por entrada que se pasan a *torch.export*. Tiene prioridad sobre *dynamic*.

prefer_deferred_runtime_asserts_over_guards (*bool*, *opcional*, valor predeterminado *False*) : Cuando *True*, las restricciones de forma dependientes de los datos se emiten como aserciones en tiempo de ejecución en el grafo exportado, en lugar de hacer que la exportación falle en el momento de la trazabilidad si una restricción no se cumple en todo el rango de formas simbólicas. La mayoría de los LLMs basados en transformers necesitan establecer esto en *True* al usar límites de `Dim(min=, max=)` de grano fino. No es necesario con `dynamic=True` / `Dim.AUTO`, donde `torch.export` infiere las relaciones de forma en lugar de verificarlas contra los límites declarados por el usuario.

quantizer ([*~exporters.quantizers.ExportQuantizer*], *opcional*) : Cuantización posterior al entrenamiento aplicada durante la exportación: [*~exporters.quantizers.PT2EQuantizer*] o [*~exporters.quantizers.NNCFTorchFXQuantizer*] en el grafo FX para cada backend, [*~exporters.quantizers.OnnxRuntimeQuantizer*] en el modelo ONNX convertido, o [*~exporters.quantizers.NNCFOpenVINOQuantizer*] / [*~exporters.quantizers.NNCFOnnxQuantizer*] en el modelo OpenVINO / ONNX convertido.

Clase de configuración para exportar modelos mediante *torch.export*.

## OnnxConfig[[transformers.exporters.OnnxConfig]]

#### transformers.exporters.OnnxConfig[[transformers.exporters.OnnxConfig]]

```python
transformers.exporters.OnnxConfig(export_format: ExportFormat = <ExportFormat.ONNX: 'onnx'>, dynamic: bool = False, strict: bool = False, dynamic_shapes: dict[str, Any] | None = None, prefer_deferred_runtime_asserts_over_guards: bool = False, quantizer: ExportQuantizer | None = None, output_path: str | PathLike | None = None, opset_version: int | None = None, external_data: bool = True, optimize: bool = True, export_params: bool = True, keep_initializers_as_inputs: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/configs.py#L125)

**Parámetros:**

output_path (`str` o `PathLike`, *opcional*) : Ruta de salida para el archivo `.onnx`. Cuando es `None` (valor predeterminado), el modelo exportado se mantiene en memoria como un `ONNXProgram` y no se escribe en el disco.

opset_version (`int`, *opcional*) : Versión del opset de ONNX a la que se dirige. Por defecto, es la última opset admitida por la versión de `onnxscript` instalada.

external_data (`bool`, *opcional*, valor predeterminado `True`) : Almacena los tensores de pesos grandes en un archivo lateral `.onnx_data` separado, en lugar de incrustarlos en el protobuf. Es obligatorio para modelos cuyos pesos superan el límite de protobuf de 2 GB.

optimize (`bool`, *opcional*, valor predeterminado `True`) : Ejecuta las pasadas de optimización de `onnxscript` (plegado de constantes, eliminación de código muerto, …) en el grafo exportado. Desactívalo para modelos que se encuentren con errores del optimizador de `onnxscript` de versiones anteriores.

export_params (`bool`, *opcional*, valor predeterminado `True`) : Incorpora los pesos del modelo en el grafo ONNX. Establezca `False` para exportar un grafo sin pesos (los pesos deben proporcionarse en tiempo de ejecución).

keep_initializers_as_inputs (`bool`, *opcional*, valor predeterminado `False`) : Expone los inicializadores de pesos como entradas explícitas del grafo. Es requerido por algunos runtimes de ONNX más antiguos (opset < 9).

Clase de configuración para exportar modelos a ONNX mediante `torch.onnx.export`.

Hereda todos los campos de `DynamoConfig` (`dynamic`, `strict`, `dynamic_shapes`, `prefer_deferred_runtime_asserts_over_guards`).

## ExecutorchConfig[[transformers.exporters.ExecutorchConfig]]

#### transformers.exporters.ExecutorchConfig[[transformers.exporters.ExecutorchConfig]]

```python
transformers.exporters.ExecutorchConfig(export_format: ExportFormat = <ExportFormat.EXECUTORCH: 'executorch'>, dynamic: bool = False, strict: bool = False, dynamic_shapes: dict[str, Any] | None = None, prefer_deferred_runtime_asserts_over_guards: bool = False, quantizer: ExportQuantizer | None = None, backend: str = 'xnnpack', alloc_graph_input: bool = True, alloc_graph_output: bool = True, alloc_mutable_buffers: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/configs.py#L167)

**Parámetros:**

backend (`str`, *opcional*, valor predeterminado `"xnnpack"`) : Backend de ExecuTorch de destino. Valores admitidos:  - `"xnnpack"` — Inferencia en CPU mediante la biblioteca XNNPACK (predeterminado; se ejecuta en cualquier lugar). - `"cuda"` — Inferencia en GPU mediante el backend CUDA de ExecuTorch. - `"mlx"` — Inferencia en GPU mediante el backend MLX de ExecuTorch en Apple Silicon.

alloc_graph_input (`bool`, *opcional*, valor predeterminado `True`) : Indica si la pasada de planificación de memoria reserva memoria de arena para las entradas del grafo. Cuando es `False`, el tiempo de ejecución utiliza directamente los búferes de entrada proporcionados por el llamador en lugar de copiarlos en la arena, de modo que una `USER_INPUT_MUTATION` in situ (por ejemplo, una escritura en `StaticCache`) se aplica al tensor del llamador y no a una copia en la arena.

alloc_graph_output (`bool`, *opcional*, valor predeterminado `True`) : Indica si la pasada de planificación de memoria reserva memoria de arena para las salidas del grafo. Cuando es `False`, el llamador debe vincular los búferes de salida en tiempo de ejecución (`Method::set_output_data_ptr`); vincular una salida al búfer de su entrada mutada evita el ciclo de copia de salida.

alloc_mutable_buffers (`bool`, *opcional*, valor predeterminado `True`) : Indica si la pasada de planificación de memoria reserva memoria de arena para búferes mutables (estado residente en el modelo). Se transmite a `MemoryPlanningPass`.

Clase de configuración para exportar modelos al formato ExecuTorch.

Hereda todos los campos de `DynamoConfig` (`dynamic`, `strict`, `dynamic_shapes`, `prefer_deferred_runtime_asserts_over_guards`).

## OpenVINOConfig[[transformers.exporters.OpenVINOConfig]]

#### transformers.exporters.OpenVINOConfig[[transformers.exporters.OpenVINOConfig]]

```python
transformers.exporters.OpenVINOConfig(export_format: ExportFormat = <ExportFormat.OPENVINO: 'openvino'>, dynamic: bool = False, strict: bool = False, dynamic_shapes: dict[str, Any] | None = None, prefer_deferred_runtime_asserts_over_guards: bool = False, quantizer: ExportQuantizer | None = None, output_path: str | PathLike | None = None, compress_to_fp16: bool = True, stateful: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/configs.py#L204)

**Parámetros:**

output_path (*str* o *PathLike*, *opcional*) : Ruta de salida para el archivo *.xml* (el archivo *.bin* correspondiente se escribe junto a él). Cuando es *None* (valor predeterminado), el modelo convertido se mantiene en memoria como un `openvino.Model`.

compress_to_fp16 (*bool*, *opcional*, valor predeterminado *True*) : Comprime los pesos de punto flotante a FP16 al guardar, lo que reduce a la mitad el tamaño en disco con un impacto despreciable en la precisión para la mayoría de los modelos. Solo se aplica cuando se establece `output_path`.

stateful (*bool*, *optional*, defaults to *True*) : Fold round-tripped state tensors (KV cache, SSM states, …) into internal OV variables (`ReadValue`/``Assign`). The runtime then carries state across `infer()` calls instead of marshalling cache tensors through inputs/outputs on every step, and a fused `beam_idx`` input reorders state in-graph for beam search. No-op for models without round-tripped state (encoders, prefill-only exports). Set it to *False* for targets that take no stateful model, such as the NPU plugin.

Clase de configuración para exportar modelos a OpenVINO IR mediante `openvino.convert_model`.

Hereda todos los campos de [*DynamoConfig*] (*dynamic*, *strict*, *dynamic_shapes*, *prefer_deferred_runtime_asserts_over_guards*).

## Cuantizadores[[transformers.exporters.ExportQuantizer]]

#### transformers.exporters.ExportQuantizer[[transformers.exporters.ExportQuantizer]]

```python
transformers.exporters.ExportQuantizer(calibration_dataset: Iterable[dict[str, Any]] | None = None)
```

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

**Parámetros:**

calibration_dataset (`Iterable[dict]`, *opcional*) : Diccionarios de entrada sobre los que el cuantizador realiza la calibración: una lista, o un `DataLoader` cuyos lotes se combinan en entradas del modelo. Para `~HfExporter.export_for_generation`, son los argumentos de generate, capturados en un conjunto de calibración por componente. Cuando es `None`, un cuantizador que necesita datos se calibra con las propias entradas de muestra de la exportación, emitiendo una advertencia.

Clase base para cuantificadores de pos-entrenamiento aplicados durante la exportación.

Un cuantizador declara los formatos de exportación que admite y los paquetes que necesita (con las versiones en las que se ha probado, al igual que los exportadores), y si cuantiza el grafo FX de `torch.export` antes de cualquier conversión (de modo que cada backend tome el resultado) o el modelo en el que un backend lo convierte (`onnx_ir.Model`, `openvino.Model`). El exportador lo valida contra la exportación de antemano y luego llama a `~ExportQuantizer.quantize` con ese modelo y las entradas de ejemplo de la exportación. Subclásalo e implementa `quantize` para añadir un nuevo método de cuantización; un `CalibrationSet` mapea las muestras de calibración a las propias entradas del modelo.

#### quantize[[transformers.exporters.ExportQuantizer.quantize]]

```python
quantize(model: Any, sample_inputs: dict[str, Any], export_format: ExportFormat)
```

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

Cuantiza `model` (el grafo FX si `quantizes_fx_graph`, en caso contrario, el modelo del backend) y devuelve el resultado, calibrado con `calibration_dataset` o, si no lo hay, con `sample_inputs` de la exportación.

#### validate_environment[[transformers.exporters.ExportQuantizer.validate_environment]]

```python
validate_environment(export_format: ExportFormat)
```

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

Lanza una excepción si este cuantizador no puede ejecutarse en una exportación de `export_format`, o si falta un paquete necesario o su versión es demasiado antigua; emite una advertencia cuando una versión difiere de la con la que se ha probado.

#### with_calibration[[transformers.exporters.ExportQuantizer.with_calibration]]

```python
with_calibration(calibration_dataset: Iterable[dict[str, Any]])
```

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

Una copia de este cuantizador que calibra en `calibration_dataset`.

#### transformers.exporters.quantizers.CalibrationSet[[transformers.exporters.quantizers.CalibrationSet]]

```python
transformers.exporters.quantizers.CalibrationSet(calibration_dataset: Iterable[dict[str, Any]] | None, sample_inputs: dict[str, Any], transform: Callable[[dict[str, Any]], Any])
```

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

Vista re-iterable de las muestras de calibración como entradas del modelo.

Las muestras son el `calibration_dataset` del cuantizador, o las propias `sample_inputs` de la exportación (con una advertencia, una vez que se leen) cuando no hay ninguna. Pueden ser cualquier mapeo, como un `BatchEncoding` de un tokenizador. `transform` mapea cada muestra de los argumentos de la llamada en adelante a lo que recibe el modelo cuantizado (argumentos trazados, entradas de ONNX, entradas de puertos de OpenVINO), de forma perezosa, una muestra a la vez, en cada pasada.

#### transformers.exporters.PT2EQuantizer[[transformers.exporters.PT2EQuantizer]]

```python
transformers.exporters.PT2EQuantizer(quantizer: Any, calibration_dataset: Iterable[dict[str, Any]] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_pt2e.py#L34)

**Parámetros:**

quantizer (`torchao.quantization.pt2e.quantizer.Quantizer`) : El cuantizador PT2E que anota el grafo. Sus operaciones de cuantizar/descuantizar deben ser las que el backend de destino admita: `X86InductorQuantizer` para inductor, ONNX (QDQ) o OpenVINO, `XNNPACKQuantizer` para ExecuTorch.

calibration_dataset (`Iterable[dict]`, *opcional*) : Diccionarios de entrada sobre los que los observadores realizan la calibración (ver `ExportQuantizer`), uno por cada paso de propagación hacia adelante. Para calibrar con lotes, pase un `DataLoader` que agrupe las muestras en diccionarios de entrada por lotes, en lugar de una lista de muestras individuales.

Cuantice el grafo FX con [cuantización de PyTorch 2 Export (PT2E)](https://docs.pytorch.org/ao/main/pt2e_quantization/index.html): `prepare_pt2e` inserta observadores, el conjunto de calibración los dirige y `convert_pt2e` los reemplaza con operaciones de cuantizar/des-cuantizar. Funciona con cada backend de exportación.

Ejemplo:

```python
>>> from torchao.quantization.pt2e.quantizer.x86_inductor_quantizer import (
...     X86InductorQuantizer,
...     get_default_x86_inductor_quantization_config,
... )
>>> from transformers.exporters import DynamoConfig, PT2EQuantizer

>>> x86 = X86InductorQuantizer().set_global(get_default_x86_inductor_quantization_config())
>>> DynamoConfig(quantizer=PT2EQuantizer(x86, calibration_dataset=samples))
```

#### transformers.exporters.OnnxRuntimeQuantizer[[transformers.exporters.OnnxRuntimeQuantizer]]

```python
transformers.exporters.OnnxRuntimeQuantizer(config: OnnxRuntimeStaticConfig | OnnxRuntimeDynamicConfig | None = None, calibration_dataset: Iterable[dict[str, Any]] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_onnxruntime.py#L78)

Cuantice el modelo ONNX convertido con las propias herramientas de ONNX Runtime (`onnxruntime.quantization`): `quantize_static` con una `OnnxRuntimeStaticConfig` (el valor predeterminado) o `quantize_dynamic` con una `OnnxRuntimeDynamicConfig`.

Ejemplo:

```python
>>> from transformers.exporters import (
...     OnnxConfig,
...     OnnxRuntimeDynamicConfig,
...     OnnxRuntimeQuantizer,
...     OnnxRuntimeStaticConfig,
... )

>>> static = OnnxRuntimeStaticConfig(per_channel=True)
>>> OnnxConfig(quantizer=OnnxRuntimeQuantizer(static, calibration_dataset=samples))
>>> OnnxConfig(quantizer=OnnxRuntimeQuantizer(OnnxRuntimeDynamicConfig()))
```

#### transformers.exporters.OnnxRuntimeStaticConfig[[transformers.exporters.OnnxRuntimeStaticConfig]]

```python
transformers.exporters.OnnxRuntimeStaticConfig(quant_format: Any = None, op_types_to_quantize: list[str] | None = None, per_channel: bool | None = None, reduce_range: bool | None = None, activation_type: Any = None, weight_type: Any = None, nodes_to_quantize: list[str] | None = None, nodes_to_exclude: list[str] | None = None, calibrate_method: Any = None, calibration_providers: list[str] | None = None, extra_options: dict[str, Any] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_onnxruntime.py#L41)

Argumentos de `onnxruntime.quantization.quantize_static`: activaciones y pesos int8 (QDQ por defecto), calibrados con el `calibration_dataset` del cuantizador. Un campo dejado en `None` conserva el valor predeterminado de ONNX Runtime. Consulte [`quantize_static`](https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html) para cada uno.

#### transformers.exporters.OnnxRuntimeDynamicConfig[[transformers.exporters.OnnxRuntimeDynamicConfig]]

```python
transformers.exporters.OnnxRuntimeDynamicConfig(op_types_to_quantize: list[str] | None = None, per_channel: bool | None = None, reduce_range: bool | None = None, weight_type: Any = None, nodes_to_quantize: list[str] | None = None, nodes_to_exclude: list[str] | None = None, extra_options: dict[str, Any] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_onnxruntime.py#L62)

Argumentos de `onnxruntime.quantization.quantize_dynamic`: pesos int8, activaciones cuantizadas en tiempo de ejecución, sin calibración. Un campo dejado en `None` conserva el valor predeterminado de ONNX Runtime. Consulte [`quantize_dynamic`](https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html) para cada uno.

#### transformers.exporters.NNCFOpenVINOQuantizer[[transformers.exporters.NNCFOpenVINOQuantizer]]

```python
transformers.exporters.NNCFOpenVINOQuantizer(config: NNCFQuantizationConfig | NNCFWeightCompressionConfig | None = None, calibration_dataset: Iterable[dict[str, Any]] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_nncf.py#L143)

Cuantice el modelo de OpenVINO convertido con [NNCF](https://github.com/openvinotoolkit/nncf): `nncf.quantize` con una `NNCFQuantizationConfig` (el valor predeterminado), o `nncf.compress_weights` con una `NNCFWeightCompressionConfig`.

Ejemplo:

```python
>>> import nncf
>>> from transformers.exporters import NNCFOpenVINOQuantizer, NNCFWeightCompressionConfig, OpenVINOConfig

>>> OpenVINOConfig(quantizer=NNCFOpenVINOQuantizer(calibration_dataset=samples))
>>> OpenVINOConfig(
...     quantizer=NNCFOpenVINOQuantizer(NNCFWeightCompressionConfig(mode=nncf.CompressWeightsMode.INT4_SYM))
... )
```

#### transformers.exporters.NNCFOnnxQuantizer[[transformers.exporters.NNCFOnnxQuantizer]]

```python
transformers.exporters.NNCFOnnxQuantizer(config: NNCFQuantizationConfig | NNCFWeightCompressionConfig | None = None, calibration_dataset: Iterable[dict[str, Any]] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_nncf.py#L175)

Cuantice el modelo ONNX convertido con [NNCF](https://github.com/openvinotoolkit/nncf) a través de su backend de ONNX: `nncf.quantize` con una `NNCFQuantizationConfig` (el valor predeterminado, int8 QDQ), o `nncf.compress_weights` con una `NNCFWeightCompressionConfig` (int4 como `MatMulNBits` de ONNX Runtime).

Ejemplo:

```python
>>> import nncf
>>> from transformers.exporters import NNCFOnnxQuantizer, NNCFWeightCompressionConfig, OnnxConfig

>>> OnnxConfig(quantizer=NNCFOnnxQuantizer(calibration_dataset=samples))
>>> OnnxConfig(quantizer=NNCFOnnxQuantizer(NNCFWeightCompressionConfig(mode=nncf.CompressWeightsMode.INT4_SYM)))
```

#### transformers.exporters.NNCFTorchFXQuantizer[[transformers.exporters.NNCFTorchFXQuantizer]]

```python
transformers.exporters.NNCFTorchFXQuantizer(config: NNCFQuantizationConfig | NNCFWeightCompressionConfig | None = None, calibration_dataset: Iterable[dict[str, Any]] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_nncf.py#L231)

Cuantice el grafo FX de `torch.export` con [NNCF](https://github.com/openvinotoolkit/nncf) a través de su backend TorchFX: `nncf.quantize` con una `NNCFQuantizationConfig` (el valor predeterminado, operaciones `quantize`/`dequantize`), o `nncf.compress_weights` con una `NNCFWeightCompressionConfig`. Al igual que `PT2EQuantizer`, se ejecuta antes de cualquier conversión, por lo que cada backend toma su resultado. ExecuTorch solo reduce el resultado solo de pesos: XNNPACK no delega las operaciones `quantize`/`dequantize`, y ExecuTorch no tiene kernels para ellas.

Ejemplo:

```python
>>> from transformers.exporters import DynamoConfig, NNCFTorchFXQuantizer

>>> DynamoConfig(quantizer=NNCFTorchFXQuantizer(calibration_dataset=samples))
```

#### transformers.exporters.NNCFQuantizationConfig[[transformers.exporters.NNCFQuantizationConfig]]

```python
transformers.exporters.NNCFQuantizationConfig(mode: Any = None, preset: Any = None, target_device: Any = None, subset_size: int | None = None, fast_bias_correction: bool | None = None, model_type: Any = None, ignored_scope: Any = None, advanced_parameters: Any = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_nncf.py#L58)

Argumentos de `nncf.quantize`: activaciones y pesos int8, calibrados en el `calibration_dataset` del cuantizador. Un campo dejado en `None` conserva el valor predeterminado de NNCF, excepto `model_type`, cuyo valor predeterminado es `nncf.ModelType.TRANSFORMER`. Consulte [`nncf.quantize`](https://openvinotoolkit.github.io/nncf/autoapi/nncf/index.html#nncf.quantize) para cada uno.

#### transformers.exporters.NNCFWeightCompressionConfig[[transformers.exporters.NNCFWeightCompressionConfig]]

```python
transformers.exporters.NNCFWeightCompressionConfig(mode: Any = None, ratio: float | None = None, group_size: int | None = None, ignored_scope: Any = None, all_layers: bool | None = None, sensitivity_metric: Any = None, subset_size: int | None = None, awq: bool | None = None, scale_estimation: bool | None = None, gptq: bool | None = None, lora_correction: bool | None = None, backup_mode: Any = None, compression_format: Any = None, advanced_parameters: Any = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_nncf.py#L76)

Argumentos de `nncf.compress_weights`: int8 o int4 solo de pesos, con métodos conscientes de los datos (AWQ, estimación de escala, GPTQ) para los modos int4. Los modos int8 son independientes de los datos; los demás calibran con el `calibration_dataset` del cuantizador. `gptq` y `lora_correction` son exclusivos de OpenVINO. Un campo dejado en `None` conserva el valor predeterminado de NNCF. Consulte [`nncf.compress_weights`](https://openvinotoolkit.github.io/nncf/autoapi/nncf/index.html#nncf.compress_weights) para cada uno.

## Utilidades[[transformers.exporters.utils.get_leaf_tensors]]

Funciones de bajo nivel que impulsan `export_for_generation`, útiles cuando necesitas intervenir entre la descomposición de un modelo y la exportación de cada componente.

#### transformers.exporters.utils.get_leaf_tensors[[transformers.exporters.utils.get_leaf_tensors]]

```python
transformers.exporters.utils.get_leaf_tensors(obj: Any)
```

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

**Parámetros:**

obj (`Any`): un tensor, dataclass, dict, list, tuple o cualquier anidación de estos.

**Devuelve:** `dict[str, torch.Tensor]`

Mapeo plano de cadenas de ruta con puntos a tensores.

Recupera recursivamente todos los tensores hoja de una estructura potencialmente anidada.

#### transformers.exporters.utils.prepare_for_export[[transformers.exporters.utils.prepare_for_export]]

```python
transformers.exporters.utils.prepare_for_export(model: PreTrainedModel | torch.nn.Module, inputs: MutableMapping[str, Any])
```

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

Configura el modelo y las entradas para la exportación. Modifica `model` y `inputs` in situ, devolviendo `(model, inputs, output_flags)`, donde `output_flags` contiene los valores extraídos de `inputs` para `use_cache`, `return_dict`, etc. (para aplicarse de forma reversible sobre `model.config` mediante `patch_model_config` durante la trazabilidad).

- Elimina las entradas de etiquetas (`labels`, `future_values`); no se admite el cálculo de la pérdida.
- Extrae las banderas de salida (`use_cache`, `return_dict`, …) de `inputs` para que no aparezcan como kwargs trazados; los valores se devuelven para que el bloque de trazado los aplique en `model.config`.
- Precomputa los kwargs de visión/áudio dependientes de los datos registrados mediante `@register_export_input_preparer` y los escribe en `inputs`.
- Convierte los tensores de entrada para que coincidan con el `dtype` / `device` del modelo.

#### transformers.exporters.utils.decompose_prefill_decode[[transformers.exporters.utils.decompose_prefill_decode]]

```python
transformers.exporters.utils.decompose_prefill_decode(model: PreTrainedModel, inputs: dict[str, Any], generation_config: Any = None, multi_token_decode: bool = False)
```

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

**Devuelve:** `dict[str, tuple[torch.nn.Module, dict]]`

`{"prefill": (model, prefill_inputs), "decode": (model, decode_inputs)}`.

Ejecuta `model.generate()` y captura las entradas de prefill y decode.

Reutiliza el mecanismo completo de generación para que cada arquitectura (solo decodificador, SSM, codificador-decodificador, multimodal, …) reciba las entradas correctas sin reimplementar el bucle.

`generation_config` se reenvía a `generate()` (con el valor predeterminado del propio modelo), por lo que las entradas capturadas utilizan la caché que `generate()` construiría. Pasa una con `cache_implementation="static"` y `max_cache_len=N` para capturar una caché de **tamaño estático** en las entradas de decodificación, que es la base para una exportación con caché estática. `max_cache_len` dimensiona la caché de forma independiente a la captura, de modo que la decodificación exportada utiliza una caché fija de `[..., N, ...]` en lugar de una que crece.

Cuando `multi_token_decode`, el componente `decode` se captura como un **multi-token** decode: dos pasos de decodificación consecutivos fusionados (ver `_merge_decode_calls`) para que su eje de secuencia de consulta permanezca simbólico (un decode de un solo token especializaría ese eje a 1). A continuación, maneja tanto un solo token (decodificación ordinaria) como muchos (continuation-from-past, o un prefill simple cuando la caché está vacía). En caso contrario, `decode` es el decode clásico de un solo token.

#### transformers.exporters.utils.decompose_multimodal[[transformers.exporters.utils.decompose_multimodal]]

```python
transformers.exporters.utils.decompose_multimodal(model: PreTrainedModel, inputs: dict[str, Any])
```

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

**Devuelve:** `dict[str, tuple[torch.nn.Module, dict]]`

Una entrada `name: (module, inputs)` por cada submódulo detectado (codificador de imagen/audio, proyector, modelo de lenguaje, lm_head).

**Excepciones:** ``ValueError``

- ``ValueError`` -- si no se encuentran submódulos multimodales conocidos en el modelo.

Captura las entradas de cada submódulo multimodal mediante una única pasada hacia adelante.

Detecta todos los submódulos multimodales conocidos por nombre de atributo (torre de visión, proyector, modelo de lenguaje, lm_head, …) y captura sus kwargs de forward durante una llamada a `model(**inputs)`.

Cada submódulo se devuelve como una entrada independiente `name: (module, inputs)` para su exportación por separado. El paso de fusión de tokens (p. ej. `masked_scatter` para modelos multimodales) se deja deliberadamente fuera de los grafos exportados: es responsabilidad del llamador ensamblar `inputs_embeds` a partir de las salidas del codificador antes de ejecutar el decodificador.

#### transformers.exporters.utils.decompose_for_generation[[transformers.exporters.utils.decompose_for_generation]]

```python
transformers.exporters.utils.decompose_for_generation(model: PreTrainedModel, inputs: dict[str, Any], generation_config: Any = None, multi_token_decode: bool = False)
```

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

**Parámetros:**

model : Modelo generativo. Debe admitir `model.generate(**inputs)`.

inputs : kwargs de **Generate** — lo que se pasaría a `model.generate(**inputs)`.

generation_config : `GenerationConfig` opcional que se reenvía a `generate()` durante la captura. Pasa una con `cache_implementation="static"` + `max_cache_len=N` para exportar contra una caché de tamaño estático (ver `decompose_prefill_decode`).

multi_token_decode : Cuando `True`, captura el componente `decode` como un decodificado de múltiples tokens (eje de secuencia de consulta dinámica: varios tokens a la vez — continuación desde el pasado, o un prefill simple cuando la caché está vacía); un decodificado de un solo token no puede mantenerse dinámico (ver `decompose_prefill_decode`).

**Devuelve:** `{component_name

(submodel, forward_inputs)}`. Keys are `"prefill"` / `"decode"` for plain generative models and `"<modality>_encoder"` / `"multi_modal_projector"` / `"language_model"` / `"lm_head"` / `"decode"` for multi-modal generative models.

Descomponer un modelo generativo en pares `(model, forward_inputs)` exportables de forma independiente.

Ejecuta `decompose_prefill_decode` para capturar los kwargs de prefill y decode de una llamada real a `model.generate(**inputs, max_new_tokens=2)`. Si el prefill es multimodal (según `is_multimodal`), lo divide además en una entrada por submódulo (codificador de visión/audios, proyector, modelo de lenguaje, `lm_head`) mediante `decompose_multimodal`.

#### transformers.exporters.utils.is_multimodal[[transformers.exporters.utils.is_multimodal]]

```python
transformers.exporters.utils.is_multimodal(model: PreTrainedModel | torch.nn.Module)
```

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

Devuelve `True` si el modelo es multimodal con codificadores modales y un modelo de lenguaje.

Un modelo que no es `PreTrainedModel` (por ejemplo, un `nn.Module` simple) no tiene los accesores canónicos `get_encoder`/`get_decoder` y no es multimodal de forma trivial, por lo que devuelve `False` directamente.