# Trình xuất

Các backend xuất mới có thể được thêm vào Transformers bằng cách kế thừa `HfExporter` và đăng ký nó với [register_backend()](/docs/transformers/v5.23.0/vi/main_classes/exporters#transformers.exporters.register_backend).

Tìm hiểu cách sử dụng các trình xuất có sẵn trong hướng dẫn [Exporters](../exporters).

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

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

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

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

Lớp Auto-HF exporter chịu trách nhiệm tự động khởi tạo thành `HfExporter` phù hợp dựa trên `ExportConfig` được cung cấp.

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

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

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

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

Lớp cấu hình xuất Auto-HF chịu trách nhiệm tự động chuyển hướng đến cấu hình xuất chính xác dựa trên cấu hình xuất được lưu trong một từ điển.

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

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

Đăng ký một exporter, cùng với `config_class` của nó, dưới `export_format` của nó, và runner thực hiện các xuất của nó, để các lớp auto có thể tìm thấy chúng.

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

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

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

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

Lớp trừu tượng cơ sở cho tất cả các trình xuất của Transformers.

Để thêm một backend, hãy kế thừa và triển khai `~HfExporter.export_program` để trace một graph, cùng với `~HfExporter.save_program` / `~HfExporter.load_program` để ghi ra và đọc lại. Các phương thức công khai `~HfExporter.export` và `~HfExporter.export_for_generation` sẽ xây dựng một `ExportedModel` dựa trên chúng.

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

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

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

**Trả về:** `ExportedModel`

Một thành phần `"model"` duy nhất; chương trình của backend là `.program`, và `save_pretrained` sẽ ghi nó cùng với metadata và cấu hình mô hình.

Xuất mô hình dưới dạng một đồ thị duy nhất.

Nhận cùng các tham số **forward** như `~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)
```

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

**Tham số:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel)) : Mô hình sinh cần xuất. Phải hỗ trợ `model.generate(**sample_inputs)`.

sample_inputs (`dict[str, torch.Tensor | Cache]`) : **Generate** kwargs — những gì bạn sẽ truyền vào `model.generate(**sample_inputs)` (thường là `input_ids` + `attention_mask`, cùng với các đầu vào đa phương thức như `pixel_values` / `input_features` cho các mô hình đa phương thức). Các kwargs forward cho từng giai đoạn được ghi nhận bên trong.

config (`ExportConfigMixin` hoặc `dict[str, ExportConfigMixin]`) : Cấu hình cụ thể cho backend. Truyền một cấu hình duy nhất để áp dụng cho mọi thành phần, hoặc một `dict` có khóa là tên thành phần (ví dụ: `"image_encoder"`, `"language_model"`, `"lm_head"`, `"decode"`) để ghi đè cho từng thành phần — tất cả tên thành phần phải có mặt trong dict.

generation_config ([GenerationConfig](/docs/transformers/v5.23.0/vi/main_classes/text_generation#transformers.GenerationConfig), *tuỳ chọn*) : Được chuyển tiếp đến capture `generate()` (mặc định là của chính model). Truyền một cấu hình có `cache_implementation="static"` để xuất đối với `StaticCache` có kích thước cố định.

multi_token_decode (`bool`, *tuỳ chọn*, mặc định là `False`) : Xác định xem thành phần `decode` có xử lý nhiều token truy vấn cùng lúc — một trục truy vấn động (prefill trên bộ nhớ đệm trống, hoặc tiếp nối từ quá khứ trong các trường hợp khác) — hay là bước đơn token cổ điển (xem [decompose_for_generation()](/docs/transformers/v5.23.0/vi/main_classes/exporters#transformers.exporters.utils.decompose_for_generation)). Chỉ duy trì ở chế độ động khi xuất với hình dạng động (`config.dynamic=True`).

**Trả về:** `ExportedModel`

Một `ExportedComponent` cho mỗi giai đoạn, với các khóa giống như [decompose_for_generation()](/docs/transformers/v5.23.0/vi/main_classes/exporters#transformers.exporters.utils.decompose_for_generation).

Phân tách một mô hình sinh và xuất từng thành phần một cách độc lập.

Lớp bọc mỏng quanh [decompose_for_generation()](/docs/transformers/v5.23.0/vi/main_classes/exporters#transformers.exporters.utils.decompose_for_generation), gọi `~HfExporter.export_program` trên mỗi cặp `(submodel, forward_inputs)` được trả về. Nếu bạn cần các cặp `(submodel, forward_inputs)` trung gian (để xác minh, đầu vào tùy chỉnh, bỏ qua một giai đoạn, …), hãy gọi trực tiếp [decompose_for_generation()](/docs/transformers/v5.23.0/vi/main_classes/exporters#transformers.exporters.utils.decompose_for_generation).

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

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

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

**Tham số:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel)): Mô hình cần xuất.

sample_inputs (`dict[str, torch.Tensor | Cache]`) : **Forward** kwargs — những gì bạn sẽ truyền vào `model(**sample_inputs)`. Chúng được sử dụng trực tiếp làm đầu vào mẫu trong quá trình tracing. Đối với xuất khẩu bước giải mã tự hồi quy, điều này có nghĩa là bạn cần bao gồm `past_key_values`, `cache_position`, v.v. Nếu bạn chỉ có các đầu vào kiểu sinh, hãy sử dụng `~HfExporter.export_for_generation` thay thế — nó sẽ chạy `model.generate` cho bạn và xuất khẩu từng giai đoạn.

config (`ExportConfigMixin`) : Cấu hình cụ thể cho backend.

**Trả về:** `tuple[Any, ExportMetadata]`

Đối tượng chương trình của backend (`ExportedProgram`, `onnx_ir.Model`, `ExecutorchProgramManager`, `openvino.Model`) và các metadata được ghi lại trong quá trình tracing (`build_export_metadata()`), được trả về riêng biệt vì chỉ một số định dạng có thể chứa metadata này.

Truy vết một đồ thị. Điểm mở rộng backend, kết hợp với `~HfExporter.save_program`.

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

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

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

Đọc lại một chương trình được viết bởi `~HfExporter.save_program`. Nó có thể khác với những gì `~HfExporter.export_program` đã trả về: một `Program` thời gian chạy cho ExecuTorch, mà `ExecutorchProgramManager` của nó không thể được xây dựng lại từ tệp.

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

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

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

Các tệp mà `~HfExporter.save_program` ghi cho một chương trình được lưu dưới tên `filename`: chính tệp đó, cùng với bất kỳ tệp nào khác mà định dạng giữ bên cạnh nó (trọng số, dữ liệu bên ngoài).

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

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

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

Viết một chương trình được trả về bởi `~HfExporter.export_program` vào `path`, theo định dạng tệp của backend.

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

```python
validate_environment()
```

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

Kiểm tra `required_packages` đã được cài đặt và cảnh báo khi có sự lệch phiên bản so với `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)
```

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

Một mô hình đã xuất: các đồ thị của nó (`components`, `{name: ExportedComponent}`) và các cấu hình mà chúng được theo dõi, được gọi theo cách bạn sẽ gọi mô hình mà chúng bắt nguồn từ đó.

`~HfExporter.export` tạo ra một thành phần `"model"` duy nhất, có chương trình là `.program`; `~HfExporter.export_for_generation` tạo ra một thành phần cho mỗi giai đoạn 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)
```

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

Chạy xuất đơn đồ thị, trả về kết quả mà mô hình nguồn trả về. Các tham số kwargs mà quá trình xuất không được theo dõi sẽ bị loại bỏ, do đó toàn bộ đầu ra của bộ xử lý có thể được truyền vào. `share_inputs` và `share_outputs` được chuyển đến trình chạy (xem `ModelRunner.__call__`): với `share_outputs`, các đầu ra sẽ hợp lệ cho đến lần gọi tiếp theo.

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

```python
program()
```

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

Chương trình của chính backend, dành cho xuất một đồ thị đơn.

#### đến[[transformers.exporters.ExportedModel.to]]

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

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

Tải các chương trình lên runtime của backend, trên `device` (mặc định của backend khi là `None`). `runner_kwargs` được truyền đến runner của backend: `providers` và `session_options` cho ONNX Runtime, `config` (các thuộc tính biên dịch) và `torch_threads` (chia CPU với công việc của torch xung quanh mô hình) cho OpenVINO.

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

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

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

**Tham số:**

save_directory (`str` hoặc `Path`) : Thư mục để ghi vào, sẽ được tạo nếu chưa tồn tại.

push_to_hub (`bool`, *tùy chọn*, mặc định là `False`) : Có nên tải các tệp đã lưu lên Hub không, đến `repo_id` (mặc định là tên của `save_directory` trong không gian tên của bạn).

kwargs (`dict[str, Any]`, *tùy chọn*) : Được truyền vào Hub upload: `repo_id`, `commit_message`, `token`, `private`, ...

Viết các thành phần (mỗi thành phần một tệp), các cấu hình và một tệp manifest ghi tên tệp của từng thành phần cùng với các metadata được ghi lại khi theo dõi (tracing) chúng. `~ExportedModel.from_pretrained` sẽ nạp lại chúng.

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

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

**Tham số:**

pretrained_model_name_or_path (`str` hoặc `Path`) : Một thư mục cục bộ, hoặc id của kho trên Hub. Từ Hub, chỉ các tệp được nêu tên trong manifest mới được tải xuống, do đó một bản xuất có thể nằm cạnh trọng số của chính mô hình.

device (`str` hoặc `torch.device`, *tùy chọn*) : Nơi để chạy (mặc định của backend khi là `None`).

cache_dir (`Union[str, os.PathLike]`, *tùy chọn*) : Đường dẫn đến thư mục mà cấu hình mô hình được huấn luyện trước đã tải xuống sẽ được lưu vào bộ nhớ đệm nếu không sử dụng bộ nhớ đệm tiêu chuẩn.

force_download (`bool`, *tùy chọn*, mặc định là `False`) : Xác định có nên ép buộc tải lại (re-download) trọng số mô hình và các tệp cấu hình hay không, ghi đè lên các phiên bản đã được lưu trong bộ nhớ đệm nếu chúng tồn tại.

local_files_only (`bool`, *tùy chọn*, mặc định là `False`) : Có chỉ xem các tệp cục bộ hay không (tức là không cố gắng tải xuống mô hình).

token (`str` hoặc `bool`, *tùy chọn*) : Token được sử dụng làm HTTP bearer authorization cho các tệp từ xa. Nếu là `True`, hoặc không được chỉ định, sẽ sử dụng token được tạo khi chạy `hf auth login` (được lưu trong `~/.huggingface`).

revision (`str`, *tùy chọn*, mặc định là `"main"`) : Phiên bản mô hình cụ thể cần sử dụng. Nó có thể là tên nhánh, tên thẻ hoặc id commit, vì chúng tôi sử dụng hệ thống dựa trên git để lưu trữ các mô hình và các sản phẩm khác trên huggingface.co, do đó `revision` có thể là bất kỳ định danh nào được git cho phép.    Để kiểm tra một pull request bạn đã tạo trên Hub, bạn có thể truyền `revision="refs/pr/<pr_number>"`.

subfolder (`str`, *tùy chọn*, mặc định là `""`) : Trong trường hợp các tệp liên quan nằm trong một thư mục con của kho mô hình trên huggingface.co, bạn có thể chỉ định tên thư mục ở đây.

trust_remote_code (`bool`, *tùy chọn*, mặc định là `False`) : Có tải cấu hình của một mô hình mà mã của nó nằm trong kho của nó hay không, giống như [from_pretrained()](/docs/transformers/v5.23.0/vi/model_doc/auto#transformers.AutoConfig.from_pretrained).

runner_kwargs (*tùy chọn*) : Các tùy chọn runner của backend, giống như `~ExportedModel.to`: `providers` và `session_options` cho ONNX Runtime, `config` và `torch_threads` cho OpenVINO.

Tải những gì `~ExportedModel.save_pretrained` đã ghi: mỗi thành phần thông qua `~HfExporter.load_program` của backend tương ứng, cùng với metadata của nó và các cấu hình được lưu ngay bên cạnh. Các chương trình được tải lên runtime của backend ngay lập tức, sẵn sàng để chạy.

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

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

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

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

Một đồ thị đã xuất: chương trình của backend, và những gì trình xuất đã ghi lại về nó.

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

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

Những gì trình xuất ghi lại về một đồ thị (`build_export_metadata()`).

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

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

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

Xây dựng metadata từ dict đã lưu, bỏ qua các trường mà lớp này không có (được thêm bởi một phiên bản mới hơn).

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

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

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

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

Chạy một chương trình đã xuất trên backend của nó: `runner(**kwargs)` trả về kết quả mà mô hình nguồn trả về.

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

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

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

Một runner cho một chương trình dưới dạng export sẽ trả về nó, hoặc `~HfExporter.load_program` sẽ đọc lại nó trên `device` (mặc định của backend khi là `None`).

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

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

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

Xây dựng lại các đầu ra của mô hình từ các đầu ra phẳng của chương trình (nằm ở cuối) và các hằng số đã được ghi lại.

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

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

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

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

Trình xuất chuyển đổi [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel) thành `ExportedProgram`.

Ví dụ:

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

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

**Trả về:** `ExportedModel`

Một thành phần `"model"` duy nhất; chương trình của backend là `.program`, và `save_pretrained` sẽ ghi nó cùng với metadata và cấu hình mô hình.

Xuất mô hình dưới dạng một đồ thị duy nhất.

Nhận cùng các tham số **forward** như `~HfExporter.export_program`.

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

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

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

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

Trình xuất chuyển đổi [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel) thành đồ thị ONNX (một `onnx_ir.Model`).

Ví dụ:

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

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

**Trả về:** `ExportedModel`

Một thành phần `"model"` duy nhất; chương trình của backend là `.program`, và `save_pretrained` sẽ ghi nó cùng với metadata và cấu hình mô hình.

Xuất mô hình dưới dạng một đồ thị duy nhất.

Nhận cùng các tham số **forward** như `~HfExporter.export_program`.

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

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

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

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

Trình xuất chuyển đổi [PreTrainedModel](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel) thành `ExecutorchProgramManager` của ExecuTorch.

Ví dụ:

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

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

**Trả về:** `ExportedModel`

Một thành phần `"model"` duy nhất; chương trình của backend là `.program`, và `save_pretrained` sẽ ghi nó cùng với metadata và cấu hình mô hình.

Xuất mô hình dưới dạng một đồ thị duy nhất.

Nhận cùng các tham số **forward** như `~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)
```

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

**Tham số:**

dynamic (*bool*, *optional*, mặc định là *False*) : Có xuất với các hình dạng động (biểu tượng) hay không. Khi *True* và *dynamic_shapes* không được đặt, tất cả các chiều tensor sẽ được đặt thành *Dim.AUTO* một cách tự động.

strict (*bool*, *optional*, mặc định là *False*) : Có bật chế độ nghiêm ngặt trong *torch.export* hay không. Chạy truy vết biểu tượng đầy đủ và bắt được nhiều lỗi hơn, nhưng chậm hơn và dễ thất bại hơn trên các mô hình phức tạp.

dynamic_shapes (*dict[str, Any]*, *tùy chọn*) : Các quy định hình dạng động riêng cho từng đầu vào được truyền vào *torch.export*. Có quyền ưu tiên cao hơn *dynamic*.

prefer_deferred_runtime_asserts_over_guards (*bool*, *optional*, mặc định là *False*) : Khi *True*, các guard hình dạng phụ thuộc dữ liệu sẽ được phát ra dưới dạng assert thời gian chạy trong đồ thị đã xuất, thay vì khiến quá trình xuất thất bại ở thời điểm trace nếu guard không được giữ nguyên trên toàn bộ phạm vi hình dạng biểu tượng. Hầu hết các LLM transformer cần đặt giá trị này thành *True* khi sử dụng các ràng buộc `Dim(min=, max=)` chi tiết. Không cần thiết khi dùng `dynamic=True` / `Dim.AUTO`, vì `torch.export` sẽ suy luận các quan hệ hình dạng thay vì kiểm chứng chúng với các ràng buộc do người dùng khai báo.

quantizer ([*~exporters.quantizers.ExportQuantizer*], *optional*) : Lượng tử hóa sau huấn luyện được áp dụng trong quá trình xuất: [*~exporters.quantizers.PT2EQuantizer*] hoặc [*~exporters.quantizers.NNCFTorchFXQuantizer*] trên đồ thị FX cho mọi backend, [*~exporters.quantizers.OnnxRuntimeQuantizer*] trên mô hình ONNX đã chuyển đổi, hoặc [*~exporters.quantizers.NNCFOpenVINOQuantizer*] / [*~exporters.quantizers.NNCFOnnxQuantizer*] trên mô hình OpenVINO / ONNX đã chuyển đổi.

Lớp cấu hình để xuất mô hình thông qua *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)
```

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

**Tham số:**

opset_version (`int`, *tuỳ chọn*) : Phiên bản opset ONNX cần nhắm tới. Mặc định là opset mới nhất được hỗ trợ bởi phiên bản `onnxscript` đã cài đặt.

optimize (`bool`, *tuỳ chọn*, mặc định là `True`) : Chạy các bước tối ưu `onnxscript` (gấp hằng, loại bỏ mã chết, …) trên đồ thị đã xuất. Tắt đối với các mô hình gặp lỗi của trình tối ưu `onnxscript` thượng nguồn.

ort_fusions (`str`, *tùy chọn*) : Gộp đồ thị vào các ops của ONNX Runtime cho execution provider mà nó chạy trên: `"cpu"`, `"cuda"`, `"webgpu"` hoặc `"dml"`. Đồ thị đã gộp chỉ chạy trên ONNX Runtime. Yêu cầu `optimize=True`.

Lớp cấu hình để xuất mô hình sang ONNX thông qua `torch.onnx.export`.

Kế thừa tất cả các trường từ `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)
```

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

**Tham số:**

backend (`str`, *tùy chọn*, mặc định là `"xnnpack"`) : Backend ExecuTorch đích. Các giá trị được hỗ trợ:  - `"xnnpack"` — Suy luận CPU thông qua thư viện XNNPACK (mặc định; chạy ở bất kỳ đâu). - `"cuda"` — Suy luận GPU thông qua backend CUDA của ExecuTorch. - `"mlx"` — Suy luận GPU thông qua backend MLX của ExecuTorch trên Apple Silicon.

alloc_graph_input (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem bước lập kế hoạch bộ nhớ có dành trước bộ nhớ arena cho các đầu vào của đồ thị hay không. Khi `False`, thời gian chạy sẽ sử dụng trực tiếp các bộ đệm đầu vào do người gọi cung cấp thay vì sao chép vào arena — do đó, một thao tác `USER_INPUT_MUTATION` tại chỗ (ví dụ: ghi vào `StaticCache`) sẽ được thực hiện trên tensor của người gọi thay vì trên bản sao trong arena.

alloc_graph_output (`bool`, *tuỳ chọn*, mặc định là `True`) : Xác định xem bước lập kế hoạch bộ nhớ có dành trước bộ nhớ arena cho các đầu ra của đồ thị hay không. Khi `False`, người gọi phải liên kết các bộ đệm đầu ra tại thời điểm chạy (`Method::set_output_data_ptr`); việc liên kết một đầu ra với bộ đệm của đầu vào đã bị thay đổi sẽ tránh được vòng lặp sao chép ra ngoài.

alloc_mutable_buffers (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem bước lập kế hoạch bộ nhớ có dành trước bộ nhớ arena cho các bộ đệm có thể thay đổi (trạng thái nằm trong mô hình) hay không. Giá trị này được truyền qua `MemoryPlanningPass`.

Lớp cấu hình để xuất mô hình sang định dạng ExecuTorch.

Kế thừa tất cả các trường từ `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)
```

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

**Tham số:**

compress_to_fp16 (*bool*, *optional*, mặc định là *False*) : Nén trọng số *float32* của mô hình đã chuyển đổi sang *float16*, giảm một nửa kích thước. Mặc định là tắt do phạm vi hẹp hơn.

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.

Lớp cấu hình để xuất mô hình sang OpenVINO IR thông qua `openvino.convert_model`.

Kế thừa tất cả các trường từ [*DynamoConfig*] (*dynamic*, *strict*, *dynamic_shapes*, *prefer_deferred_runtime_asserts_over_guards*).

## Bộ lượng tử hóa[[transformers.exporters.ExportQuantizer]]

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

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

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

**Tham số:**

calibration_dataset (`Iterable[dict]`, *tùy chọn*) : Các dict đầu vào mà bộ lượng tử hóa dùng để hiệu chuẩn: một danh sách, hoặc một `DataLoader` có các batch được collate thành đầu vào của model. Đối với `~HfExporter.export_for_generation`, chúng là các kwargs của generate, được thu thập thành một tập hiệu chuẩn cho từng thành phần. Khi `None`, một bộ lượng tử hóa cần dữ liệu sẽ hiệu chuẩn trên các đầu vào mẫu của chính quá trình xuất, kèm theo một cảnh báo.

Lớp cơ sở cho các bộ lượng tử hóa sau huấn luyện được áp dụng trong quá trình xuất.

Bộ lượng tử hóa khai báo các định dạng xuất mà nó hỗ trợ và các gói cần thiết (kèm theo các phiên bản đã được kiểm thử, giống như các bộ xuất) cũng như việc nó lượng tử hóa đồ thị FX của `torch.export` trước bất kỳ bước chuyển đổi nào (để mọi backend đều nhận kết quả) hay lượng tử hóa mô hình mà một backend chuyển đổi nó thành (`onnx_ir.Model`, `openvino.Model`). Bộ xuất xác thực nó với quá trình xuất ngay từ đầu, sau đó gọi `~ExportQuantizer.quantize` với mô hình đó và các đầu vào mẫu của quá trình xuất. Hãy kế thừa lớp này và triển khai `quantize` để thêm một phương pháp lượng tử hóa mới; một `CalibrationSet` ánh xạ các mẫu hiệu chuẩn sang các đầu vào của chính mô hình.

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

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

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

Lượng tử hóa `model` (đồ thị FX nếu `quantizes_fx_graph`, ngược lại là model backend) và trả về kết quả, được hiệu chuẩn trên `calibration_dataset`, hoặc trên `sample_inputs` của bản xuất khi không có bộ dữ liệu hiệu chuẩn.

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

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

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

Các mẫu hiệu chuẩn dưới dạng kwargs được theo dõi, dành cho các bộ lượng tử hóa FX-graph.

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

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

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

Ném ngoại lệ nếu bộ lượng tử hóa này không thể chạy trên xuất `export_format`, hoặc một gói cần thiết bị thiếu hoặc quá cũ; cảnh báo khi một gói khác với phiên bản đã được kiểm thử.

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

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

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

Một bản sao của bộ lượng tử hóa này, được hiệu chuẩn trên `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])
```

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

Xem lại có thể lặp lại các mẫu hiệu chuẩn dưới dạng đầu vào của mô hình.

Các mẫu là `calibration_dataset` của bộ lượng tử hóa, hoặc chính `sample_inputs` của bản xuất (kèm một cảnh báo, một khi chúng được đọc) nếu không có gì. Chúng có thể là bất kỳ ánh xạ nào, chẳng hạn như `BatchEncoding` của bộ mã hóa. `transform` ánh xạ từng mẫu forward-kwarg thành những gì mô hình đã lượng tử hóa nhận (các kwargs được theo dõi, các feed ONNX, các feed cổng OpenVINO), một cách lười biếng, từng mẫu một, trong mỗi lượt.

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

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

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

**Tham số:**

quantizer (`torchao.quantization.pt2e.quantizer.Quantizer`) : Bộ lượng tử hóa PT2E chú thích đồ thị. Các toán tử lượng tử hóa/giải lượng tử hóa của nó phải là những toán tử được backend đích hỗ trợ: `X86InductorQuantizer` cho inductor, ONNX (QDQ) hoặc OpenVINO, `XNNPACKQuantizer` cho ExecuTorch.

calibration_dataset (`Iterable[dict]`, *tùy chọn*) : Các dict đầu vào mà các observer dùng để hiệu chuẩn (xem `ExportQuantizer`), mỗi dict tương ứng với một lần forward. Để hiệu chuẩn trên các batch, hãy truyền một `DataLoader` gộp các mẫu thành các dict đầu vào dạng batch thay vì một danh sách các mẫu đơn lẻ.

Thực hiện lượng hóa đồ thị FX bằng [lượng hóa PyTorch 2 Export (PT2E)](https://docs.pytorch.org/ao/main/pt2e_quantization/index.html): `prepare_pt2e` chèn các observer, tập hiệu chuẩn điều khiển chúng, và `convert_pt2e` thay thế chúng bằng các op quantize/dequantize. Hoạt động với mọi backend xuất.

Ví dụ:

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

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

Lượng tử hóa mô hình ONNX đã chuyển đổi bằng các công cụ riêng của ONNX Runtime (`onnxruntime.quantization`): `quantize_static` với `OnnxRuntimeStaticConfig` (mặc định), hoặc `quantize_dynamic` với `OnnxRuntimeDynamicConfig`.

Ví dụ:

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

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

Các tham số của `onnxruntime.quantization.quantize_static`: kích hoạt và trọng số int8 (mặc định là QDQ), được hiệu chuẩn trên `calibration_dataset` của bộ lượng tử hóa. Một trường được đặt thành `None` sẽ giữ nguyên giá trị mặc định của ONNX Runtime. Xem [`quantize_static`](https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html) cho từng tham số.

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

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

Các tham số của `onnxruntime.quantization.quantize_dynamic`: trọng số int8, kích hoạt được lượng tử hóa tại thời điểm chạy, không hiệu chuẩn. Một trường được đặt thành `None` sẽ giữ nguyên giá trị mặc định của ONNX Runtime. Xem [`quantize_dynamic`](https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html) cho từng tham số.

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

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

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

Thực hiện lượng tử hóa mô hình OpenVINO đã chuyển đổi bằng [NNCF](https://github.com/openvinotoolkit/nncf): `nncf.quantize` với `NNCFQuantizationConfig` (mặc định), hoặc `nncf.compress_weights` với `NNCFWeightCompressionConfig`.

Ví dụ:

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

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

Thực hiện lượng tử hóa mô hình ONNX đã chuyển đổi bằng [NNCF](https://github.com/openvinotoolkit/nncf) thông qua backend ONNX của nó: `nncf.quantize` với `NNCFQuantizationConfig` (mặc định, int8 QDQ), hoặc `nncf.compress_weights` với `NNCFWeightCompressionConfig` (int4 dưới dạng `MatMulNBits` của ONNX Runtime).

Ví dụ:

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

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

Lượng tử hóa đồ thị FX của `torch.export` bằng [NNCF](https://github.com/openvinotoolkit/nncf) thông qua backend TorchFX của nó: `nncf.quantize` với một `NNCFQuantizationConfig` (mặc định, các op `quantize`/`dequantize`), hoặc `nncf.compress_weights` với một `NNCFWeightCompressionConfig`. Giống như `PT2EQuantizer`, nó chạy trước bất kỳ bước chuyển đổi nào, nên mọi backend đều nhận kết quả của nó. ExecuTorch chỉ hạ thấp kết quả weight-only: XNNPACK không ủy quyền cho các op `quantize`/`dequantize`, và ExecuTorch không có kernel cho chúng.

Ví dụ:

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

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

Các tham số của `nncf.quantize`: kích hoạt và trọng số int8, được hiệu chuẩn trên `calibration_dataset` của bộ lượng tử hóa. Một trường được đặt thành `None` sẽ giữ nguyên giá trị mặc định của NNCF, ngoại trừ `model_type`, có giá trị mặc định là `nncf.ModelType.TRANSFORMER`. Xem [`nncf.quantize`](https://openvinotoolkit.github.io/nncf/autoapi/nncf/index.html#nncf.quantize) cho từng tham số.

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

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

Các tham số của `nncf.compress_weights`: int8 hoặc int4 chỉ cho trọng số, với các phương pháp nhận thức dữ liệu (AWQ, ước lượng tỷ lệ, GPTQ) cho các chế độ int4. Các chế độ int8 không cần dữ liệu; các chế độ khác hiệu chuẩn trên `calibration_dataset` của bộ lượng tử hóa. `gptq` và `lora_correction` chỉ dành cho OpenVINO. Một trường được đặt thành `None` sẽ giữ nguyên giá trị mặc định của NNCF. Xem [`nncf.compress_weights`](https://openvinotoolkit.github.io/nncf/autoapi/nncf/index.html#nncf.compress_weights) cho từng tham số.

## Công cụ tiện ích[[transformers.exporters.utils.get_leaf_tensors]]

Các hàm cấp thấp hơn hỗ trợ `export_for_generation`, hữu ích khi bạn cần can thiệp giữa việc phân rã mô hình và xuất từng thành phần.

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

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

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

**Tham số:**

obj (`Any`) : Một tensor, dataclass, dict, list, tuple, hoặc bất kỳ sự lồng nhau nào của chúng.

**Trả về:** `dict[str, torch.Tensor]`

Ánh xạ phẳng từ các chuỗi đường dẫn có dấu chấm sang các tensor.

Lấy đệ quy tất cả các tensor lá từ một cấu trúc có thể lồng nhau.

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

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

Cấu hình model và inputs để xuất. Thay đổi cả `model` và `inputs` tại chỗ, trả về `(model, inputs, output_flags)` trong đó `output_flags` chứa các giá trị đã được lấy ra khỏi `inputs` cho `use_cache`, `return_dict`, v.v. (để được áp dụng một cách có thể đảo ngược lên `model.config` bởi `patch_model_config` trong quá trình trace).

- Loại bỏ các đầu vào nhãn (`labels`, `future_values`) — không hỗ trợ tính toán loss.
- Lấy các cờ đầu ra (`use_cache`, `return_dict`, …) ra khỏi `inputs` để chúng không xuất hiện dưới dạng kwargs được theo dõi; các giá trị này được trả về để khối trace áp dụng lên `model.config`.
- Tiền xử lý các tham số kwargs của thị giác/âm thanh phụ thuộc vào dữ liệu đã được đăng ký thông qua `@register_export_input_preparer` và ghi chúng vào `inputs`.
- Chuyển đổi các tensor đầu vào để khớp với `dtype` / `device` của mô hình.

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

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

**Trả về:** `dict[str, tuple[torch.nn.Module, dict]]`

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

Chạy `model.generate()` và ghi nhận các đầu vào của prefill và decode.

Tái sử dụng toàn bộ cơ chế sinh để mọi kiến trúc (chỉ có bộ giải mã, SSM, bộ mã hóa - bộ giải mã, đa phương thức, …) đều nhận được các đầu vào chính xác mà không cần cài đặt lại vòng lặp.

`generation_config` được chuyển tiếp đến `generate()` (mặc định là cấu hình của chính model), do đó các đầu vào được ghi lại sẽ sử dụng bất kỳ cache nào mà `generate()` sẽ xây dựng. Truyền một cấu hình có `cache_implementation="static"` và `max_cache_len=N` để ghi lại một cache **có kích thước tĩnh** trong các đầu vào decode — nền tảng cho việc xuất (export) cache tĩnh. `max_cache_len` xác định kích thước cache độc lập với quá trình ghi lại, nên bản decode được xuất sẽ nhận một cache cố định `[..., N, ...]` thay vì một cache tăng dần.

Khi `multi_token_decode`, thành phần `decode` được bắt giữ dưới dạng **multi-token** decode — hai bước decode liên tiếp được gộp lại (xem `_merge_decode_calls`) để trục query-sequence của nó vẫn ở dạng biểu tượng (một bước decode single-token sẽ đặc biệt hóa trục đó thành 1). Sau đó, nó xử lý cả trường hợp một token (giải mã thông thường) và nhiều token (tiếp nối từ quá khứ, hoặc prefill thông thường khi cache trống). Ngược lại, `decode` là decode single-token cổ điển.

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

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

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

**Trả về:** `dict[str, tuple[torch.nn.Module, dict]]`

Một mục `name: (module, inputs)` cho mỗi submodule được phát hiện (bộ mã hóa ảnh/âm thanh, bộ chiếu, mô hình ngôn ngữ, lm_head).

**Lỗi:** ``ValueError``

- ``ValueError`` -- nếu không tìm thấy các module con đa phương thức đã biết nào trên model.

Thu thập đầu vào cho từng mô-đun con đa phương thức thông qua một lần truyền tiến duy nhất.

Phát hiện tất cả các module con đa phương thức đã biết theo tên thuộc tính (vision tower, projector, language model, lm_head, …) và ghi lại các tham số kwargs của forward trong một lần gọi `model(**inputs)`.

Mỗi submodule được trả về dưới dạng một mục `name: (module, inputs)` riêng biệt để xuất độc lập. Bước hợp nhất token (ví dụ `masked_scatter` cho các model đa phương thức) được cố ý giữ bên ngoài các đồ thị đã xuất — trách nhiệm của người gọi là lắp ráp `inputs_embeds` từ đầu ra của encoder trước khi chạy 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)
```

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

**Tham số:**

model : Mô hình sinh. Phải hỗ trợ `model.generate(**inputs)`.

inputs : **Generate** kwargs — những gì bạn sẽ truyền vào `model.generate(**inputs)`.

generation_config : `GenerationConfig` tùy chọn được chuyển tiếp đến `generate()` trong quá trình capture. Truyền một cấu hình có `cache_implementation="static"` + `max_cache_len=N` để xuất đối với bộ nhớ đệm có kích thước tĩnh (xem `decompose_prefill_decode`).

multi_token_decode : Khi `True`, bắt (capture) thành phần `decode` dưới dạng decode đa token (trục chuỗi truy vấn động: nhiều token cùng lúc — tiếp nối từ quá khứ, hoặc prefill thông thường khi cache trống); decode đơn token không thể duy trì ở chế độ động (xem `decompose_prefill_decode`).

**Trả về:** `{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.

Phân tách một mô hình sinh thành thành các cặp `(model, forward_inputs)` có thể xuất độc lập.

Chạy `decompose_prefill_decode` để thu thập các kwargs của forward cho prefill và decode từ một `model.generate(**inputs, max_new_tokens=2)` thực tế. Nếu prefill là đa phương thức (theo `is_multimodal`), nó sẽ tách thêm thành một mục cho mỗi submodule (encoder thị giác/âm thanh, projector, mô hình ngôn ngữ, `lm_head`) thông qua `decompose_multimodal`.

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

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

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

Trả về `True` nếu mô hình là đa phương thức với các bộ mã hóa phương thức và một mô hình ngôn ngữ.

Một mô hình không phải là `PreTrainedModel` (ví dụ: một `nn.Module` thuần túy) không có các bộ truy cập chuẩn `get_encoder`/`get_decoder` và rõ ràng không phải là đa phương thức, do đó nó sẽ trả về `False` ngay lập tức.

