# Exportadores

Se pueden agregar nuevos backends de exportación a Transformers creando una subclase de `HfExporter` y registrándola con [register_backend()](/docs/transformers/v5.23.0/es/main_classes/exporters#transformers.exporters.register_backend).

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/v5.23.0/src/transformers/exporters/auto.py#L112)

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

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

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/auto.py#L101)

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.

## register_backend[[transformers.exporters.register_backend]]

#### transformers.exporters.register_backend[[transformers.exporters.register_backend]]

```python
transformers.exporters.register_backend(exporter: type[HfExporter], runner: type[ModelRunner] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/auto.py#L61)

Registre un exportador, con su `config_class`, bajo su `export_format`, y el ejecutor que realiza sus exportaciones, para que las clases automáticas los encuentren.

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

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L321)

Clase base abstracta para todos los exportadores de Transformers.

Para añadir un backend, hereda de la clase e implementa `~HfExporter.export_program` para trazar un grafo, y `~HfExporter.save_program` / `~HfExporter.load_program` para escribirlo y volver a leerlo. Las funciones públicas `~HfExporter.export` y `~HfExporter.export_for_generation` construyen un `ExportedModel` sobre ellas.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L407)

**Devuelve:** `ExportedModel`

Un único componente `"model"`; el programa del backend es `.program`, y `save_pretrained` lo escribe junto con sus metadatos y la configuración del modelo.

Exporta el modelo como un solo grafo.

Acepta los mismos kwargs de **forward** que `~HfExporter.export_program`.

#### 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/v5.23.0/src/transformers/exporters/base.py#L426)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/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/v5.23.0/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/v5.23.0/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:** `ExportedModel`

Un `ExportedComponent` por etapa, con las mismas claves que [decompose_for_generation()](/docs/transformers/v5.23.0/es/main_classes/exporters#transformers.exporters.utils.decompose_for_generation).

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

Envoltorio fino alrededor de [decompose_for_generation()](/docs/transformers/v5.23.0/es/main_classes/exporters#transformers.exporters.utils.decompose_for_generation) que llama a `~HfExporter.export_program` 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/v5.23.0/es/main_classes/exporters#transformers.exporters.utils.decompose_for_generation).

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L351)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/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:** `tuple[Any, ExportMetadata]`

El objeto de programa del backend (`ExportedProgram`, `onnx_ir.Model`, `ExecutorchProgramManager`, `openvino.Model`) y los metadatos registrados durante su trazado (`build_export_metadata()`), devueltos por separado ya que solo algunos formatos pueden incluirlos.

Traza un solo grafo. El punto de extensión del backend, emparejado con `~HfExporter.save_program`.

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

```python
load_program(path: str | Path)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L385)

Lee de nuevo un programa escrito por `~HfExporter.save_program`. Puede diferir de lo que devolvió `~HfExporter.export_program`: un `Program` de tiempo de ejecución para ExecuTorch, cuyo `ExecutorchProgramManager` no se puede reconstruir desde el archivo.

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

```python
program_files(filename: str)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L392)

Los archivos que `~HfExporter.save_program` escribe para un programa guardado como `filename`: el archivo en sí, más cualquier otro que el formato mantenga a su lado (pesos, datos externos).

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

```python
save_program(program: Any, path: str | Path)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L380)

Escribe un programa devuelto por `~HfExporter.export_program` en `path`, en el formato de archivo del backend.

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

```python
validate_environment()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L347)

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

## ExportedModel[[transformers.exporters.ExportedModel]]

#### transformers.exporters.ExportedModel[[transformers.exporters.ExportedModel]]

```python
transformers.exporters.ExportedModel(components: dict[str, ExportedComponent], export_format: ExportFormat | str, config: PreTrainedConfig | None = None, generation_config: GenerationConfig | None = None)
```

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

Un modelo exportado: sus grafos (`components`, `{name: ExportedComponent}`) y las configuraciones con las que se trazaron, llamadas de la misma manera que se llamaría al modelo del que proviene.

`~HfExporter.export` produce un único componente `"model"`, cuyo programa es `.program`; `~HfExporter.export_for_generation` produce un componente por cada etapa de generación.

```python
>>> exported = OnnxExporter().export(model, inputs, OnnxConfig(dynamic=True))
>>> exported.save_pretrained("exported")
>>> outputs = ExportedModel.from_pretrained("exported", device="cuda")(**inputs)
>>> outputs.last_hidden_state
```

#### __llamada__[[transformers.exporters.ExportedModel.__call__]]

```python
__call__(share_inputs: bool = True, share_outputs: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L143)

Ejecuta una exportación de un solo grafo, devolviendo lo que devuelve el modelo de origen. Los kwargs con los que no se trazó la exportación se descartan, por lo que se puede pasar la salida completa de un procesador. `share_inputs` y `share_outputs` se pasan al ejecutor (ver `ModelRunner.__call__`): con `share_outputs`, las salidas son válidas hasta la siguiente llamada.

#### program[[transformers.exporters.ExportedModel.program]]

```python
program()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L108)

El propio programa del backend, para una exportación de un solo grafo.

#### a[[transformers.exporters.ExportedModel.to]]

```python
to(device = None, **runner_kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L130)

Carga los programas en el tiempo de ejecución de su backend, en `device` (el predeterminado del backend cuando es `None`). `runner_kwargs` se envían al runner del backend: `providers` y `session_options` para ONNX Runtime, `config` (propiedades de compilación) y `torch_threads` (dividir la CPU con el trabajo de torch alrededor del modelo) para OpenVINO.

#### save_pretrained[[transformers.exporters.ExportedModel.save_pretrained]]

```python
save_pretrained(save_directory: str | Path, push_to_hub: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L156)

**Parámetros:**

save_directory (`str` o `Path`) : El directorio donde escribir, se crea si no existe.

push_to_hub (`bool`, *opcional*, por defecto `False`) : Si se deben subir los archivos guardados también al Hub, a `repo_id` (por defecto, el nombre de `save_directory` en tu espacio de nombres).

kwargs (`dict[str, Any]`, *opcional*) : Se pasa a la carga en el Hub: `repo_id`, `commit_message`, `token`, `private`, ...

Escribe los componentes (uno por archivo), las configuraciones y un manifiesto que nombre el archivo de cada componente y los metadatos registrados al realizar el trazado. `~ExportedModel.from_pretrained` los vuelve a cargar.

#### from_pretrained[[transformers.exporters.ExportedModel.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | Path, device = None, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', subfolder: str = '', trust_remote_code: bool = False, **runner_kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L206)

**Parámetros:**

pretrained_model_name_or_path (`str` o `Path`) : Un directorio local o un id de repositorio del Hub. Desde el Hub, solo se descargan los archivos que nombra el manifiesto, por lo que una exportación puede colocarse junto a los pesos propios del modelo.

device (`str` o `torch.device`, *opcional*) : Dónde ejecutarlo (el valor predeterminado del backend cuando es `None`).

cache_dir (`Union[str, os.PathLike]`, *opcional*) : Ruta a un directorio en el que se debe almacenar en caché la configuración de un modelo preentrenado descargado si no se debe usar la caché estándar.

force_download (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe forzar la (re)descarga de los pesos del modelo y los archivos de configuración, reemplazando las versiones en caché si existen.

local_files_only (`bool`, *opcional*, por defecto `False`) : Si se deben buscar solo archivos locales (es decir, no intentar descargar el modelo).

token (`str` o `bool`, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True`, o no se especifica, se usará el token generado al ejecutar `hf auth login` (almacenado en `~/.huggingface`).

revision (`str`, *opcional*, valor predeterminado `"main"`) : La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta o un id de commit, ya que utilizamos un sistema basado en git para almacenar modelos y otros artefactos en huggingface.co, por lo que `revision` puede ser cualquier identificador permitido por git.    Para probar una pull request que hayas realizado en el Hub, puedes pasar `revision="refs/pr/<pr_number>"`.

subfolder (`str`, *opcional*, valor predeterminado `""`) : Si los archivos relevantes se encuentran en una subcarpeta del repositorio del modelo en huggingface.co, puede especificar aquí el nombre de la carpeta.

trust_remote_code (`bool`, *opcional*, valor predeterminado `False`) : Si se debe cargar la configuración de un modelo cuyo código se encuentra en su repositorio, como en [from_pretrained()](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoConfig.from_pretrained).

runner_kwargs (*opcional*) : Las opciones del ejecutor del backend, como en `~ExportedModel.to`: `providers` y `session_options` para ONNX Runtime, `config` y `torch_threads` para OpenVINO.

Carga lo que `~ExportedModel.save_pretrained` escribió: cada componente a través de `~HfExporter.load_program` de su backend, con su metadatos, y las configuraciones guardadas junto a ellos. Los programas se cargan en el runtime de su backend de inmediato, listos para ejecutarse.

## ExportedComponent[[transformers.exporters.ExportedComponent]]

#### transformers.exporters.ExportedComponent[[transformers.exporters.ExportedComponent]]

```python
transformers.exporters.ExportedComponent(program: Any, metadata: ExportMetadata)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L60)

Un solo grafo exportado: el programa del backend y lo que el exportador registró sobre él.

## ExportMetadata[[transformers.exporters.ExportMetadata]]

#### transformers.exporters.ExportMetadata[[transformers.exporters.ExportMetadata]]

```python
transformers.exporters.ExportMetadata(architecture: str | None = None, packages: dict[str, str] = <factory>, export_config: dict[str, Any] = <factory>, export_dtype: str | None = None, export_device: str | None = None, kwargs: dict[str, dict] = <factory>, in_spec: str | None = None, out_spec: str | None = None, in_constants: dict[str, Any] = <factory>, out_constants: list = <factory>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/metadata.py#L58)

Lo que el exportador registró sobre un grafo (`build_export_metadata()`).

#### from_dict[[transformers.exporters.ExportMetadata.from_dict]]

```python
from_dict(values: Mapping[str, Any])
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/metadata.py#L75)

Construye los metadatos a partir de su diccionario guardado, omitiendo los campos que esta clase no tiene (añadidos por una versión más reciente).

## ModelRunner[[transformers.exporters.ModelRunner]]

#### transformers.exporters.ModelRunner[[transformers.exporters.ModelRunner]]

```python
transformers.exporters.ModelRunner(metadata: ExportMetadata)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/runners/base.py#L29)

Ejecuta un programa exportado en su backend: `runner(**kwargs)` devuelve lo que devuelve el modelo de origen.

#### from_program[[transformers.exporters.ModelRunner.from_program]]

```python
from_program(program: Any, metadata: ExportMetadata, device = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/runners/base.py#L56)

Un ejecutor para un programa como exportación lo devuelve o `~HfExporter.load_program` lo vuelve a leer, en `device` (el predeterminado del backend cuando es `None`).

#### unflatten[[transformers.exporters.ModelRunner.unflatten]]

```python
unflatten(outputs: list)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/runners/base.py#L47)

Reconstruir las salidas del modelo a partir de las salidas planas del programa (que aparecen al final) y las constantes registradas.

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

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

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

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

Exportador que convierte un [PreTrainedModel](/docs/transformers/v5.23.0/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(**inputs)
>>> exported.save_pretrained("exported")  # `model.pt2`, its metadata and the model config
```

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L407)

**Devuelve:** `ExportedModel`

Un único componente `"model"`; el programa del backend es `.program`, y `save_pretrained` lo escribe junto con sus metadatos y la configuración del modelo.

Exporta el modelo como un solo grafo.

Acepta los mismos kwargs de **forward** que `~HfExporter.export_program`.

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

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/exporter_onnx.py#L113)

Exportador que convierte un [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel) en un grafo ONNX (un `onnx_ir.Model`).

Ejemplo:

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

>>> exporter = OnnxExporter()
>>> exported = exporter.export(model, inputs, config=OnnxConfig(dynamic=True))
>>> outputs = exported(**inputs)  # on ONNX Runtime
>>> onnx_model = exported.program  # an `onnx_ir.Model`
>>> exported.save_pretrained("exported")  # `model.onnx`, its metadata and the model config
```

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L407)

**Devuelve:** `ExportedModel`

Un único componente `"model"`; el programa del backend es `.program`, y `save_pretrained` lo escribe junto con sus metadatos y la configuración del modelo.

Exporta el modelo como un solo grafo.

Acepta los mismos kwargs de **forward** que `~HfExporter.export_program`.

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

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/exporter_executorch.py#L107)

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

Ejemplo:

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

>>> exporter = ExecutorchExporter()
>>> exported = exporter.export(model, inputs, config=ExecutorchConfig(backend="xnnpack"))
>>> outputs = exported(**inputs)  # on the ExecuTorch runtime
>>> exported.save_pretrained("exported")  # `model.pte`, its metadata and the model config
```

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L407)

**Devuelve:** `ExportedModel`

Un único componente `"model"`; el programa del backend es `.program`, y `save_pretrained` lo escribe junto con sus metadatos y la configuración del modelo.

Exporta el modelo como un solo grafo.

Acepta los mismos kwargs de **forward** que `~HfExporter.export_program`.

## 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/v5.23.0/src/transformers/exporters/configs.py#L92)

**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, opset_version: int | None = None, optimize: bool = True, ort_fusions: Literal['cpu', 'cuda', 'webgpu', 'dml'] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/configs.py#L134)

**Parámetros:**

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.

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.

ort_fusions (`str`, *opcional*) : Fusiona el grafo en las operaciones de ONNX Runtime para el proveedor de ejecución en el que se ejecuta: `"cpu"`, `"cuda"`, `"webgpu"` o `"dml"`. El grafo fusionado solo se ejecuta en ONNX Runtime. Requiere `optimize=True`.

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/v5.23.0/src/transformers/exporters/configs.py#L168)

**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, compress_to_fp16: bool = False, stateful: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/configs.py#L205)

**Parámetros:**

compress_to_fp16 (*bool*, *opcional*, valor predeterminado *False*) : Comprime los pesos *float32* del modelo convertido a *float16*, reduciendo su tamaño a la mitad. Desactivado de forma predeterminada debido al rango más estrecho.

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/v5.23.0/src/transformers/exporters/quantizers/base.py#L33)

**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/v5.23.0/src/transformers/exporters/quantizers/base.py#L83)

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.

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

```python
traced_calibration(sample_inputs: dict[str, Any])
```

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

Muestras de calibración como los kwargs trazados, para cuantizadores de grafo FX.

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

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

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

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/v5.23.0/src/transformers/exporters/quantizers/base.py#L62)

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/v5.23.0/src/transformers/exporters/quantizers/base.py#L89)

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/v5.23.0/src/transformers/exporters/quantizers/quantizer_pt2e.py#L33)

**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/v5.23.0/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/v5.23.0/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/v5.23.0/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/v5.23.0/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/v5.23.0/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/v5.23.0/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/v5.23.0/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/v5.23.0/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/v5.23.0/src/transformers/exporters/utils.py#L348)

**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/v5.23.0/src/transformers/exporters/utils.py#L519)

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/v5.23.0/src/transformers/exporters/utils.py#L922)

**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/v5.23.0/src/transformers/exporters/utils.py#L1045)

**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/v5.23.0/src/transformers/exporters/utils.py#L1089)

**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/v5.23.0/src/transformers/exporters/utils.py#L1036)

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.

