# Ekspor

Backend ekspor baru dapat ditambahkan ke Transformers dengan membuat subclass dari `HfExporter`.

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/main/src/transformers/exporters/auto.py#L93)

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

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

```python
from_pretrained(pretrained_model_name_or_path, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/auto.py#L113)

Muat instance exporter dari model/checkpoint terlatih sebelumnya yang menyertakan konfigurasi ekspor.

**Belum diimplementasikan** — placeholder untuk alur kerja "export recipe" yang first-class.

Idenya: pemilik model menerbitkan `export_config.json` (atau field `export_config` di `config.json`) bersama bobot mereka di Hub. File tersebut merekam pengaturan yang sudah divalidasi pemilik untuk arsitektur mereka — format target (`dynamo` / `onnx` / `executorch`), spesifikasi bentuk dinamis yang tepat (misalnya `text_ids` dinamis hingga 4096, ubin gambar tetap pada 448, `batch=1` untuk deployment edge), flag `strict`, opset ONNX, tata letak prefill vs. decode, pilihan backend ExecuTorch, dan semua pengaturan lain yang saat ini hanya ada sebagai pengetahuan lisan di README atau notebook pribadi.

Konsumen kemudian mendapatkan ekspor yang telah divalidasi oleh pemilik dalam satu panggilan:

```python
exporter = AutoHfExporter.from_pretrained("org/model-name")
program = exporter.export(model, inputs)
```

        Bekerja sama dengan registry [*register_export_input_preparer*]: pemilik menyediakan spesifikasi bentuk melalui `export_config.json`, sedangkan transformers menyediakan pra-komputasi yang bergantung pada data (`cu_seqlens`, id posisi visual, indeks jendela, …) untuk arsitektur tersebut. Bersama-sama, keduanya mencakup dua bagian sulit dalam mengekspor model baru — mengetahui kontrak bentuk yang tepat dan menyiapkan input yang tepat — sehingga pengguna hilir tidak perlu menurunkannya kembali dari nol (dan tidak akan rusak di produksi jika keliru).

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

```python
supports_export_format(export_config_dict: dict)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/auto.py#L145)

Kembalikan True jika dict yang diberikan menggambarkan `export_format` yang memiliki kelas config terdaftar dan kelas exporter terdaftar. Memberikan peringatan dengan pesan yang dapat ditindaklanjuti jika format tersebut hilang sepenuhnya, tidak dikenal, atau hanya terdaftar setengah.

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

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/auto.py#L65)

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

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

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/base.py#L41)

Kelas basis abstrak untuk semua pengekspor Transformers.

Subclass dan implementasikan `~HfExporter.export` untuk menambahkan backend ekspor baru.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/base.py#L61)

**Parameter:**

model ([PreTrainedModel](/docs/transformers/main/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:**

Artefak ekspor yang spesifik untuk backend.

Ekspor model dan kembalikan objek program yang spesifik untuk backend.

#### 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/main/src/transformers/exporters/base.py#L93)

**Parameter:**

model ([PreTrainedModel](/docs/transformers/main/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/main/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/main/id/main_classes/exporters#transformers.exporters.utils.decompose_for_generation)). Hanya tetap dinamis di bawah ekspor bentuk-dinamis (`config.dynamic=True`).

**Mengembalikan:** `dict[str, Any]`

`{component_name: backend_specific_artifact}` — kunci yang sama dengan [decompose_for_generation()](/docs/transformers/main/id/main_classes/exporters#transformers.exporters.utils.decompose_for_generation). Nilainya adalah apa pun yang dikembalikan oleh `~HfExporter.export` untuk backend yang konkret (`ExportedProgram`, `ONNXProgram`, `ExecutorchProgramManager`).

Uraikan model generatif dan ekspor setiap komponen secara independen.

Wrapper tipis di sekitar [decompose_for_generation()](/docs/transformers/main/id/main_classes/exporters#transformers.exporters.utils.decompose_for_generation) yang memanggil `~HfExporter.export` 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/main/id/main_classes/exporters#transformers.exporters.utils.decompose_for_generation) secara langsung.

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

```python
validate_environment(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/base.py#L57)

Periksa apakah `required_packages` terpasang dan beri peringatan jika ada perbedaan versi dari `tested_versions`.

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

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

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

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

Exporter yang mengonversi [PreTrainedModel](/docs/transformers/main/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.module()(**inputs)
```

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

```python
export(model: PreTrainedModel, sample_inputs: MutableMapping[str, Any], config: DynamoConfig | dict[str, Any])
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_dynamo.py#L87)

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

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_onnx.py#L108)

Exporter yang mengonversi [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel) menjadi `ONNXProgram` ONNX.

Contoh:

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

>>> exporter = OnnxExporter()
>>> onnx_program = exporter.export(model, inputs, config=OnnxConfig(dynamic=True))
>>> outputs = onnx_program(**inputs)  # run in-memory
>>> exporter.export(model, inputs, config=OnnxConfig(output_path="model.onnx"))  # save to disk
```

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

```python
export(model: PreTrainedModel, sample_inputs: MutableMapping[str, Any], config: OnnxConfig | dict[str, Any])
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_onnx.py#L126)

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

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_executorch.py#L109)

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

Contoh:

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

>>> exporter = ExecutorchExporter()
>>> et_program = exporter.export(model, inputs, config=ExecutorchConfig(backend="xnnpack"))
>>> et_program.write_to_file("model.pte")
```

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

```python
export(model: PreTrainedModel, sample_inputs: MutableMapping[str, Any], config: ExecutorchConfig | dict[str, Any])
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_executorch.py#L126)

Ekspor model ke ExecuTorch, menerapkan persiapan backend dan patch torch op.

## 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/main/src/transformers/exporters/configs.py#L83)

**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, output_path: str | PathLike | None = None, opset_version: int | None = None, external_data: bool = True, optimize: bool = True, export_params: bool = True, keep_initializers_as_inputs: bool = False)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/configs.py#L125)

**Parameter:**

output_path (`str` atau `PathLike`, *opsional*) : Jalur keluaran untuk file `.onnx`. Jika `None` (default), model yang diekspor disimpan di memori sebagai `ONNXProgram` dan tidak ditulis ke disk.

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

external_data (`bool`, *opsional*, default `True`) : Menyimpan tensor bobot besar dalam file sidecar `.onnx_data` terpisah, alih-alih menyematkannya di dalam protobuf. Diperlukan untuk model yang bobotnya melebihi batas protobuf 2 GB.

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.

export_params (`bool`, *opsional*, default `True`) : Menyematkan bobot model ke dalam graf ONNX. Atur ke `False` untuk mengekspor graf tanpa bobot (bobot harus disediakan saat runtime).

keep_initializers_as_inputs (`bool`, *opsional*, default `False`) : Menampilkan inisialisator bobot sebagai input grafik eksplisit. Diperlukan oleh beberapa runtime ONNX yang lebih lama (opset < 9).

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/main/src/transformers/exporters/configs.py#L167)

**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, output_path: str | PathLike | None = None, compress_to_fp16: bool = True, stateful: bool = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/configs.py#L204)

**Parameter:**

output_path (*str* atau *PathLike*, *opsional*) : Jalur keluaran untuk file *.xml* (file *.bin* yang sesuai ditulis berdampingan). Ketika *None* (default), model yang dikonversi disimpan di memori sebagai `openvino.Model`.

compress_to_fp16 (*bool*, *opsional*, default *True*) : Kompres bobot floating-point ke FP16 saat menyimpan — mengurangi ukuran di disk menjadi setengahnya dengan dampak akurasi yang dapat diabaikan pada sebagian besar model. Hanya diterapkan ketika `output_path` disetel.

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/main/src/transformers/exporters/quantizers/base.py#L32)

**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/main/src/transformers/exporters/quantizers/base.py#L77)

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.

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

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

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

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/main/src/transformers/exporters/quantizers/base.py#L61)

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

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/main/src/transformers/exporters/quantizers/quantizer_pt2e.py#L34)

**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/main/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/main/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/main/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/main/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/main/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/main/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/main/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/main/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/main/src/transformers/exporters/utils.py#L340)

**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/main/src/transformers/exporters/utils.py#L407)

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/main/src/transformers/exporters/utils.py#L811)

**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/main/src/transformers/exporters/utils.py#L934)

**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/main/src/transformers/exporters/utils.py#L978)

**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/main/src/transformers/exporters/utils.py#L925)

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