# المصدّرون

يمكن إضافة واجهات تصدير جديدة إلى Transformers عن طريق إنشاء فئة فرعية من `HfExporter`.

تعلّم كيفية استخدام مُصدِّرات النظام المدمجة في دليل [Exporters](../exporters).

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

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/auto.py#L93)

فئة مُصدِّر Auto-HF التي تتولى إنشاء `HfExporter` الصحيح تلقائيًا بناءً على `ExportConfig`.

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/auto.py#L113)

حمّل مثيل مُصدِّر من نموذج/نقطة تحقق مُدرَّب مسبقًا يتضمن إعداد تصدير.

**لم يتم تنفيذه بعد** — عنصر احتيازي لمسار عمل "وصفة التصدير" من الدرجة الأولى.

الفكرة: ينشر مالكو النماذج ملف `export_config.json` (أو حقل `export_config` داخل `config.json`) إلى جانب أوزانهم على الـ Hub. يلتقط هذا الملف الإعدادات التي سبق للمالك التحقق منها بخصوص بنيته المعمارية — وهي: الصيغة المستهدفة (`dynamo` / `onnx` / `executorch`)، مواصفات الأشكال الديناميكية الدقيقة (مثل: `text_ids` ديناميكي حتى 4096، بلاطات الصور ثابتة عند 448، `batch=1` للنشر على الحافة)، علم `strict`، مجموعة عمليات ONNX، تخطيط prefill مقابل decode، اختيار خلفية ExecuTorch، وأي إعداد آخر كان يُعتبر حتى اليوم معرفةً شفوية محفوظة في ملف README أو دفتر ملاحظات خاص.

ثم يحصل المستهلكون على التصدير المُتحقَّق منه من قِبل المالك في استدعاء واحد:

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

        يتكامل مع سجل [*register_export_input_preparer*]: حيث يوفّر المالك مواصفات الأبعاد عبر `export_config.json`، بينما يوفّر transformers الحسابات المسبقة المعتمدة على البيانات (`cu_seqlens`، معرّفات مواضع الرؤية، فهارس النوافذ، …) لتلك البنية. معاً، يغطّيان الجزأين الصعيبين في تصدير النماذج الجديدة — معرفة عقد الأبعاد الصحيح وإعداد المدخلات الصحيحة — بحيث لا يضطر المستخدمون في المراحل اللاحقة إلى إعادة اشتقاق أيٍّ منهما من الصفر (ولا يواجهون أعطالاً في بيئة الإنتاج عند ارتكابهم خطأً).

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/auto.py#L145)

تُرجع True إذا كان القاموس المُقدَّم يصف `export_format` يحتوي على كلا من فئة الإعدادات المسجّلة وفئة المُصدِّر المسجّلة. تُصدر تحذيراً برسالة قابلة للتنفيذ عندما يكون التنسيق مفقوداً بالكامل، أو غير معروف، أو مسجّلاً جزئياً فقط.

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

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/auto.py#L65)

فئة تصدير Auto-HF التي تتولى التوجيه تلقائيًا إلى فئة التصدير الصحيحة بناءً على فئة التصدير المخزنة في قاموس.

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

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/base.py#L41)

فئة أساسية مجردة لجميع مُصدِّرات Transformers.

أنشئ فئة فرعية ونفّذ `~HfExporter.export` لإضافة واجهة تصدير جديدة.

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/base.py#L61)

**المعاملات:**

model ([PreTrainedModel](/docs/transformers/main/ar/main_classes/model#transformers.PreTrainedModel)) : النموذج الذي سيتم تصديره.

sample_inputs (`dict[str, torch.Tensor | Cache]`) : **Forward** kwargs — ما ستمرره إلى `model(**sample_inputs)`. تُستخدم هذه القيم مباشرةً كمدخلات مثال أثناء التتبع. في حالة تصدير خطوة فك الترميز التلقائية، يعني ذلك أنك بحاجة إلى تضمين `past_key_values` و`cache_position` وما إلى ذلك. إذا كان لديك مدخلات بأسلوب التوليد فقط، فاستخدم `~HfExporter.export_for_generation` بدلاً من ذلك — إذ يقوم بتشغيل `model.generate` نيابةً عنك ويصدّر كل مرحلة.

config (`ExportConfigMixin`) : إعدادات خاصة بالخلفية.

**يعيد:**

مُنتَج تصدير خاص بالخلفية.

صدّر النموذج وأعد كائن البرنامج الخاص بالخلفية.

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

```python
export_for_generation(model: PreTrainedModel, sample_inputs: MutableMapping[str, torch.Tensor | Cache], config: ExportConfigMixin | dict[str, ExportConfigMixin], generation_config: GenerationConfig | None = None, multi_token_decode: bool = False)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/base.py#L93)

**المعاملات:**

model ([PreTrainedModel](/docs/transformers/main/ar/main_classes/model#transformers.PreTrainedModel)) : النموذج التوليدي الذي سيتم تصديره. يجب أن يدعم `model.generate(**sample_inputs)`.

sample_inputs (`dict[str, torch.Tensor | Cache]`) : معاملات **Generate** — ما ستمرره إلى `model.generate(**sample_inputs)` (عادةً `input_ids` + `attention_mask`، بالإضافة إلى أي مدخلات نمطية مثل `pixel_values` / `input_features` للنماذج متعددة الأنماط). تُلتقط معاملات الأمامية لكل مرحلة داخليًا.

config (`ExportConfigMixin` أو `dict[str, ExportConfigMixin]`) : إعدادات خاصة بالخلفية. مرّر إعدادًا واحدًا لتطبيقه على جميع المكونات، أو مرّر `dict` مفهرسًا باسم المكوّن (مثل `"image_encoder"`، `"language_model"`، `"lm_head"`، `"decode"`) لتجاوز الإعدادات لكل مكوّن على حدة — يجب أن تكون جميع أسماء المكونات موجودة في القاموس.

generation_config ([GenerationConfig](/docs/transformers/main/ar/main_classes/text_generation#transformers.GenerationConfig)، *اختياري*) : يُمرَّر إلى التقاط `generate()` (افتراضيًا، يُستخدم إعداد النموذج نفسه). مرِّر نسخة تحتوي على `cache_implementation="static"` للتصدير مقابل `StaticCache` بحجم ثابت.

multi_token_decode (`bool`، *اختياري*، القيمة الافتراضية `False`) : ما إذا كان مكوّن `decode` يعالج رموز الاستعلام المتعددة دفعة واحدة — محور استعلام ديناميكي (تعبئة مسبقة عند وجود ذاكرة تخزين مؤقت فارغة، أو استكمال من الماضي في الحالات الأخرى) — مقابل خطوة الرمز الواحد الكلاسيكية (انظر [decompose_for_generation()](/docs/transformers/main/ar/main_classes/exporters#transformers.exporters.utils.decompose_for_generation)). يبقى ديناميكيًا فقط عند تصدير بأشكال ديناميكية (`config.dynamic=True`).

**يعيد:** `dict[str, Any]`

`{component_name: backend_specific_artifact}` — نفس المفاتيح الموجودة في [decompose_for_generation()](/docs/transformers/main/ar/main_classes/exporters#transformers.exporters.utils.decompose_for_generation). أما القيم فهي ما يعيده `~HfExporter.export` للخلفية المحددة (`ExportedProgram`، `ONNXProgram`، `ExecutorchProgramManager`).

قم بتفكيك نموذج توليدي وتصدير كل مكوّن بشكل مستقل.

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

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/base.py#L57)

تحقق من تثبيت `required_packages` وأصدر تحذيرًا عند وجود انحراف في الإصدارات عن `tested_versions`.

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

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_dynamo.py#L69)

مُصدِّر يقوم بتحويل [PreTrainedModel](/docs/transformers/main/ar/main_classes/model#transformers.PreTrainedModel) إلى `ExportedProgram`.

مثال:

```python
>>> from transformers.exporters.exporter_dynamo import DynamoExporter, DynamoConfig

>>> exporter = DynamoExporter()
>>> exported = exporter.export(model, inputs, config=DynamoConfig(dynamic=True))
>>> outputs = exported.module()(**inputs)
```

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

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

[المصدر](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()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_onnx.py#L108)

مُصدِّر يقوم بتحويل [PreTrainedModel](/docs/transformers/main/ar/main_classes/model#transformers.PreTrainedModel) إلى `ONNXProgram` بصيغة ONNX.

مثال:

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

[المصدر](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()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_executorch.py#L109)

مُصدِّر يقوم بتحويل [PreTrainedModel](/docs/transformers/main/ar/main_classes/model#transformers.PreTrainedModel) إلى `ExecutorchProgramManager` في ExecuTorch.

مثال:

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/exporter_executorch.py#L126)

تصدير نموذج إلى ExecuTorch، مع تطبيق إعدادات الخلفية (backend) وإصلاحات عمليات torch.

## DynamoConfig[[transformers.exporters.DynamoConfig]]

#### transformers.exporters.DynamoConfig[[transformers.exporters.DynamoConfig]]

```python
transformers.exporters.DynamoConfig(export_format: ExportFormat = <ExportFormat.DYNAMO: 'dynamo'>, dynamic: bool = False, strict: bool = False, dynamic_shapes: dict[str, Any] | None = None, prefer_deferred_runtime_asserts_over_guards: bool = False, quantizer: ExportQuantizer | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/configs.py#L83)

**المعاملات:**

dynamic (*bool*، *اختياري*، القيمة الافتراضية *False*) : ما إذا كان سيتم التصدير بأشكال ديناميكية (رمزية). عند تعيين *True* وعدم تعيين *dynamic_shapes*، يتم تعيين جميع أبعاد المصفوفات إلى *Dim.AUTO* تلقائيًا.

strict (*bool*، *اختياري*، القيمة الافتراضية *False*) : ما إذا كان سيتم تفعيل الوضع الصارم في *torch.export*. يقوم بتشغيل التتبع الرمزي الكامل ويكشف عن أخطاء أكثر، لكنه أبطأ وأكثر عرضة للفشل في النماذج المعقدة.

dynamic_shapes (*dict[str, Any]*، *اختياري*) : مواصفات الشكل الديناميكي الصريحة لكل مدخل تُمرَّر إلى *torch.export*. لها الأولوية على *dynamic*.

prefer_deferred_runtime_asserts_over_guards (*bool*، *اختياري*، القيمة الافتراضية *False*) : عند تعيين *True*، تُصدر حواجز الأشكال المعتمدة على البيانات كعمليات تحقق (asserts) وقت التشغيل في الرسم البياني المُصدَّر، بدلاً من فشل التصدير وقت التتبع (trace) عندما لا يتحقق الحاجز عبر نطاق الشكل الرمزي الكامل. تحتاج معظم نماذج LLM من نوع Transformer إلى تعيين هذا الخيار إلى *True* عند استخدام حدود `Dim(min=, max=)` الدقيقة. لا حاجة إليه عند استخدام `dynamic=True` / `Dim.AUTO`، حيث يستنتج `torch.export` علاقات الأشكال بدلاً من التحقق منها مقابل الحدود التي حددها المستخدم.

quantizer ([*~exporters.quantizers.ExportQuantizer*], *اختياري*) : التكميم بعد التدريب المطبّق أثناء التصدير: [*~exporters.quantizers.PT2EQuantizer*] أو [*~exporters.quantizers.NNCFTorchFXQuantizer*] على رسم FX لكل واجهة خلفية، أو [*~exporters.quantizers.OnnxRuntimeQuantizer*] على نموذج ONNX المحوّل، أو [*~exporters.quantizers.NNCFOpenVINOQuantizer*] / [*~exporters.quantizers.NNCFOnnxQuantizer*] على نموذج OpenVINO / ONNX المحوّل.

فئة الإعدادات لتصدير النماذج عبر *torch.export*.

## OnnxConfig[[transformers.exporters.OnnxConfig]]

#### transformers.exporters.OnnxConfig[[transformers.exporters.OnnxConfig]]

```python
transformers.exporters.OnnxConfig(export_format: ExportFormat = <ExportFormat.ONNX: 'onnx'>, dynamic: bool = False, strict: bool = False, dynamic_shapes: dict[str, Any] | None = None, prefer_deferred_runtime_asserts_over_guards: bool = False, quantizer: ExportQuantizer | None = None, 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)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/configs.py#L125)

**المعاملات:**

output_path (`str` أو `PathLike`، *اختياري*) : مسار الإخراج لملف `.onnx`. عند تعيين `None` (الافتراضي)، يُحفظ النموذج المُصدَّر في الذاكرة كـ`ONNXProgram` ولا يُكتب على القرص.

opset_version (`int`، *اختياري*) : إصدار مجموعة عمليات ONNX المستهدفة. الافتراضي هو أحدث مجموعة عمليات مدعومة من قبل إصدار `onnxscript` المثبت.

external_data (`bool`، *اختياري*، القيمة الافتراضية `True`) : تخزين متجهات الأوزان الكبيرة في ملف جانبي منفصل `.onnx_data` بدلاً من تضمينها في ملف البروتوكول. هذا الشرط إلزامي للنماذج التي تتجاوز أوزانها حد البروتوكول البالغ 2 غيغابايت.

optimize (`bool`، *اختياري*، القيمة الافتراضية `True`) : تشغيل مسارات تحسين `onnxscript` (طيّ الثوابت، إزالة الكود الميت، …) على الرسم البياني المُصدَّر. عطّل هذا الخيار للنماذج التي تصطدم بأخطاء في مُحسِّن `onnxscript` الأصلي.

export_params (`bool`، *اختياري*، القيمة الافتراضية `True`) : تضمين أوزان النموذج في رسم ONNX. اضبطه على `False` لتصدير رسم خالٍ من الأوزان (يجب توفير الأوزان وقت التشغيل).

keep_initializers_as_inputs (`bool`، *اختياري*، القيمة الافتراضية `False`) : كشف مُهيئات الأوزان كمُدخلات صريحة للرسوم البيانية. مطلوب في بعض بيئات تشغيل ONNX الأقدم (opset < 9).

فئة التهيئة لتصدير النماذج إلى ONNX عبر `torch.onnx.export`.

يرث جميع الحقول من `DynamoConfig` (`dynamic`، `strict`، `dynamic_shapes`، `prefer_deferred_runtime_asserts_over_guards`).

## ExecutorchConfig[[transformers.exporters.ExecutorchConfig]]

#### transformers.exporters.ExecutorchConfig[[transformers.exporters.ExecutorchConfig]]

```python
transformers.exporters.ExecutorchConfig(export_format: ExportFormat = <ExportFormat.EXECUTORCH: 'executorch'>, dynamic: bool = False, strict: bool = False, dynamic_shapes: dict[str, Any] | None = None, prefer_deferred_runtime_asserts_over_guards: bool = False, quantizer: ExportQuantizer | None = None, backend: str = 'xnnpack', alloc_graph_input: bool = True, alloc_graph_output: bool = True, alloc_mutable_buffers: bool = True)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/configs.py#L167)

**المعاملات:**

backend (`str`، *اختياري*، القيمة الافتراضية `"xnnpack"`) : الخلفية المستهدفة لـ ExecuTorch. القيم المدعومة: - `"xnnpack"` — استنتاج على المعالج المركزي عبر مكتبة XNNPACK (افتراضي؛ يعمل في أي مكان). - `"cuda"` — استنتاج على وحدة معالجة الرسوميات عبر خلفية ExecuTorch CUDA. - `"mlx"` — استنتاج على وحدة معالجة الرسوميات عبر خلفية ExecuTorch MLX على Apple Silicon.

alloc_graph_input (`bool`، *اختياري*، القيمة الافتراضية `True`) : ما إذا كانت مرحلة تخطيط الذاكرة تحجز ذاكرة الساحة (arena) لإدخالات الرسم البياني. عند تعيين `False`، يستخدم وقت التشغيل مخازن الإدخال التي يوفرها المستدعي مباشرةً بدلاً من نسخها إلى الساحة — وبالتالي فإن أي `USER_INPUT_MUTATION` في الموقع (مثل كتابة `StaticCache`) يقع في متجه المستدعي بدلاً من نسخة في الساحة.

alloc_graph_output (`bool`، *اختياري*، القيمة الافتراضية `True`) : ما إذا كانت مرحلة تخطيط الذاكرة تحجز ذاكرة الساحة (arena) لمخرجات الرسم البياني. عند تعيين `False`، يجب على المستدعي ربط مخازن المخرجات وقت التشغيل (`Method::set_output_data_ptr`)؛ وربط مخرج بمخزن مدخله المُعدَّل يتجنّب دورة النسخ للخارج.

alloc_mutable_buffers (`bool`، *اختياري*، القيمة الافتراضية `True`) : ما إذا كانت مرحلة تخطيط الذاكرة تحجز ذاكرة الساحة للمخازن المؤقتة القابلة للتعديل (الحالة المقيمة في النموذج). يتم تمريرها إلى `MemoryPlanningPass`.

فئة الإعدادات لتصدير النماذج إلى تنسيق ExecuTorch.

يرث جميع الحقول من `DynamoConfig` (`dynamic`، `strict`، `dynamic_shapes`، `prefer_deferred_runtime_asserts_over_guards`).

## OpenVINOConfig[[transformers.exporters.OpenVINOConfig]]

#### transformers.exporters.OpenVINOConfig[[transformers.exporters.OpenVINOConfig]]

```python
transformers.exporters.OpenVINOConfig(export_format: ExportFormat = <ExportFormat.OPENVINO: 'openvino'>, dynamic: bool = False, strict: bool = False, dynamic_shapes: dict[str, Any] | None = None, prefer_deferred_runtime_asserts_over_guards: bool = False, quantizer: ExportQuantizer | None = None, output_path: str | PathLike | None = None, compress_to_fp16: bool = True, stateful: bool = True)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/configs.py#L204)

**المعاملات:**

output_path (*str* أو *PathLike*، *اختياري*) : مسار الإخراج لملف *.xml* (يتم كتابة الملف المطابق *.bin* بجانبه). عند تعيين *None* (الافتراضي)، يُحفظ النموذج المحوّل في الذاكرة كـ`openvino.Model`.

compress_to_fp16 (*bool*، *اختياري*، القيمة الافتراضية *True*) : ضغط الأوزان العائمة إلى FP16 عند الحفظ — يقلل حجم التخزين على القرص إلى النصف مع تأثير ضئيل على الدقة في معظم النماذج. يُطبَّق فقط عند تعيين `output_path`.

stateful (*bool*, *optional*, defaults to *True*) : Fold round-tripped state tensors (KV cache, SSM states, …) into internal OV variables (`ReadValue`/``Assign`). The runtime then carries state across `infer()` calls instead of marshalling cache tensors through inputs/outputs on every step, and a fused `beam_idx`` input reorders state in-graph for beam search. No-op for models without round-tripped state (encoders, prefill-only exports). Set it to *False* for targets that take no stateful model, such as the NPU plugin.

فئة الإعدادات لتصدير النماذج إلى OpenVINO IR عبر `openvino.convert_model`.

يرث جميع الحقول من [*DynamoConfig*] (*dynamic*، *strict*، *dynamic_shapes*، *prefer_deferred_runtime_asserts_over_guards*).

## مُكمِّسات[[transformers.exporters.ExportQuantizer]]

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/base.py#L32)

**المعاملات:**

calibration_dataset (`Iterable[dict]`، *اختياري*) : قوامير الإدخال التي يُعاير عليها المُكمِّم: قائمة، أو `DataLoader` تُجمَّع دفعاته إلى مدخلات النموذج. في حالة `~HfExporter.export_for_generation` تكون هذه معاملات generate، وتُلتقط في مجموعة معايرة لكل مكوّن. عند كونها `None`، يُعاير المُكمِّم الذي يحتاج إلى بيانات على مدخلات العينة الخاصة بالتصدير نفسه، مع إصدار تحذير.

الفئة الأساسية لمكمّسات ما بعد التدريب المطبّقة أثناء التصدير.

يُعلن المُكمِّم (Quantizer) عن صيغ التصدير التي يدعمها والحزم التي يحتاجها (مع الإصدارات التي تم اختبارها عليها، كما هو الحال مع مُصدِّرات التصدير)، وعن ما إذا كان يُكمِّم رسم `torch.export` الخاص بـ FX قبل أي تحويل (لذا يتلقى كل مُنفِّذ النتيجة)، أم يُكمِّم النموذج الذي يحوله المُنفِّذ (`onnx_ir.Model`، `openvino.Model`). يتحقق مُصدِّر التصدير من ذلك مقابل عملية التصدير مسبقاً، ثم يستدعي `~ExportQuantizer.quantize` مع ذلك النموذج ومدخلات العينة الخاصة بالتصدير. قم بإنشاء فئة فرعية منه ونفّذ `quantize` لإضافة طريقة كمّية جديدة؛ حيث تُطبّق `CalibrationSet` عينات المعايرة على مدخلات النموذج نفسه.

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/base.py#L77)

قم بتكميم `model` (مخطط FX إذا كان `quantizes_fx_graph`، وإلا النموذج الخلفي) وأعد النتيجة، معتمداً على `calibration_dataset`، أو على `sample_inputs` الخاص بالتصدير في حال عدم وجوده.

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/base.py#L67)

ارفع استثناءً إذا لم يستطع هذا المُكمِّم (quantizer) العمل على تصدير بصيغة `export_format`، أو إذا كان الحزمة المطلوبة مفقودة أو قديمة جداً؛ وأصدر تحذيراً إذا اختلفت أي حزمة عن الإصدار الذي تم اختباره عليه.

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/base.py#L61)

نسخة من هذا المُكمِّم تُعاير على `calibration_dataset`.

#### transformers.exporters.quantizers.CalibrationSet[[transformers.exporters.quantizers.CalibrationSet]]

```python
transformers.exporters.quantizers.CalibrationSet(calibration_dataset: Iterable[dict[str, Any]] | None, sample_inputs: dict[str, Any], transform: Callable[[dict[str, Any]], Any])
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/base.py#L83)

عرض قابل لإعادة التكرار لعينات المعايرة كمدخلات للنموذج.

تكون العينات هي `calibration_dataset` الخاص بمُكمِّم (quantizer)، أو `sample_inputs` الخاصة بالتصدير نفسه (مع إصدار تحذير عند قراءتها) في حال عدم وجود أي منها. يمكن أن تكون هذه العينات أي خرائط (mapping)، مثل `BatchEncoding` الخاص بمُرمِّز (tokenizer). يقوم `transform` بتحويل كل عينة من معاملات (kwargs) الأمامية إلى ما يقبله النموذج المُكمَّم (معاملات مُتبعة، مدخلات ONNX، مدخلات منافذ OpenVINO)، بشكل كسول (lazy)، عينة واحدة في كل مرة، في كل مسار.

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_pt2e.py#L34)

**المعاملات:**

quantizer (`torchao.quantization.pt2e.quantizer.Quantizer`) : مُكمِّم PT2E الذي يضيف التسميات إلى الرسم البياني. يجب أن تكون عمليات التكميم/إلغاء التكميم الخاصة به مدعومة من قبل الخلفية المستهدفة: `X86InductorQuantizer` لـ inductor، أو ONNX (QDQ) أو OpenVINO، و`XNNPACKQuantizer` لـ ExecuTorch.

calibration_dataset (`Iterable[dict]`، *اختياري*) : قواميس الإدخال التي تُعاير عليها المُراقِبات (انظر `ExportQuantizer`)، مع تمريرة أمامية واحدة لكل قاموس. لمعايرة على دفعات، مرّر `DataLoader` يجمع العينات في قواميس إدخال مُجمَّعة بدلاً من قائمة من عينات مفردة.

قم بتكميم رسم FX باستخدام [تكميم PyTorch 2 Export (PT2E)](https://docs.pytorch.org/ao/main/pt2e_quantization/index.html): يقوم `prepare_pt2e` بإدراج المراقبين، وتُشغّل مجموعة المعايرة هذه المراقبين، ثم يستبدل `convert_pt2e` المراقبين بعمليات التكميم/إلغاء التكميم. يعمل مع جميع واجهات التصدير.

مثال:

```python
>>> from torchao.quantization.pt2e.quantizer.x86_inductor_quantizer import (
...     X86InductorQuantizer,
...     get_default_x86_inductor_quantization_config,
... )
>>> from transformers.exporters import DynamoConfig, PT2EQuantizer

>>> x86 = X86InductorQuantizer().set_global(get_default_x86_inductor_quantization_config())
>>> DynamoConfig(quantizer=PT2EQuantizer(x86, calibration_dataset=samples))
```

#### transformers.exporters.OnnxRuntimeQuantizer[[transformers.exporters.OnnxRuntimeQuantizer]]

```python
transformers.exporters.OnnxRuntimeQuantizer(config: OnnxRuntimeStaticConfig | OnnxRuntimeDynamicConfig | None = None, calibration_dataset: Iterable[dict[str, Any]] | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_onnxruntime.py#L78)

قم بتكميم نموذج ONNX المُحوَّل باستخدام أدوات ONNX Runtime الخاصة (`onnxruntime.quantization`): إما `quantize_static` مع `OnnxRuntimeStaticConfig` (الافتراضي)، أو `quantize_dynamic` مع `OnnxRuntimeDynamicConfig`.

مثال:

```python
>>> from transformers.exporters import (
...     OnnxConfig,
...     OnnxRuntimeDynamicConfig,
...     OnnxRuntimeQuantizer,
...     OnnxRuntimeStaticConfig,
... )

>>> static = OnnxRuntimeStaticConfig(per_channel=True)
>>> OnnxConfig(quantizer=OnnxRuntimeQuantizer(static, calibration_dataset=samples))
>>> OnnxConfig(quantizer=OnnxRuntimeQuantizer(OnnxRuntimeDynamicConfig()))
```

#### transformers.exporters.OnnxRuntimeStaticConfig[[transformers.exporters.OnnxRuntimeStaticConfig]]

```python
transformers.exporters.OnnxRuntimeStaticConfig(quant_format: Any = None, op_types_to_quantize: list[str] | None = None, per_channel: bool | None = None, reduce_range: bool | None = None, activation_type: Any = None, weight_type: Any = None, nodes_to_quantize: list[str] | None = None, nodes_to_exclude: list[str] | None = None, calibrate_method: Any = None, calibration_providers: list[str] | None = None, extra_options: dict[str, Any] | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_onnxruntime.py#L41)

حجج `onnxruntime.quantization.quantize_static`: تفعيلات وأوزان من نوع int8 (QDQ افتراضياً)، مُعايرة على `calibration_dataset` الخاص بالمعاير. أي حقل يُترك على `None` يحافظ على القيمة الافتراضية لـ ONNX Runtime. راجع [`quantize_static`](https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html) لكل حقل.

#### transformers.exporters.OnnxRuntimeDynamicConfig[[transformers.exporters.OnnxRuntimeDynamicConfig]]

```python
transformers.exporters.OnnxRuntimeDynamicConfig(op_types_to_quantize: list[str] | None = None, per_channel: bool | None = None, reduce_range: bool | None = None, weight_type: Any = None, nodes_to_quantize: list[str] | None = None, nodes_to_exclude: list[str] | None = None, extra_options: dict[str, Any] | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_onnxruntime.py#L62)

حجج `onnxruntime.quantization.quantize_dynamic`: أوزان من نوع int8، وتكميم التفعيلات في وقت التشغيل، دون معايرة. أي حقل يُترك على `None` يحافظ على القيمة الافتراضية لـ ONNX Runtime. راجع [`quantize_dynamic`](https://onnxruntime.ai/docs/performance/model-optimizations/quantization.html) لكل منها.

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_nncf.py#L143)

قم بتكميم نموذج OpenVINO المحوّل باستخدام [NNCF](https://github.com/openvinotoolkit/nncf): إما `nncf.quantize` مع `NNCFQuantizationConfig` (الافتراضي)، أو `nncf.compress_weights` مع `NNCFWeightCompressionConfig`.

مثال:

```python
>>> import nncf
>>> from transformers.exporters import NNCFOpenVINOQuantizer, NNCFWeightCompressionConfig, OpenVINOConfig

>>> OpenVINOConfig(quantizer=NNCFOpenVINOQuantizer(calibration_dataset=samples))
>>> OpenVINOConfig(
...     quantizer=NNCFOpenVINOQuantizer(NNCFWeightCompressionConfig(mode=nncf.CompressWeightsMode.INT4_SYM))
... )
```

#### transformers.exporters.NNCFOnnxQuantizer[[transformers.exporters.NNCFOnnxQuantizer]]

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_nncf.py#L175)

قم بتكميم نموذج ONNX المُحوَّل باستخدام [NNCF](https://github.com/openvinotoolkit/nncf) عبر واجهته الخلفية الخاصة بـ ONNX: إما `nncf.quantize` مع `NNCFQuantizationConfig` (الافتراضي، int8 QDQ)، أو `nncf.compress_weights` مع `NNCFWeightCompressionConfig` (int4 على شكل `MatMulNBits` في ONNX Runtime).

مثال:

```python
>>> import nncf
>>> from transformers.exporters import NNCFOnnxQuantizer, NNCFWeightCompressionConfig, OnnxConfig

>>> OnnxConfig(quantizer=NNCFOnnxQuantizer(calibration_dataset=samples))
>>> OnnxConfig(quantizer=NNCFOnnxQuantizer(NNCFWeightCompressionConfig(mode=nncf.CompressWeightsMode.INT4_SYM)))
```

#### transformers.exporters.NNCFTorchFXQuantizer[[transformers.exporters.NNCFTorchFXQuantizer]]

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_nncf.py#L231)

قم بتكميم مخطط `torch.export` الخاص بـ FX باستخدام [NNCF](https://github.com/openvinotoolkit/nncf) عبر واجهة TorchFX الخاصة به: إما `nncf.quantize` مع `NNCFQuantizationConfig` (الافتراضي، عمليات `quantize`/`dequantize`)، أو `nncf.compress_weights` مع `NNCFWeightCompressionConfig`. على غرار `PT2EQuantizer`، يتم تشغيله قبل أي تحويل، لذا تستقبل جميع الواجهات الخلفية نتيجته. يقوم ExecuTorch بتحويل النتيجة الخاصة بالأوزان فقط: فـ XNNPACK لا يفوّض عمليات `quantize`/`dequantize`، ولا يحتوي ExecuTorch على نوى (kernels) لهذه العمليات.

مثال:

```python
>>> from transformers.exporters import DynamoConfig, NNCFTorchFXQuantizer

>>> DynamoConfig(quantizer=NNCFTorchFXQuantizer(calibration_dataset=samples))
```

#### transformers.exporters.NNCFQuantizationConfig[[transformers.exporters.NNCFQuantizationConfig]]

```python
transformers.exporters.NNCFQuantizationConfig(mode: Any = None, preset: Any = None, target_device: Any = None, subset_size: int | None = None, fast_bias_correction: bool | None = None, model_type: Any = None, ignored_scope: Any = None, advanced_parameters: Any = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_nncf.py#L58)

حجج `nncf.quantize`: تفعيلات وأوزان من نوع int8، مُعايرة على `calibration_dataset` الخاص بالمعاير. يُبقي الحقل المُتروك على `None` على القيمة الافتراضية لـ NNCF، باستثناء `model_type` الذي تكون قيمته الافتراضية `nncf.ModelType.TRANSFORMER`. راجع [`nncf.quantize`](https://openvinotoolkit.github.io/nncf/autoapi/nncf/index.html#nncf.quantize) لكل منها.

#### transformers.exporters.NNCFWeightCompressionConfig[[transformers.exporters.NNCFWeightCompressionConfig]]

```python
transformers.exporters.NNCFWeightCompressionConfig(mode: Any = None, ratio: float | None = None, group_size: int | None = None, ignored_scope: Any = None, all_layers: bool | None = None, sensitivity_metric: Any = None, subset_size: int | None = None, awq: bool | None = None, scale_estimation: bool | None = None, gptq: bool | None = None, lora_correction: bool | None = None, backup_mode: Any = None, compression_format: Any = None, advanced_parameters: Any = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/quantizers/quantizer_nncf.py#L76)

حجج `nncf.compress_weights`: int8 أو int4 للأوزان فقط، مع استخدام طرق واعية بالبيانات (AWQ، تقدير المقياس، GPTQ) في أوضاع int4. أوضاع int8 لا تتطلب بيانات؛ بينما تُعاير الأوضاع الأخرى على `calibration_dataset` الخاص بالمُكمِّم. `gptq` و`lora_correction` حصرية لـ OpenVINO. أي حقل يُترك على `None` يحافظ على القيمة الافتراضية لـ NNCF. راجع [`nncf.compress_weights`](https://openvinotoolkit.github.io/nncf/autoapi/nncf/index.html#nncf.compress_weights) لكل حقل.

## أدوات[[transformers.exporters.utils.get_leaf_tensors]]

دوال على مستوى أدنى تدعم `export_for_generation`، وهي مفيدة عندما تحتاج إلى التدخّل بين تفكيك النموذج وتصدير كل مكوّن على حدة.

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/utils.py#L340)

**المعاملات:**

obj (`Any`) : متجه، أو dataclass، أو dict، أو list، أو tuple، أو أي تداخل منها.

**يعيد:** `dict[str, torch.Tensor]`

تعيين مسطّح من مسارات النقط إلى المتجهات.

استرجاع جميع الموترات الورقية بشكل تكراري من بنية قد تكون متداخلة.

#### transformers.exporters.utils.prepare_for_export[[transformers.exporters.utils.prepare_for_export]]

```python
transformers.exporters.utils.prepare_for_export(model: PreTrainedModel | torch.nn.Module, inputs: MutableMapping[str, Any])
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/utils.py#L407)

اضبط النموذج والمدخلات للتصدير. يعدّل كلًا من `model` و`inputs` في مكانهما، ويعيد `(model, inputs, output_flags)` حيث يحتوي `output_flags` على القيم المستخرجة من `inputs` الخاصة بـ`use_cache` و`return_dict` وما إلى ذلك (لتُطبَّق بشكل قابل للعكس على `model.config` بواسطة `patch_model_config` أثناء التتبع).

- يُزيل مدخلات التسميات (`labels`، `future_values`) — لا يُدعم حساب الخسارة.
- يستخرج أعلام المخرجات (`use_cache`، `return_dict`، …) من `inputs` حتى لا تظهر كحجج اختيارية مُتبعة (traced kwargs)؛ وتُعاد القيم إلى كتلة التتبع (trace block) لتُطبَّق على `model.config`.
- يحسب مسبقًا معاملات الرؤية/الصوت المعتمدة على البيانات والمسجلة عبر `@register_export_input_preparer` ويكتبها في `inputs`.
- يحوّل تينسورات الإدخال لتطابق `dtype` / `device` الخاص بالنموذج.

#### transformers.exporters.utils.decompose_prefill_decode[[transformers.exporters.utils.decompose_prefill_decode]]

```python
transformers.exporters.utils.decompose_prefill_decode(model: PreTrainedModel, inputs: dict[str, Any], generation_config: Any = None, multi_token_decode: bool = False)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/utils.py#L811)

**يعيد:** `dict[str, tuple[torch.nn.Module, dict]]`

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

شغّل `model.generate()` وقُم بالتقاط مدخلات prefill و decode.

يعيد استخدام آلية التوليد الكاملة بحيث تحصل كل بنية (فكّ الترميز فقط، SSM، ترميز-فكّ ترميز، متعدد الوسائط، ...) على مدخلات صحيحة دون الحاجة إلى إعادة تنفيذ الحلقة.

يُمرَّر `generation_config` إلى `generate()` (وافتراضيًا يُستخدم إعداد النموذج الخاص به)، لذا فإن المدخلات المُلتقطة تستخدم أي كاش يبنيه `generate()`. مرّر كائنًا يحتوي على `cache_implementation="static"` و`max_cache_len=N` لالتقاط كاش **بحجم ثابت** في مدخلات فك الترميز — وهو الأساس لتصدير كاش ثابت. يحدد `max_cache_len` حجم الكاش بشكل مستقل عن الالتقاط، لذا فإن فك الترميز المُصدَّر يتعامل مع كاش بحجم ثابت `[..., N, ...]` بدلاً من كاش متزايد.

عند تفعيل `multi_token_decode`، يُلتقط مكوّن `decode` كـ **فك ترميز متعدد الرموز** — وهو دمج خطوتين متتاليتين من فك الترميز (انظر `_merge_decode_calls`) بحيث تبقى محور تسلسل الاستعلام رمزيًا (فإن كان فك الترميز لرمز واحد فقط، سيتخصص ذلك المحور بقيمة 1). ثم يتعامل مع رمز واحد (فك ترميز عادي) أو مع عدة رموز (استمرار من الماضي، أو تعبئة مسبقة عادية عندما تكون ذاكرة التخزين المؤقت فارغة). وإلا، يكون `decode` هو فك الترميز الكلاسيكي لرمز واحد.

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/utils.py#L934)

**يعيد:** `dict[str, tuple[torch.nn.Module, dict]]`

سجل واحد `name: (module, inputs)` لكل وحدة فرعية مكتشفة (مُشفِّر الصورة/الصوت، المُسقط، نموذج اللغة، lm_head).

**يرفع:** ``ValueError``

- ``ValueError`` -- إذا لم يتم العثور على أي وحدات فرعية متعددة الوسائط معروفة في النموذج.

التقاط المدخلات لكل وحدة فرعية متعددة الوسائط عبر تمريرة أمامية واحدة.

يكتشف جميع الوحدات الفرعية متعددة الوسائط المعروفة من خلال اسم الخاصية (برج الرؤية، المُشغِّل، نموذج اللغة، lm_head، ...) ويلتقط معاملات استدعاء الأمامي الخاصة بها أثناء استدعاء واحد لـ`model(**inputs)`.

يُعاد كل وحدة فرعية كعنصر مستقل بصيغة `name: (module, inputs)` من أجل التصدير المستقل. وقد تم استبعاد خطوة دمج الرموز (مثل `masked_scatter` في النماذج متعددة الوسائط) عمدًا من الرسوم البيانية المُصدَّرة — إذ تقع على عاتق المستدعي مسؤولية تجميع `inputs_embeds` من مخرجات المُشفِّر قبل تشغيل المُفكِّك.

#### transformers.exporters.utils.decompose_for_generation[[transformers.exporters.utils.decompose_for_generation]]

```python
transformers.exporters.utils.decompose_for_generation(model: PreTrainedModel, inputs: dict[str, Any], generation_config: Any = None, multi_token_decode: bool = False)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/utils.py#L978)

**المعاملات:**

model : نموذج توليدي. يجب أن يدعم `model.generate(**inputs)`.

inputs : **Generate** kwargs — ما ستمرره إلى `model.generate(**inputs)`.

generation_config : `GenerationConfig` اختياري يُمرَّر إلى `generate()` أثناء الالتقاط. مرِّر نسخة منها مع `cache_implementation="static"` + `max_cache_len=N` للتصدير مقابل ذاكرة مؤقتة بحجم ثابت (انظر `decompose_prefill_decode`).

multi_token_decode : عند تعيين `True`، يتم التقاط مكوّن `decode` كإفكوك متعدد الرموز (محور تسلسل الاستعلام الديناميكي: عدة رموز في آنٍ واحد — إما استكمال من الماضي، أو تعبئة مسبقة عادية عندما تكون ذاكرة التخزين المؤقت فارغة)؛ ولا يمكن للإفكوك أحادي الرمز أن يبقى ديناميكيًا (انظر `decompose_prefill_decode`).

**يعيد:** `{component_name

(submodel, forward_inputs)}`. Keys are `"prefill"` / `"decode"` for plain generative models and `"<modality>_encoder"` / `"multi_modal_projector"` / `"language_model"` / `"lm_head"` / `"decode"` for multi-modal generative models.

فكّك نموذجًا توليديًا إلى أزواج `(model, forward_inputs)` قابلة للتصدير بشكل مستقل.

ينفّذ `decompose_prefill_decode` لالتقاط معاملات استدعاءات prefill وdecode من `model.generate(**inputs, max_new_tokens=2)` حقيقية. إذا كان prefill متعدد الوسائط (وفقًا لـ`is_multimodal`)، فإنه يقسمه إلى عنصر واحد لكل وحدة فرعية (مشفر الرؤية/الصوت، المُشغِّل، نموذج اللغة، `lm_head`) عبر `decompose_multimodal`.

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

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

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/exporters/utils.py#L925)

يعيد `True` إذا كان النموذج متعدد الوسائط مع مشفّرات الوسائط ونموذج لغوي.

النموذج الذي ليس `PreTrainedModel` (مثل `nn.Module` عادي) لا يحتوي على مُوجِّهات `get_encoder`/`get_decoder` قياسية، وهو ليس متعدد الوسائط بوضوح، لذلك يُرجع `False` مباشرة.