# Exportadores

Novos backends de exportação podem ser adicionados ao Transformers criando uma subclasse de `HfExporter` e registrando-a com [register_backend()](/docs/transformers/v5.23.0/pt/main_classes/exporters#transformers.exporters.register_backend).

Aprenda a usar os exportadores integrados no guia [Exporters](../exporters).

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

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

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

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

A classe exportadora Auto-HF que cuida da instanciação automática para o `HfExporter` correto, dado o `ExportConfig`.

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

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

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

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

A classe de configuração de exportação Auto-HF que se encarrega de despachar automaticamente para a configuração de exportação correta, dada uma configuração de exportação armazenada em um dicionário.

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

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

Registre um exportador, com sua `config_class`, sob seu `export_format`, e o runner que executa seus exports, para que as classes auto os encontrem.

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

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

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

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

Classe base abstrata para todos os exportadores do Transformers.

Para adicionar um backend, crie uma subclasse e implemente `~HfExporter.export_program` para rastrear um grafo, e `~HfExporter.save_program` / `~HfExporter.load_program` para gravá-lo e lê-lo de volta. Os métodos públicos `~HfExporter.export` e `~HfExporter.export_for_generation` constroem um `ExportedModel` com base neles.

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

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

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

**Retorna:** `ExportedModel`

Um único componente `"model"`; o programa do backend é `.program`, e `save_pretrained` o grava junto com seus metadados e a configuração do modelo.

Exporte o modelo como um único grafo.

Recebe os mesmos 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)
```

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

**Parâmetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel)): O modelo generativo a ser exportado. Deve suportar `model.generate(**sample_inputs)`.

sample_inputs (`dict[str, torch.Tensor | Cache]`) : argumentos de **Generate** — o que você passaria para `model.generate(**sample_inputs)` (tipicamente `input_ids` + `attention_mask`, além de quaisquer entradas de modalidade, como `pixel_values` / `input_features`, para modelos multimodais). Os argumentos de forward por etapa são capturados internamente.

config (`ExportConfigMixin` ou `dict[str, ExportConfigMixin]`) : Configuração específica do backend. Passe uma única configuração para aplicar a todos os componentes, ou um `dict` com chaves pelo nome do componente (por exemplo, `"image_encoder"`, `"language_model"`, `"lm_head"`, `"decode"`) para sobrescrever por componente — todos os nomes de componentes devem estar presentes no dict.

generation_config ([GenerationConfig](/docs/transformers/v5.23.0/pt/main_classes/text_generation#transformers.GenerationConfig), *opcional*) : Encaminhado para a captura `generate()` (padrão: a própria do modelo). Passe um com `cache_implementation="static"` para exportar em relação a um `StaticCache` de tamanho fixo.

multi_token_decode (`bool`, *opcional*, padrão `False`) : Se o componente `decode` processa múltiplos tokens de consulta de uma vez — um eixo de consulta dinâmico (prefill em um cache vazio, continuação a partir do passado caso contrário) — em vez do passo clássico de um único token (veja [decompose_for_generation()](/docs/transformers/v5.23.0/pt/main_classes/exporters#transformers.exporters.utils.decompose_for_generation)). Permanece dinâmico apenas sob uma exportação de forma dinâmica (`config.dynamic=True`).

**Retorna:** `ExportedModel`

Um `ExportedComponent` por estágio, com as mesmas chaves de [decompose_for_generation()](/docs/transformers/v5.23.0/pt/main_classes/exporters#transformers.exporters.utils.decompose_for_generation).

Decomponha um modelo generativo e exporte cada componente de forma independente.

Wrapper fino em torno de [decompose_for_generation()](/docs/transformers/v5.23.0/pt/main_classes/exporters#transformers.exporters.utils.decompose_for_generation) que chama `~HfExporter.export_program` em cada par retornado `(submodel, forward_inputs)`. Se você precisar dos pares intermediários `(submodel, forward_inputs)` (para verificação, entradas personalizadas, pular uma etapa, …), chame [decompose_for_generation()](/docs/transformers/v5.23.0/pt/main_classes/exporters#transformers.exporters.utils.decompose_for_generation) diretamente.

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

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

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

**Parâmetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel)) : O modelo a ser exportado.

sample_inputs (`dict[str, torch.Tensor | Cache]`) : **Forward** kwargs — o que você passaria para `model(**sample_inputs)`. Eles são usados diretamente como entradas de exemplo durante o tracing. Para uma exportação de etapa de decodificação autoregressiva, isso significa que você precisa incluir `past_key_values`, `cache_position`, etc. Se você tiver apenas entradas no estilo geração, use `~HfExporter.export_for_generation` em vez disso — ele executa `model.generate` para você e exporta cada etapa.

config (`ExportConfigMixin`) : Configuração específica do backend.

**Retorna:** `tuple[Any, ExportMetadata]`

O objeto de programa do backend (`ExportedProgram`, `onnx_ir.Model`, `ExecutorchProgramManager`, `openvino.Model`) e os metadados registrados durante o tracing dele (`build_export_metadata()`), retornados separadamente, pois apenas alguns formatos podem transportá-los.

Trace um único grafo. O ponto de extensão do backend, em conjunto com `~HfExporter.save_program`.

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

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

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

Lê de volta um programa escrito por `~HfExporter.save_program`. Ele pode diferir do que `~HfExporter.export_program` retornou: um `Program` de runtime para ExecuTorch, cujo `ExecutorchProgramManager` não pode ser reconstruído a partir do arquivo.

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

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

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

Os arquivos que `~HfExporter.save_program` escreve para um programa salvo como `filename`: o arquivo em si, além de quaisquer outros que o formato mantém ao lado dele (pesos, dados externos).

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

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

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

Escreva um programa retornado por `~HfExporter.export_program` em `path`, no formato de arquivo do backend.

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

```python
validate_environment()
```

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

Verifique se os `required_packages` estão instalados e emita um aviso em caso de divergência de versão em relação aos `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)
```

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

Um modelo exportado: seus grafos (`components`, `{name: ExportedComponent}`) e as configurações com as quais foram rastreados, chamados da mesma forma que você chamaria o modelo do qual vieram.

`~HfExporter.export` produz um único componente `"model"`, cujo programa é `.program`; `~HfExporter.export_for_generation` produz um componente por etapa de geração.

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

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

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

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

Executa uma exportação de grafo único, retornando o que o modelo de origem retorna. Kwargs com os quais a exportação não foi rastreada são descartados, portanto, a saída inteira de um processador pode ser passada. `share_inputs` e `share_outputs` são enviados ao runner (veja `ModelRunner.__call__`): com `share_outputs`, as saídas são válidas até a próxima chamada.

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

```python
program()
```

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

O próprio programa do backend, para uma exportação de um único grafo.

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

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

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

Carregue os programas no runtime do backend, em `device` (o padrão do backend quando `None`). `runner_kwargs` são enviados para o runner do backend: `providers` e `session_options` para ONNX Runtime, `config` (propriedades de compilação) e `torch_threads` (dividir a CPU com o trabalho do torch ao redor do modelo) para OpenVINO.

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

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

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

**Parâmetros:**

save_directory (`str` ou `Path`) : O diretório para onde será escrito, criado caso não exista.

push_to_hub (`bool`, *opcional*, padrão `False`) : Se os arquivos salvos devem ser enviados também para o Hub, para `repo_id` (padrão é o nome de `save_directory` no seu namespace).

kwargs (`dict[str, Any]`, *opcional*) : Passado para o upload no Hub: `repo_id`, `commit_message`, `token`, `private`, ...

Escreva os componentes (um arquivo para cada), as configurações e um manifesto que nomeia o arquivo de cada componente e os metadados registrados durante o rastreamento. `~ExportedModel.from_pretrained` os carrega novamente.

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

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

**Parâmetros:**

pretrained_model_name_or_path (`str` ou `Path`) : Um diretório local ou um id de repositório do Hub. Do Hub, apenas os arquivos nomeados no manifesto são baixados, permitindo que uma exportação fique ao lado dos próprios pesos do modelo.

device (`str` ou `torch.device`, *opcional*) : Onde executá-lo (o padrão do backend quando `None`).

cache_dir (`Union[str, os.PathLike]`, *opcional*) : Caminho para um diretório no qual a configuração de um modelo pré-treinado baixado deve ser armazenada em cache, caso o cache padrão não deva ser usado.

force_download (`bool`, *opcional*, padrão `False`) : Indica se deve forçar o (re-)download dos pesos do modelo e dos arquivos de configuração, sobrescrevendo as versões em cache, caso existam.

local_files_only (`bool`, *opcional*, padrão `False`) : Se deve ou não considerar apenas arquivos locais (ou seja, não tentar baixar o modelo).

token (`str` ou `bool`, *opcional*) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se `True`, ou não especificado, usará o token gerado ao executar `hf auth login` (armazenado em `~/.huggingface`).

revision (`str`, *opcional*, padrão `"main"`) : A versão específica do modelo a ser usada. Pode ser o nome de uma branch, o nome de uma tag ou um id de commit, pois usamos um sistema baseado em git para armazenar modelos e outros artefatos no huggingface.co, portanto `revision` pode ser qualquer identificador permitido pelo git.    Para testar um pull request que você fez no Hub, você pode passar `revision="refs/pr/<pr_number>"`.

subfolder (`str`, *opcional*, padrão `""`) : Caso os arquivos relevantes estejam localizados em uma subpasta do repositório do modelo no huggingface.co, você pode especificar o nome da pasta aqui.

trust_remote_code (`bool`, *opcional*, padrão `False`) : Se deve carregar a configuração de um modelo cujo código está em seu repositório, como em [from_pretrained()](/docs/transformers/v5.23.0/pt/model_doc/auto#transformers.AutoConfig.from_pretrained).

runner_kwargs (*opcional*) : As opções de runner do backend, conforme `~ExportedModel.to`: `providers` e `session_options` para ONNX Runtime, `config` e `torch_threads` para OpenVINO.

Carregue o que `~ExportedModel.save_pretrained` gravou: cada componente por meio do `~HfExporter.load_program` do backend correspondente, com seus metadados, e as configurações salvas ao lado deles. Os programas são carregados imediatamente no runtime do backend, prontos para execução.

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

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

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

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

Um único grafo exportado: o programa do backend e o que o exportador registrou sobre ele.

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

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

O que o exportador registrou sobre um grafo (`build_export_metadata()`).

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

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

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

Construa os metadados a partir do dicionário salvo, ignorando os campos que esta classe não possui (adicionados por uma versão mais recente).

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

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

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

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

Executa um programa exportado em seu backend: `runner(**kwargs)` retorna o que o modelo de origem retorna.

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

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

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

Um runner para um programa como export retorna-o ou `~HfExporter.load_program` o lê de volta, em `device` (o padrão do backend quando `None`).

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

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

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

Reconstrua as saídas do modelo a partir das saídas planas do programa (que vêm por último) e das constantes gravadas.

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

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

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

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

Exportador que converte um [PreTrainedModel](/docs/transformers/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel) em um `ExportedProgram`.

Exemplo:

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

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

**Retorna:** `ExportedModel`

Um único componente `"model"`; o programa do backend é `.program`, e `save_pretrained` o grava junto com seus metadados e a configuração do modelo.

Exporte o modelo como um único grafo.

Recebe os mesmos kwargs de **forward** que `~HfExporter.export_program`.

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

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

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

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

Exportador que converte um [PreTrainedModel](/docs/transformers/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel) em um grafo ONNX (um `onnx_ir.Model`).

Exemplo:

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

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

**Retorna:** `ExportedModel`

Um único componente `"model"`; o programa do backend é `.program`, e `save_pretrained` o grava junto com seus metadados e a configuração do modelo.

Exporte o modelo como um único grafo.

Recebe os mesmos kwargs de **forward** que `~HfExporter.export_program`.

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

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

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

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

Exportador que converte um [PreTrainedModel](/docs/transformers/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel) em um `ExecutorchProgramManager` do ExecuTorch.

Exemplo:

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

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

**Retorna:** `ExportedModel`

Um único componente `"model"`; o programa do backend é `.program`, e `save_pretrained` o grava junto com seus metadados e a configuração do modelo.

Exporte o modelo como um único grafo.

Recebe os mesmos 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)
```

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

**Parâmetros:**

dynamic (*bool*, *opcional*, padrão *False*) : Se deve exportar com formas dinâmicas (simbólicas). Quando *True* e *dynamic_shapes* não está definido, todas as dimensões dos tensors são definidas automaticamente como *Dim.AUTO*.

strict (*bool*, *opcional*, padrão *False*) : Se deve habilitar o modo estrito no *torch.export*. Executa o rastreamento simbólico completo e captura mais erros, mas é mais lento e tem maior probabilidade de falhar em modelos complexos.

dynamic_shapes (*dict[str, Any]*, *opcional*) : Especificações explícitas de formas dinâmicas por entrada passadas para *torch.export*. Tem precedência sobre *dynamic*.

prefer_deferred_runtime_asserts_over_guards (*bool*, *opcional*, padrão *False*) : Quando *True*, as verificações de forma dependentes dos dados são emitidas como asserts em tempo de execução no grafo exportado, em vez de falhar a exportação no momento do trace quando uma verificação não se mantém ao longo de todo o intervalo de formas simbólicas. A maioria dos LLMs de transformadores precisa que isso seja definido como *True* ao usar limites finos de `Dim(min=, max=)`. Não é necessário com `dynamic=True` / `Dim.AUTO`, onde o `torch.export` infere as relações de forma em vez de verificá-las contra os limites declarados pelo usuário.

quantizer ([*~exporters.quantizers.ExportQuantizer*], *opcional*) : Quantização pós-treinamento aplicada durante a exportação: [*~exporters.quantizers.PT2EQuantizer*] ou [*~exporters.quantizers.NNCFTorchFXQuantizer*] no grafo FX para todos os backends, [*~exporters.quantizers.OnnxRuntimeQuantizer*] no modelo ONNX convertido, ou [*~exporters.quantizers.NNCFOpenVINOQuantizer*] / [*~exporters.quantizers.NNCFOnnxQuantizer*] no modelo OpenVINO / ONNX convertido.

Classe de configuração para exportar modelos via *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)
```

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

**Parâmetros:**

opset_version (`int`, *opcional*) : Versão do opset ONNX a ser usada como alvo. O padrão é o opset mais recente suportado pela versão instalada do `onnxscript`.

optimize (`bool`, *opcional*, padrão `True`) : Executa as passes de otimização do `onnxscript` (dobramento de constantes, eliminação de código morto, …) no grafo exportado. Desative para modelos que encontram bugs no otimizador upstream do `onnxscript`.

ort_fusions (`str`, *opcional*) : Funde o grafo nos ops do ONNX Runtime para o execution provider em que ele é executado: `"cpu"`, `"cuda"`, `"webgpu"` ou `"dml"`. O grafo fundido só é executado no ONNX Runtime. Exige `optimize=True`.

Classe de configuração para exportar modelos para ONNX via `torch.onnx.export`.

Herdita todos os 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)
```

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

**Parâmetros:**

backend (`str`, *opcional*, padrão `"xnnpack"`) : Backend do ExecuTorch de destino. Valores suportados:  - `"xnnpack"` — Inferência em CPU por meio da biblioteca XNNPACK (padrão; funciona em qualquer lugar). - `"cuda"` — Inferência em GPU por meio do backend CUDA do ExecuTorch. - `"mlx"` — Inferência em GPU por meio do backend MLX do ExecuTorch em Apple Silicon.

alloc_graph_input (`bool`, *opcional*, padrão `True`) : Indica se a etapa de planejamento de memória reserva memória de arena para as entradas do grafo. Quando `False`, o tempo de execução usa diretamente os buffers de entrada fornecidos pelo chamador, em vez de copiá-los para a arena — assim, uma `USER_INPUT_MUTATION` in-place (por exemplo, uma escrita em `StaticCache`) é aplicada ao tensor do chamador, e não a uma cópia na arena.

alloc_graph_output (`bool`, *opcional*, padrão `True`) : Indica se a etapa de planejamento de memória reserva memória de arena para as saídas do grafo. Quando `False`, o chamador deve vincular os buffers de saída em tempo de execução (`Method::set_output_data_ptr`); vincular uma saída ao buffer da sua entrada mutada evita a cópia de saída.

alloc_mutable_buffers (`bool`, *opcional*, padrão `True`) : Indica se a etapa de planejamento de memória reserva memória de arena para buffers mutáveis (estado residente no modelo). Transmitido para o `MemoryPlanningPass`.

Classe de configuração para exportar modelos para o formato ExecuTorch.

Herdita todos os 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)
```

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

**Parâmetros:**

compress_to_fp16 (*bool*, *opcional*, padrão *False*) : Comprime os pesos *float32* do modelo convertido para *float16*, reduzindo seu tamanho pela metade. Desativado por padrão devido à faixa mais estreita.

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.

Classe de configuração para exportar modelos para o IR do OpenVINO via `openvino.convert_model`.

Herdita todos os campos de [*DynamoConfig*] (*dynamic*, *strict*, *dynamic_shapes*, *prefer_deferred_runtime_asserts_over_guards*).

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

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

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

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

**Parâmetros:**

calibration_dataset (`Iterable[dict]`, *opcional*) : Dicionários de entrada nos quais o quantizador realiza a calibração: uma lista, ou um `DataLoader` cujos lotes são colacionados para as entradas do modelo. Para `~HfExporter.export_for_generation`, são os kwargs de generate, capturados em um conjunto de calibração por componente. Quando `None`, um quantizador que precisa de dados realiza a calibração nas próprias entradas de amostra da exportação, com um aviso.

Classe base para quantizadores de pós-treino aplicados durante a exportação.

Um quantizador declara os formatos de exportação que suporta e os pacotes de que precisa (com as versões em que foi testado, assim como os exportadores), bem como se ele quantiza o grafo FX de `torch.export`, antes de qualquer conversão (de modo que todos os backends recebem o resultado), ou o modelo para o qual um backend o converte (`onnx_ir.Model`, `openvino.Model`). O exportador valida-o em relação à exportação antecipadamente e, em seguida, chama `~ExportQuantizer.quantize` com esse modelo e as entradas de exemplo da exportação. Subclasse-o e implemente `quantize` para adicionar um novo método de quantização; um `CalibrationSet` mapeia as amostras de calibração para as entradas próprias do modelo.

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

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

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

Quantize `model` (o grafo FX se `quantizes_fx_graph`, caso contrário, o modelo do backend) e retorne o resultado, calibrado em `calibration_dataset`, ou nos `sample_inputs` da exportação, quando não houver nenhum.

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

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

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

Amostras de calibração como os kwargs rastreados, para quantizadores de grafo FX.

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

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

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

Gera um erro se este quantizer não puder ser executado em uma exportação `export_format`, ou se um pacote necessário estiver ausente ou for muito antigo; emite um aviso quando a versão for diferente daquela em que foi testado.

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

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

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

Uma cópia deste quantizador que calibra em `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])
```

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

Visualização re-iterável das amostras de calibração como entradas do modelo.

As amostras são o `calibration_dataset` do quantizador, ou o próprio `sample_inputs` da exportação (com um aviso, uma vez que são lidos) quando ele não possui nenhum. Elas podem ser qualquer mapeamento, como um `BatchEncoding` de um tokenizer. O `transform` mapeia cada amostra de kwarg de forward para o que o modelo quantizado recebe (kwarg rastreados, feeds ONNX, feeds de porta OpenVINO), de forma preguiçosa, uma amostra por vez, em cada passagem.

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

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

[Origem](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`) : O quantizador PT2E que anota o grafo. Suas operações de quantização/desquantização devem ser aquelas suportadas pelo backend de destino: `X86InductorQuantizer` para inductor, ONNX (QDQ) ou OpenVINO, `XNNPACKQuantizer` para ExecuTorch.

calibration_dataset (`Iterable[dict]`, *opcional*) : Dicionários de entrada nos quais os observadores calibram (veja `ExportQuantizer`), um forward cada. Para calibrar em lotes, passe um `DataLoader` que agrupa as amostras em dicionários de entrada em lote, em vez de uma lista de amostras individuais.

Quantize o grafo FX com a quantização [PyTorch 2 Export (PT2E)](https://docs.pytorch.org/ao/main/pt2e_quantization/index.html): `prepare_pt2e` insere observadores, o conjunto de calibração os direciona e `convert_pt2e` os substitui por operações de quantize/dequantize. Funciona com todos os backends de exportação.

Exemplo:

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

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

Quantize o modelo ONNX convertido com as próprias ferramentas do ONNX Runtime (`onnxruntime.quantization`): `quantize_static` com um `OnnxRuntimeStaticConfig` (o padrão) ou `quantize_dynamic` com um `OnnxRuntimeDynamicConfig`.

Exemplo:

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

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

Argumentos de `onnxruntime.quantization.quantize_static`: ativações e pesos int8 (QDQ por padrão), calibrados no `calibration_dataset` do quantizador. Um campo deixado como `None` mantém o padrão do ONNX Runtime. Consulte [`quantize_static`](https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html) para cada um.

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

[Origem](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, ativações quantizadas em tempo de execução, sem calibração. Um campo deixado como `None` mantém o padrão do ONNX Runtime. Consulte [`quantize_dynamic`](https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html) para cada um deles.

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

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

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

Quantize o modelo OpenVINO convertido com [NNCF](https://github.com/openvinotoolkit/nncf): `nncf.quantize` com um `NNCFQuantizationConfig` (o padrão), ou `nncf.compress_weights` com um `NNCFWeightCompressionConfig`.

Exemplo:

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

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

Quantize o modelo ONNX convertido com [NNCF](https://github.com/openvinotoolkit/nncf) por meio de seu backend ONNX: `nncf.quantize` com uma `NNCFQuantizationConfig` (o padrão, int8 QDQ), ou `nncf.compress_weights` com uma `NNCFWeightCompressionConfig` (int4 como `MatMulNBits` do ONNX Runtime).

Exemplo:

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

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

Quantize o grafo FX do `torch.export` com [NNCF](https://github.com/openvinotoolkit/nncf) por meio de seu backend TorchFX: `nncf.quantize` com um `NNCFQuantizationConfig` (o padrão, ops `quantize`/`dequantize`), ou `nncf.compress_weights` com um `NNCFWeightCompressionConfig`. Assim como o `PT2EQuantizer`, ele é executado antes de qualquer conversão, de modo que todos os backends recebem seu resultado. O ExecuTorch reduz apenas o resultado somente de pesos: o XNNPACK não delega os ops `quantize`/`dequantize`, e o ExecuTorch não possui kernels para eles.

Exemplo:

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

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

Argumentos de `nncf.quantize`: ativações e pesos int8, calibrados no `calibration_dataset` do quantizador. Um campo deixado como `None` mantém o padrão do NNCF, exceto `model_type`, que tem como padrão `nncf.ModelType.TRANSFORMER`. Consulte [`nncf.quantize`](https://openvinotoolkit.github.io/nncf/autoapi/nncf/index.html#nncf.quantize) para cada um deles.

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

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

Argumentos de `nncf.compress_weights`: int8 ou int4 apenas para pesos, com métodos conscientes dos dados (AWQ, estimativa de escala, GPTQ) para os modos int4. Os modos int8 são independentes de dados; os outros calibram no `calibration_dataset` do quantizador. `gptq` e `lora_correction` são exclusivos do OpenVINO. Um campo deixado como `None` mantém o padrão do NNCF. Consulte [`nncf.compress_weights`](https://openvinotoolkit.github.io/nncf/autoapi/nncf/index.html#nncf.compress_weights) para cada um.

## Utilitários[[transformers.exporters.utils.get_leaf_tensors]]

Funções de nível inferior que sustentam o `export_for_generation`, úteis quando você precisa intervir entre a decomposição de um modelo e a exportação de cada componente.

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

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

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/utils.py#L348)

**Parâmetros:**

obj (`Any`) : Um tensor, dataclass, dict, list, tuple ou qualquer aninhamento desses.

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

Mapeamento plano de strings de caminho pontuado para tensores.

Recupere recursivamente todos os tensores folha de uma estrutura potencialmente aninhada.

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

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/utils.py#L519)

Configure o modelo e as entradas para a exportação. Modifica tanto `model` quanto `inputs` no local, retornando `(model, inputs, output_flags)`, onde `output_flags` contém os valores removidos de `inputs` para `use_cache`, `return_dict`, etc. (a serem aplicados de forma reversível em `model.config` por `patch_model_config` durante o trace).

- Remove as entradas de rótulo (`labels`, `future_values`) — o cálculo de perda não é suportado.
- Extrai as flags de saída (`use_cache`, `return_dict`, …) de `inputs` para que não apareçam como kwargs rastreados; os valores são retornados para que o bloco de trace os aplique em `model.config`.
- Pré-computa os kwargs de visão/áudio dependentes de dados registrados via `@register_export_input_preparer` e os grava em `inputs`.
- Converte os tensores de entrada para corresponder ao `dtype` / `device` do 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)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/utils.py#L922)

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

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

Execute `model.generate()` e capture as entradas de prefill e decode.

Reutiliza todo o mecanismo de geração para que cada arquitetura (somente decodificador, SSM, codificador-decodificador, multimodal, …) receba entradas corretas sem reimplementar o loop.

`generation_config` é encaminhado para `generate()` (padrão: o próprio do modelo), de modo que as entradas capturadas utilizam o cache que `generate()` construiria. Passe um com `cache_implementation="static"` e `max_cache_len=N` para capturar um cache de **tamanho estático** nas entradas de decodificação — a base para uma exportação com cache estático. `max_cache_len` dimensiona o cache de forma independente da captura, de modo que a decodificação exportada utiliza um cache fixo `[..., N, ...]` em vez de um que cresce.

Quando `multi_token_decode`, o componente `decode` é capturado como um **multi-token** decode — duas etapas consecutivas de decode mescladas (veja `_merge_decode_calls`) para que o eixo de sequência de consulta permaneça simbólico (um decode de token único especializaria esse eixo para 1). Em seguida, ele lida tanto com um token (decodificação comum) quanto com muitos (continuação a partir do passado, ou um prefill simples quando o cache está vazio). Caso contrário, `decode` é o decode clássico de token único.

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

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

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/utils.py#L1045)

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

Uma entrada `name: (module, inputs)` para cada submódulo detectado (codificador de imagem/áudio, projetor, modelo de linguagem, lm_head).

**Exceções:** ``ValueError``

- ``ValueError`` -- se nenhum submódulo multi-modal conhecido for encontrado no modelo.

Capture as entradas de cada submódulo multimodal por meio de uma única passagem de frente.

Detecta todos os submódulos multimodais conhecidos pelo nome do atributo (torre de visão, projetor, modelo de linguagem, lm_head, …) e captura os kwargs do forward durante uma chamada de `model(**inputs)`.

Cada submódulo é retornado como uma entrada separada `name: (module, inputs)` para exportação independente. A etapa de mesclagem de tokens (por exemplo, `masked_scatter` para modelos multimodais) é intencionalmente deixada fora dos grafos exportados — é responsabilidade do chamador montar `inputs_embeds` a partir das saídas do codificador antes de executar o 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)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/utils.py#L1089)

**Parâmetros:**

model : Modelo generativo. Deve suportar `model.generate(**inputs)`.

inputs : kwargs de **Generate** — o que você passaria para `model.generate(**inputs)`.

generation_config : `GenerationConfig` opcional encaminhado para `generate()` durante a captura. Passe um com `cache_implementation="static"` + `max_cache_len=N` para exportar em relação a um cache de tamanho estático (veja `decompose_prefill_decode`).

multi_token_decode : Quando `True`, captura o componente `decode` como um decode de múltiplos tokens (eixo de sequência de consulta dinâmico: múltiplos tokens de uma vez — continuação a partir do passado, ou um prefill simples quando o cache está vazio); um decode de token único não pode permanecer dinâmico (veja `decompose_prefill_decode`).

**Retorna:** `{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.

Decomponha um modelo generativo em pares `(model, forward_inputs)` exportáveis de forma independente.

Executa `decompose_prefill_decode` para capturar os kwargs de forward de prefill e decode a partir de uma chamada real de `model.generate(**inputs, max_new_tokens=2)`. Se o prefill for multimodal (conforme `is_multimodal`), ele é dividido ainda mais em uma entrada por submódulo (codificador de visão/áudio, projetor, modelo de linguagem, `lm_head`) por meio de `decompose_multimodal`.

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

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

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/utils.py#L1036)

Retorna `True` se o modelo for multimodal, com codificadores de modalidade e um modelo de linguagem.

Um modelo que não é um `PreTrainedModel` (por exemplo, um `nn.Module` simples) não possui os acessores canônicos `get_encoder`/`get_decoder` e, trivialmente, não é multimodal, portanto, retorna `False` diretamente.

