Optimum

( )

返回此模型是否可以使用 .generate() 生成序列。

from_pretrained

( model_id: typing.Union[str, pathlib.Path] export: bool = False force_download: bool = False use_auth_token: typing.Union[bool, str, NoneType] = None token: typing.Union[bool, str, NoneType] = None cache_dir: str = '/root/.cache/huggingface/hub' subfolder: str = '' config: typing.Optional[ForwardRef('PretrainedConfig')] = None local_files_only: bool = False provider: str = 'CPUExecutionProvider' session_options: typing.Optional[onnxruntime.capi.onnxruntime_pybind11_state.SessionOptions] = None provider_options: typing.Union[typing.Dict[str, typing.Any], NoneType] = None use_io_binding: typing.Optional[bool] = None **kwargs ) → ORTModel

参数

model_id (Union[str, Path]) — 可以是以下之一：
- 一个字符串，托管在 huggingface.co 模型仓库中的预训练模型的模型 ID。有效的模型 ID 可以位于根级别，例如 bert-base-uncased，或者在用户或组织名称下命名空间，例如 dbmdz/bert-base-german-cased。
- 一个目录的路径，其中包含使用 ~OptimizedModel.save_pretrained 保存的模型，例如 ./my_model_directory/。
export (bool, 默认为 False) — 定义是否需要将提供的 model_id 导出为目标格式。
force_download (bool, 默认为 True) — 是否强制（重新）下载模型权重和配置文件，覆盖缓存版本（如果存在）。
use_auth_token (Optional[Union[bool,str]], 默认为 None) — 已弃用。请改用 token 参数。
token (Optional[Union[bool,str]], 默认为 None) — 用作远程文件 HTTP Bearer 授权的令牌。如果为 True，将使用运行 huggingface-cli login 时生成的令牌（存储在 huggingface_hub.constants.HF_TOKEN_PATH 中）。
cache_dir (Optional[str], 默认为 None) — 如果不应使用标准缓存，则应在其中缓存下载的预训练模型配置的目录路径。
subfolder (str, 默认为 "") — 如果相关文件位于模型仓库的子文件夹中（本地或在 huggingface.co 上），您可以在此处指定文件夹名称。
config (Optional[transformers.PretrainedConfig], 默认为 None) — 模型配置。
local_files_only (Optional[bool], 默认为 False) — 是否仅查看本地文件（即，不尝试下载模型）。
trust_remote_code (bool, 默认为 False) — 是否允许 Hub 上的自定义代码在其自己的建模中。此选项仅应针对您信任的存储库设置为 True，并在其中阅读代码，因为它将在您的本地计算机上执行 Hub 上存在的代码。
revision (Optional[str], 默认为 None) — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID，因为我们使用基于 git 的系统来存储 huggingface.co 上的模型和其他工件，因此 revision 可以是 git 允许的任何标识符。
provider (str, 默认为 "CPUExecutionProvider") — 用于加载模型的 ONNX Runtime 提供程序。有关可能的提供程序，请参阅 https://onnxruntime.ai/docs/execution-providers/ 。
session_options (Optional[onnxruntime.SessionOptions], 默认为 None), — 用于加载模型的 ONNX Runtime 会话选项。
provider_options (Optional[Dict[str, Any]], 默认为 None) — 与使用的提供程序对应的提供程序选项字典。请参阅每个提供程序的可用选项： https://onnxruntime.ai/docs/api/c/group___global.html 。
use_io_binding (Optional[bool], 默认为 None) — 是否在推理期间使用 IOBinding 以避免主机和设备之间或 numpy/torch 张量与 ONNX Runtime ORTValue 之间的内存复制。如果执行提供程序是 CUDAExecutionProvider，则默认为 True。[~onnxruntime.ORTModelForCausalLM] 默认为 CPUExecutionProvider 上的 True，在所有其他情况下默认为 False。
kwargs (Dict[str, Any]) — 将传递给底层模型加载方法。

解码器模型的参数 (ORTModelForCausalLM, ORTModelForSeq2SeqLM, ORTModelForSeq2SeqLM, ORTModelForSpeechSeq2Seq, ORTModelForVision2Seq)

use_cache (Optional[bool], defaults to True) — 是否使用过去的键/值缓存。默认为 True。

ORTModelForCausalLM 的参数

use_merged (Optional[bool], defaults to None) — 是否使用单个 ONNX，该 ONNX 既处理不带过去键值的解码，也处理带过去键值的解码重用。如果从本地仓库加载并且找到合并的解码器，则此选项默认为 True。当使用 export=True 导出时，默认为 False。应将此选项设置为 True 以最大限度地减少内存使用。

返回值

ORTModel

加载的 ORTModel 模型。

从预训练模型配置实例化预训练模型。

load_model

( path: typing.Union[str, pathlib.Path] provider: str = 'CPUExecutionProvider' session_options: typing.Optional[onnxruntime.capi.onnxruntime_pybind11_state.SessionOptions] = None provider_options: typing.Union[typing.Dict[str, typing.Any], NoneType] = None )

参数

path (Union[str, Path]) — ONNX 模型的路径。
provider (str, defaults to "CPUExecutionProvider") — 用于加载模型的 ONNX Runtime provider。请参阅 https://onnxruntime.ai/docs/execution-providers/ 以获取可能的 providers。
session_options (Optional[onnxruntime.SessionOptions], defaults to None) — 用于加载模型的 ONNX Runtime session options。
provider_options (Optional[Dict[str, Any]], defaults to None) — 与使用的 provider 相对应的 Provider option 字典。请参阅每个 provider 的可用选项： https://onnxruntime.ai/docs/api/c/group___global.html 。

使用给定的 provider 加载 ONNX Inference session。默认 provider 是 CPUExecutionProvider，以匹配 PyTorch/TensorFlow/JAX 中的默认行为。

raise_on_numpy_input_io_binding

( use_torch: bool )

参数

use_torch (bool) — 推理期间使用的张量是否为 torch.Tensor 类型。

如果请求 IO Binding，但使用的张量是 numpy 数组，则引发错误。

shared_attributes_init

( model: InferenceSession use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

初始化可能在多个 ONNX Runtime 推理会话之间共享的属性。

to

( device: typing.Union[torch.device, str, int] ) → ORTModel

参数

device (torch.device or str or int) — CPU/GPU 支持的设备序号。将其设置为 -1 将利用 CPU，正值将在关联的 CUDA 设备 ID 上运行模型。您可以传递原生 torch.device 或 str。

返回值

ORTModel

放置在请求设备上的模型。

根据设备更改 ONNX Runtime provider。

class optimum.onnxruntime.ORTModelForCausalLM

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None generation_config: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None use_cache: typing.Optional[bool] = None **kwargs )

带有因果语言建模头的 ONNX 模型，用于 ONNX Runtime 推理。此类正式支持 bloom、codegen、falcon、gpt2、gpt_bigcode、gpt_neo、gpt_neox、gptj、llama。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_ids: LongTensor attention_mask: typing.Optional[torch.FloatTensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None labels: typing.Optional[torch.LongTensor] = None use_cache_branch: bool = None **kwargs )

参数

input_ids (torch.LongTensor) — 解码器输入序列标记在词汇表中的索引，形状为 (batch_size, sequence_length)。
attention_mask (torch.LongTensor) — 用于避免在填充标记索引上执行注意力的掩码，形状为 (batch_size, sequence_length)。掩码值在 [0, 1] 中选择。
past_key_values (tuple(tuple(torch.FloatTensor), *optional*, defaults to None) — 包含用于加速解码的注意力块的预计算键和值隐藏状态。元组的长度为 config.n_layers，每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。

ORTModelForCausalLM forward 方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

文本生成示例

>>> from transformers import AutoTokenizer
>>> from optimum.onnxruntime import ORTModelForCausalLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/gpt2")
>>> model = ORTModelForCausalLM.from_pretrained("optimum/gpt2")

>>> inputs = tokenizer("My name is Arthur and I live in", return_tensors="pt")

>>> gen_tokens = model.generate(**inputs,do_sample=True,temperature=0.9, min_length=20,max_length=20)
>>> tokenizer.batch_decode(gen_tokens)

使用 transformers.pipelines 的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.onnxruntime import ORTModelForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/gpt2")
>>> model = ORTModelForCausalLM.from_pretrained("optimum/gpt2")
>>> onnx_gen = pipeline("text-generation", model=model, tokenizer=tokenizer)

>>> text = "My name is Arthur and I live in"
>>> gen = onnx_gen(text)

class optimum.onnxruntime.ORTModelForMaskedLM

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

带有 MaskedLMOutput 的 ONNX 模型，用于 masked language modeling 任务。此类正式支持 albert、bert、camembert、convbert、data2vec_text、deberta、deberta_v2、distilbert、electra、flaubert、ibert、mobilebert、roberta、roformer、squeezebert、xlm、xlm_roberta。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None attention_mask: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None token_type_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None **kwargs )

参数

input_ids (Union[torch.Tensor, np.ndarray, None] 形状为 (batch_size, sequence_length), defaults to None) — 输入序列标记在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是输入 ID？
attention_mask (Union[torch.Tensor, np.ndarray, None] 形状为 (batch_size, sequence_length), defaults to None) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示未掩码的标记，
- 0 表示已掩码的标记。什么是注意力掩码？
token_type_ids (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引从 [0, 1] 中选择：
- 1 表示 句子 A 的 token，
- 0 表示 句子 B 的 token。什么是 token 类型 ID？

ORTModelForMaskedLM 的 forward 方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

特征提取示例

>>> from transformers import AutoTokenizer
>>> from optimum.onnxruntime import ORTModelForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/bert-base-uncased-for-fill-mask")
>>> model = ORTModelForMaskedLM.from_pretrained("optimum/bert-base-uncased-for-fill-mask")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="np")

>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 8, 28996]

使用 transformers.pipeline 的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.onnxruntime import ORTModelForMaskedLM

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/bert-base-uncased-for-fill-mask")
>>> model = ORTModelForMaskedLM.from_pretrained("optimum/bert-base-uncased-for-fill-mask")
>>> fill_masker = pipeline("fill-mask", model=model, tokenizer=tokenizer)

>>> text = "The capital of France is [MASK]."
>>> pred = fill_masker(text)

class optimum.onnxruntime.ORTModelForSeq2SeqLM

( encoder_session: InferenceSession decoder_session: InferenceSession config: PretrainedConfig onnx_paths: typing.List[str] decoder_with_past_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None use_cache: bool = True use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None generation_config: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None **kwargs )

用于 ONNX Runtime 推理的，带有语言建模头的序列到序列模型。此类正式支持 bart、blenderbot、blenderbot_small、longt5、m2m_100、marian、mbart、mt5、pegasus、t5。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None labels: typing.Optional[torch.LongTensor] = None **kwargs )

参数

input_ids (torch.LongTensor) — 输入序列 token 在词汇表中的索引，形状为 (batch_size, encoder_sequence_length)。
attention_mask (torch.LongTensor) — 掩码，用于避免在 padding token 索引上执行 attention，形状为 (batch_size, encoder_sequence_length)。掩码值从 [0, 1] 中选择。
decoder_input_ids (torch.LongTensor) — 解码器输入序列 token 在词汇表中的索引，形状为 (batch_size, decoder_sequence_length)。
encoder_outputs (torch.FloatTensor) — 编码器的 last_hidden_state，形状为 (batch_size, encoder_sequence_length, hidden_size)。
past_key_values (tuple(tuple(torch.FloatTensor), *optional*, defaults to None) — 包含用于加速解码的 attention 模块的预计算键和值 hidden states。该元组的长度为 config.n_layers，其中每个元组有 2 个形状为 (batch_size, num_heads, decoder_sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

ORTModelForSeq2SeqLM 的 forward 方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

文本生成示例

>>> from transformers import AutoTokenizer
>>> from optimum.onnxruntime import ORTModelForSeq2SeqLM

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/t5-small")
>>> model = ORTModelForSeq2SeqLM.from_pretrained("optimum/t5-small")

>>> inputs = tokenizer("My name is Eustache and I like to", return_tensors="pt")

>>> gen_tokens = model.generate(**inputs)
>>> outputs = tokenizer.batch_decode(gen_tokens)

使用 transformers.pipeline 的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.onnxruntime import ORTModelForSeq2SeqLM

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/t5-small")
>>> model = ORTModelForSeq2SeqLM.from_pretrained("optimum/t5-small")
>>> onnx_translation = pipeline("translation_en_to_de", model=model, tokenizer=tokenizer)

>>> text = "My name is Eustache."
>>> pred = onnx_translation(text)

class optimum.onnxruntime.ORTModelForSequenceClassification

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

ONNX 模型，顶部带有序列分类/回归头（池化输出顶部的线性层），例如用于 GLUE 任务。此类正式支持 albert、bart、bert、camembert、convbert、data2vec_text、deberta、deberta_v2、distilbert、electra、flaubert、ibert、mbart、mobilebert、nystromformer、roberta、roformer、squeezebert、xlm、xlm_roberta。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None attention_mask: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None token_type_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None **kwargs )

参数

input_ids (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 输入序列 token 在词汇表中的索引。索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是输入 ID？
attention_mask (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 掩码，用于避免在 padding token 索引上执行 attention。掩码值从 [0, 1] 中选择：
- 1 表示 未被掩码 的 token，
- 0 表示 已被掩码 的 token。什么是 attention 掩码？
token_type_ids (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引从 [0, 1] 中选择：
- 1 表示 句子 A 的 token，
- 0 表示 句子 B 的 token。什么是 token 类型 ID？

ORTModelForSequenceClassification 的 forward 方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

单标签分类示例

>>> from transformers import AutoTokenizer
>>> from optimum.onnxruntime import ORTModelForSequenceClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/distilbert-base-uncased-finetuned-sst-2-english")
>>> model = ORTModelForSequenceClassification.from_pretrained("optimum/distilbert-base-uncased-finetuned-sst-2-english")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")

>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 2]

使用 transformers.pipelines 的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.onnxruntime import ORTModelForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/distilbert-base-uncased-finetuned-sst-2-english")
>>> model = ORTModelForSequenceClassification.from_pretrained("optimum/distilbert-base-uncased-finetuned-sst-2-english")
>>> onnx_classifier = pipeline("text-classification", model=model, tokenizer=tokenizer)

>>> text = "Hello, my dog is cute"
>>> pred = onnx_classifier(text)

使用零样本分类 transformers.pipelines 的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.onnxruntime import ORTModelForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/distilbert-base-uncased-mnli")
>>> model = ORTModelForSequenceClassification.from_pretrained("optimum/distilbert-base-uncased-mnli")
>>> onnx_z0 = pipeline("zero-shot-classification", model=model, tokenizer=tokenizer)

>>> sequence_to_classify = "Who are you voting for in 2020?"
>>> candidate_labels = ["Europe", "public health", "politics", "elections"]
>>> pred = onnx_z0(sequence_to_classify, candidate_labels, multi_label=True)

class optimum.onnxruntime.ORTModelForTokenClassification

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

ONNX 模型，顶部带有 token 分类头（hidden-states 输出顶部的线性层），例如用于命名实体识别 (NER) 任务。此类正式支持 albert、bert、bloom、camembert、convbert、data2vec_text、deberta、deberta_v2、distilbert、electra、flaubert、gpt2、ibert、mobilebert、roberta、roformer、squeezebert、xlm、xlm_roberta。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None attention_mask: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None token_type_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None **kwargs )

参数

input_ids (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 输入序列 token 在词汇表中的索引。索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是输入 ID？
attention_mask (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 掩码，用于避免在 padding token 索引上执行 attention。掩码值从 [0, 1] 中选择：
- 1 表示 未被掩码 的 token，
- 0 表示 已被掩码 的 token。什么是 attention 掩码？
token_type_ids (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引从 [0, 1] 中选择：
- 1 表示 句子 A 的 token，
- 0 表示 句子 B 的 token。什么是 token 类型 ID？

ORTModelForTokenClassification 的 forward 方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

Token 分类示例

>>> from transformers import AutoTokenizer
>>> from optimum.onnxruntime import ORTModelForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/bert-base-NER")
>>> model = ORTModelForTokenClassification.from_pretrained("optimum/bert-base-NER")

>>> inputs = tokenizer("My name is Philipp and I live in Germany.", return_tensors="np")

>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> list(logits.shape)
[1, 12, 9]

使用 transformers.pipelines 的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.onnxruntime import ORTModelForTokenClassification

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/bert-base-NER")
>>> model = ORTModelForTokenClassification.from_pretrained("optimum/bert-base-NER")
>>> onnx_ner = pipeline("token-classification", model=model, tokenizer=tokenizer)

>>> text = "My name is Philipp and I live in Germany."
>>> pred = onnx_ner(text)

class optimum.onnxruntime.ORTModelForMultipleChoice

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

ONNX 模型，顶部带有多项选择分类头（池化输出顶部的线性层和一个 softmax），例如用于 RocStories/SWAG 任务。此类正式支持 albert、bert、camembert、convbert、data2vec_text、deberta_v2、distilbert、electra、flaubert、ibert、mobilebert、nystromformer、roberta、roformer、squeezebert、xlm、xlm_roberta。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None attention_mask: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None token_type_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None **kwargs )

参数

input_ids (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是输入 ID？
attention_mask (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。什么是注意力掩码？
token_type_ids (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 1 表示属于句子 A 的标记，
- 0 表示属于句子 B 的标记。什么是标记类型 ID？

ORTModelForMultipleChoice 的 forward 方法覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

多项选择示例

>>> from transformers import AutoTokenizer
>>> from optimum.onnxruntime import ORTModelForMultipleChoice

>>> tokenizer = AutoTokenizer.from_pretrained("ehdwns1516/bert-base-uncased_SWAG")
>>> model = ORTModelForMultipleChoice.from_pretrained("ehdwns1516/bert-base-uncased_SWAG", export=True)

>>> num_choices = 4
>>> first_sentence = ["Members of the procession walk down the street holding small horn brass instruments."] * num_choices
>>> second_sentence = [
...     "A drum line passes by walking down the street playing their instruments.",
...     "A drum line has heard approaching them.",
...     "A drum line arrives and they're outside dancing and asleep.",
...     "A drum line turns the lead singer watches the performance."
... ]
>>> inputs = tokenizer(first_sentence, second_sentence, truncation=True, padding=True)

# Unflatten the inputs values expanding it to the shape [batch_size, num_choices, seq_length]
>>> for k, v in inputs.items():
...     inputs[k] = [v[i: i + num_choices] for i in range(0, len(v), num_choices)]
>>> inputs = dict(inputs.convert_to_tensors(tensor_type="pt"))
>>> outputs = model(**inputs)
>>> logits = outputs.logits

class optimum.onnxruntime.ORTModelForQuestionAnswering

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

用于抽取式问答任务（如 SQuAD）的具有 QuestionAnsweringModelOutput 的 ONNX 模型。此类正式支持 albert、bart、bert、camembert、convbert、data2vec_text、deberta、deberta_v2、distilbert、electra、flaubert、gptj、ibert、mbart、mobilebert、nystromformer、roberta、roformer、squeezebert、xlm、xlm_roberta。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None attention_mask: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None token_type_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None **kwargs )

参数

input_ids (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是输入 ID？
attention_mask (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。什么是注意力掩码？
token_type_ids (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 1 表示属于句子 A 的标记，
- 0 表示属于句子 B 的标记。什么是标记类型 ID？

ORTModelForQuestionAnswering 的 forward 方法覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

问答示例

>>> from transformers import AutoTokenizer
>>> from optimum.onnxruntime import ORTModelForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/roberta-base-squad2")
>>> model = ORTModelForQuestionAnswering.from_pretrained("optimum/roberta-base-squad2")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="np")
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])

>>> outputs = model(**inputs, start_positions=start_positions, end_positions=end_positions)
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits

使用 transformers.pipeline 的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.onnxruntime import ORTModelForQuestionAnswering

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/roberta-base-squad2")
>>> model = ORTModelForQuestionAnswering.from_pretrained("optimum/roberta-base-squad2")
>>> onnx_qa = pipeline("question-answering", model=model, tokenizer=tokenizer)

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> pred = onnx_qa(question, text)

class optimum.onnxruntime.ORTModelForImageClassification

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

用于图像分类任务的 ONNX 模型。此类正式支持 beit、convnext、convnextv2、data2vec_vision、deit、levit、mobilenet_v1、mobilenet_v2、mobilevit、poolformer、resnet、segformer、swin、vit。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( pixel_values: typing.Union[torch.Tensor, numpy.ndarray] **kwargs )

参数

pixel_values (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, num_channels, height, width)，默认为 None) — 与当前批次中的图像对应的像素值。像素值可以使用 AutoFeatureExtractor 从编码图像中获得。

ORTModelForImageClassification 的 forward 方法覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

图像分类示例

>>> import requests
>>> from PIL import Image
>>> from optimum.onnxruntime import ORTModelForImageClassification
>>> from transformers import AutoFeatureExtractor

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> preprocessor = AutoFeatureExtractor.from_pretrained("optimum/vit-base-patch16-224")
>>> model = ORTModelForImageClassification.from_pretrained("optimum/vit-base-patch16-224")

>>> inputs = preprocessor(images=image, return_tensors="np")

>>> outputs = model(**inputs)
>>> logits = outputs.logits

使用 transformers.pipeline 的示例

>>> import requests
>>> from PIL import Image
>>> from transformers import AutoFeatureExtractor, pipeline
>>> from optimum.onnxruntime import ORTModelForImageClassification

>>> preprocessor = AutoFeatureExtractor.from_pretrained("optimum/vit-base-patch16-224")
>>> model = ORTModelForImageClassification.from_pretrained("optimum/vit-base-patch16-224")
>>> onnx_image_classifier = pipeline("image-classification", model=model, feature_extractor=preprocessor)

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> pred = onnx_image_classifier(url)

class optimum.onnxruntime.ORTModelForSemanticSegmentation

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

用于语义分割的 ONNX 模型，顶部具有全 MLP 解码头，例如用于 ADE20k、CityScapes。此类正式支持 segformer。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( pixel_values: typing.Union[torch.Tensor, numpy.ndarray] **kwargs )

参数

pixel_values (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, num_channels, height, width)，默认为 None) — 与当前批次中的图像对应的像素值。像素值可以使用 AutoFeatureExtractor 从编码图像中获得。

ORTModelForSemanticSegmentation 的 forward 方法覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

语义分割示例

>>> import requests
>>> from PIL import Image
>>> from optimum.onnxruntime import ORTModelForSemanticSegmentation
>>> from transformers import AutoFeatureExtractor

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> preprocessor = AutoFeatureExtractor.from_pretrained("optimum/segformer-b0-finetuned-ade-512-512")
>>> model = ORTModelForSemanticSegmentation.from_pretrained("optimum/segformer-b0-finetuned-ade-512-512")

>>> inputs = preprocessor(images=image, return_tensors="np")

>>> outputs = model(**inputs)
>>> logits = outputs.logits

使用 transformers.pipeline 的示例

>>> import requests
>>> from PIL import Image
>>> from transformers import AutoFeatureExtractor, pipeline
>>> from optimum.onnxruntime import ORTModelForSemanticSegmentation

>>> preprocessor = AutoFeatureExtractor.from_pretrained("optimum/segformer-b0-finetuned-ade-512-512")
>>> model = ORTModelForSemanticSegmentation.from_pretrained("optimum/segformer-b0-finetuned-ade-512-512")
>>> onnx_image_segmenter = pipeline("image-segmentation", model=model, feature_extractor=preprocessor)

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> pred = onnx_image_segmenter(url)

class optimum.onnxruntime.ORTModelForAudioClassification

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

用于音频分类的 ONNX 模型，顶部带有序列分类头（池化输出之上的线性层），用于诸如 SUPERB 关键词识别之类的任务。此类正式支持 audio_spectrogram_transformer、data2vec_audio、hubert、sew、sew_d、unispeech、unispeech_sat、wavlm、wav2vec2、wav2vec2-conformer。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_values: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None attention_mask: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None input_features: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None **kwargs )

参数

input_values (形状为 (batch_size, sequence_length) 的 torch.Tensor) — 输入原始语音波形的浮点值。输入值可以使用 AutoFeatureExtractor 从加载到数组中的音频文件中获得。

ORTModelForAudioClassification 的 forward 方法覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

音频分类示例

>>> from transformers import AutoFeatureExtractor
>>> from optimum.onnxruntime import ORTModelForAudioClassification
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("optimum/hubert-base-superb-ks")
>>> model = ORTModelForAudioClassification.from_pretrained("optimum/hubert-base-superb-ks")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.argmax(logits, dim=-1).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]

使用 transformers.pipeline 的示例

>>> from transformers import AutoFeatureExtractor, pipeline
>>> from optimum.onnxruntime import ORTModelForAudioClassification

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("optimum/hubert-base-superb-ks")
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")

>>> model = ORTModelForAudioClassification.from_pretrained("optimum/hubert-base-superb-ks")
>>> onnx_ac = pipeline("audio-classification", model=model, feature_extractor=feature_extractor)

>>> pred = onnx_ac(dataset[0]["audio"]["array"])

类 optimum.onnxruntime.ORTModelForAudioFrameClassification

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

用于诸如说话人日志等任务的，带有一个帧分类头的 ONNX 模型。此类正式支持 data2vec_audio、unispeech_sat、wavlm、wav2vec2、wav2vec2-conformer。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_values: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None **kwargs )

参数

input_values (torch.Tensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。输入值可以从加载到数组中的音频文件中获得，使用 AutoFeatureExtractor。

ORTModelForAudioFrameClassification 的 forward 方法，重写了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

音频帧分类示例

>>> from transformers import AutoFeatureExtractor
>>> from optimum.onnxruntime import ORTModelForAudioFrameClassification
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("optimum/wav2vec2-base-superb-sd")
>>> model =  ORTModelForAudioFrameClassification.from_pretrained("optimum/wav2vec2-base-superb-sd")

>>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> probabilities = torch.sigmoid(logits[0])
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()

类 optimum.onnxruntime.ORTModelForCTC

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

用于连接时序分类 (CTC) 的，带有一个语言建模头的 ONNX 模型。此类正式支持 data2vec_audio、hubert、sew、sew_d、unispeech、unispeech_sat、wavlm、wav2vec2、wav2vec2-conformer。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_values: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None **kwargs )

参数

input_values (torch.Tensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。输入值可以从加载到数组中的音频文件中获得，使用 AutoFeatureExtractor。

ORTModelForCTC 的 forward 方法，重写了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

CTC 示例

>>> from transformers import AutoProcessor, HubertForCTC
>>> from optimum.onnxruntime import ORTModelForCTC
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("optimum/hubert-large-ls960-ft")
>>> model = ORTModelForCTC.from_pretrained("optimum/hubert-large-ls960-ft")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> transcription = processor.batch_decode(predicted_ids)

类 optimum.onnxruntime.ORTModelForSpeechSeq2Seq

( encoder_session: InferenceSession decoder_session: InferenceSession config: PretrainedConfig onnx_paths: typing.List[str] decoder_with_past_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None use_cache: bool = True use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None generation_config: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None **kwargs )

用于 ONNX Runtime 推理的，带有一个语言建模头的语音序列到序列模型。此类正式支持 whisper、speech_to_text。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_features: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None labels: typing.Optional[torch.LongTensor] = None cache_position: typing.Optional[torch.Tensor] = None **kwargs )

参数

input_features (torch.FloatTensor) — 从原始语音波形中提取的梅尔特征。 (batch_size, feature_size, encoder_sequence_length)。
decoder_input_ids (torch.LongTensor) — 解码器输入序列标记在词汇表中的索引，形状为 (batch_size, decoder_sequence_length)。
encoder_outputs (torch.FloatTensor) — 编码器的 last_hidden_state，形状为 (batch_size, encoder_sequence_length, hidden_size)。
past_key_values (tuple(tuple(torch.FloatTensor), *optional*, defaults to None) — 包含用于加速解码的注意力模块的预计算的键和值隐藏状态。元组的长度为 config.n_layers，其中每个元组包含 2 个形状为 (batch_size, num_heads, decoder_sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

ORTModelForSpeechSeq2Seq 的 forward 方法，重写了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

文本生成示例

>>> from transformers import AutoProcessor
>>> from optimum.onnxruntime import ORTModelForSpeechSeq2Seq
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("optimum/whisper-tiny.en")
>>> model = ORTModelForSpeechSeq2Seq.from_pretrained("optimum/whisper-tiny.en")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor.feature_extractor(ds[0]["audio"]["array"], return_tensors="pt")

>>> gen_tokens = model.generate(inputs=inputs.input_features)
>>> outputs = processor.tokenizer.batch_decode(gen_tokens)

使用 transformers.pipeline 的示例

>>> from transformers import AutoProcessor, pipeline
>>> from optimum.onnxruntime import ORTModelForSpeechSeq2Seq
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("optimum/whisper-tiny.en")
>>> model = ORTModelForSpeechSeq2Seq.from_pretrained("optimum/whisper-tiny.en")
>>> speech_recognition = pipeline("automatic-speech-recognition", model=model, tokenizer=processor.tokenizer, feature_extractor=processor.feature_extractor)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> pred = speech_recognition(ds[0]["audio"]["array"])

类 optimum.onnxruntime.ORTModelForAudioXVector

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

用于诸如说话人验证等任务的，带有一个 XVector 特征提取头的 ONNX 模型。此类正式支持 data2vec_audio、unispeech_sat、wavlm、wav2vec2、wav2vec2-conformer。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_values: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None **kwargs )

参数

input_values (torch.Tensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。输入值可以从加载到数组中的音频文件中获得，使用 AutoFeatureExtractor。

ORTModelForAudioXVector 的 forward 方法，重写了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

音频 XVector 示例

>>> from transformers import AutoFeatureExtractor
>>> from optimum.onnxruntime import ORTModelForAudioXVector
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("optimum/wav2vec2-base-superb-sv")
>>> model = ORTModelForAudioXVector.from_pretrained("optimum/wav2vec2-base-superb-sv")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
...     [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
...     embeddings = model(**inputs).embeddings

>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()

>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7
>>> if similarity < threshold:
...     print("Speakers are not the same!")
>>> round(similarity.item(), 2)

类 optimum.onnxruntime.ORTModelForVision2Seq

( encoder_session: InferenceSession decoder_session: InferenceSession config: PretrainedConfig onnx_paths: typing.List[str] decoder_with_past_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None use_cache: bool = True use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None generation_config: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None **kwargs )

VisionEncoderDecoder 序列到序列模型，带有用于 ONNX Runtime 推理的语言建模头。此类正式支持 trocr 和 vision-encoder-decoder。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( pixel_values: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None labels: typing.Optional[torch.LongTensor] = None **kwargs )

参数

pixel_values (torch.FloatTensor) — 从图像中提取的特征。此张量的形状应为 (batch_size, num_channels, height, width)。
decoder_input_ids (torch.LongTensor) — 解码器输入序列标记在词汇表中的索引，形状为 (batch_size, decoder_sequence_length)。
encoder_outputs (torch.FloatTensor) — 形状为 (batch_size, encoder_sequence_length, hidden_size) 的编码器 last_hidden_state。
past_key_values (tuple(tuple(torch.FloatTensor), *optional*, defaults to None)) — 包含用于加速解码的注意力模块的预计算键和值隐藏状态。元组的长度为 config.n_layers，每个元组有 2 个形状为 (batch_size, num_heads, decoder_sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

ORTModelForVision2Seq 的 forward 方法重写了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

文本生成示例

>>> from transformers import AutoImageProcessor, AutoTokenizer
>>> from optimum.onnxruntime import ORTModelForVision2Seq
>>> from PIL import Image
>>> import requests


>>> processor = AutoImageProcessor.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
>>> tokenizer = AutoTokenizer.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
>>> model = ORTModelForVision2Seq.from_pretrained("nlpconnect/vit-gpt2-image-captioning", export=True)

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(image, return_tensors="pt")

>>> gen_tokens = model.generate(**inputs)
>>> outputs = tokenizer.batch_decode(gen_tokens, skip_special_tokens=True)

使用 transformers.pipeline 的示例

>>> from transformers import AutoImageProcessor, AutoTokenizer, pipeline
>>> from optimum.onnxruntime import ORTModelForVision2Seq
>>> from PIL import Image
>>> import requests


>>> processor = AutoImageProcessor.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
>>> tokenizer = AutoTokenizer.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
>>> model = ORTModelForVision2Seq.from_pretrained("nlpconnect/vit-gpt2-image-captioning", export=True)

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_to_text = pipeline("image-to-text", model=model, tokenizer=tokenizer, feature_extractor=processor, image_processor=processor)
>>> pred = image_to_text(image)

class optimum.onnxruntime.ORTModelForPix2Struct

( encoder_session: InferenceSession decoder_session: InferenceSession config: PretrainedConfig onnx_paths: typing.List[str] decoder_with_past_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None use_cache: bool = True use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None generation_config: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None **kwargs )

用于 ONNX Runtime 推理的带有语言建模头的 Pix2struct 模型。此类正式支持 pix2struct。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( flattened_patches: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None labels: typing.Optional[torch.LongTensor] = None **kwargs )

参数

flattened_patches (形状为 (batch_size, seq_length, hidden_size) 的 torch.FloatTensor) — 扁平化的像素块。 hidden_size 通过以下公式获得：hidden_size = num_channels patch_size patch_size。像素块的扁平化处理由 Pix2StructProcessor 完成。
attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor, 可选) — 用于避免在填充 token 索引上执行注意力的掩码。
decoder_input_ids (形状为 (batch_size, target_sequence_length) 的 torch.LongTensor, 可选) — 词汇表中解码器输入序列 token 的索引。Pix2StructText 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用 past_key_values，则可以选择仅输入最后一个 decoder_input_ids (参见 past_key_values)。
decoder_attention_mask (形状为 (batch_size, target_sequence_length) 的 torch.BoolTensor, 可选) — 默认行为：生成一个忽略 decoder_input_ids 中的 pad token 的张量。默认情况下也会使用因果掩码。
encoder_outputs (tuple(tuple(torch.FloatTensor), 可选) — 元组由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成。形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state 是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中使用。
past_key_values (tuple(tuple(torch.FloatTensor), *optional*, defaults to None)) — 包含用于加速解码的注意力模块的预计算键和值隐藏状态。元组的长度为 config.n_layers，每个元组有 2 个形状为 (batch_size, num_heads, decoder_sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

ORTModelForPix2Struct 的 forward 方法重写了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

Pix2struct 示例

>>> from transformers import AutoProcessor
>>> from optimum.onnxruntime import ORTModelForPix2Struct
>>> from PIL import Image
>>> import requests

>>> processor = AutoProcessor.from_pretrained("google/pix2struct-ai2d-base")
>>> model = ORTModelForPix2Struct.from_pretrained("google/pix2struct-ai2d-base", export=True, use_io_binding=True)

>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> question = "What does the label 15 represent? (1) lava (2) core (3) tunnel (4) ash cloud"
>>> inputs = processor(images=image, text=question, return_tensors="pt")

>>> gen_tokens = model.generate(**inputs)
>>> outputs = processor.batch_decode(gen_tokens, skip_special_tokens=True)

class optimum.onnxruntime.ORTModelForCustomTasks

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

用于任何自定义任务的 ONNX 模型。它可用于为任何单文件 ONNX 模型利用推理加速，这些模型可能使用自定义输入和输出。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( **model_inputs: typing.Union[torch.Tensor, numpy.ndarray] )

ORTModelForCustomTasks 的 forward 方法重写了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

自定义任务示例 (例如，将 pooler_output 作为输出的句子转换器)

>>> from transformers import AutoTokenizer
>>> from optimum.onnxruntime import ORTModelForCustomTasks

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/sbert-all-MiniLM-L6-with-pooler")
>>> model = ORTModelForCustomTasks.from_pretrained("optimum/sbert-all-MiniLM-L6-with-pooler")

>>> inputs = tokenizer("I love burritos!", return_tensors="np")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooler_output = outputs.pooler_output

使用 transformers.pipelines 的示例 (仅当任务受支持时)

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.onnxruntime import ORTModelForCustomTasks

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/sbert-all-MiniLM-L6-with-pooler")
>>> model = ORTModelForCustomTasks.from_pretrained("optimum/sbert-all-MiniLM-L6-with-pooler")
>>> onnx_extractor = pipeline("feature-extraction", model=model, tokenizer=tokenizer)

>>> text = "I love burritos!"
>>> pred = onnx_extractor(text)

class optimum.onnxruntime.ORTModelForFeatureExtraction

( model: InferenceSession config: PretrainedConfig use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None preprocessors: typing.Optional[typing.List] = None **kwargs )

用于特征提取任务的 ONNX 模型。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

forward

( input_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None attention_mask: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None token_type_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None **kwargs )

参数

input_ids (形状为 (batch_size, sequence_length) 的 Union[torch.Tensor, np.ndarray, None], 默认为 None) — 词汇表中输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。有关详细信息，请参见 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是输入 ID？
attention_mask (形状为 (batch_size, sequence_length) 的 Union[torch.Tensor, np.ndarray, None], 默认为 None) — 用于避免在填充 token 索引上执行注意力的掩码。在 [0, 1] 中选择掩码值：
- 1 表示 未被掩码 的 token，
- 0 表示 被掩码 的 token。什么是注意力掩码？
token_type_ids (形状为 (batch_size, sequence_length) 的 Union[torch.Tensor, np.ndarray, None], 默认为 None) — 分段 token 索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 1 表示 句子 A 的 token，
- 0 表示 句子 B 的 token。什么是 token 类型 ID？

ORTModelForFeatureExtraction 的 forward 方法重写了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

特征提取示例

>>> from transformers import AutoTokenizer
>>> from optimum.onnxruntime import ORTModelForFeatureExtraction
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/all-MiniLM-L6-v2")
>>> model = ORTModelForFeatureExtraction.from_pretrained("optimum/all-MiniLM-L6-v2")

>>> inputs = tokenizer("My name is Philipp and I live in Germany.", return_tensors="np")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> list(last_hidden_state.shape)
[1, 12, 384]

使用 transformers.pipeline 的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.onnxruntime import ORTModelForFeatureExtraction

>>> tokenizer = AutoTokenizer.from_pretrained("optimum/all-MiniLM-L6-v2")
>>> model = ORTModelForFeatureExtraction.from_pretrained("optimum/all-MiniLM-L6-v2")
>>> onnx_extractor = pipeline("feature-extraction", model=model, tokenizer=tokenizer)

>>> text = "My name is Philipp and I live in Germany."
>>> pred = onnx_extractor(text)

class optimum.onnxruntime.ORTDiffusionPipeline

( scheduler: SchedulerMixin unet_session: InferenceSession vae_decoder_session: InferenceSession vae_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_2_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None feature_extractor: typing.Optional[ForwardRef('CLIPFeatureExtractor')] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None **kwargs )

call

( *args **kwargs )

class optimum.onnxruntime.ORTStableDiffusionPipeline

( scheduler: SchedulerMixin unet_session: InferenceSession vae_decoder_session: InferenceSession vae_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_2_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None feature_extractor: typing.Optional[ForwardRef('CLIPFeatureExtractor')] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None **kwargs )

由 ONNX Runtime 驱动的稳定扩散 pipeline，对应于 diffusers.StableDiffusionPipeline。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

call

( *args **kwargs )

类 optimum.onnxruntime.ORTStableDiffusionImg2ImgPipeline

( scheduler: SchedulerMixin unet_session: InferenceSession vae_decoder_session: InferenceSession vae_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_2_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None feature_extractor: typing.Optional[ForwardRef('CLIPFeatureExtractor')] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None **kwargs )

由 ONNX Runtime 驱动的稳定扩散 pipeline，对应于 diffusers.StableDiffusionImg2ImgPipeline。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

call

( *args **kwargs )

类 optimum.onnxruntime.ORTStableDiffusionInpaintPipeline

( scheduler: SchedulerMixin unet_session: InferenceSession vae_decoder_session: InferenceSession vae_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_2_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None feature_extractor: typing.Optional[ForwardRef('CLIPFeatureExtractor')] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None **kwargs )

由 ONNX Runtime 驱动的稳定扩散 pipeline，对应于 diffusers.StableDiffusionInpaintPipeline。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

call

( *args **kwargs )

类 optimum.onnxruntime.ORTStableDiffusionXLPipeline

( scheduler: SchedulerMixin unet_session: InferenceSession vae_decoder_session: InferenceSession vae_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_2_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None feature_extractor: typing.Optional[ForwardRef('CLIPFeatureExtractor')] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None **kwargs )

由 ONNX Runtime 驱动的稳定扩散 pipeline，对应于 diffusers.StableDiffusionXLPipeline。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

call

( *args **kwargs )

类 optimum.onnxruntime.ORTStableDiffusionXLImg2ImgPipeline

( scheduler: SchedulerMixin unet_session: InferenceSession vae_decoder_session: InferenceSession vae_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_2_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None feature_extractor: typing.Optional[ForwardRef('CLIPFeatureExtractor')] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None **kwargs )

由 ONNX Runtime 驱动的稳定扩散 pipeline，对应于 diffusers.StableDiffusionXLImg2ImgPipeline。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

call

( *args **kwargs )

类 optimum.onnxruntime.ORTLatentConsistencyModelPipeline

( scheduler: SchedulerMixin unet_session: InferenceSession vae_decoder_session: InferenceSession vae_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None text_encoder_2_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None feature_extractor: typing.Optional[ForwardRef('CLIPFeatureExtractor')] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None **kwargs )

由 ONNX Runtime 驱动的稳定扩散 pipeline，对应于 diffusers.LatentConsistencyModelPipeline。

此模型继承自 ORTModel，请查看其文档以获取该库为其所有模型实现的通用方法（例如下载或保存）。

此类应使用 onnxruntime.modeling_ort.ORTModel.from_pretrained() 方法初始化。

call