La clase exportadora Auto-HF que se encarga de instanciar automáticamente el HfExporter correcto a partir de la ExportConfig.

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

La clase de configuración de exportación Auto-HF que se encarga de enrutar automáticamente a la configuración de exportación correcta a partir de una configuración de exportación almacenada en un diccionario.

Clase base abstracta para todos los exportadores de Transformers.

Subclase e implementa ~HfExporter.export para añadir un nuevo backend de exportación.

Exportador que convierte un PreTrainedModel en un ExportedProgram.

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

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

Exportador que convierte un PreTrainedModel en un ONNXProgram de 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

Exportador que convierte un PreTrainedModel en un ExecutorchProgramManager de 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")

Clase de configuración para exportar modelos mediante torch.export.

Clase de configuración para exportar modelos a ONNX mediante torch.onnx.export.

Hereda todos los campos de DynamoConfig (dynamic, strict, dynamic_shapes, prefer_deferred_runtime_asserts_over_guards).

Clase de configuración para exportar modelos al formato ExecuTorch.

Hereda todos los campos de DynamoConfig (dynamic, strict, dynamic_shapes, prefer_deferred_runtime_asserts_over_guards).

Clase de configuración para exportar modelos a OpenVINO IR mediante openvino.convert_model.

Hereda todos los campos de [DynamoConfig] (dynamic, strict, dynamic_shapes, prefer_deferred_runtime_asserts_over_guards).

Clase base para cuantificadores de pos-entrenamiento aplicados durante la exportación.

Un cuantizador declara los formatos de exportación que admite y los paquetes que necesita (con las versiones en las que se ha probado, al igual que los exportadores) y si cuantiza el grafo FX de torch.export, antes de cualquier conversión (de modo que cada backend tome el resultado), o el modelo en el que un backend lo convierte (onnx_ir.Model, openvino.Model). El exportador lo valida frente a la exportación de antemano y luego llama a ~ExportQuantizer.quantize con ese modelo y las entradas de ejemplo de la exportación. Subclásalo e implementa quantize para añadir un nuevo método de cuantización; un CalibrationSet mapea las muestras de calibración a las propias entradas del modelo.

Vista re-iterable de las muestras de calibración como entradas del modelo.

Las muestras son el calibration_dataset del cuantizador, o las propias sample_inputs de la exportación (con una advertencia, una vez que se leen) cuando no tiene ninguna. Pueden ser cualquier mapeo, como un BatchEncoding de un tokenizador. transform mapea cada muestra de forward-kwarg a lo que toma el modelo cuantizado (kwargs trazados, feeds de ONNX, feeds de puertos de OpenVINO), de forma perezosa, una muestra a la vez, en cada pasada.

Cuantice el grafo FX con cuantización de PyTorch 2 Export (PT2E): prepare_pt2e inserta observadores, el conjunto de calibración los dirige y convert_pt2e los reemplaza con operaciones de cuantizar/des-cuantizar. Funciona con todos los backends de exportación.

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

Cuantice el modelo ONNX convertido con las propias herramientas de ONNX Runtime (onnxruntime.quantization): quantize_static con una OnnxRuntimeStaticConfig (el valor predeterminado) o quantize_dynamic con una 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()))

Argumentos de onnxruntime.quantization.quantize_static: activaciones y pesos int8 (QDQ por defecto), calibrados en el calibration_dataset del cuantizador. Un campo dejado en None mantiene el valor predeterminado de ONNX Runtime. Consulte quantize_static para cada uno.

Argumentos de onnxruntime.quantization.quantize_dynamic: pesos int8, activaciones cuantizadas en tiempo de ejecución, sin calibración. Un campo dejado en None mantiene el valor predeterminado de ONNX Runtime. Consulte quantize_dynamic para cada uno.

Cuantice el modelo de OpenVINO convertido con NNCF: nncf.quantize con una NNCFQuantizationConfig (el valor predeterminado), o nncf.compress_weights con una 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))
... )

Cuantice el modelo ONNX convertido con NNCF a través de su backend ONNX: nncf.quantize con una NNCFQuantizationConfig (el valor predeterminado, int8 QDQ), o nncf.compress_weights con una NNCFWeightCompressionConfig (int4 como MatMulNBits de 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)))

Cuantice el grafo FX de torch.export con NNCF a través de su backend TorchFX: nncf.quantize con una NNCFQuantizationConfig (el valor predeterminado, operaciones quantize/dequantize), o nncf.compress_weights con una NNCFWeightCompressionConfig. Al igual que PT2EQuantizer, se ejecuta antes de cualquier conversión, por lo que cada backend toma su resultado. ExecuTorch solo reduce el resultado solo de pesos: XNNPACK no delega las operaciones quantize/dequantize, y ExecuTorch no tiene kernels para ellas.

>>> from transformers.exporters import DynamoConfig, NNCFTorchFXQuantizer

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

Argumentos de nncf.quantize: activaciones y pesos int8, calibrados en el calibration_dataset del cuantizador. Un campo dejado en None conserva el valor predeterminado de NNCF, excepto model_type, cuyo valor predeterminado es nncf.ModelType.TRANSFORMER. Consulte nncf.quantize para cada uno.

Argumentos de nncf.compress_weights: int8 o int4 solo de pesos, con métodos conscientes de los datos (AWQ, estimación de escala, GPTQ) para los modos int4. Los modos int8 son independientes de los datos; los demás calibran con el calibration_dataset del cuantizador. gptq y lora_correction son exclusivos de OpenVINO. Un campo dejado en None conserva el valor predeterminado de NNCF. Consulte nncf.compress_weights para cada uno.

Recupera recursivamente todos los tensores hoja de una estructura potencialmente anidada.

Configura el modelo y las entradas para la exportación. Modifica model y inputs in situ, devolviendo (model, inputs, output_flags), donde output_flags contiene los valores extraídos de inputs para use_cache, return_dict, etc. (para aplicarse de forma reversible sobre model.config mediante patch_model_config durante la traza).

• Elimina las entradas de etiquetas (labels, future_values); no se admite el cálculo de la pérdida.
• Extrae las banderas de salida (use_cache, return_dict, …) de inputs para que no aparezcan como kwargs trazados; los valores se devuelven para que el bloque de trazado los aplique en model.config.
• Precomputa los kwargs de visión/áudio dependientes de los datos registrados mediante @register_export_input_preparer y los escribe en inputs.
• Convierte los tensores de entrada para que coincidan con el dtype / device del modelo.

Ejecuta model.generate() y captura las entradas de prefill y decode.

Reutiliza el mecanismo completo de generación para que cada arquitectura (solo decodificador, SSM, codificador-decodificador, multimodal, …) reciba las entradas correctas sin reimplementar el bucle.

generation_config se reenvía a generate() (por defecto, la del propio modelo), por lo que las entradas capturadas utilizan la caché que generate() construiría. Pasa una con cache_implementation="static" y max_cache_len=N para capturar una caché de tamaño estático en las entradas de decodificación, la base para una exportación con caché estática. max_cache_len dimensiona la caché de forma independiente a la captura, por lo que la decodificación exportada toma una caché fija de [..., N, ...] en lugar de una que crece.

Cuando multi_token_decode, el componente decode se captura como un decodificado multi-token: dos pasos de decodificado consecutivos fusionados (ver _merge_decode_calls) para que su eje de secuencia de consulta se mantenga simbólico (un decodificado de un solo token especializaría ese eje a 1). A continuación, maneja tanto un solo token (decodificado ordinario) como muchos (continuación desde el pasado, o un prefill simple cuando la caché está vacía). En caso contrario, decode es el decodificado clásico de un solo token.

Captura las entradas de cada submódulo multimodal mediante una única pasada hacia adelante.

Detecta todos los submódulos multimodales conocidos por nombre de atributo (torre de visión, proyector, modelo de lenguaje, lm_head, …) y captura sus kwargs de forward durante una llamada a model(**inputs).

Cada submódulo se devuelve como una entrada separada name: (module, inputs) para su exportación independiente. El paso de fusión de tokens (p. ej. masked_scatter para modelos multimodales) se deja deliberadamente fuera de los grafos exportados: es responsabilidad del llamador ensamblar inputs_embeds a partir de las salidas del codificador antes de ejecutar el decodificador.

Descomponer un modelo generativo en pares (model, forward_inputs) exportables de forma independiente.

Ejecuta decompose_prefill_decode para capturar los kwargs de prefill y decode de una llamada real a model.generate(**inputs, max_new_tokens=2). Si el prefill es multimodal (según is_multimodal), se divide además en una entrada por submódulo (codificador de visión/audios, proyector, modelo de lenguaje, lm_head) mediante decompose_multimodal.

Devuelve True si el modelo es multimodal con codificadores modales y un modelo de lenguaje.

Un modelo que no es PreTrainedModel (por ejemplo, un nn.Module simple) no tiene los accesores canónicos get_encoder/get_decoder y no es multimodal de forma trivial, por lo que devuelve False directamente.