# Ekspor

Backend ekspor baru dapat ditambahkan ke Transformers dengan membuat subclass dari `HfExporter` dan mendaftarkannya menggunakan [register_backend()](/docs/transformers/v5.23.0/id/main_classes/exporters#transformers.exporters.register_backend).

Pelajari cara menggunakan exporter bawaan dalam panduan [Exporters](../exporters).

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

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

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

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

Kelas Auto-HF exporter yang menangani instansiasi otomatis ke `HfExporter` yang tepat berdasarkan `ExportConfig`.

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

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

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

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

Kelas konfigurasi ekspor Auto-HF yang menangani penugasan otomatis ke konfigurasi ekspor yang tepat berdasarkan konfigurasi ekspor yang disimpan dalam kamus.

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

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

Daftarkan sebuah exporter, beserta `config_class`-nya, di bawah `export_format`-nya, dan runner yang menjalankan ekspor-nya, agar kelas auto dapat menemukannya.

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

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

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

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

Kelas basis abstrak untuk semua pengekspor Transformers.

Untuk menambahkan backend, turunkan kelas dan implementasikan `~HfExporter.export_program` untuk menelusuri satu graf, serta `~HfExporter.save_program` / `~HfExporter.load_program` untuk menulis dan membacanya kembali. Fungsi publik `~HfExporter.export` dan `~HfExporter.export_for_generation` membangun `ExportedModel` di atasnya.

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

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

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

**Mengembalikan:** `ExportedModel`

Satu komponen `"model"`; program backend adalah `.program`, dan `save_pretrained` menuliskannya bersama metadata dan konfigurasi model.

Ekspor model sebagai satu graf.

Menerima kwargs **forward** yang sama seperti `~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)
```

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

**Parameter:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel)) : Model generatif yang akan diekspor. Harus mendukung `model.generate(**sample_inputs)`.

sample_inputs (`dict[str, torch.Tensor | Cache]`) : **Generate** kwargs — apa yang akan Anda lewati ke `model.generate(**sample_inputs)` (biasanya `input_ids` + `attention_mask`, ditambah input modalitas apa pun seperti `pixel_values` / `input_features` untuk model multi-modal). Per-stage forward kwargs ditangkap secara internal.

config (`ExportConfigMixin` atau `dict[str, ExportConfigMixin]`) : Konfigurasi spesifik backend. Teruskan satu konfigurasi untuk diterapkan ke setiap komponen, atau `dict` yang dikey berdasarkan nama komponen (mis. `"image_encoder"`, `"language_model"`, `"lm_head"`, `"decode"`) untuk menimpa per komponen — semua nama komponen harus ada dalam dict.

generation_config ([GenerationConfig](/docs/transformers/v5.23.0/id/main_classes/text_generation#transformers.GenerationConfig), *opsional*) : Diteruskan ke capture `generate()` (defaultnya adalah milik model itu sendiri). Sampaikan satu dengan `cache_implementation="static"` untuk mengekspor terhadap `StaticCache` berukuran tetap.

multi_token_decode (`bool`, *opsional*, default `False`) : Apakah komponen `decode` memproses beberapa token kueri sekaligus — sumbu kueri dinamis (prefill pada cache kosong, kelanjutan-dari-masa-lalu selain itu) — atau langkah token-tunggal klasik (lihat [decompose_for_generation()](/docs/transformers/v5.23.0/id/main_classes/exporters#transformers.exporters.utils.decompose_for_generation)). Hanya tetap dinamis di bawah ekspor bentuk-dinamis (`config.dynamic=True`).

**Mengembalikan:** `ExportedModel`

Satu `ExportedComponent` per tahap, dengan kunci yang sama seperti [decompose_for_generation()](/docs/transformers/v5.23.0/id/main_classes/exporters#transformers.exporters.utils.decompose_for_generation).

Uraikan model generatif dan ekspor setiap komponen secara independen.

Wrapper tipis di sekitar [decompose_for_generation()](/docs/transformers/v5.23.0/id/main_classes/exporters#transformers.exporters.utils.decompose_for_generation) yang memanggil `~HfExporter.export_program` pada setiap pasangan `(submodel, forward_inputs)` yang dikembalikan. Jika Anda membutuhkan pasangan `(submodel, forward_inputs)` antara (untuk verifikasi, input kustom, melewati tahap, …), panggil [decompose_for_generation()](/docs/transformers/v5.23.0/id/main_classes/exporters#transformers.exporters.utils.decompose_for_generation) secara langsung.

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

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

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

**Parameter:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan diekspor.

sample_inputs (`dict[str, torch.Tensor | Cache]`) : **Forward** kwargs — apa yang akan Anda lewati ke `model(**sample_inputs)`. Argumen ini digunakan langsung sebagai input contoh selama tracing. Untuk ekspor langkah dekode autoregresif, ini berarti Anda perlu menyertakan `past_key_values`, `cache_position`, dan sebagainya. Jika Anda hanya memiliki input bergaya generasi, gunakan `~HfExporter.export_for_generation` sebagai gantinya — metode ini menjalankan `model.generate` untuk Anda dan mengekspor setiap tahap.

config (`ExportConfigMixin`) : Konfigurasi yang spesifik untuk backend.

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

Objek program backend (`ExportedProgram`, `onnx_ir.Model`, `ExecutorchProgramManager`, `openvino.Model`) dan metadata yang dicatat saat pelacakan (`build_export_metadata()`), dikembalikan secara terpisah karena hanya beberapa format yang dapat membawanya.

Lacak satu graf. Titik ekstensi backend, berpasangan dengan `~HfExporter.save_program`.

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

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

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

Baca kembali program yang ditulis oleh `~HfExporter.save_program`. Hasilnya dapat berbeda dari yang dikembalikan oleh `~HfExporter.export_program`: sebuah `Program` runtime untuk ExecuTorch, di mana `ExecutorchProgramManager` tidak dapat dibangun ulang dari file tersebut.

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

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

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

File yang ditulis oleh `~HfExporter.save_program` untuk program yang disimpan sebagai `filename`: file itu sendiri, plus apa pun yang dipertahankan oleh format di sisinya (bobot, data eksternal).

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

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

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

Tulis satu program yang dikembalikan oleh `~HfExporter.export_program` ke `path`, dalam format file backend.

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

```python
validate_environment()
```

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

Periksa apakah `required_packages` terpasang dan beri peringatan jika ada perbedaan versi dari `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)
```

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

Model yang diekspor: grafnya (`components`, `{name: ExportedComponent}`) dan konfigurasi yang menjadi acuan pelacakannya, yang dipanggil dengan cara yang sama seperti memanggil model asalnya.

`~HfExporter.export` menghasilkan satu komponen `"model"`, yang programnya adalah `.program`; `~HfExporter.export_for_generation` menghasilkan satu komponen per tahap 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)
```

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

Jalankan ekspor single-graph, mengembalikan apa yang dikembalikan oleh model sumber. Kwargs yang tidak ditelusuri saat ekspor akan dibuang, sehingga seluruh output dari processor dapat diteruskan. `share_inputs` dan `share_outputs` diteruskan ke runner (lihat `ModelRunner.__call__`): dengan `share_outputs`, output valid hingga pemanggilan berikutnya.

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

```python
program()
```

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

Program backend itu sendiri, untuk ekspor grafik tunggal.

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

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

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

Muat program pada runtime backend mereka, di `device` (default backend saat `None`). `runner_kwargs` diteruskan ke runner backend: `providers` dan `session_options` untuk ONNX Runtime, `config` (properti kompilasi) dan `torch_threads` (bagikan CPU dengan kerja torch di sekitar model) untuk OpenVINO.

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

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

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

**Parameter:**

save_directory (`str` atau `Path`) : Direktori untuk ditulis, dibuat jika tidak ada.

push_to_hub (`bool`, *opsional*, defaultnya `False`) : Apakah file yang disimpan juga akan diunggah ke Hub, ke `repo_id` (defaultnya adalah nama `save_directory` di namespace Anda).

kwargs (`dict[str, Any]`, *opsional*) : Diteruskan ke unggah Hub: `repo_id`, `commit_message`, `token`, `private`, ...

Tulis komponen (satu file masing-masing), konfigurasi, dan manifest yang menyebutkan file setiap komponen serta metadata yang dicatat saat pelacakan. `~ExportedModel.from_pretrained` memuatnya kembali.

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

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

**Parameter:**

pretrained_model_name_or_path (`str` atau `Path`) : Direktori lokal, atau id repo Hub. Dari Hub, hanya file yang namanya tercantum dalam manifest yang diunduh, sehingga hasil ekspor dapat berada berdampingan dengan bobot model itu sendiri.

device (`str` atau `torch.device`, *opsional*) : Di mana untuk menjalankannya (default backend saat `None`).

cache_dir (`Union[str, os.PathLike]`, *opsional*) : Path ke direktori tempat konfigurasi model pretrained yang diunduh harus di-cache jika cache standar tidak digunakan.

force_download (`bool`, *opsional*, default `False`) : Apakah akan memaksa (mengunduh ulang) bobot model dan file konfigurasi, menimpa versi yang sudah di-cache jika ada.

local_files_only (`bool`, *opsional*, defaultnya `False`) : Apakah hanya melihat file lokal (yaitu, tidak mencoba mengunduh model).

token (`str` atau `bool`, *opsional*) : Token yang digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika `True`, atau tidak ditentukan, akan menggunakan token yang dihasilkan saat menjalankan `hf auth login` (disimpan di `~/.huggingface`).

revision (`str`, *opsional*, defaultnya `"main"`) : Versi model spesifik yang akan digunakan. Ini bisa berupa nama branch, nama tag, atau id commit, karena kami menggunakan sistem berbasis git untuk menyimpan model dan artefak lainnya di huggingface.co, sehingga `revision` dapat berupa identifikasi apa pun yang diizinkan oleh git.    Untuk menguji pull request yang Anda buat di Hub, Anda dapat meneruskan `revision="refs/pr/<pr_number>"`.

subfolder (`str`, *opsional*, default `""`) : Jika file yang relevan berada di dalam subfolder dari repo model di huggingface.co, Anda dapat menentukan nama folder di sini.

trust_remote_code (`bool`, *opsional*, defaultnya `False`) : Apakah akan memuat konfigurasi model yang kodenya berada di repo-nya, seperti pada [from_pretrained()](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoConfig.from_pretrained).

runner_kwargs (*opsional*) : Opsi runner backend, seperti pada `~ExportedModel.to`: `providers` dan `session_options` untuk ONNX Runtime, `config` dan `torch_threads` untuk OpenVINO.

Muat apa yang ditulis oleh `~ExportedModel.save_pretrained`: setiap komponen melalui `~HfExporter.load_program` dari backend-nya, beserta metadata-nya, dan konfigurasi yang disimpan di sebelahnya. Program dimuat langsung pada runtime backend-nya, siap untuk dijalankan.

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

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

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

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

Satu graf yang diekspor: program backend, dan apa yang dicatat oleh exporter tentang program tersebut.

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

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

Apa yang dicatat oleh exporter tentang satu graf (`build_export_metadata()`).

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

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

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

Bangun metadata dari dict yang disimpan, lewati field yang tidak dimiliki kelas ini (ditambahkan oleh versi yang lebih baru).

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

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

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

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

Menjalankan satu program yang diekspor pada backend-nya: `runner(**kwargs)` mengembalikan apa yang dikembalikan oleh model sumber.

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

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

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

Pelaksana untuk program sebagai ekspor mengembalikannya atau `~HfExporter.load_program` membacanya kembali, pada `device` (default backend ketika `None`).

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

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

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

Bangun ulang output model dari output datar program (yang berada di akhir) dan konstanta yang direkam.

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

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

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

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

Exporter yang mengonversi [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel) menjadi `ExportedProgram`.

Contoh:

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

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

**Mengembalikan:** `ExportedModel`

Satu komponen `"model"`; program backend adalah `.program`, dan `save_pretrained` menuliskannya bersama metadata dan konfigurasi model.

Ekspor model sebagai satu graf.

Menerima kwargs **forward** yang sama seperti `~HfExporter.export_program`.

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

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

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

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

Exporter yang mengonversi [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel) menjadi graf ONNX (sebuah `onnx_ir.Model`).

Contoh:

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

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

**Mengembalikan:** `ExportedModel`

Satu komponen `"model"`; program backend adalah `.program`, dan `save_pretrained` menuliskannya bersama metadata dan konfigurasi model.

Ekspor model sebagai satu graf.

Menerima kwargs **forward** yang sama seperti `~HfExporter.export_program`.

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

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

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

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

Exporter yang mengonversi [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel) menjadi `ExecutorchProgramManager` ExecuTorch.

Contoh:

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

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

**Mengembalikan:** `ExportedModel`

Satu komponen `"model"`; program backend adalah `.program`, dan `save_pretrained` menuliskannya bersama metadata dan konfigurasi model.

Ekspor model sebagai satu graf.

Menerima kwargs **forward** yang sama seperti `~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)
```

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

**Parameter:**

dynamic (*bool*, *opsional*, default *False*) : Apakah akan mengekspor dengan bentuk dinamis (simbolik). Jika *True* dan *dynamic_shapes* tidak diatur, semua dimensi tensor akan diatur ke *Dim.AUTO* secara otomatis.

strict (*bool*, *opsional*, default *False*) : Apakah akan mengaktifkan mode ketat di *torch.export*. Menjalankan penelusuran simbolik penuh dan menangkap lebih banyak error, tetapi lebih lambat dan lebih berisiko gagal pada model yang kompleks.

dynamic_shapes (*dict[str, Any]*, *opsional*) : Spesifikasi bentuk dinamis per input eksplisit yang diteruskan ke *torch.export*. Mengambil prioritas di atas *dynamic*.

prefer_deferred_runtime_asserts_over_guards (*bool*, *opsional*, default *False*) : Jika *True*, guard bentuk yang bergantung pada data akan diterbitkan sebagai assert runtime dalam graf yang diekspor, alih-alih membuat ekspor gagal pada saat trace ketika guard tidak berlaku di seluruh rentang bentuk simbolik. Sebagian besar LLM transformer perlu mengatur ini ke *True* saat menggunakan batas `Dim(min=, max=)` yang terperinci. Tidak diperlukan dengan `dynamic=True` / `Dim.AUTO`, di mana `torch.export` menyimpulkan relasi bentuk alih-alih memverifikasinya terhadap batas yang dinyatakan pengguna.

quantizer ([*~exporters.quantizers.ExportQuantizer*], *opsional*) : Kuantisasi pasca-pelatihan yang diterapkan selama ekspor: [*~exporters.quantizers.PT2EQuantizer*] atau [*~exporters.quantizers.NNCFTorchFXQuantizer*] pada grafik FX untuk setiap backend, [*~exporters.quantizers.OnnxRuntimeQuantizer*] pada model ONNX yang dikonversi, atau [*~exporters.quantizers.NNCFOpenVINOQuantizer*] / [*~exporters.quantizers.NNCFOnnxQuantizer*] pada model OpenVINO / ONNX yang dikonversi.

Kelas konfigurasi untuk mengekspor model melalui *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)
```

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

**Parameter:**

opset_version (`int`, *opsional*) : versi opset ONNX yang ditargetkan. Secara default menggunakan opset terbaru yang didukung oleh versi `onnxscript` yang terpasang.

optimize (`bool`, *opsional*, default `True`) : Jalankan jalur optimasi `onnxscript` (constant folding, dead-code elimination, …) pada graf yang diekspor. Nonaktifkan untuk model yang mengalami bug pada optimiser `onnxscript` upstream.

ort_fusions (`str`, *opsional*) : Menggabungkan graf ke dalam ops ONNX Runtime untuk execution provider tempatnya berjalan: `"cpu"`, `"cuda"`, `"webgpu"` atau `"dml"`. Graf yang digabungkan hanya berjalan di ONNX Runtime. Memerlukan `optimize=True`.

Kelas konfigurasi untuk mengekspor model ke ONNX melalui `torch.onnx.export`.

Mewarisi semua field dari `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)
```

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

**Parameter:**

backend (`str`, *opsional*, default `"xnnpack"`) : Backend ExecuTorch target. Nilai yang didukung:  - `"xnnpack"` — Inferensi CPU melalui pustaka XNNPACK (default; berjalan di mana saja). - `"cuda"` — Inferensi GPU melalui backend ExecuTorch CUDA. - `"mlx"` — Inferensi GPU melalui backend ExecuTorch MLX pada Apple Silicon.

alloc_graph_input (`bool`, *opsional*, default `True`) : Apakah pass perencanaan memori mencadangkan memori arena untuk input graf. Ketika `False`, runtime menggunakan buffer input yang disediakan pemanggil secara langsung alih-alih menyalinnya ke arena — sehingga `USER_INPUT_MUTATION` in-place (misalnya penulisan `StaticCache`) akan terjadi pada tensor pemanggil, bukan pada salinan arena.

alloc_graph_output (`bool`, *opsional*, default `True`) : Apakah pass perencanaan memori mencadangkan memori arena untuk output graf. Jika `False`, pemanggil harus mengikat buffer output saat runtime (`Method::set_output_data_ptr`); mengikat output ke buffer input yang dimodifikasi menghindari roundtrip copy-out.

alloc_mutable_buffers (`bool`, *opsional*, default `True`) : Apakah pass perencanaan memori mencadangkan memori arena untuk buffer yang dapat diubah (state yang berada di model). Diteruskan ke `MemoryPlanningPass`.

Kelas konfigurasi untuk mengekspor model ke format ExecuTorch.

Mewarisi semua field dari `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)
```

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

**Parameter:**

compress_to_fp16 (*bool*, *opsional*, default *False*) : Kompres bobot *float32* model yang dikonversi menjadi *float16*, sehingga ukurannya berkurang setengah. Nonaktif secara default karena rentang nilainya lebih sempit.

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.

Kelas konfigurasi untuk mengekspor model ke OpenVINO IR melalui `openvino.convert_model`.

Mewarisi semua field dari [*DynamoConfig*] (*dynamic*, *strict*, *dynamic_shapes*, *prefer_deferred_runtime_asserts_over_guards*).

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

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

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

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

**Parameter:**

calibration_dataset (`Iterable[dict]`, *opsional*) : Dict input yang digunakan kuantizer untuk kalibrasi: sebuah list, atau `DataLoader` yang batch-nya dicollate menjadi input model. Untuk `~HfExporter.export_for_generation`, ini adalah kwargs generate, yang ditangkap ke dalam set kalibrasi per komponen. Ketika `None`, kuantizer yang membutuhkan data akan melakukan kalibrasi pada input sampel dari export itu sendiri, disertai peringatan.

Kelas dasar untuk kuantizer pasca-pelatihan yang diterapkan selama ekspor.

Quantizer menyatakan format ekspor yang didukungnya dan paket yang dibutuhkan (beserta versi yang diujinya, seperti pada exporter), serta apakah ia mengkuantisasi graf FX dari `torch.export` sebelum konversi apa pun (sehingga setiap backend menerima hasilnya), atau model yang dikonversi oleh backend (`onnx_ir.Model`, `openvino.Model`). Exporter memvalidasinya terhadap ekspor di awal, lalu memanggil `~ExportQuantizer.quantize` dengan model tersebut dan input sampel dari ekspor. Turunkan kelas ini dan implementasikan `quantize` untuk menambahkan metode kuantisasi baru; `CalibrationSet` memetakan sampel kalibrasi ke input model itu sendiri.

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

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

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

Kuantisasi `model` (graf FX jika `quantizes_fx_graph`, selain itu model backend) dan kembalikan hasilnya, yang dikalibrasi pada `calibration_dataset`, atau pada `sample_inputs` dari ekspor jika tidak ada.

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

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

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

Contoh kalibrasi sebagai kwargs yang ditelusuri, untuk kuantizer FX-graph.

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

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

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

Lempar error jika quantizer ini tidak dapat dijalankan pada ekspor `export_format`, atau jika paket yang dibutuhkan tidak ada atau versinya terlalu lama; berikan peringatan jika salah satunya berbeda dari versi yang diuji.

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

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

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

Salinan kuantizer ini yang melakukan kalibrasi pada `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])
```

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

Tampilan yang dapat diiterasi ulang dari sampel kalibrasi sebagai input model.

Sampel-sampel tersebut adalah `calibration_dataset` dari kuantizer, atau `sample_inputs` milik export itu sendiri (dengan peringatan, sekali dibaca) jika tidak ada. Sampel-sampel ini dapat berupa pemetaan apa pun, seperti `BatchEncoding` dari tokenizer. `transform` memetakan setiap sampel forward-kwarg menjadi apa yang diterima oleh model terkuantisasi (kwargs yang ditelusuri, umpan ONNX, umpan port OpenVINO), secara malas, satu sampel pada satu waktu, di setiap pass.

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

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

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

**Parameter:**

quantizer (`torchao.quantization.pt2e.quantizer.Quantizer`) : PT2E quantizer yang mengannotasi graf. Op quantize/dequantize-nya harus didukung oleh backend target: `X86InductorQuantizer` untuk inductor, ONNX (QDQ) atau OpenVINO, `XNNPACKQuantizer` untuk ExecuTorch.

calibration_dataset (`Iterable[dict]`, *opsional*) : Dict input yang digunakan observer untuk kalibrasi (lihat `ExportQuantizer`), satu forward per item. Untuk melakukan kalibrasi pada batch, berikan `DataLoader` yang menggabungkan sampel menjadi dict input ber-batch, alih-alih daftar sampel tunggal.

Kuantisasi graf FX dengan [PyTorch 2 Export (PT2E) quantization](https://docs.pytorch.org/ao/main/pt2e_quantization/index.html): `prepare_pt2e` menyisipkan observer, set kalibrasi menggerakkan observer tersebut, dan `convert_pt2e` menggantinya dengan op quantize/dequantize. Berfungsi dengan semua backend export.

Contoh:

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

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

Kuantisasi model ONNX yang telah dikonversi menggunakan alat bawaan ONNX Runtime (`onnxruntime.quantization`): `quantize_static` dengan `OnnxRuntimeStaticConfig` (default), atau `quantize_dynamic` dengan `OnnxRuntimeDynamicConfig`.

Contoh:

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

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

Argumen dari `onnxruntime.quantization.quantize_static`: aktivasi dan bobot int8 (QDQ secara default), dikalibrasi pada `calibration_dataset` kuantizer. Field yang dibiarkan `None` akan mempertahankan default ONNX Runtime. Lihat [`quantize_static`](https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html) untuk masing-masing argumen.

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

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

Argumen dari `onnxruntime.quantization.quantize_dynamic`: bobot int8, aktivasi dikuantisasi saat runtime, tanpa kalibrasi. Field yang dibiarkan `None` mempertahankan default ONNX Runtime. Lihat [`quantize_dynamic`](https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html) untuk masing-masing.

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

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

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

Kuantisasi model OpenVINO yang telah dikonversi dengan [NNCF](https://github.com/openvinotoolkit/nncf): `nncf.quantize` dengan `NNCFQuantizationConfig` (default), atau `nncf.compress_weights` dengan `NNCFWeightCompressionConfig`.

Contoh:

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

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

Kuantisasi model ONNX yang telah dikonversi dengan [NNCF](https://github.com/openvinotoolkit/nncf) melalui backend ONNX-nya: `nncf.quantize` dengan `NNCFQuantizationConfig` (default, int8 QDQ), atau `nncf.compress_weights` dengan `NNCFWeightCompressionConfig` (int4 sebagai `MatMulNBits` dari ONNX Runtime).

Contoh:

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

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

Kuantisasi graf FX `torch.export` dengan [NNCF](https://github.com/openvinotoolkit/nncf) melalui backend TorchFX-nya: `nncf.quantize` dengan `NNCFQuantizationConfig` (default, ops `quantize`/`dequantize`), atau `nncf.compress_weights` dengan `NNCFWeightCompressionConfig`. Seperti `PT2EQuantizer`, ini dijalankan sebelum konversi apa pun, sehingga setiap backend mengambil hasilnya. ExecuTorch hanya menurunkan hasil weight-only: XNNPACK tidak mendelegasikan ops `quantize`/`dequantize`, dan ExecuTorch tidak memiliki kernel untuk ops tersebut.

Contoh:

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

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

Argumen dari `nncf.quantize`: aktivasi dan bobot int8, dikalibrasi pada `calibration_dataset` kuantizer. Bidang yang dibiarkan `None` mempertahankan nilai default NNCF, kecuali `model_type`, yang defaultnya adalah `nncf.ModelType.TRANSFORMER`. Lihat [`nncf.quantize`](https://openvinotoolkit.github.io/nncf/autoapi/nncf/index.html#nncf.quantize) untuk masing-masing.

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

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

Argumen dari `nncf.compress_weights`: int8 atau int4 hanya untuk bobot, dengan metode yang sadar data (AWQ, estimasi skala, GPTQ) untuk mode int4. Mode int8 bebas data; yang lain melakukan kalibrasi pada `calibration_dataset` dari kuantizer. `gptq` dan `lora_correction` hanya tersedia di OpenVINO. Bidang yang dibiarkan sebagai `None` akan mempertahankan nilai default NNCF. Lihat [`nncf.compress_weights`](https://openvinotoolkit.github.io/nncf/autoapi/nncf/index.html#nncf.compress_weights) untuk detail masing-masing.

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

Fungsi tingkat rendah yang mendukung `export_for_generation`, berguna ketika Anda perlu melakukan intervensi antara dekomposisi model dan ekspor setiap komponen.

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

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

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

**Parameter:**

obj (`Any`) : Tensor, dataclass, dict, list, tuple, atau penelanan (nesting) dari salah satu di antaranya.

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

Pemetaan datar dari string jalur bertitik ke tensor.

Ambil semua tensor daun secara rekursif dari struktur yang mungkin bersarang.

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

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

Konfigurasikan model dan input untuk ekspor. Mengubah `model` dan `inputs` secara langsung, mengembalikan `(model, inputs, output_flags)` di mana `output_flags` berisi nilai yang diambil dari `inputs` untuk `use_cache`, `return_dict`, dan sebagainya (untuk diterapkan secara reversibel ke `model.config` oleh `patch_model_config` selama pelacakan).

- Menghapus input label (`labels`, `future_values`) — perhitungan loss tidak didukung.
- Mengeluarkan flag output (`use_cache`, `return_dict`, …) dari `inputs` agar tidak muncul sebagai kwargs yang ditelusuri; nilai-nilai tersebut dikembalikan agar blok trace dapat menerapkannya ke `model.config`.
- Menghitung sebelumnya kwargs visi/audio yang bergantung pada data yang didaftarkan melalui `@register_export_input_preparer` dan menuliskannya ke dalam `inputs`.
- Mengubah tipe tensor input agar sesuai dengan `dtype` / `device` model.

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

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

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

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

Jalankan `model.generate()` dan tangkap input prefill dan decode.

Menggunakan mekanisme generasi penuh sehingga setiap arsitektur (decoder-only, SSM, encoder-decoder, multi-modal, …) mendapatkan input yang benar tanpa perlu mengimplementasikan ulang loop.

`generation_config` diteruskan ke `generate()` (defaultnya adalah milik model itu sendiri), sehingga input yang ditangkap menggunakan cache apa pun yang akan dibangun oleh `generate()`. Sampaikan satu dengan `cache_implementation="static"` dan `max_cache_len=N` untuk menangkap cache **berukuran statis** pada input decode — dasar untuk ekspor cache statis. `max_cache_len` menentukan ukuran cache secara independen dari proses penangkapan, sehingga decode yang diekspor menerima cache `[..., N, ...]` yang tetap, bukan yang terus bertambah.

Ketika `multi_token_decode`, komponen `decode` ditangkap sebagai decode **multi-token** — dua langkah decode berurutan yang digabungkan (lihat `_merge_decode_calls`) sehingga sumbu query-sequence-nya tetap simbolik (decode single-token akan menspesialisasikan sumbu tersebut menjadi 1). Komponen ini kemudian menangani baik satu token (decoding biasa) maupun banyak token (continuation-from-past, atau prefill biasa jika cache kosong). Sebaliknya, `decode` adalah decode single-token klasik.

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

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

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

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

Satu entri `name: (module, inputs)` per submodul yang terdeteksi (encoder gambar/audio, projector, model bahasa, lm_head).

**Mengangkat:** ``ValueError``

- ``ValueError`` -- jika tidak ada submodul multi-modal yang dikenal ditemukan pada model.

Ambil input untuk setiap submodul multi-modal melalui satu jalur maju (forward pass).

Mendeteksi semua submodul multi-modal yang dikenal berdasarkan nama atribut (vision tower, projector, language model, lm_head, …) dan menangkap kwargs forward mereka selama satu pemanggilan `model(**inputs)`.

Setiap submodul dikembalikan sebagai entri `name: (module, inputs)` terpisah untuk ekspor independen. Langkah penggabungan token (misalnya `masked_scatter` untuk model multi-modal) sengaja dibiarkan di luar grafik yang diekspor — menjadi tanggung jawab pemanggil untuk merakit `inputs_embeds` dari keluaran encoder sebelum menjalankan decoder.

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

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

**Parameter:**

model : Model generatif. Harus mendukung `model.generate(**inputs)`.

inputs : kwargs **Generate** — apa yang akan Anda lewati ke `model.generate(**inputs)`.

generation_config : `GenerationConfig` opsional yang diteruskan ke `generate()` selama capture. Berikan satu dengan `cache_implementation="static"` + `max_cache_len=N` untuk mengekspor terhadap cache berukuran statis (lihat `decompose_prefill_decode`).

multi_token_decode : Ketika `True`, tangkap komponen `decode` sebagai decode multi-token (sumbu urutan query dinamis: beberapa token sekaligus — kelanjutan dari masa lalu, atau prefill biasa jika cache kosong); decode single-token tidak bisa tetap dinamis (lihat `decompose_prefill_decode`).

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

Uraikan model generatif menjadi pasangan `(model, forward_inputs)` yang dapat diekspor secara independen.

Menjalankan `decompose_prefill_decode` untuk menangkap kwargs forward prefill dan decode dari `model.generate(**inputs, max_new_tokens=2)` yang sebenarnya. Jika prefill bersifat multi-modal (sesuai `is_multimodal`), maka dipecah lebih lanjut menjadi satu entri per submodul (vision/audio encoder, projector, language model, `lm_head`) melalui `decompose_multimodal`.

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

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

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

Mengembalikan `True` jika model bersifat multi-modal dengan encoder modal dan model bahasa.

Model yang bukan `PreTrainedModel` (misalnya `nn.Module` polos) tidak memiliki accessor `get_encoder`/`get_decoder` yang kanonik dan secara trivial bukan multi-modal, sehingga langsung mengembalikan `False`.