# エクスポート

`HfExporter` をサブクラス化し、[register_backend()](/docs/transformers/v5.23.0/ja/main_classes/exporters#transformers.exporters.register_backend) で登録することで、Transformers に新しいエクスポートバックエンドを追加できます。

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

`ExportConfig`に基づいて、適切な`HfExporter`に自動的にインスタンス化を行うAuto-HFエクスポートクラスです。

## 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` 配下およびエクスポートを実行するランナーとして登録し、auto クラスがそれらを発見できるようにします。

## 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` を実装して1つのグラフをトレースし、`~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`はこれにメタデータとモデル設定を付けて書き出します。

モデルを1つのグラフとしてエクスポートします。

`~HfExporter.export_program` と同じ **forward** の kwargs を受け取ります。

#### 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/ja/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"`）を渡すことでコンポーネントごとに上書きできます。dict にはすべてのコンポーネント名が含まれている必要があります。

generation_config ([GenerationConfig](/docs/transformers/v5.23.0/ja/main_classes/text_generation#transformers.GenerationConfig)、*optional*) : `generate()` のキャプチャに転送されます（デフォルトではモデル自身のものを使用）。固定サイズの`StaticCache`に対してエクスポートするには、`cache_implementation="static"`を指定したものを渡してください。

multi_token_decode (`bool`、*任意*、デフォルトは `False`) : `decode` コンポーネントが複数のクエリトークンを一度に処理するかどうかを示します。動的なクエリ軸（キャッシュが空の場合は prefill、それ以外は past からの継続）と、従来の単一トークンステップ（[decompose_for_generation()](/docs/transformers/v5.23.0/ja/main_classes/exporters#transformers.exporters.utils.decompose_for_generation) を参照）のいずれかを指定します。動的な形状のエクスポート（`config.dynamic=True`）の場合にのみ、動的な状態を維持します。

**戻り値:** `ExportedModel`

ステージごとに1つの`ExportedComponent`があり、[decompose_for_generation()](/docs/transformers/v5.23.0/ja/main_classes/exporters#transformers.exporters.utils.decompose_for_generation)と同じキーを持ちます。

生成モデルを分解し、各コンポーネントを独立してエクスポートします。

Thin wrapper around [decompose_for_generation()](/docs/transformers/v5.23.0/ja/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/ja/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/ja/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()`）は、一部のフォーマットのみがメタデータを保持できるため、別々に返されます。

1つのグラフをトレースします。`~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` が返したものと異なる場合があります。ExecuTorch 用のランタイム `Program` であり、その `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` が返す 1 つのプログラムを、バックエンドのファイル形式で `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` は、生成ステージごとに1つのコンポーネントを生成します。

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

単一グラフのエクスポートを実行し、ソースモデルが返すものを返します。エクスポート時にトレースされなかったKwargは破棄されるため、プロセッサの出力全体を渡すことができます。`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` はバックエンドのランナーに渡されます。ONNX Runtime には `providers` と `session_options`、OpenVINO には `config`（コンパイルプロパティ）と `torch_threads`（モデルの周りで torch の処理と CPU を分割）を指定します。

#### 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`) : 保存されたファイルを`repo_id`（デフォルトは`save_directory`の名前）に、Hub にもアップロードするかどうか。

kwargs (`dict[str, Any]`, *省略可*) : Hub アップロードに渡されます: `repo_id`, `commit_message`, `token`, `private`, ...

コンポーネント（1つにつき1ファイル）、設定ファイル、および各コンポーネントのファイル名とトレース時に記録されたメタデータを含むマニフェストを作成します。`~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 のリポジトリ ID。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 ベアラ認証に使用するトークン。`True` の場合、または指定されていない場合は、`hf auth login` を実行した際に生成されたトークン（`~/.huggingface` に保存）が使用されます。

revision (`str`、*任意*、デフォルトは`"main"`) : 使用する特定のモデルのバージョンです。huggingface.co ではモデルやその他の成果物を保存するために git ベースのシステムを使用しているため、`revision` には git で許可される任意の識別子（ブランチ名、タグ名、コミット ID など）を指定できます。    Hub で作成したプルリクエストをテストするには、`revision="refs/pr/<pr_number>"` を渡すことができます。

subfolder (`str`、*任意*、デフォルトは`""`) : 関連するファイルが huggingface.co 上のモデルリポジトリ内のサブフォルダに配置されている場合、ここにフォルダ名を指定できます。

trust_remote_code (`bool`、*任意*、デフォルトは`False`) : [from_pretrained()](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoConfig.from_pretrained)と同様に、コードがリポジトリに存在するモデルの設定を読み込むかどうか。

runner_kwargs (*任意*) : `~ExportedModel.to` と同様に、バックエンドのランナーオプションです。ONNX Runtime には `providers` と `session_options`、OpenVINO には `config` と `torch_threads` が該当します。

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

エクスポートされたグラフは1つ: バックエンドのプログラムと、エクスポートツールがそれについて記録した情報です。

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

エクスポートが1つのグラフについて記録した内容(`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)

バックエンドでエクスポートされたプログラムを1つ実行します: `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)

`ExportedProgram` に変換する [PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) のエクスポートツールです。

例:

```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`はこれにメタデータとモデル設定を付けて書き出します。

モデルを1つのグラフとしてエクスポートします。

`~HfExporter.export_program` と同じ **forward** の kwargs を受け取ります。

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

`onnx_ir.Model`（ONNXグラフ）へ[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)を変換するエクスポートツール。

例:

```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`はこれにメタデータとモデル設定を付けて書き出します。

モデルを1つのグラフとしてエクスポートします。

`~HfExporter.export_program` と同じ **forward** の kwargs を受け取ります。

## 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/ja/main_classes/model#transformers.PreTrainedModel) を ExecuTorch の `ExecutorchProgramManager` に変換する Exporter です。

例:

```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`はこれにメタデータとモデル設定を付けて書き出します。

モデルを1つのグラフとしてエクスポートします。

`~HfExporter.export_program` と同じ **forward** の kwargs を受け取ります。

## 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]*、*optional*) : *torch.export* に渡す、入力ごとの動的形状の明示的な指定です。*dynamic* より優先されます。

prefer_deferred_runtime_asserts_over_guards (*bool*、*optional*、デフォルトは *False*) : *True* の場合、データ依存の形状ガードは、トレース時にガードがシンボリック形状の全範囲にわたって成立しない場合にエクスポートを失敗させるのではなく、エクスポートされたグラフ内でランタイムアサートとして出力されます。細粒度の `Dim(min=, max=)` 境界を使用するほとんどの Transformer LLM では、これを *True* に設定する必要があります。`dynamic=True` / `Dim.AUTO` を使用する場合、`torch.export` がユーザーが指定した境界に対して検証するのではなく、形状の関係を推論するため、この設定は不要です。

quantizer ([*~exporters.quantizers.ExportQuantizer*]、*optional*) : エクスポート時に適用されるポストトレーニング量子化: すべてのバックエンドの FX グラフに対して [*~exporters.quantizers.PT2EQuantizer*] または [*~exporters.quantizers.NNCFTorchFXQuantizer*]、変換後の ONNX モデルに対して [*~exporters.quantizers.OnnxRuntimeQuantizer*]、変換後の OpenVINO / ONNX モデルに対して [*~exporters.quantizers.NNCFOpenVINOQuantizer*] / [*~exporters.quantizers.NNCFOnnxQuantizer*]。

*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`, *任意*) : ターゲットとする ONNX opset のバージョンです。デフォルトでは、インストールされている `onnxscript` のバージョンがサポートする最新の opset が使用されます。

optimize (`bool`、*任意*、デフォルトは`True`) : エクスポートされたグラフに対して`onnxscript`の最適化パス（定数畳み込み、デッドコードエリミネーションなど）を実行します。アップストリームの`onnxscript`オプティマイザーのバグに遭遇するモデルでは無効にしてください。

ort_fusions (`str`, *任意*) : グラフを、実行する実行プロバイダー（`"cpu"`、`"cuda"`、`"webgpu"`または`"dml"`）のONNX Runtimeのオペレーターに融合します。融合されたグラフはONNX Runtimeでのみ実行できます。`optimize=True`が必要です。

`torch.onnx.export` を介してモデルを ONNX にエクスポートするための設定クラスです。

`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"` — XNNPACK ライブラリによる CPU 推論（デフォルト。どこでも実行可能）。 - `"cuda"` — ExecuTorch CUDA バックエンドによる GPU 推論。 - `"mlx"` — Apple Silicon 上で ExecuTorch MLX バックエンドによる GPU 推論。

alloc_graph_input (`bool`、*任意*、デフォルトは `True`) : メモリ計画パスがグラフの入力に対してアレーナメモリを確保するかどうかを指定します。`False` の場合、ランタイムはコピーせずに呼び出し元が提供した入力バッファを直接使用します。そのため、インプレースの `USER_INPUT_MUTATION`（例：`StaticCache` への書き込み）は、アレーナのコピーではなく呼び出し元のテンソルに反映されます。

alloc_graph_output (`bool`、*任意*、デフォルトは `True`) : メモリ計画パスがグラフの出力用にアレーナメモリを確保するかどうか。`False` の場合、呼び出し側が実行時に出力バッファをバインドする必要があります（`Method::set_output_data_ptr`）。出力を、変更された入力と同じバッファにバインドすることで、コピーアウトの往復を回避できます。

alloc_mutable_buffers (`bool`、*任意*、デフォルトは `True`) : メモリ計画パスが、可変バッファ（モデル常駐状態）のためにアリーナメモリを確保するかどうかを指定します。`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.convert_model` を介してモデルを OpenVINO IR にエクスポートするための設定クラスです。

[*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 の kwarg であり、コンポーネントごとにキャリブレーションセットとして取得されます。`None`の場合、データが必要な量子化器は、エクスポート自身のサンプル入力でキャリブレーションを行い、警告が表示されます。

エクスポート時に適用されるポストトレーニング量子化器の基底クラスです。

Quantizer は、エクスポート時にサポートするエクスポート形式と、必要なパッケージ（exporter と同様に、テスト済みのバージョンを含む）を宣言します。また、変換を行う前に `torch.export` FX グラフを量子化するか（その場合、すべてのバックエンドが結果を受け取ります）、それともバックエンドが変換したモデル（`onnx_ir.Model`、`openvino.Model`）を量子化するかを指定します。exporter は最初にエクスポートに対して検証を行い、その後、そのモデルとエクスポートのサンプル入力引数を引数として `~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`（`quantizes_fx_graph` が真の場合は FX グラフ、それ以外の場合はバックエンドモデル）を量子化し、`calibration_dataset` 上でキャリブレーションした結果を返します。`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)

FXグラフ量子化器用の、トレースされたkwargsとしてのキャリブレーションサンプル。

#### 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`は、各パスにおいて1サンプルずつ遅延評価で、各フォワード kwarg のサンプルを、量子化モデルが受け取る形式（トレースされた 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 クアンタイザーです。その quantize/dequantize 演算子は、ターゲットバックエンドがサポートしているものでなければなりません: inductor には `X86InductorQuantizer`、ONNX (QDQ) または OpenVINO、ExecuTorch には `XNNPACKQuantizer`。

calibration_dataset (`Iterable[dict]`、*任意*) : 観測者がキャリブレーションに使用する入力辞書（`ExportQuantizer`を参照）で、1回ずつのフォワードパス分です。バッチでキャリブレーションを行う場合は、単一のサンプルのリストではなく、サンプルをバッチ化された入力辞書にまとめる`DataLoader`を渡してください。

[PyTorch 2 Export (PT2E) 量子化](https://docs.pytorch.org/ao/main/pt2e_quantization/index.html)で FX グラフを量子化します: `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`) で量子化します。`OnnxRuntimeStaticConfig` (デフォルト) を使用した `quantize_static`、または `OnnxRuntimeDynamicConfig` を使用した `quantize_dynamic` を使用できます。

例:

```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` (ONNX Runtime の `MatMulNBits` による int4) を指定します。

例:

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

`torch.export` FX グラフを、その TorchFX バックエンド経由で [NNCF](https://github.com/openvinotoolkit/nncf) により量子化します: `NNCFQuantizationConfig` (デフォルトの `quantize`/`dequantize` オペレーション) を使用した `nncf.quantize`、または `NNCFWeightCompressionConfig` を使用した `nncf.compress_weights` です。`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` の引数: データ認識型手法 (AWQ、スケール推定、GPTQ) を用いた weight-only の int8 または int4 です。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` には、`use_cache` や `return_dict` などの値が `inputs` からポップされて保持されます（トレース中に `patch_model_config` によって `model.config` に可逆的に適用されます）。

- ラベル入力(`labels`、`future_values`)を除去します。損失の計算はサポートされていません。
- `inputs` から出力フラグ（`use_cache`、`return_dict` など）を取り除き、トレースされた kwargs として表示されないようにします。これらの値は返され、トレースブロックによって `model.config` に適用されます。
- `@register_export_input_preparer` によって登録されたデータ依存の vision/audio kwargs を事前計算し、`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 の入力を取得します。

完全な生成機構を再利用することで、すべてのアーキテクチャ（decoder-only、SSM、encoder-decoder、マルチモーダルなど）が、ループを再実装することなく正しい入力を受け取ります。

`generation_config` は `generate()` に転送されます（デフォルトではモデル自身の設定が使用されます）。そのため、キャプチャされる入力には、`generate()` が構築するであろうキャッシュが使用されます。`cache_implementation="static"` と `max_cache_len=N` を指定して渡すことで、デコード入力に**静的にサイズ指定された**キャッシュをキャプチャできます。これが static-cache エクスポートの基盤となります。`max_cache_len` はキャプチャとは独立してキャッシュのサイズを決定するため、エクスポートされたデコードは増加するキャッシュではなく、固定の `[..., N, ...]` キャッシュを使用します。

`multi_token_decode` が設定されている場合、`decode` コンポーネントは**マルチトークン**デコードとしてキャプチャされます。これは2つの連続するデコードステップをマージしたものです（`_merge_decode_calls` を参照）。これにより、クエリシーケンス軸がシンボリックな状態を維持されます（単一トークンのデコードでは、その軸が 1 に特殊化されてしまうためです）。その後、1 トークン（通常のデコード）と複数トークン（過去からの継続、またはキャッシュが空の場合の通常のプリフィル）の両方を処理します。それ以外の場合、`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]]`

検出された各サブモジュール（画像/音声エンコーダー、プロジェクター、言語モデル、lm_head）ごとに、`name: (module, inputs)` エントリが1つあります。

**例外:** ``ValueError``

- ``ValueError`` -- モデル上で既知のマルチモーダルサブモジュールが見つからない場合。

単一の forward passで、各マルチモーダルサブモジュールへの入力をキャプチャします。

属性名（vision tower、projector、language model、lm_head など）に基づいて既知のマルチモーダルサブモジュールをすべて検出し、`model(**inputs)` の呼び出し1回中にそれらの forward kwargs を取得します。

各サブモジュールは、独立したエクスポートのために、`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 : キャプチャ中に `generate()` に転送される任意の `GenerationConfig`。静的にサイズ指定されたキャッシュに対してエクスポートするには、`cache_implementation="static"` と `max_cache_len=N` を指定して渡します（`decompose_prefill_decode` を参照）。

multi_token_decode : `True`の場合、`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` を実行し、実際の `model.generate(**inputs, max_new_tokens=2)` から prefill と decode の forward kwargs を取得します。prefill がマルチモーダルである場合(`is_multimodal` に従う)、`decompose_multimodal` を介して、サブモジュール(ビジョン/オーディオエンコーダー、プロジェクター、言語モデル、`lm_head`)ごとに1エントリずつ分割します。

#### 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` にショートサーキットします。

