La classe exportateur Auto-HF qui s’occupe d’instantier automatiquement le HfExporter approprié à partir de la ExportConfig.

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

La classe de configuration d’export Auto-HF qui se charge de dispatcher automatiquement vers la configuration d’export correcte à partir d’une configuration d’export stockée dans un dictionnaire.

Classe de base abstraite pour tous les exportateurs de Transformers.

Sous-classez et implémentez ~HfExporter.export pour ajouter un nouveau backend d’exportation.

Exporter qui convertit un PreTrainedModel en ExportedProgram.

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

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

Exporteur qui convertit un PreTrainedModel en ONNXProgram ONNX.

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

Exporteur qui convertit un PreTrainedModel en ExecutorchProgramManager ExecuTorch.

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

Classe de configuration pour l’exportation de modèles via torch.export.

Classe de configuration pour l’exportation de modèles vers ONNX via torch.onnx.export.

Hérite de tous les champs de DynamoConfig (dynamic, strict, dynamic_shapes, prefer_deferred_runtime_asserts_over_guards).

Classe de configuration pour l’exportation de modèles au format ExecuTorch.

Hérite de tous les champs de DynamoConfig (dynamic, strict, dynamic_shapes, prefer_deferred_runtime_asserts_over_guards).

Classe de configuration pour l’exportation de modèles vers OpenVINO IR via openvino.convert_model.

Hérite de tous les champs de [DynamoConfig] (dynamic, strict, dynamic_shapes, prefer_deferred_runtime_asserts_over_guards).

Classe de base pour les quantificateurs post-entraînement appliqués lors de l’export.

Un quantiseur déclare les formats d’exportation qu’il prend en charge et les paquets dont il a besoin (avec les versions sur lesquelles il est testé, comme les exportateurs), ainsi que s’il quantise le graphe FX de torch.export, avant toute conversion (de sorte que chaque backend utilise le résultat), ou le modèle dans lequel un backend le convertit (onnx_ir.Model, openvino.Model). L’exportateur le valide par rapport à l’exportation dès le départ, puis appelle ~ExportQuantizer.quantize avec ce modèle et les entrées d’exemple de l’exportation. Sous-classez-le et implémentez quantize pour ajouter une nouvelle méthode de quantification ; un CalibrationSet associe les échantillons de calibration aux entrées propres au modèle.

Vue réitérable des échantillons de calibration en tant qu'entrées du modèle.

Les échantillons sont le calibration_dataset du quantificateur, ou les sample_inputs propres à l’export (avec un avertissement, une fois qu’ils sont lus) s’il n’en possède pas. Ils peuvent être n’importe quel mapping, tel qu’un BatchEncoding de tokeniseur. transform mappe chaque échantillon de kwargs en avant sur ce que le modèle quantisé reçoit (kwargs tracés, entrées ONNX, entrées de ports OpenVINO), de manière paresseuse, un échantillon à la fois, à chaque passage.

Quantifier le graphe FX avec la quantification PyTorch 2 Export (PT2E) : prepare_pt2e insère des observateurs, le jeu de calibration les pilote, et convert_pt2e les remplace par des opérations quantize/dequantize. Fonctionne avec tous les backends d'export.

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

Quantifier le modèle ONNX converti à l’aide des outils d’ONNX Runtime (onnxruntime.quantization) : quantize_static avec un OnnxRuntimeStaticConfig (par défaut), ou quantize_dynamic avec un OnnxRuntimeDynamicConfig.

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

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

Arguments de onnxruntime.quantization.quantize_static : activations et poids int8 (QDQ par défaut), calibrés sur le calibration_dataset du quantiseur. Un champ laissé à None conserve la valeur par défaut d’ONNX Runtime. Consultez quantize_static pour chacun d’eux.

Arguments de onnxruntime.quantization.quantize_dynamic : poids int8, activations quantifiées à l’exécution, aucune calibration. Un champ laissé à None conserve la valeur par défaut d’ONNX Runtime. Consultez quantize_dynamic pour chacun d’eux.

Quantifier le modèle OpenVINO converti avec NNCF : nncf.quantize avec un NNCFQuantizationConfig (par défaut), ou nncf.compress_weights avec un NNCFWeightCompressionConfig.

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

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

Quantifier le modèle ONNX converti avec NNCF via son backend ONNX : nncf.quantize avec un NNCFQuantizationConfig (par défaut, int8 QDQ), ou nncf.compress_weights avec un NNCFWeightCompressionConfig (int4 en tant que MatMulNBits d’ONNX Runtime).

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

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

Quantifier le graphe FX de torch.export avec NNCF via son backend TorchFX : nncf.quantize avec un NNCFQuantizationConfig (par défaut, les opérations quantize/dequantize), ou nncf.compress_weights avec un NNCFWeightCompressionConfig. Comme PT2EQuantizer, il s’exécute avant toute conversion, de sorte que chaque backend utilise son résultat. ExecuTorch ne réduit que le résultat weight-only : XNNPACK ne délègue pas les opérations quantize/dequantize, et ExecuTorch ne dispose pas de noyaux pour elles.

>>> from transformers.exporters import DynamoConfig, NNCFTorchFXQuantizer

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

Arguments de nncf.quantize : activations et poids int8, calibrés sur le calibration_dataset du quantiseur. Un champ laissé à None conserve la valeur par défaut de NNCF, à l’exception de model_type, dont la valeur par défaut est nncf.ModelType.TRANSFORMER. Voir nncf.quantize pour chacun d’eux.

Arguments de nncf.compress_weights : int8 ou int4 uniquement sur les poids, avec des méthodes prenant en compte les données (AWQ, estimation d’échelle, GPTQ) pour les modes int4. Les modes int8 sont sans données ; les autres effectuent une calibration sur le calibration_dataset du quantiseur. gptq et lora_correction sont exclusifs à OpenVINO. Un champ laissé à None conserve la valeur par défaut de NNCF. Consultez nncf.compress_weights pour chacun d’eux.

Récupérer récursivement tous les tenseurs feuilles d'une structure potentiellement imbriquée.

Configure le modèle et les entrées pour l'export. Modifie à la fois model et inputs en place, renvoyant (model, inputs, output_flags) où output_flags contient les valeurs extraites de inputs pour use_cache, return_dict, etc. (à appliquer de manière réversible sur model.config par patch_model_config pendant la trace).

• Supprime les entrées d'étiquettes (labels, future_values) — le calcul de la perte n'est pas pris en charge.
• Extrait les drapeaux de sortie (use_cache, return_dict, …) de inputs afin qu’ils n’apparaissent pas en tant que kwargs tracés ; les valeurs sont renvoyées pour que le bloc de trace les applique à model.config.
• Pré-calcule les kwargs de vision/audio dépendants des données enregistrés via @register_export_input_preparer et les écrit dans inputs.
• Convertit les tenseurs d’entrée pour correspondre au dtype / device du modèle.

Exécutez model.generate() et capturez les entrées de préremplissage et de décodage.

Réutilise le mécanisme complet de génération afin que chaque architecture (decoder-only, SSM, encoder-decoder, multi-modal, …) reçoive des entrées correctes sans réimplémenter la boucle.

generation_config est transmis à generate() (en utilisant par défaut celui du modèle), de sorte que les entrées capturées utilisent le cache que generate() construirait. Transmettez-en un avec cache_implementation="static" et max_cache_len=N pour capturer un cache de taille statique dans les entrées de décodage — la base d’une exportation avec cache statique. max_cache_len dimensionne le cache indépendamment de la capture, de sorte que le décodage exporté utilise un cache fixe [..., N, ...] plutôt qu’un cache qui croît.

Lorsque multi_token_decode est actif, le composant decode est capturé comme un décodage multi-tokens — deux étapes de décodage consécutives fusionnées (voir _merge_decode_calls) afin que son axe de séquence de requête reste symbolique (un décodage mono-token spécialiserait cet axe à 1). Il gère ensuite à la fois un seul token (décodage ordinaire) et plusieurs (continuation à partir du passé, ou un préremplissage simple si le cache est vide). Sinon, decode est le décodage mono-token classique.

Capturer les entrées de chaque sous-module multi-modal via un seul passage avant.

Détecte tous les sous-modules multi-modaux connus par nom d'attribut (tour de vision, projecteur, modèle de langage, lm_head, …) et capture leurs kwargs de forward lors d'un appel model(**inputs).

Chaque sous-module est renvoyé comme une entrée distincte name: (module, inputs) pour un export indépendant. L'étape de fusion des jetons (par exemple masked_scatter pour les modèles multi-modaux) est volontairement laissée en dehors des graphes exportés — il incombe à l'appelant d'assembler inputs_embeds à partir des sorties de l'encodeur avant d'exécuter le décodeur.

Décomposer un modèle génératif en paires (model, forward_inputs) exportables indépendamment.

Exécute decompose_prefill_decode pour capturer les kwargs de préremplissage et de décodage en avant à partir d'un appel réel à model.generate(**inputs, max_new_tokens=2). Si le préremplissage est multimodal (selon is_multimodal), il le découpe ensuite en une entrée par sous-module (encodeur vision/audio, projecteur, modèle de langage, lm_head) via decompose_multimodal.

Retourne True si le modèle est multimodal avec des encodeurs modaux et un modèle de langage.

Un modèle qui n'est pas un PreTrainedModel (par exemple un simple nn.Module) ne dispose pas d'accesseurs canoniques get_encoder/get_decoder et n'est pas multimodal, il renvoie donc directement False.