ExportConfig verildiğinde doğru HfExporter sınıfını otomatik olarak örneklemekten sorumlu olan Auto-Hf dışa aktarıcı sınıfı.

Bir sözlükte saklanan bir dışa aktarma yapılandırması verildiğinde doğru dışa aktarma yapılandırmasına otomatik olarak yönlendirmeyi üstlenen Auto-HF dışa aktarma yapılandırma sınıfı.

Bir dışa aktarıcıyı, config_class'ı ile birlikte, export_format'ı altında ve dışa aktarmalarını çalıştıran runner ile birlikte kaydedin, böylece otomatik sınıflar bunları bulabilsin.

Tüm Transformers dışa aktarıcıları için soyut temel sınıf.

Bir backend eklemek için ~HfExporter.export_program yöntemini alt sınıflandırıp tek bir grafiği izlemek için ve ~HfExporter.save_program / ~HfExporter.load_program yöntemlerini yazmak ve geri okumak için uygulayın. Halka açık ~HfExporter.export ve ~HfExporter.export_for_generation yöntemleri, bunların üzerine bir ExportedModel oluşturur.

Dışa aktarılmış bir model: grafikleri (components, {name: ExportedComponent}) ve bunların izlendiği yapılandırmalar, modelin geldiği modelin çağrılma biçiminde adlandırılır.

~HfExporter.export, programı .program olan tek bir "model" bileşeni üretir; ~HfExporter.export_for_generation ise her üretim aşaması için bir bileşen üretir.

>>> exported = OnnxExporter().export(model, inputs, OnnxConfig(dynamic=True))
>>> exported.save_pretrained("exported")
>>> outputs = ExportedModel.from_pretrained("exported", device="cuda")(**inputs)
>>> outputs.last_hidden_state

Dışa aktarılan tek grafik: arka uç programı ve dışa aktarıcının bu program hakkında kaydettiği bilgiler.

Dışa aktarıcının bir grafik hakkında kaydettiği bilgiler (build_export_metadata()).

Arka uydusunda bir dışa aktarılmış programı çalıştırır: runner(**kwargs), kaynak modelin döndürdüğünü döndürür.

Bir PreTrainedModel'i ExportedProgram'a dönüştüren dışa aktarıcı.

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

Bir PreTrainedModel'i ONNX grafiğine (bir onnx_ir.Model) dönüştüren dışa aktarıcı.

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

Bir PreTrainedModel'i ExecuTorch ExecutorchProgramManager'ine dönüştüren dışa aktarıcı.

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

torch.export ile modelleri dışa aktarmak için yapılandırma sınıfı.

torch.onnx.export üzerinden modelleri ONNX'e dışa aktarmak için yapılandırma sınıfı.

DynamoConfig sınıfından tüm alanları devralır (dynamic, strict, dynamic_shapes, prefer_deferred_runtime_asserts_over_guards).

ExecuTorch formatına model dışa aktarma için yapılandırma sınıfı.

DynamoConfig sınıfından tüm alanları devralır (dynamic, strict, dynamic_shapes, prefer_deferred_runtime_asserts_over_guards).

openvino.convert_model aracılığıyla modelleri OpenVINO IR formatına dışa aktarmak için yapılandırma sınıfı.

[DynamoConfig] sınıfından tüm alanları devralır (dynamic, strict, dynamic_shapes, prefer_deferred_runtime_asserts_over_guards).

Dışa aktarma sırasında uygulanan eğitim sonrası niceliklendiriciler için temel sınıf.

Bir quantizer, desteklediği dışa aktarma biçimlerini ve ihtiyaç duyduğu paketleri (exporter'lar gibi, test edildiği sürümlerle birlikte) ve herhangi bir dönüştürme işleminden önce torch.export FX grafiğini mi (böylece her backend sonucu alır) yoksa bir backendin dönüştürdüğü modeli mi (onnx_ir.Model, openvino.Model) kuantize ettiğini bildirir. Exporter, bunu baştan dışa aktarma ile doğrular, ardından o model ve dışa aktarmanın örnek girdileriyle ~ExportQuantizer.quantize çağrısını yapar. Yeni bir kuantizasyon yöntemi eklemek için bunu alt sınıflandırın ve quantize uygulayın; bir CalibrationSet, kalibrasyon örneklerini modelin kendi girdilerine eşler.

Model girdileri olarak kalibrasyon örneklerinin yeniden yinelebilir görünümü.

Örnekler, kuantizatörün calibration_dataset değeridir; yoksa dışa aktarımın kendi sample_inputs değeridir (okunduklarında bir kez uyarı verilir). Bunlar, bir tokenizer’ın BatchEncoding gibi herhangi bir eşleme olabilir. transform, her geçişte, örnekleri tek tek ve tembel (lazy) bir şekilde, her forward-kwarg örneğini kuantize edilmiş modelin kabul ettiği biçime (izlenen kwargs, ONNX beslemeleri, OpenVINO port beslemeleri) eşler.

FX grafiğini PyTorch 2 Export (PT2E) kuantizasyonu ile kuantize edin: prepare_pt2e gözlemcileri (observers) ekler, kalibrasyon seti bunları yönlendirir ve convert_pt2e bunları quantize/dequantize işlemleriyle değiştirir. Tüm dışa aktarma (export) arka uçlarıyla çalışır.

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

Dönüştürülen ONNX modelini ONNX Runtime'ın kendi araçları (onnxruntime.quantization) ile kuantize edin: OnnxRuntimeStaticConfig (varsayılan) ile quantize_static veya OnnxRuntimeDynamicConfig ile quantize_dynamic.

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

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

onnxruntime.quantization.quantize_static argümanları: int8 aktivasyonlar ve ağırlıklar (varsayılan olarak QDQ), kuantizörün calibration_dataset üzerinde kalibre edilir. None olarak bırakılan bir alan, ONNX Runtime varsayılanını korur. Her biri için quantize_static dokümantasyonuna bakın.

onnxruntime.quantization.quantize_dynamic argümanları: int8 ağırlıklar, çalışma zamanında kuantize edilen aktivasyonlar, kalibrasyon yok. None olarak bırakılan bir alan, ONNX Runtime varsayılanını korur. Her biri için bkz. quantize_dynamic.

Dönüştürülen OpenVINO modelini NNCF ile kuantize edin: nncf.quantize bir NNCFQuantizationConfig (varsayılan) ile veya nncf.compress_weights bir NNCFWeightCompressionConfig ile.

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

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

Dönüştürülen ONNX modelini NNCF aracılığıyla ONNX arka ucu üzerinden kuantize edin: nncf.quantize ile NNCFQuantizationConfig (varsayılan, int8 QDQ) veya nncf.compress_weights ile NNCFWeightCompressionConfig (ONNX Runtime'ın MatMulNBits olarak int4).

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

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

torch.export FX grafiğini, TorchFX arka ucu üzerinden NNCF ile kuantize edin: NNCFQuantizationConfig ile nncf.quantize (varsayılan, quantize/dequantize işlemleri) veya NNCFWeightCompressionConfig ile nncf.compress_weights. PT2EQuantizer gibi, herhangi bir dönüştürmeden önce çalıştığından, tüm arka uçlar sonucunu alır. ExecuTorch yalnızca ağırlık-kuantize edilmiş sonucu düşürür: XNNPACK, quantize/dequantize işlemlerini devretmez ve ExecuTorch için bunlara ait çekirdekler yoktur.

>>> from transformers.exporters import DynamoConfig, NNCFTorchFXQuantizer

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

nncf.quantize argümanları: int8 aktivasyonlar ve ağırlıklar, quantizer’ın calibration_dataset üzerinde kalibre edilmiştir. None olarak bırakılan bir alan, model_type hariç olmak üzere NNCF varsayılanını korur; model_type varsayılan olarak nncf.ModelType.TRANSFORMER değerini alır. Her biri için nncf.quantize dokümantasyonuna bakın.

nncf.compress_weights argümanları: veriye duyarlı yöntemler (AWQ, ölçek tahmini, GPTQ) içeren int4 modları için yalnızca ağırlıklı int8 veya int4. int8 modları verisizdir; diğerleri ise kuantizörün calibration_dataset üzerinde kalibre eder. gptq ve lora_correction yalnızca OpenVINO içindir. None olarak bırakılan bir alan, NNCF varsayılanını korur. Her biri için bkz. nncf.compress_weights.

Olası olarak iç içe geçmiş bir yapıdan tüm yaprak tensörleri özyinelemeli olarak getirir.

Dışa aktarma için model ve girdileri yapılandırır. Hem model hem de inputs yerinde değiştirilir ve output_flags, inputs içinden use_cache, return_dict vb. için alınan değerleri tutan (model, inputs, output_flags) döndürülür (izleme sırasında patch_model_config tarafından model.config üzerine geri döndürülebilir şekilde uygulanacak).

• Etiket girdilerini (labels, future_values) ayıklar — kayıp hesabı desteklenmez.
• Çıktı bayraklarını (use_cache, return_dict, …) inputs içinden çıkarır, böylece izlenen kwargs olarak görünmezler; değerler, model.config üzerine uygulanması için izleme bloğuna döndürülür.
• @register_export_input_preparer ile kayıtlı veriye bağımlı görme/ses kwargs'larını önceden hesaplar ve bunları inputs içine yazar.
• Girdi tensörlerini modelin dtype / device değerleriyle eşleşecek şekilde dönüştürür.

model.generate() çalıştırın ve prefill ile decode girdilerini yakalayın.

Tüm üretim mekanizmasını yeniden kullanır; böylece her mimari (yalnızca çözücü, SSM, kodlayıcı-çözücü, çok modlu, …) döngüyü yeniden uygulamaya gerek kalmadan doğru girdileri alır.

generation_config, generate() işlevine iletilir (varsayılan olarak modelin kendi ayarları kullanılır); bu nedenle yakalanan girdiler, generate() işlevinin oluşturacağı önbelleği kullanır. cache_implementation="static" ve max_cache_len=N değerlerini içeren bir yapılandırma iletirseniz, çözümleme girdilerinde statik boyutlu bir önbellek yakalanır; bu, statik önbellek dışa aktarımının temelini oluşturur. max_cache_len, yakalama işleminden bağımsız olarak önbelleğin boyutunu belirler; böylece dışa aktarılan çözümleme, büyüyen bir önbellek yerine sabit bir [..., N, ...] önbelleği alır.

multi_token_decode olduğunda, decode bileşeni çoklu token olarak yakalanır — iki ardışık decode adımı birleştirilir (_merge_decode_calls bkz.) böylece sorgu dizisi ekseni sembolik kalır (tek token'lı bir decode, bu ekseni 1'e özelleştirirdi). Ardından hem tek token'ı (sıradan çözümleme) hem de birçok token'ı (geçmişten devam veya önbellek boşken düz bir prefill) işler. Aksi halde decode, klasik tek token'lı decode'dur.

Her çok modlu alt modülün girdilerini tek bir ileri geçişle yakalayın.

Öznitelik adına göre (görüntü kulesi, projeksiyoncu, dil modeli, lm_head, …) bilinen tüm çok modlu alt modülleri algılar ve tek bir model(**inputs) çağrısı sırasında ileri yönlü (forward) anahtar kelime argümanlarını yakalar.

Her alt modül, bağımsız dışa aktarım için ayrı bir name: (module, inputs) girdisi olarak döndürülür. Token birleştirme adımı (ör. çok modlu modeller için masked_scatter), bilinçli olarak dışa aktarılan grafiklerin dışında bırakılır — inputs_embeds'i decoder'ı çalıştırmadan önce kodlayıcı çıktılarından bir araya getirmek çağırıcının sorumluluğundadır.

Üretken bir modeli bağımsız olarak dışa aktarılabilir (model, forward_inputs) çiftlerine ayırın.

decompose_prefill_decode çalıştırılarak gerçek bir model.generate(**inputs, max_new_tokens=2) çağrısından prefill ve decode forward kwargs'ları yakalanır. Prefill çok modluysa (is_multimodal göre), decompose_multimodal aracılığıyla her alt modül için (görüntü/ses kodlayıcı, projeksiyon, dil modeli, lm_head) birer giriş olacak şekilde daha da bölünür.

Model, modal kodlayıcılar ve bir dil modeline sahip çok modluysa True döndürür.

PreTrainedModel olmayan bir model (ör. çıplak bir nn.Module) standart get_encoder/get_decoder erişimcilerine sahip değildir ve açıkça çok modallı değildir, bu nedenle False değerine kısaltılır.