A classe exportadora Auto-HF que cuida da instanciação automática para o HfExporter correto, dado o ExportConfig.

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

A classe de configuração de exportação Auto-HF que se encarrega de despachar automaticamente para a configuração de exportação correta, dada uma configuração de exportação armazenada em um dicionário.

Classe base abstrata para todos os exportadores do Transformers.

Subclasse e implemente ~HfExporter.export para adicionar um novo backend de exportação.

Exportador que converte um PreTrainedModel em um 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 converte um PreTrainedModel em um 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

Exportador que converte um PreTrainedModel em um ExecutorchProgramManager do 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 configuração para exportar modelos via torch.export.

Classe de configuração para exportar modelos para ONNX via torch.onnx.export.

Herdita todos os campos de DynamoConfig (dynamic, strict, dynamic_shapes, prefer_deferred_runtime_asserts_over_guards).

Classe de configuração para exportar modelos para o formato ExecuTorch.

Herdita todos os campos de DynamoConfig (dynamic, strict, dynamic_shapes, prefer_deferred_runtime_asserts_over_guards).

Classe de configuração para exportar modelos para o IR do OpenVINO via openvino.convert_model.

Herdita todos os campos de [DynamoConfig] (dynamic, strict, dynamic_shapes, prefer_deferred_runtime_asserts_over_guards).

Classe base para quantizadores de pós-treino aplicados durante a exportação.

Um quantizer declara os formatos de exportação que suporta e os pacotes de que precisa (com as versões em que foi testado, assim como os exporters) e se ele quantiza o grafo FX de torch.export, antes de qualquer conversão (de modo que cada backend recebe o resultado), ou o modelo para o qual um backend o converte (onnx_ir.Model, openvino.Model). O exporter valida-o em relação à exportação antecipadamente e, em seguida, chama ~ExportQuantizer.quantize com esse modelo e as entradas de exemplo da exportação. Subclasse-o e implemente quantize para adicionar um novo método de quantização; um CalibrationSet mapeia as amostras de calibração para as entradas próprias do modelo.

Visualização re-iterável das amostras de calibração como entradas do modelo.

As amostras são o calibration_dataset do quantizador, ou o próprio sample_inputs da exportação (com um aviso, uma vez que são lidos) quando este não possui nenhum. Podem ser qualquer mapeamento, como um BatchEncoding de um tokenizador. O transform mapeia cada amostra de kwarg de forward para o que o modelo quantizado recebe (kwarg rastreados, feeds ONNX, feeds de porta OpenVINO), de forma preguiçosa, uma amostra por vez, em cada passagem.

Quantize o grafo FX com a quantização PyTorch 2 Export (PT2E): prepare_pt2e insere observadores, o conjunto de calibração os direciona e convert_pt2e os substitui por operações de quantize/dequantize. Funciona com todos os backends de exportação.

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

Quantize o modelo ONNX convertido com as próprias ferramentas do ONNX Runtime (onnxruntime.quantization): quantize_static com um OnnxRuntimeStaticConfig (o padrão) ou quantize_dynamic com um 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: ativações e pesos int8 (QDQ por padrão), calibrados no calibration_dataset do quantizador. Um campo deixado como None mantém o padrão do ONNX Runtime. Consulte quantize_static para cada um.

Argumentos de onnxruntime.quantization.quantize_dynamic: pesos int8, ativações quantizadas em tempo de execução, sem calibração. Um campo deixado como None mantém o padrão do ONNX Runtime. Consulte quantize_dynamic para cada um.

Quantize o modelo OpenVINO convertido com NNCF: nncf.quantize com um NNCFQuantizationConfig (o padrão), ou nncf.compress_weights com um 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))
... )

Quantize o modelo ONNX convertido com NNCF por meio de seu backend ONNX: nncf.quantize com um NNCFQuantizationConfig (o padrão, int8 QDQ), ou nncf.compress_weights com um NNCFWeightCompressionConfig (int4 como MatMulNBits do 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)))

Quantize o grafo FX do torch.export com NNCF por meio de seu backend TorchFX: nncf.quantize com um NNCFQuantizationConfig (o padrão, ops quantize/dequantize), ou nncf.compress_weights com um NNCFWeightCompressionConfig. Assim como o PT2EQuantizer, ele é executado antes de qualquer conversão, de modo que todos os backends utilizam seu resultado. O ExecuTorch reduz apenas o resultado somente de pesos: o XNNPACK não delega os ops quantize/dequantize, e o ExecuTorch não possui kernels para eles.

>>> from transformers.exporters import DynamoConfig, NNCFTorchFXQuantizer

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

Argumentos de nncf.quantize: ativações e pesos int8, calibrados no calibration_dataset do quantizador. Um campo deixado como None mantém o padrão do NNCF, exceto model_type, cujo padrão é nncf.ModelType.TRANSFORMER. Consulte nncf.quantize para cada um.

Argumentos de nncf.compress_weights: int8 ou int4 apenas para pesos, com métodos conscientes dos dados (AWQ, estimativa de escala, GPTQ) para os modos int4. Os modos int8 são independentes de dados; os outros calibram no calibration_dataset do quantizador. gptq e lora_correction são exclusivos do OpenVINO. Um campo deixado como None mantém o padrão do NNCF. Consulte nncf.compress_weights para cada um.

Recupere recursivamente todos os tensores folha de uma estrutura potencialmente aninhada.

Configure o modelo e as entradas para exportação. Modifica tanto model quanto inputs no local, retornando (model, inputs, output_flags), onde output_flags contém os valores removidos de inputs para use_cache, return_dict, etc. (a serem aplicados de forma reversível em model.config por patch_model_config durante o trace).

• Remove as entradas de rótulo (labels, future_values) — o cálculo de perda não é suportado.
• Remove as flags de saída (use_cache, return_dict, …) de inputs para que não apareçam como kwargs rastreados; os valores são retornados para que o bloco de rastreamento os aplique em model.config.
• Pré-computa os kwargs de visão/áudio dependentes de dados registrados via @register_export_input_preparer e os grava em inputs.
• Converte os tensores de entrada para corresponder ao dtype / device do modelo.

Execute model.generate() e capture as entradas de prefill e decode.

Reutiliza todo o mecanismo de geração para que cada arquitetura (somente decodificador, SSM, codificador-decodificador, multimodal, …) receba entradas corretas sem reimplementar o loop.

generation_config é encaminhado para generate() (padrão: o próprio do modelo), de modo que as entradas capturadas usam o cache que generate() construiria. Passe um com cache_implementation="static" e max_cache_len=N para capturar um cache de tamanho estático nas entradas de decodificação — a base para uma exportação com cache estático. max_cache_len dimensiona o cache independentemente da captura, de modo que a decodificação exportada usa um cache fixo [..., N, ...] em vez de um que cresce.

Quando multi_token_decode, o componente decode é capturado como um multi-token decode — duas etapas consecutivas de decode mescladas (veja _merge_decode_calls) para que o eixo de sequência de consulta permaneça simbólico (um decode de token único especializaria esse eixo para 1). Em seguida, ele lida tanto com um token (decodificação comum) quanto com muitos (continuação a partir do passado, ou um prefill simples quando o cache está vazio). Caso contrário, decode é o decode clássico de token único.

Capture as entradas de cada submódulo multimodal por meio de uma única passagem de frente.

Detecta todos os submódulos multimodais conhecidos pelo nome do atributo (torre de visão, projetor, modelo de linguagem, lm_head, …) e captura os kwargs do forward deles durante uma chamada model(**inputs).

Cada submódulo é retornado como uma entrada separada name: (module, inputs) para exportação independente. A etapa de mesclagem de tokens (por exemplo, masked_scatter para modelos multimodais) é intencionalmente deixada fora dos grafos exportados — é responsabilidade do chamador montar inputs_embeds a partir das saídas do codificador antes de executar o decodificador.

Decomponha um modelo generativo em pares (model, forward_inputs) exportáveis de forma independente.

Executa decompose_prefill_decode para capturar os kwargs de forward de prefill e decode a partir de uma chamada real de model.generate(**inputs, max_new_tokens=2). Se o prefill for multimodal (conforme is_multimodal), ele o divide ainda em uma entrada por submódulo (codificador de visão/áudio, projetor, modelo de linguagem, lm_head) por meio de decompose_multimodal.

Retorna True se o modelo for multimodal, com codificadores de modalidade e um modelo de linguagem.

Um modelo que não é um PreTrainedModel (por exemplo, um nn.Module simples) não possui os acessores canônicos get_encoder/get_decoder e, trivialmente, não é multimodal, portanto, retorna False diretamente.