# Экспортеры

Новые backends экспорта можно добавить в Transformers, создав подкласс `HfExporter` и зарегистрировав его с помощью [register_backend()](/docs/transformers/v5.23.0/ru/main_classes/exporters#transformers.exporters.register_backend).

Узнайте, как использовать встроенные экспортеры, в руководстве [Exporters](../exporters).

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

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/auto.py#L112)

Класс экспортера Auto-HF, который автоматически создаёт экземпляр правильного `HfExporter` на основе переданного `ExportConfig`.

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

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/auto.py#L101)

Класс конфигурации экспорта Auto-HF, который автоматически выбирает правильную конфигурацию экспорта на основе конфигурации, сохранённой в словаре.

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/auto.py#L61)

Зарегистрируйте экспортер, указав его `config_class`, под его `export_format`, а также раннер, который выполняет его экспорт, чтобы автоклассы могли их найти.

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

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L321)

Абстрактный базовый класс для всех экспортеров Transformers.

Чтобы добавить бэкенд, создайте подкласс и реализуйте `~HfExporter.export_program` для трассировки одного графа, а также `~HfExporter.save_program` / `~HfExporter.load_program` для записи и чтения. Публичные методы `~HfExporter.export` и `~HfExporter.export_for_generation` строят `ExportedModel` на их основе.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L407)

**Возвращает:** `ExportedModel`

Один компонент `"model"`; программа бэкенда — `.program`, а `save_pretrained` записывает её вместе с метаданными и конфигурацией модели.

Экспортируйте модель как один граф.

Принимает те же аргументы **forward**, что и `~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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L426)

**Параметры:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel)): генеративная модель для экспорта. Должна поддерживать `model.generate(**sample_inputs)`.

sample_inputs (`dict[str, torch.Tensor | Cache]`) : аргументы **Generate** — то, что вы передаёте в `model.generate(**sample_inputs)` (обычно `input_ids` + `attention_mask`, а также входные данные других модальностей, например `pixel_values` / `input_features` для мультимодальных моделей). Аргументы forward для каждого этапа фиксируются внутренне.

config (`ExportConfigMixin` или `dict[str, ExportConfigMixin]`) : Конфигурация, специфичная для бэкенда. Передайте один конфиг, чтобы применить его ко всем компонентам, или `dict` с ключами по имени компонента (например, `"image_encoder"`, `"language_model"`, `"lm_head"`, `"decode"`), чтобы переопределить настройки для каждого компонента — в словаре должны присутствовать все имена компонентов.

generation_config ([GenerationConfig](/docs/transformers/v5.23.0/ru/main_classes/text_generation#transformers.GenerationConfig), *optional*) : Передаётся в вызов `generate()` (по умолчанию используется собственная конфигурация модели). Передайте объект с `cache_implementation="static"`, чтобы экспортировать модель с фиксированным размером `StaticCache`.

multi_token_decode (`bool`, *необязательный*, по умолчанию `False`) : Указывает, обрабатывает ли компонент `decode` несколько токенов запроса за один проход — динамическая ось запроса (prefill при пустом кэше, продолжение от past в противном случае) — или классический пошаговый режим с одним токеном (см. [decompose_for_generation()](/docs/transformers/v5.23.0/ru/main_classes/exporters#transformers.exporters.utils.decompose_for_generation)). Остаётся динамической только при экспорте с динамической формой (`config.dynamic=True`).

**Возвращает:** `ExportedModel`

По одному `ExportedComponent` на каждый этап, с теми же ключами, что и у [decompose_for_generation()](/docs/transformers/v5.23.0/ru/main_classes/exporters#transformers.exporters.utils.decompose_for_generation).

Разложите генеративную модель и экспортируйте каждый компонент независимо.

Thin wrapper around [decompose_for_generation()](/docs/transformers/v5.23.0/ru/main_classes/exporters#transformers.exporters.utils.decompose_for_generation) that calls `~HfExporter.export_program` on every returned `(submodel, forward_inputs)` pair. If you need the intermediate `(submodel, forward_inputs)` pairs (for verification, custom inputs, skipping a stage, …), call [decompose_for_generation()](/docs/transformers/v5.23.0/ru/main_classes/exporters#transformers.exporters.utils.decompose_for_generation) directly.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L351)

**Параметры:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel)): модель, которую нужно экспортировать.

sample_inputs (`dict[str, torch.Tensor | Cache]`) : **Forward** kwargs — аргументы, которые вы передаёте в `model(**sample_inputs)`. Они используются непосредственно в качестве примеров входных данных во время трассировки. Для экспорта шага авторегрессивного декодирования необходимо включить `past_key_values`, `cache_position` и т. д. Если у вас есть только входные данные в стиле генерации, используйте вместо этого `~HfExporter.export_for_generation` — он запускает `model.generate` за вас и экспортирует каждый этап.

config (`ExportConfigMixin`) : Конфигурация, специфичная для бэкенда.

**Возвращает:** `tuple[Any, ExportMetadata]`

Объект программы бэкенда (`ExportedProgram`, `onnx_ir.Model`, `ExecutorchProgramManager`, `openvino.Model`) и метаданные, записанные при трассировке (`build_export_metadata()`), возвращаются отдельно, поскольку только некоторые форматы могут их содержать.

Отслеживание одного графа. Точка расширения бэкенда, используемая в паре с `~HfExporter.save_program`.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L385)

Чтение программы, сохранённой с помощью `~HfExporter.save_program`. Она может отличаться от той, которую вернул `~HfExporter.export_program`: это программа `Program` для ExecuTorch, `ExecutorchProgramManager` которой невозможно восстановить из файла.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L392)

Файлы, которые `~HfExporter.save_program` записывает для программы, сохранённой как `filename`: сам файл, а также любые данные, которые формат хранит рядом с ним (веса, внешние данные).

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L380)

Запишите одну программу, возвращаемую `~HfExporter.export_program`, в `path` в формате файла, используемом бэкендом.

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

```python
validate_environment()
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L347)

Проверьте, установлены ли `required_packages`, и предупредите о расхождении версий с `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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L67)

Экспортированная модель: её графы (`components`, `{name: ExportedComponent}`) и конфигурации, по которым они были прослежены, вызываемые так же, как и исходная модель.

`~HfExporter.export` создаёт один компонент `"model"`, чья программа — `.program`; `~HfExporter.export_for_generation` создаёт по одному компоненту на каждый этап генерации.

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L143)

Выполняет экспорт с одним графом, возвращая то, что возвращает исходная модель. Ключевые аргументы, с которыми экспорт не был прослежен, отбрасываются, поэтому можно передать весь вывод процессора. `share_inputs` и `share_outputs` передаются в раннер (см. `ModelRunner.__call__`): при `share_outputs` выводы остаются действительными до следующего вызова.

#### программа[[transformers.exporters.ExportedModel.program]]

```python
program()
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L108)

Собственная программа бэкенда для экспорта единого графа.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L130)

Загрузите программы на рантайм их бэкенда, на `device` (по умолчанию для бэкенда, если `None`). `runner_kwargs` передаются в раннер бэкенда: `providers` и `session_options` для ONNX Runtime, `config` (свойства компиляции) и `torch_threads` (разделить CPU с работой torch вокруг модели) для OpenVINO.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L156)

**Параметры:**

save_directory (`str` или `Path`) : Каталог для записи, создаётся, если не существует.

push_to_hub (`bool`, *необязательный*, по умолчанию `False`) : Загружать ли сохранённые файлы также в Hub, в `repo_id` (по умолчанию — имя `save_directory` в вашем пространстве имён).

kwargs (`dict[str, Any]`, *необязательный*) : Передаётся в загрузку на Hub: `repo_id`, `commit_message`, `token`, `private`, ...

Создайте компоненты (по одному файлу на каждый), конфигурации и манифест, в котором указаны файлы каждого компонента и метаданные, записанные при трассировке. `~ExportedModel.from_pretrained` загружает их обратно.

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L206)

**Параметры:**

pretrained_model_name_or_path (`str` или `Path`) : локальный каталог или идентификатор репозитория на Hub. Из Hub загружаются только файлы, указанные в манифесте, поэтому экспорт может находиться рядом с собственными весами модели.

device (`str` или `torch.device`, *необязательный*) : Где выполнять (значение по умолчанию для бэкенда, если `None`).

cache_dir (`Union[str, os.PathLike]`, *необязательный*) : Путь к каталогу, в котором должен кэшироваться загруженный конфигурационный файл предобученной модели, если стандартный кэш не используется.

force_download (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли принудительно (пере)загружать веса модели и файлы конфигурации, игнорируя кэшированные версии, если они существуют.

local_files_only (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли только локальные файлы (то есть не пытаться загрузить модель).

token (`str` или `bool`, *необязательный*) : Токен, используемый в качестве HTTP bearer-авторизации для удалённых файлов. Если указано значение `True` или параметр не задан, будет использован токен, сгенерированный при выполнении `hf auth login` (хранится в `~/.huggingface`).

revision (`str`, *необязательный*, по умолчанию `"main"`) : Конкретная версия модели, которую следует использовать. Это может быть имя ветки, имя тега или идентификатор коммита, поскольку для хранения моделей и других артефактов на huggingface.co используется система на базе git, поэтому `revision` может быть любым идентификатором, разрешённым git.    Чтобы протестировать pull request, который вы создали на Hub, можно передать `revision="refs/pr/<pr_number>"`.

subfolder (`str`, *необязательный*, по умолчанию `""`) : Если соответствующие файлы находятся в подпапке репозитория модели на huggingface.co, здесь можно указать имя папки.

trust_remote_code (`bool`, *необязательный*, по умолчанию `False`) : Загружать ли конфигурацию модели, код которой находится в её репозитории, как в случае с [from_pretrained()](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoConfig.from_pretrained).

runner_kwargs (*необязательный*) : параметры запуска бэкенда, как для `~ExportedModel.to`: `providers` и `session_options` для ONNX Runtime, `config` и `torch_threads` для OpenVINO.

Загрузите то, что записало `~ExportedModel.save_pretrained`: каждый компонент через `~HfExporter.load_program` его бэкенда, вместе с метаданными, а также конфигурации, сохранённые рядом с ними. Программы сразу загружаются в рантайм соответствующего бэкенда и готовы к запуску.

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

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L60)

Один экспортированный граф: программа бэкенда и сведения, которые экспортер записал о ней.

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/metadata.py#L58)

Что экспортер записал об одном графе (`build_export_metadata()`).

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/metadata.py#L75)

Создайте метаданные из сохранённого словаря, пропуская поля, которых нет в этом классе (добавленные в более новой версии).

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

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/runners/base.py#L29)

Выполняет один экспортированный программный модуль на его бэкенде: `runner(**kwargs)` возвращает то, что возвращает исходная модель.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/runners/base.py#L56)

Запускающая программа как экспорт возвращает его, либо `~HfExporter.load_program` считывает его обратно, на `device` (значение по умолчанию для бэкенда, если `None`).

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/runners/base.py#L47)

Восстановите выходные данные модели из плоских выходов программы (которые идут последними) и записанных констант.

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

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/exporter_dynamo.py#L69)

Экспортер, который преобразует [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel) в `ExportedProgram`.

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L407)

**Возвращает:** `ExportedModel`

Один компонент `"model"`; программа бэкенда — `.program`, а `save_pretrained` записывает её вместе с метаданными и конфигурацией модели.

Экспортируйте модель как один граф.

Принимает те же аргументы **forward**, что и `~HfExporter.export_program`.

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

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/exporter_onnx.py#L113)

Экспортер, преобразующий [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel) в граф ONNX (`onnx_ir.Model`).

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L407)

**Возвращает:** `ExportedModel`

Один компонент `"model"`; программа бэкенда — `.program`, а `save_pretrained` записывает её вместе с метаданными и конфигурацией модели.

Экспортируйте модель как один граф.

Принимает те же аргументы **forward**, что и `~HfExporter.export_program`.

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

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/exporter_executorch.py#L107)

Экспортер, который преобразует [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel) в `ExecutorchProgramManager` ExecuTorch.

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/base.py#L407)

**Возвращает:** `ExportedModel`

Один компонент `"model"`; программа бэкенда — `.program`, а `save_pretrained` записывает её вместе с метаданными и конфигурацией модели.

Экспортируйте модель как один граф.

Принимает те же аргументы **forward**, что и `~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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/configs.py#L92)

**Параметры:**

dynamic (*bool*, *optional*, по умолчанию *False*) : Экспортировать с динамическими (символьными) формами. Если *True* и *dynamic_shapes* не задано, все измерения тензоров автоматически устанавливаются в *Dim.AUTO*.

strict (*bool*, *optional*, по умолчанию *False*) : Включает ли строгий режим в *torch.export*. Выполняет полную символьную трассировку и обнаруживает больше ошибок, но работает медленнее и с большей вероятностью завершается с ошибкой на сложных моделях.

dynamic_shapes (*dict[str, Any]*, *необязательный*) : Явные спецификации динамических форм для каждого входа, передаваемые в *torch.export*. Имеют приоритет над *dynamic*.

prefer_deferred_runtime_asserts_over_guards (*bool*, *optional*, по умолчанию *False*) : Если установлено значение *True*, проверки форм данных, зависящие от данных, выводятся как runtime-asserts в экспортируемом графе, а не приводят к сбою экспорта на этапе трассировки, если проверка не выполняется для всего диапазона символьных форм. Для большинства трансформерных LLM при использовании точных границ `Dim(min=, max=)` необходимо установить это значение в *True*. Не требуется при использовании `dynamic=True` / `Dim.AUTO`, поскольку в этом случае `torch.export` выводит соотношения форм, а не проверяет их по границам, указанным пользователем.

quantizer ([*~exporters.quantizers.ExportQuantizer*], *optional*) : Посттренировочная квантизация, применяемая при экспорте: [*~exporters.quantizers.PT2EQuantizer*] или [*~exporters.quantizers.NNCFTorchFXQuantizer*] для графа FX для каждого бэкенда, [*~exporters.quantizers.OnnxRuntimeQuantizer*] для сконвертированной модели ONNX, либо [*~exporters.quantizers.NNCFOpenVINOQuantizer*] / [*~exporters.quantizers.NNCFOnnxQuantizer*] для сконвертированной модели OpenVINO / ONNX.

Класс конфигурации для экспорта моделей через *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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/configs.py#L134)

**Параметры:**

opset_version (`int`, *optional*) : версия opset ONNX, для которой выполняется генерация. По умолчанию используется последняя версия opset, поддерживаемая установленной версией `onnxscript`.

optimize (`bool`, *необязательный*, по умолчанию `True`) : Запускать проходы оптимизации `onnxscript` (свёртка констант, удаление мёртвого кода, …) для экспортированного графа. Отключите для моделей, которые сталкиваются с ошибками оптимизатора `onnxscript` в исходной реализации.

ort_fusions (`str`, *необязательный*) : Слить граф в операции ONNX Runtime для провайдера выполнения, на котором он работает: `"cpu"`, `"cuda"`, `"webgpu"` или `"dml"`. Слитый граф работает только в ONNX Runtime. Требуется `optimize=True`.

Класс конфигурации для экспорта моделей в ONNX через `torch.onnx.export`.

Наследует все поля из `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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/configs.py#L168)

**Параметры:**

backend (`str`, *необязательный*, по умолчанию `"xnnpack"`) : Целевой бэкенд ExecuTorch. Поддерживаемые значения:  - `"xnnpack"` — CPU-инференс через библиотеку XNNPACK (по умолчанию; работает везде). - `"cuda"` — GPU-инференс через CUDA-бэкенд ExecuTorch. - `"mlx"` — GPU-инференс через MLX-бэкенд ExecuTorch на Apple Silicon.

alloc_graph_input (`bool`, *необязательный*, по умолчанию `True`) : Определяет, резервирует ли этап планирования памяти память арены для входов графа. Если `False`, среда выполнения использует буферы входов, переданные вызывающим кодом, напрямую, вместо копирования в арену — в результате in-place `USER_INPUT_MUTATION` (например, запись в `StaticCache`) выполняется в тензоре вызывающего кода, а не в копии в арене.

alloc_graph_output (`bool`, *необязательный*, по умолчанию `True`) : Указывает, резервирует ли этап планирования памяти память арены для выходов графа. Если `False`, вызывающая сторона должна привязать буферы выходов во время выполнения (`Method::set_output_data_ptr`); привязка выхода к буферу изменённого входа позволяет избежать дополнительного копирования данных.

alloc_mutable_buffers (`bool`, *необязательный*, по умолчанию `True`) : Указывает, резервирует ли этап планирования памяти (memory-planning pass) память в арене для изменяемых буферов (состояние, резидентное в модели). Передаётся в `MemoryPlanningPass`.

Класс конфигурации для экспорта моделей в формат ExecuTorch.

Наследует все поля из `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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/configs.py#L205)

**Параметры:**

compress_to_fp16 (*bool*, *optional*, по умолчанию *False*) : Сжать веса *float32* преобразованной модели до *float16*, уменьшив её размер вдвое. По умолчанию отключено из-за более узкого диапазона значений.

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.

Класс конфигурации для экспорта моделей в формат OpenVINO IR с помощью `openvino.convert_model`.

Наследует все поля из [*DynamoConfig*] (*dynamic*, *strict*, *dynamic_shapes*, *prefer_deferred_runtime_asserts_over_guards*).

## Квантизаторы[[transformers.exporters.ExportQuantizer]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/base.py#L33)

**Параметры:**

calibration_dataset (`Iterable[dict]`, *необязательный*) : Входящие словари, на которых квантизатор выполняет калибровку: список или `DataLoader`, чьи батчи собираются в входные данные модели. Для `~HfExporter.export_for_generation` это аргументы generate, которые фиксируются в набор для калибровки для каждого компонента. Если указано `None`, квантизатор, требующий данных, выполняет калибровку на собственных примерах экспорта, при этом выводится предупреждение.

Базовый класс для квантизаторов, применяемых на этапе пост-обучения при экспорте.

Квантизатор объявляет поддерживаемые форматы экспорта и необходимые пакеты (с версиями, на которых он протестирован, как и экспортеры), а также то, квантизует ли он граф FX из `torch.export` до какого-либо преобразования (чтобы каждый бэкенд получал результат) или модель, в которую бэкенд преобразует этот граф (`onnx_ir.Model`, `openvino.Model`). Экспортер заранее валидирует его по отношению к экспорту, а затем вызывает `~ExportQuantizer.quantize`, передавая эту модель и входные данные для примеров из экспорта. Чтобы добавить новый метод квантизации, создайте подкласс и реализуйте `quantize`; `CalibrationSet` сопоставляет калибровочные примеры с собственными входами модели.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/base.py#L83)

Квантуйте `model` (FX-граф, если `quantizes_fx_graph`, иначе — модель бэкенда) и верните результат, откалиброванный на `calibration_dataset` или на `sample_inputs` экспорта, если датасет не задан.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/base.py#L76)

Образцы калибровки в качестве отслеженных kwargs, для квантизаторов FX-графов.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/base.py#L68)

Вызвать исключение, если данный квантизатор не может работать с экспортом в формате `export_format`, либо если отсутствует или устарела необходимая зависимость; выдать предупреждение, если версия отличается от той, на которой проводилось тестирование.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/base.py#L62)

Копия этого квантизатора, выполняющая калибровку на `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])
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/base.py#L89)

Повторно итерируемое представление калибровочных образцов в качестве входных данных модели.

Образцами служат `calibration_dataset` квантизатора либо собственные `sample_inputs` экспорта (с предупреждением, при первом чтении), если квантизатор их не содержит. Образцами может быть любое отображение, например `BatchEncoding` токенизатора. `transform` преобразует каждый образец, соответствующий аргументам forward, в то, что принимает квантованная модель (отслеживаемые kwargs, входные данные ONNX, входные порты OpenVINO), лениво, по одному образцу за раз, на каждом проходе.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/quantizer_pt2e.py#L33)

**Параметры:**

quantizer (`torchao.quantization.pt2e.quantizer.Quantizer`) : PT2E-квантизатор, который размечает граф. Его операции квантизации/деквантизации должны поддерживаться целевым бэкендом: `X86InductorQuantizer` для inductor, ONNX (QDQ) или OpenVINO, `XNNPACKQuantizer` для ExecuTorch.

calibration_dataset (`Iterable[dict]`, *необязательный*) : Входящие словари, на которых наблюдатели выполняют калибровку (см. `ExportQuantizer`), по одному пропуску на каждый. Для калибровки на батчах передайте `DataLoader`, который объединяет примеры в батчи входных словарей, а не список отдельных примеров.

Квантизация графа FX с помощью [квантизации PyTorch 2 Export (PT2E)](https://docs.pytorch.org/ao/main/pt2e_quantization/index.html): `prepare_pt2e` вставляет наблюдатели, набор данных калибровки управляет ими, а `convert_pt2e` заменяет их на операции квантизации/деквантизации. Работает со всеми бэкендами экспорта.

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/quantizer_onnxruntime.py#L78)

Квантуйте преобразованную ONNX-модель с помощью собственных инструментов ONNX Runtime (`onnxruntime.quantization`): `quantize_static` с `OnnxRuntimeStaticConfig` (по умолчанию) или `quantize_dynamic` с `OnnxRuntimeDynamicConfig`.

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/quantizer_onnxruntime.py#L41)

Аргументы `onnxruntime.quantization.quantize_static`: int8 для активаций и весов (по умолчанию QDQ), калиброванные на `calibration_dataset` квантизатора. Поле, оставленное равным `None`, сохраняет значение по умолчанию ONNX Runtime. См. [`quantize_static`](https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html) для каждого из них.

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/quantizer_onnxruntime.py#L62)

Аргументы `onnxruntime.quantization.quantize_dynamic`: веса int8, активации квантуются во время выполнения, калибровка не требуется. Поле, оставленное равным `None`, сохраняет значение по умолчанию ONNX Runtime. См. [`quantize_dynamic`](https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html) для каждого из них.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/quantizer_nncf.py#L143)

Квантуйте преобразованную модель OpenVINO с помощью [NNCF](https://github.com/openvinotoolkit/nncf): `nncf.quantize` с `NNCFQuantizationConfig` (по умолчанию) или `nncf.compress_weights` с `NNCFWeightCompressionConfig`.

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/quantizer_nncf.py#L175)

Квантуйте сконвертированную ONNX-модель с помощью [NNCF](https://github.com/openvinotoolkit/nncf) через её ONNX-бэкенд: `nncf.quantize` с `NNCFQuantizationConfig` (по умолчанию, int8 QDQ) или `nncf.compress_weights` с `NNCFWeightCompressionConfig` (int4 в виде `MatMulNBits` ONNX Runtime).

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/quantizer_nncf.py#L231)

Квантизация графа FX из `torch.export` с помощью [NNCF](https://github.com/openvinotoolkit/nncf) через его бэкенд TorchFX: `nncf.quantize` с `NNCFQuantizationConfig` (по умолчанию, операции `quantize`/`dequantize`) или `nncf.compress_weights` с `NNCFWeightCompressionConfig`. Как и `PT2EQuantizer`, она выполняется до любого преобразования, поэтому каждый бэкенд получает её результат. ExecuTorch понижает только результат weight-only: XNNPACK не делегирует операции `quantize`/`dequantize`, а в ExecuTorch нет для них ядер.

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/quantizer_nncf.py#L58)

Аргументы `nncf.quantize`: int8-активации и веса, откалиброванные на `calibration_dataset` квантизатора. Поле, оставленное равным `None`, сохраняет значение по умолчанию NNCF, за исключением `model_type`, для которого значением по умолчанию является `nncf.ModelType.TRANSFORMER`. См. [`nncf.quantize`](https://openvinotoolkit.github.io/nncf/autoapi/nncf/index.html#nncf.quantize) для каждого из них.

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/quantizers/quantizer_nncf.py#L76)

Аргументы `nncf.compress_weights`: только веса int8 или int4, с методами, учитывающими данные (AWQ, оценка масштаба, GPTQ), для режимов int4. Режимы int8 не требуют данных; остальные калибруются на `calibration_dataset` квантизатора. `gptq` и `lora_correction` доступны только в OpenVINO. Поле, оставленное равным `None`, сохраняет значение по умолчанию NNCF. См. [`nncf.compress_weights`](https://openvinotoolkit.github.io/nncf/autoapi/nncf/index.html#nncf.compress_weights) для каждого из них.

## Утилиты[[transformers.exporters.utils.get_leaf_tensors]]

Функции низкого уровня, обеспечивающие работу `export_for_generation`, которые полезны, когда необходимо вмешаться между декомпозицией модели и экспортом каждого компонента.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/utils.py#L348)

**Параметры:**

obj (`Any`): тензор, dataclass, dict, list, tuple или любая вложенная комбинация этих типов.

**Возвращает:** `dict[str, torch.Tensor]`

Плоское отображение из строковых путей с точками в тензоры.

Рекурсивно получить все тензоры-листья из потенциально вложенной структуры.

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/utils.py#L519)

Настройте модель и входные данные для экспорта. Метод изменяет `model` и `inputs` на месте, возвращая `(model, inputs, output_flags)`, где `output_flags` содержит значения, извлечённые из `inputs` для `use_cache`, `return_dict` и т. д. (они будут обратимо применены к `model.config` с помощью `patch_model_config` во время трассировки).

- Удаляет входные данные меток (`labels`, `future_values`) — вычисление потерь не поддерживается.
- Удаляет флаги вывода (`use_cache`, `return_dict`, …) из `inputs`, чтобы они не появлялись в трассируемых kwargs; значения возвращаются для применения блоком трассировки к `model.config`.
- Предварительно вычисляет kwargs для зрения/аудио, зависящие от данных и зарегистрированные через `@register_export_input_preparer`, и записывает их в `inputs`.
- Преобразует входные тензоры в соответствии с `dtype` / `device` модели.

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/utils.py#L922)

**Возвращает:** `dict[str, tuple[torch.nn.Module, dict]]`

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

Запустите `model.generate()` и зафиксируйте входные данные для prefill и decode.

Повторно использует полный механизм генерации, чтобы каждая архитектура (только декодер, SSM, энкодер-декодер, мультимодальная, …) получала корректные входные данные без необходимости переписывать цикл.

`generation_config` передаётся в `generate()` (по умолчанию используется собственный конфиг модели), поэтому захваченные входные данные используют тот же кэш, который построит `generate()`. Передайте конфиг с `cache_implementation="static"` и `max_cache_len=N`, чтобы захватить кэш **фиксированного размера** во входных данных декодирования — это основа для экспорта со статическим кэшем. `max_cache_len` задаёт размер кэша независимо от процесса захвата, поэтому экспортированный декодер работает с фиксированным кэшем `[..., N, ...]`, а не с растущим.

При `multi_token_decode` компонент `decode` захватывается как **multi-token** decode — два последовательных шага декодирования объединяются (см. `_merge_decode_calls`), чтобы ось query-последовательности оставалась символьной (при single-token decode эта ось специализируется в 1). В таком режиме обрабатываются как один токен (обычное декодирование), так и несколько (продолжение из past, или обычный prefill, если кэш пуст). В противном случае `decode` — это классический single-token decode.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/utils.py#L1045)

**Возвращает:** `dict[str, tuple[torch.nn.Module, dict]]`

Одна запись `name: (module, inputs)` на каждый обнаруженный подмодуль (кодировщик изображений/аудио, проектор, языковая модель, lm_head).

**Исключения:** ``ValueError``

- ``ValueError`` — если в модели не найдены известные мультимодальные подмодули.

Захватите входные данные для каждого мультимодального подмодуля за один прямой проход.

Определяет все известные мультимодальные подмодули по имени атрибута (vision tower, projector, language model, lm_head, …) и фиксирует их forward kwargs во время одного вызова `model(**inputs)`.

Каждый подмодуль возвращается как отдельная запись `name: (module, inputs)` для независимого экспорта. Шаг слияния токенов (например, `masked_scatter` для мультимодальных моделей) намеренно вынесен за пределы экспортируемых графов — ответственность за сборку `inputs_embeds` из выходов энкодера перед запуском декодера лежит на вызывающей стороне.

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/utils.py#L1089)

**Параметры:**

model : Генеративная модель. Должна поддерживать `model.generate(**inputs)`.

inputs : **Generate** kwargs — то, что вы передаёте в `model.generate(**inputs)`.

generation_config : Необязательный `GenerationConfig`, передаваемый в `generate()` во время захвата. Передайте конфигурацию с `cache_implementation="static"` + `max_cache_len=N`, чтобы экспортировать модель с кэшем фиксированного размера (см. `decompose_prefill_decode`).

multi_token_decode : Если `True`, компонент `decode` захватывается как много-токеновый decode (динамическая ось последовательности запроса: несколько токенов за раз — продолжение из кэша или обычный prefill, если кэш пуст); одно-токеновый decode не может оставаться динамическим (см. `decompose_prefill_decode`).

**Возвращаемое значение:** `{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.

Разбейте генеративную модель на независимо экспортируемые пары `(model, forward_inputs)`.

Выполняет `decompose_prefill_decode`, чтобы получить kwargs для forward-прохода prefill и decode из реального вызова `model.generate(**inputs, max_new_tokens=2)`. Если prefill мультимодальный (по `is_multimodal`), он дополнительно разбивается на один элемент на подмодуль (vision/audio encoder, projector, language model, `lm_head`) с помощью `decompose_multimodal`.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/exporters/utils.py#L1036)

Возвращает `True`, если модель мультимодальная и содержит модальные энкодеры и языковую модель.

Модель, не являющаяся `PreTrainedModel` (например, обычный `nn.Module`), не имеет канонических аксессоров `get_encoder`/`get_decoder` и тривиально не является мультимодальной, поэтому функция сразу возвращает `False`.

