模型 - Hugging Face 机器学习平台

class optimum.onnxruntime.ORTModel

( 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 Runtime 实现模型的基础类。

ORTModel 实现了用于与 Hugging Face Hub 交互的通用方法，以及使用 optimum.exporters.onnx 工具链将原始 transformers 模型导出到 ONNX 的方法。

类属性

model_type (str, 可选, 默认为 "onnx_model") — 注册 ORTModel 类时使用的模型类型名称。
auto_model_class (Type, 可选, 默认为 AutoModel) — 由当前 ORTModel 类表示的 “AutoModel” 类。

通用属性

model (ort.InferenceSession) — 运行模型的 ONNX Runtime InferenceSession。
config (PretrainedConfig) — 模型的配置。
use_io_binding (bool, 可选, 默认为 True) — 是否将 I/O 绑定与 CUDAExecutionProvider 的 ONNX Runtime 一起使用，这可以显着加速推理，具体取决于任务。
model_save_dir (Path) — 导出到 ONNX 的模型保存的目录。默认情况下，如果加载的模型是本地的，则将使用原始模型的目录。否则，将使用缓存目录。
providers (List[str]) — ONNX Runtime 可用的执行提供程序列表。

can_generate

< 源码 >

( )

返回此模型是否可以使用 .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 revision: typing.Optional[str] = None provider: str = 'CPUExecutionProvider' session_options: typing.Optional[onnxruntime.capi.onnxruntime_pybind11_state.SessionOptions] = None provider_options: typing.Optional[typing.Dict[str, typing.Any]] = 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://runtime.onnx.org.cn/docs/execution-providers/。
session_options (Optional[onnxruntime.SessionOptions], 默认为 None), — 用于加载模型的 ONNX Runtime 会话选项。
provider_options (Optional[Dict[str, Any]], 默认为 None) — 与使用的提供程序对应的提供程序选项字典。请参阅每个提供程序的可用选项：https://runtime.onnx.org.cn/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 模型来处理不使用和使用过去键值重用的解码。如果从本地仓库加载并找到合并的解码器，则此选项默认为 True。当使用 export=True 导出时，默认为 False。应将此选项设置为 True 以最小化内存使用。

返回

ORTModel

加载的 ORTModel 模型。

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

load_model

< source >

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

参数

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

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

raise_on_numpy_input_io_binding

< source >

( use_torch: bool )

参数

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

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

shared_attributes_init

< source >

( 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

< source >

( 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

< source >

( 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 Runtime 推理的具有因果语言建模头的 ONNX 模型。此类正式支持 bloom、codegen、falcon、gpt2、gpt_bigcode、gpt_neo、gpt_neox、gptj、llama。

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

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

forward

< source >

( 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 use_cache_branch: bool = None **kwargs )

参数

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

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

< source >

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

用于 masked language modeling 任务的具有 MaskedLMOutput 的 ONNX 模型。此类正式支持 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

< source >

( 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) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是 input IDs？
attention_mask (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 掩码，用于避免对 padding token 索引执行 attention。掩码值在 [0, 1] 中选择：
- 1 表示 token 未被掩盖，
- 0 表示 token 被掩盖。什么是 attention masks？
token_type_ids (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 分段 token 索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 1 表示 token 是 句子 A，
- 0 表示 token 是 句子 B。什么是 token type IDs？

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

< source >

( 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

< source >

( 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 **kwargs )

参数

input_ids (torch.LongTensor) — 词汇表中输入序列 tokens 的索引，形状为 (batch_size, encoder_sequence_length)。
attention_mask (torch.LongTensor) — 掩码，用于避免对 padding token 索引执行 attention，形状为 (batch_size, encoder_sequence_length)。掩码值在 [0, 1] 中选择。
decoder_input_ids (torch.LongTensor) — 词汇表中解码器输入序列 tokens 的索引，形状为 (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

< source >

( 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

< source >

( 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) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是 input IDs？
attention_mask (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 掩码，用于避免对 padding token 索引执行 attention。掩码值在 [0, 1] 中选择：
- 1 表示 token 未被掩盖，
- 0 表示 token 被掩盖。什么是 attention masks？
token_type_ids (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 分段 token 索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 1 表示 token 是 句子 A，
- 0 表示 token 是 句子 B。什么是 token type IDs？

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)

使用 zero-shot-classification 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

< source >

( 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

< source >

( 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) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是 input IDs？
attention_mask (Union[torch.Tensor, np.ndarray, None]，形状为 (batch_size, sequence_length)，默认为 None) — 掩码，用于避免对 padding token 索引执行 attention。掩码值在 [0, 1] 中选择：
- 1 表示 token 未被掩盖，
- 0 表示 token 被掩盖。什么是 attention masks？
token_type_ids (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引从 [0, 1] 中选择：
- 1 表示 token 属于 句子 A，
- 0 表示 token 属于 句子 B。什么是 token type IDs？

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

< source >

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

在池化输出之上（线性层和 softmax）具有多项选择分类头的 ONNX 模型，例如用于 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

< source >

( 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] of shape (batch_size, sequence_length), defaults to None) — 词汇表中输入序列 token 的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是 input IDs？
attention_mask (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值从 [0, 1] 中选择：
- 1 表示 token 未被 masked，
- 0 表示 token 已被 masked。什么是 attention masks？
token_type_ids (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引从 [0, 1] 中选择：
- 1 表示 token 属于 句子 A，
- 0 表示 token 属于 句子 B。什么是 token type IDs？

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

< source >

( 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

< source >

( 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] of shape (batch_size, sequence_length), defaults to None) — 词汇表中输入序列 token 的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是 input IDs？
attention_mask (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值从 [0, 1] 中选择：
- 1 表示 token 未被 masked，
- 0 表示 token 已被 masked。什么是 attention masks？
token_type_ids (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引从 [0, 1] 中选择：
- 1 表示 token 属于 句子 A，
- 0 表示 token 属于 句子 B。什么是 token type IDs？

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

< source >

( 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、dinov2、levit、mobilenet_v1、mobilenet_v2、mobilevit、poolformer、resnet、segformer、swin、swinv2、vit。

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

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

forward

< source >

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

参数

pixel_values (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, num_channels, height, width), defaults to 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

< source >

( 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。此类正式支持 maskformer、segformer。

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

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

forward

< source >

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

参数

pixel_values (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, num_channels, height, width), defaults to 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

< source >

( 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

< source >

( 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 (torch.Tensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点数值。输入值可以从加载到数组中的音频文件中获得，使用 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"])

class optimum.onnxruntime.ORTModelForAudioFrameClassification

< source >

( 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

< source >

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

class optimum.onnxruntime.ORTModelForCTC

< source >

( 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 模型的语言建模头，用于连接时序分类 (CTC)。此类正式支持 data2vec_audio、hubert、sew、sew_d、unispeech、unispeech_sat、wavlm、wav2vec2、wav2vec2-conformer。

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

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

forward

< source >

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

class optimum.onnxruntime.ORTModelForSpeechSeq2Seq

< source >

( 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

< source >

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

class optimum.onnxruntime.ORTModelForAudioXVector

< source >

( 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 模型的 XVector 特征提取头，用于诸如说话人验证之类的任务。此类正式支持 data2vec_audio、unispeech_sat、wavlm、wav2vec2、wav2vec2-conformer。

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

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

forward

< source >

( 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 实例而不是此方法，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

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

class optimum.onnxruntime.ORTModelForVision2Seq

< source >

( 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

< source >

( 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 **kwargs )

参数

pixel_values (torch.FloatTensor) — 从图像中提取的特征。此张量应具有形状 (batch_size, num_channels, height, width)。
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) — 包含用于加速解码的注意力模块的预计算的键和值隐藏状态。元组的长度为 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

< source >

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

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

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

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

forward

< source >

( 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 **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, 可选) — 用于避免在 padding 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

< source >

( 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

< source >

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

< source >

( 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

< source >

( 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) — 用于避免在 padding 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)

类 optimum.onnxruntime.ORTDiffusionPipeline

< 源码 >

( scheduler: SchedulerMixin vae_decoder_session: InferenceSession unet_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None transformer_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None 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 text_encoder_3_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_3: 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 )

类 optimum.onnxruntime.ORTStableDiffusionPipeline

< 源码 >

( scheduler: SchedulerMixin vae_decoder_session: InferenceSession unet_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None transformer_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None 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 text_encoder_3_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_3: 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 vae_decoder_session: InferenceSession unet_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None transformer_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None 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 text_encoder_3_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_3: 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 vae_decoder_session: InferenceSession unet_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None transformer_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None 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 text_encoder_3_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_3: 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 vae_decoder_session: InferenceSession unet_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None transformer_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None 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 text_encoder_3_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_3: 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 vae_decoder_session: InferenceSession unet_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None transformer_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None 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 text_encoder_3_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_3: 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 vae_decoder_session: InferenceSession unet_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None transformer_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None 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 text_encoder_3_session: typing.Optional[onnxruntime.capi.onnxruntime_inference_collection.InferenceSession] = None tokenizer: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_2: typing.Optional[ForwardRef('CLIPTokenizer')] = None tokenizer_3: 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

< 源码 >

( *args **kwargs )

Optimum

模型

通用模型类

ORTModel

class optimum.onnxruntime.ORTModel

can_generate

from_pretrained

load_model

raise_on_numpy_input_io_binding

shared_attributes_init

to

自然语言处理

ORTModelForCausalLM

class optimum.onnxruntime.ORTModelForCausalLM

forward

ORTModelForMaskedLM

class optimum.onnxruntime.ORTModelForMaskedLM

forward

ORTModelForSeq2SeqLM

class optimum.onnxruntime.ORTModelForSeq2SeqLM

forward

ORTModelForSequenceClassification

class optimum.onnxruntime.ORTModelForSequenceClassification

forward

ORTModelForTokenClassification

class optimum.onnxruntime.ORTModelForTokenClassification

forward

ORTModelForMultipleChoice

class optimum.onnxruntime.ORTModelForMultipleChoice

forward

ORTModelForQuestionAnswering

class optimum.onnxruntime.ORTModelForQuestionAnswering

forward

计算机视觉

ORTModelForImageClassification

class optimum.onnxruntime.ORTModelForImageClassification

forward

ORTModelForSemanticSegmentation

class optimum.onnxruntime.ORTModelForSemanticSegmentation

forward

音频

ORTModelForAudioClassification

class optimum.onnxruntime.ORTModelForAudioClassification

forward

ORTModelForAudioFrameClassification

class optimum.onnxruntime.ORTModelForAudioFrameClassification

forward

ORTModelForCTC

class optimum.onnxruntime.ORTModelForCTC

forward

ORTModelForSpeechSeq2Seq

class optimum.onnxruntime.ORTModelForSpeechSeq2Seq

forward

ORTModelForAudioXVector

class optimum.onnxruntime.ORTModelForAudioXVector

forward

多模态

ORTModelForVision2Seq

class optimum.onnxruntime.ORTModelForVision2Seq

forward

ORTModelForPix2Struct

class optimum.onnxruntime.ORTModelForPix2Struct

forward

自定义任务

ORTModelForCustomTasks

class optimum.onnxruntime.ORTModelForCustomTasks

forward

ORTModelForFeatureExtraction

class optimum.onnxruntime.ORTModelForFeatureExtraction

forward

Stable Diffusion

ORTDiffusionPipeline

类 optimum.onnxruntime.ORTDiffusionPipeline

__call__

ORTStableDiffusionPipeline

类 optimum.onnxruntime.ORTStableDiffusionPipeline

__call__

ORTStableDiffusionImg2ImgPipeline

类 optimum.onnxruntime.ORTStableDiffusionImg2ImgPipeline

__call__

call

call

call

call

call

call

call