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承载授权的令牌。如果为True，将使用运行huggingface-cli login时生成的令牌（存储在huggingface_hub.constants.HF_TOKEN_PATH）。
cache_dir （Optional[str]，默认为None）— 当不使用标准缓存时，应将下载的预训练模型配置缓存到该目录的路径。
子文件夹 (str, 默认为 "") — 如果相关文件位于模型的子文件夹中，无论是本地还是huggingface.co，您可以在此指定文件夹名称。
config (Optional[transformers.PretrainedConfig], 默认为 None) — 模型配置。
local_files_only (Optional[bool], 默认为 False) — 是否仅查找本地文件（即不尝试下载模型）。
信任远程代码 (bool, 默认为 False) — 是否允许在 Hub 上自定义代码进行模型训练。此选项仅在您信任且已阅读过代码的存储库中设置为 True，因为它将在您的本地机器上执行 Hub 上的代码。
修订版 (Optional[str], 默认为 None) — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID，因为我们使用基于 git 的系统在 huggingface.co 上存储模型和其他工件，所以 修订版 可以是 git 允许的任何标识符。
提供者 (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], 默认为 True) — 是否使用过去键/值缓存。默认为 True。

ORTModelForCausalLM 的参数

use_merged (Optional[bool], 默认为 None) — 是否使用单个 ONNX 来处理不重复使用过去键值的解码。如果从本地存储库加载且找到合并的解码器，此选项默认为 True。当使用 export=True 导出时，默认为 False。为了最小化内存使用，应将此选项设置为 True。

返回

ORTModel

加载的 ORTModel 模型。

从预训练的模型配置创建预训练模型实例。

加载模型

( 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, 默认为 "CPUExecutionProvider") — 用于加载模型的ONNX Runtime提供者。有关可能的提供者，请参阅 https://onnxruntime.ai/docs/execution-providers/。

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

raise_on_numpy_input_io_binding

参数

use_torch (bool) — 在推理过程中使用的张量是否为 torch.Tensor 类型。

如果请求了 IO 绑定，但使用的张量是 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

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

参数

设备 (torch.device 或 str 或 int) — 适用于 CPU/GPU 的设备序号。设置为 -1 将使用 CPU，正值将在关联的 CUDA 设备 ID 上运行模型。您可以传递本地的 torch.device 或 str。

返回

ORTModel

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

根据设备更改 ONNX 运行时提供程序。

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

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

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

forward

(

参数

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 前向方法，重写了 __call__ 特殊方法。

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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)

类 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模型，用于掩码语言模型任务。该类官方支持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] of shape (batch_size, sequence_length), defaults to None) — Indices of input sequence tokens in the vocabulary. Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode and PreTrainedTokenizer.__call__ for details. What are input IDs?
attention_mask (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 为避免在填充标记索引上执行注意力而用的掩码。掩码值在[0, 1]中选取：
- 1 代表未被掩码的标记，
- 0 代表被掩码的标记。什么是注意力掩码？
token_type_ids (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 指示输入第一部分和第二部分的标识符。在[0, 1]中选择索引：
- 1 代表句子A的标记，
- 0 代表句子B的标记。什么是标记类型ID？

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

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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: typingOptional[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索引上执行注意力操作的掩码，形状为(batch_size, encoder_sequence_length)。掩码值在[0, 1]中选取。
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) 的张量。

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

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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)

类 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] of shape (batch_size, sequence_length), defaults to None) — 输入序列标记的索引，索引来自词汇表。索引可以通过 AutoTokenizer 获取。详见 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__，有关输入索引是什么的详细信息。
attention_mask (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1] 范围内：
- 1 表示非掩码标记,
- 0 表示掩码标记。有关注意力掩码是什么的更多信息。
- token_type_ids (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 段标记索引来指示输入的第一和第二部分。索引选择在 [0, 1] 范围内：
  
  1 表示句子 A 的标记,
  
  0 表示句子 B 的标记。有关标记类型 ID 是什么的更多信息。

“ORTModelForSequenceClassification” 的 forward 方法重写了特殊方法 __call__。

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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)

类 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 模型顶部具有标记分类头（隐状态输出之上的线性层），例如用于命名实体识别（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] of shape (batch_size, sequence_length), defaults to None) — 词汇表中的输入序列标记的索引。索引可以通过AutoTokenizer 获取。请参阅PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__ 了解详细信息。什么是输入ID？
attention_mask (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：
- 1 表示 未掩码 的标记，
- 0 表示掩码的标记。什么是注意力掩码？
token_type_ids (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — Segment token indices to indicate the first and second parts of the inputs. Indices are selected in [0, 1]:
- 1 for tokens that are sentence A,
- 0 for tokens that are sentence B. What are token type IDs?

ORTModelForTokenClassification 前向方法，覆盖了特殊方法 __call__。

虽然需要在函数内定义前向传递的配方，但在之后应该调用 Module 实例而不是这个实例，因为前者负责运行前置和后置处理步骤，而后者静默忽略它们。

Token classification 示例

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

类 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] of shape (batch_size, sequence_length), defaults to None) — 输入序列标记在词汇表中的索引。索引可以通过使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是输入 ID？
attention_mask (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 避免在填充标记索引上执行关注的掩码。掩码值选择在 [0, 1] 范围内：
- 1 表示 未掩码 的标记，
- 0 表示掩码的标记。什么是关注掩码？

ORTModelForMultipleChoice 前向方法，覆盖了 __call__ 特殊方法。

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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

类 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 的问答任务的抽取式问答任务的 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）— 序列token在词汇表中的索引。索引可以通过AutoTokenizer 获取。请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__ 获取详细信息。什么是input ID？
attention_mask （类型: Union[torch.Tensor, np.ndarray, None], 形状：(batch_size, sequence_length), 默认：None）— 避免在填充token索引上执行注意力的掩码。掩码值：在 [0, 1] 中选择：
- 1 表示 未掩码 的token，
- 0 表示 已掩码 的token。
什么是注意力掩码？

token_type_ids (torch.Tensor, np.ndarray 或 None 的联合，形状为 (batch_size, sequence_length)，默认为 None) — 段落标记索引以指示输入的第一部分和第二部分。索引选自 [0, 1]：

1 表示 句子 A 中的标记，
0 表示 句子 B 中的标记。什么是标记类型 ID?

ORTModelForQuestionAnswering 的前进方法覆盖了 __call__ 特殊方法。

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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)

类 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] of shape (batch_size, num_channels, height, width), defaults to None) — 当前批次图像的像素值。像素值可以通过使用 AutoFeatureExtractor 从编码图像中获得。

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

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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)

类 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 前向方法，覆盖了 __call__ 特殊方法。

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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)

类 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 (torch.Tensor of shape (batch_size, sequence_length)) — 输入原始语音波形的浮点值。输入值可以通过AutoFeatureExtractor从加载到数组中的音频文件中获取。

ORTModelForAudioClassification的前向方法，覆盖了__call__特殊方法。

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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 of shape (batch_size, sequence_length)) — 输入原始语音波形浮点值。输入值可以通过将音频文件加载到数组中并通过 AutoFeatureExtractor 获取。

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

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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

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

支持数据2D矢量音频、hubert、sew、sew_d、unispeech、unispeech_sat、wavlm、wav2vec2、wav2vec2-conformer的CTC（连接时序分类）顶部带有语言建模头部的ONNX模型。

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

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

forward

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

参数

input_values (torch.Tensor of shape (batch_size, sequence_length)) — 输入原始语音波形的浮点数值。输入值可以通过将加载到数组中的音频文件使用 AutoFeatureExtractor 获取。

ORTModelForCTC 的前进方法重写了 __call__ 特殊方法。

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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，每个元组包含形状为 (batch_size, num_heads, decoder_sequence_length, embed_size_per_head) 的 2 个张量以及 2 个附加形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的张量。

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

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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

( 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前向方法覆盖了特殊的__call__方法。

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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 )

用于ONNX Runtime推理的视觉编码器-解码器序列到序列模型，带有语言建模头。此类正式支持trocr和视觉编码器-解码器。

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

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

forward

参数

past_key_values (tuple(tuple(torch.FloatTensor), *optional*, defaults to None) — 存储用于加速解码的注意力模块的预计算关键和值隐藏状态。该元组的长度为 config.n_layers，每个元组包含形状为 (batch_size, num_heads, decoder_sequence_length, embed_size_per_head) 的 2 个张量以及形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的 2 个额外的张量。

ORTModelForVision2Seq 的前向方法，覆盖了特殊方法 __call__。

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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)

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

具有语言模型头部的Pix2struct模型，用于ONNX Runtime推理。此类正式支持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 (torch.FloatTensor of shape (batch_size, seq_length, hidden_size)) — Flatten pixel patches. The hidden_size is obtained by the following formula: hidden_size = num_channels × patch_size × patch_size. The process of flattening the pixel patches is done by 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 中的填充 token 的张量。默认情况下还会使用因果掩码。
encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 包含元素为 (last_hidden_state, optional: hidden_states, optional: attentions), last_hidden_state 的形状为 (batch_size, 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)。

ORTModelForPix2Struct 前向方法，覆盖了 __call__ 特殊方法。

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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)

类 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 前向方法，覆盖了 __call__ 特殊方法。

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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)

类 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 (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 输入序列标记的索引词汇。索引可以通过 AutoTokenizer 获取。请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__ 获取详细信息。什么是输入ID？
attention_mask (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 之间选择：
- 1 表示 未掩码 的标记,
- 0 表示 已掩码 的标记。什么是注意力掩码？
token_type_ids (Union[torch.Tensor, np.ndarray, None] of shape (batch_size, sequence_length), defaults to None) — 段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 之间选择：
- 1 表示 句子 A,
- 0 表示 句子 B。什么是标记类型ID？

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

虽然需要在函数内定义前向传递的配方，但在之后应该调用 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.ORTStableDiffusionPipeline

基于ONNX Runtime的stable diffusion流程，对应于diffusers.StableDiffusionPipeline。

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

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

call

( prompt: typing.Union[str, typing.List[str], NoneType] = Noneheight: typing.Optional[int] = Nonewidth: typing.Optional[int] = Nonenum_inference_steps: int = 50guidance_scale: float = 7.5negative_prompt: typing.Union[str, typing.List[str], NoneType] = Nonenum_images_per_prompt: int = 1eta: float = 0.0generator: typing.Optional[numpy.random.mtrand.RandomState] = Nonelatents: typing.Optional[numpy.ndarray] = Noneprompt_embeds: typing.Optional[numpy.ndarray] = Nonenegative_prompt_embeds: typing.Optional[numpy.ndarray] = Noneoutput_type: str = 'pil'return_dict: bool = Truecallback: typing.Union[typing.Callable[[int, int, numpy.ndarray], NoneType], NoneType] = Nonecallback_steps: int = 1guidance_rescale: float = 0.0 ) → ~pipelines.stable_diffusion.StableDiffusionPipelineOutput or tuple

参数

prompt (str或List[str]的Union，默认为None) —— 引导图像生成的提示或提示词。 若未定义，必须传递 prompt_embeds 而不是 prompt。
height （Optional[int]，默认为 None）— 生成图像的像素高度。
width （Optional[int]，默认为 None）— 生成图像的像素宽度。
num_inference_steps （int，默认为 50）— 消噪步骤的数量。更多的消噪步骤通常会导致图像质量更高，但推理速度会变慢。
guidance_scale (float，默认为 7.5) — 指导比例，如无分类扩散指导中定义。指导比例定义为Imagen 论文中方程 2 中的 w。通过设置 guidance_scale > 1 使用指导比例。较高的指导比例会鼓励生成与文本 prompt 关联紧密的图像，通常以牺牲图像质量为代价。
negative_prompt (Optional[Union[str, list]]) — 不用于引导图像生成的提示或提示列表。如果未定义，则需要传递 negative_prompt_embeds。在未使用指导时（即，如果 guidance_scale 小于 1）则忽略。
num_images_per_prompt (int，默认为 1) — 每个提示生成的图像数量。
eta (float, 默认值为 0.0) — 对应 DDIM 论文中参数 eta（η）：https://arxiv.org/abs/2010.02502。仅适用于 schedulers.DDIMScheduler，其他情况将被忽略。
generator (Optional[np.random.RandomState], 默认值为 None) —：用于使生成过程确定性的 np.random.RandomState。
latents (Optional[np.ndarray], 默认值为 None) — 预生成的带噪声的 latents，来自高斯分布，用于图像生成的输入。可以用以使用不同的提示调整相同的生成。如果不提供，将使用提供的随机 generator 生成 latents 张量。
prompt_embeds (Optional[np.ndarray], 默认为 None) — 预生成的文本嵌入。可以用来轻松调整文本输入，例如提示权重。如果没有提供，将从 prompt 输入参数生成文本嵌入。
negative_prompt_embeds (Optional[np.ndarray], 默认为 None) — 预生成的负文本嵌入。可以用来轻松调整文本输入，例如提示权重。如果没有提供，将从 negative_prompt 输入参数生成负文本嵌入。
output_type (str, 默认为 "pil") — 生成图像的输出格式。选择 PIL: PIL.Image.Image 或 np.array。
return_dict （布尔值，默认为 True）— 是否以 ~pipelines.stable_diffusion.StableDiffusionPipelineOutput 的形式返回，而不是普通的元组。
callback （可选[可调用对象]，默认为 None）— 在推理过程中的每 callback_steps 步时会调用的函数。该函数将使用以下参数被调用： callback(step: int, timestep: int, latents: torch.FloatTensor)。
callback_steps （整数，默认为 1）— callback 函数被调用的频率。如果没有指定，则在每一步都调用回调函数。
guidance_rescale (float, 默认值 0.0) — 指导缩放因子，由《常见的扩散噪声计划和采样步骤存在缺陷》提出。指导缩放因子定义为《常见的扩散噪声计划和采样步骤存在缺陷》中的公式16中的φ。当使用零终端SNR时，应使用指导缩放因子来纠正过度曝光。

返回

~pipelines.stable_diffusion.StableDiffusionPipelineOutput 或 tuple

~pipelines.stable_diffusion.StableDiffusionPipelineOutput 如果 return_dict 为 True，否则为一个 tuple。当返回一个元组时，第一个元素是生成图像的列表，第二个元素是代表根据 safety_checker 评估的相应生成图像可能表示“不适合工作”内容的布尔值列表。

在调用管道进行生成时调用的函数。

类 optimum.onnxruntime.ORTStableDiffusionImg2ImgPipeline

基于ONNX Runtime的稳定扩散管道，对应于diffusers.StableDiffusionImg2ImgPipeline。

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

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

call

( prompt: typing.Union[str, typing.List[str], NoneType] = None image: typing.Union[numpy.ndarray, PIL.Image.Image] = None strength: float = 0.8 num_inference_steps: int = 50 guidance_scale: float = 7.5 negative_prompt: typing.Union[str, typing.List[str], NoneType] = None num_images_per_prompt: int = 1 eta: float = 0.0 generator: typing.Optional[numpy.random.mtrand.RandomState] = None prompt_embeds: typing.Optional[numpy.ndarray] = None negative_prompt_embeds: typing.Optional[numpy.ndarray] = None output_type: str = 'pil' return_dict: bool = True callback: typing.Union[typing.Callable[[int, int, numpy.ndarray], NoneType], NoneType] = None callback_steps: int = 1 ) → ~pipelines.stable_diffusion.StableDiffusionPipelineOutput or tuple

参数

提示 (Optional[Union[str, List[str]]], 默认为 None) — 指导图像生成的提示。如果没有定义，必须传递 prompt_embeds。代替。
图像 (Union[np.ndarray, PIL.Image.Image]) — 图像，或表示将要上采样的图像批次的张量。
强度 (float, 默认为 0.8) — 概念上表示对参考图像进行多少变换。必须在 0 和 1 之间。如果 strength 值越大，则向图像添加的噪声越多。《image》将是起始点，strength 值越大，添加的噪声就越多。去噪步骤的数量取决于最初添加的噪声量。当 strength 为 1 时，添加的噪声将达到最大，去噪过程将运行到 num_inference_steps 中指定的完整迭代次数。因此，1 的值基本上忽略了 image。
num_inference_steps (int, 默认值 50) — 降噪步骤的数量。更多的降噪步骤通常会导致图像质量更高，但推理速度会变慢。
guidance_scale (float, 默认值 7.5) — 指导比率，如《无分类器扩散指导》中所述。 guidance_scale 定义为《Imagen 论文》第2式中 w 的值。通过设置 guidance_scale > 1 启用指导比率。更高的指导比率会鼓励生成与文本 prompt 密切相关的图像，通常以降低图像质量为代价。
negative_prompt (Optional[Union[str, list]]) — 不要引导图像生成的提示或提示。如果未定义，则必须传递 negative_prompt_embeds。在未使用指导的情况下（即如果 guidance_scale 小于 1）将被忽略。
num_images_per_prompt （int，默认为1） — 每个提示生成的图片数量。
eta （float，默认为0.0） — 对应DDIM论文中的参数eta（η）：[https://arxiv.org/abs/2010.02502](https://arxiv.org/abs/2010.02502)。仅适用于schedulers.DDIMScheduler，对其他将忽略。
generator （Optional[np.random.RandomState]，默认为None） —: 用于使生成过程确定性的np.random.RandomState。
prompt_embeds （Optional[np.ndarray]，默认为None） — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示加权。如果没有提供，将从prompt输入参数生成文本嵌入。
negative_prompt_embeds (Optional[np.ndarray], defaults to None) — 预生成负向文本嵌入。可用于轻松调整文本输入，例如提示加权。如果没有提供，negativePromptEmbeds将从negative_prompt参数生成。
output_type (str, defaults to "pil") — 生成图像的输出格式。在PIL: PIL.Image.Image 或 np.array 之间选择。
return_dict (bool, defaults to True) — 是否返回~pipelines.stable_diffusion.StableDiffusionPipelineOutput而不是普通元组。
callback （可选的[Callable]，默认为 None） — 在推理过程中每执行 callback_steps 步时将被调用的函数。这个函数将使用以下参数被调用： callback(step: int, timestep: int, latents: torch.FloatTensor)。
callback_steps （int，默认值为 1） — 在推理过程中调用 callback 函数的频率。如果未指定，则在每一步调用回调。

返回

~pipelines.stable_diffusion.StableDiffusionPipelineOutput 或 tuple

~pipelines.stable_diffusion.StableDiffusionPipelineOutput 如果 return_dict 为 True，否则为一个 tuple。当返回一个元组时，第一个元素是生成图像的列表，第二个元素是代表根据 safety_checker 评估的相应生成图像可能表示“不适合工作”内容的布尔值列表。

在调用管道进行生成时调用的函数。

类 optimum.onnxruntime. ORTStableDiffusionInpaintPipeline

基于ONNX Runtime的稳定扩散处理管道，对应于diffusers.StableDiffusionInpaintPipeline。

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

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

call

( prompt: typing.Union[str, typing.List[str]] image: 图像 mask_image: 图像高度: typing.Optional[int] = None 宽度: typing.Optional[int] = None num_inference_steps: int = 50 guidance_scale: float = 7.5 negative_prompt: typing.Union[str, typing.List[str], NoneType] = None num_images_per_prompt: int = 1 eta: float = 0.0 generator: typing.Optional[numpy.random.mtrand.RandomState] = None latents: typing.Optional[numpy.ndarray] = None prompt_embeds: typing.Optional[numpy.ndarray] = None negative_prompt_embeds: typing.Optional[numpy.ndarray] = None output_type: str = 'pil' return_dict: bool = True callback: typing.Union[typing.Callable[[int, int, numpy.ndarray], NoneType], NoneType] = None callback_steps: int = 1 ) → ~pipelines.stable_diffusion.StableDiffusionPipelineOutput 或 tuple

参数

prompt (Union[str, List[str]]) — 引导图像生成的提示或提示列表。如果未定义，需要传入 prompt_embeds。
image (PIL.Image.Image) — 要上采样的一批图像或代表图像批次的张量。
mask_image (PIL.Image.Image) — 要上采样的遮罩图像批次或表示遮罩图像批次的张量。
高度 (Optional[int], 默认为 None) — 生成的图像的像素高度。
宽度 (Optional[int], 默认为 None) — 生成的图像的像素宽度。
num_inference_steps (int, 默认为 50) — 降噪步骤的数量。更多的降噪步骤通常会导致图像质量更高，但推理速度会变慢。
guidance_scale (float, 默认值 7.5) — 指导尺度，如《无分类器扩散指导》中定义。`guidance_scale` 被定义为《Imagen 论文》中的方程 2 的 w。指导尺度通过设置 guidance_scale > 1 启用。更高的指导尺度鼓励生成与文本 prompt 紧密相关的图像，通常以降低图像质量为代价。
negative_prompt (Optional[Union[str, list]]) — 不用于指导图像生成的提示或提示列表。如果没有定义，必须传递 negative_prompt_embeds。当不使用指导时（即，如果 guidance_scale 小于 1），将被忽略。
num_images_per_prompt (int, 默认值 1) — 每个提示生成图像的数量。
eta (float, 默认为 0.0) — 与 DDIM 论文中参数 eta (η) 相对应：[链接](https://arxiv.org/abs/2010.02502)。仅适用于 schedulers.DDIMScheduler，对于其他情况将被忽略。
generator (Optional[np.random.RandomState], 默认为 None) — 用于使生成过程确定性的 np.random.RandomState。
latents (Optional[np.ndarray], 默认为 None) — 预先生成的嘈杂 latents，从高斯分布中抽取，用于生成图像的输入。可以用于用不同的提示调整相同的生成。如果没有提供，将使用提供的随机 generator 生成一个 latents 张量。
prompt_embeds (Optional[np.ndarray], 默认为 None) — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示权重。如果没有提供，文本嵌入将从 prompt 输入参数中生成。
negative_prompt_embeds (Optional[np.ndarray], 默认为 None) — 预生成的负文本嵌入。可用于轻松调整文本输入，例如提示权重。如果没有提供，将从 negative_prompt 输入参数中生成 negative_prompt_embeds。
output_type (str, 默认为 "pil") — 生成图像的输出格式。在 PIL: PIL.Image.Image 或 np.array 之间选择。
return_dict (bool, 默认为 True) — 是否返回 ~pipelines.stable_diffusion.StableDiffusionPipelineOutput 而不是普通的元组。
callback (可选[Callable], 默认为 None) — 在推理过程中每 callback_steps 步时将被调用的函数。函数将使用以下参数调用：callback(step: int, timestep: int, latents: torch.FloatTensor)。
callback_steps (int, 默认为 1) — callback 函数将被调用的频率。如果没有指定，回调将在每一步调用。

返回

~pipelines.stable_diffusion.StableDiffusionPipelineOutput 或 tuple

~pipelines.stable_diffusion.StableDiffusionPipelineOutput 如果 return_dict 为 True，否则为一个 tuple。当返回一个元组时，第一个元素是生成图像的列表，第二个元素是代表根据 safety_checker 评估的相应生成图像可能表示“不适合工作”内容的布尔值列表。

在调用管道进行生成时调用的函数。

类 optimum.onnxruntime.ORTStableDiffusionXLPipeline

( vae_decoder_session: 推断会话 text_encoder_session: 推断会话 unet_session: 推断会话 config: typing.Dict[str, typing.Any] tokenizer: CLIPTokenizer scheduler: typing.Union[diffusers.schedulers.scheduling_ddim.DDIMScheduler, diffusers.schedulers.scheduling_pndm.PNDMScheduler, diffusers.schedulers.scheduling_lms_discrete.LMSDiscreteScheduler] feature_extractor: typing.Optional[transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor] = None vae_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_2: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None add_watermarker: typing.Optional[bool] = None )

由ONNX Runtime驱动的与diffusers.StableDiffusionXLPipeline对应的稳定扩散流水线。

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

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

call

( 提示: typing.Union[str, typing.List[str], NoneType] = None 高度: typing.Optional[int] = None 宽度: typing.Optional[int] = None 推理步骤数: int = 50 引导缩放比例: float = 5.0 负提示: typing.Union[str, typing.List[str], NoneType] = None 每个提示的图片数量: int = 1 η: float = 0.0 生成器: typing.Optional[numpy.random.mtrand.RandomState] = None 潜在变量: typing.Optional[numpy.ndarray] = None 提示嵌入: typing.Optional[numpy.ndarray] = None 负提示嵌入: typing.Optional[numpy.ndarray] = None 汇总提示嵌入: typing.Optional[numpy.ndarray] = None 负汇总提示嵌入: typing.Optional[numpy.ndarray] = None 输出类型: str = 'pil' 返回字典: bool = True 回调: typing.Union[typing.Callable[[int, int, numpy.ndarray], NoneType], NoneType] = None 回调步骤: int = 1 交叉注意力参数: typing.Union[typing.Dict[str, typing.Any], NoneType] = None 引导重缩放比例: float = 0.0 原始大小: typing.Union[typing.Tuple[int, int], NoneType] = None 上左裁剪坐标: typing.Tuple[int, int] = (0, 0) 目标大小: typing.Union[typing.Tuple[int, int], NoneType] = None ) → ~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput 或 tuple

参数

prompt (Optional[Union[str, List[str]]], 默认值为None) —— 指导图像生成的提示词或提示词列表。如果未定义，需要传递 prompt_embeds。替代。
height (Optional[int], 默认值为None) —— 生成的图像的高度（像素）。
width (Optional[int], 默认值为None) —— 生成的图像的宽度（像素）。
num_inference_steps（《整数`, 默认值为50）— 反混淆步骤的数量。更多的反混淆步骤通常会以牺牲推理速度为代价来获得更高质量的图像。
guidance_scale（《浮点数`, 默认值为5）— 定义在《无分类器扩散指导》中的指导比例。指导比例定义为方程2中的《图片》中的w。通过设置guidance_scale > 1启用指导比例。较高的指导比例会鼓励生成与文本提示紧密相关的图像，这通常以牺牲图像质量为代价。
negative_prompt（《可选[Union[str, list]]）— 不用于引导图像生成的提示或提示列表。如果没有定义，必须传递negative_prompt_embeds代替。当不使用指导时（即当guidance_scale小于1时）被忽略。
num_images_per_prompt (int, 默认为 1) — 每个提示生成的图像数量。
eta (float, 默认为 0.0) — 对应于DDIM论文中的参数eta（η）：https://arxiv.org/abs/2010.02502。仅适用于schedulers.DDIMScheduler，对于其他类型将被忽略。
generator (Optional[np.random.RandomState], 默认为 None) —: 用于生成确定性结果的np.random.RandomState。
latents (Optional[np.ndarray], 默认为 None) — 预生成的噪声 latent，从高斯分布中采样，用作图像生成的输入。可用于使用不同的提示调整相同的生成。如果未提供，将通过提供的随机 generator 生成 latent 张量。
prompt_embeds (Optional[np.ndarray], 默认为 None) — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示权重。如果未提供，将从 prompt 输入参数生成文本嵌入。
negative_prompt_embeds (Optional[np.ndarray], 默认为 None) — 预生成的负文本嵌入。可用于轻松调整文本输入，例如提示权重。如果未提供，将从 negative_prompt 输入参数生成负文本嵌入。
output_type (str, 默认为 "pil") — 生成的图像的输出格式。选择 PIL: PIL.Image.Image 或 np.array。
return_dict (bool, 默认为 True) — 是否返回~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput而不是普通的元组。
callback (Optional[Callable], 默认为 None) — 在推理过程中每callback_steps步将调用的函数。该函数将使用以下参数调用：callback(step: int, timestep: int, latents: torch.FloatTensor)。
callback_steps (int，默认为1) — 控制回调函数被调用的频率。如果没有指定，则回调函数将在每个步骤中被调用。
guidance_rescale (float，默认为0.7) — 根据Common Diffusion Noise Schedules and Sample Steps are Flawed的指导，提出调整指导因子。指导调整因子定义为Common Diffusion Noise Schedules and Sample Steps are Flawed中的方程16的φ。在零终端信噪比的情况下，指导调整因子应该修正过曝问题。

返回

~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput 或 tuple

~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput 如果启用return_dict，否则为tuple。返回 tuple 时，第一个元素是生成图片的列表，第二个元素是由safety_checker定义的确定对应生成图像可能表示"不适宜工作环境" (nsfw) 内容的布尔值列表。

在调用管道进行生成时调用的函数。

类 optimum.onnxruntime.ORTStableDiffusionXLImg2ImgPipeline

( vae_decoder_session: 推断会话 text_encoder_session: 推断会话 unet_session: 推断会话 config: typing.Dict[str, typing.Any] tokenizer: CLIPTokenizer scheduler: typing.Union[diffusers.schedulers.scheduling_ddim.DDIMScheduler, diffusers.schedulers.scheduling_pndm.PNDMScheduler, diffusers.schedulers.scheduling_lms_discrete.LMSDiscreteScheduler] feature_extractor: typing.Optional[transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor] = None vae_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_2: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None add_watermarker: typing.Optional[bool] = None )

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

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

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

call

( prompt: typing.Union[str, typing.List[str], NoneType] = None image: typing.Union[numpy.ndarray, PIL.Image.Image] = None strength: float = 0.3 num_inference_steps: int = 50 guidance_scale: float = 5.0 negative_prompt: typing.Union[str, typing.List[str], NoneType] = None num_images_per_prompt: int = 1 eta: float = 0.0 generator: typing.Optional[numpy.random.mtrand.RandomState] = None latents: typing.Optional[numpy.ndarray] = None prompt_embeds: typing.Optional[numpy.ndarray] = None negative_prompt_embeds: typing.Optional[numpy.ndarray] = None pooled_prompt_embeds: typing.Optional[numpy.ndarray] = None negative_pooled_prompt_embeds: typing.Optional[numpy.ndarray] = None output_type: str = 'pil' return_dict: bool = True callback: typing.Union[typing.Callable[[int, int, numpy.ndarray], NoneType], NoneType] = None callback_steps: int = 1 cross_attention_kwargs: typing.Union[typing.Dict[str, typing.Any], NoneType] = None guidance_rescale: float = 0.0 original_size: typing.Union[typing.Tuple[int, int], NoneType] = None crops_coords_top_left: typing.Tuple[int, int] = (0, 0) target_size: typing.Union[typing.Tuple[int, int], NoneType] = None aesthetic_score: float = 6.0 negative_aesthetic_score: float = 2.5 ) → ~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput or tuple

参数

prompt (Optional[Union[str, List[str]]], 默认为 None) — 引导图像生成的提示或提示列表。如果没有定义，则需要传递 prompt_embeds。
image (Union[np.ndarray, PIL.Image.Image]) — Image，或将要上采样的图像的批次的张量。
strength (float，默认值是 0.8) — 从概念上讲，表示要将参考 image 转变为多少程度。必须在 0 到 1 之间。较大的 strength 表示向 image 中添加更多的噪声。去噪步骤的数量取决于最初添加的噪声量。当 strength 为 1 时，添加的噪声最大，去噪过程将运行 num_inference_steps 中指定的完整迭代次数。因此，值为 1 时基本上忽略了 image。
num_inference_steps (int，默认值是 50) — 去噪步骤的数量。更多的去噪步骤通常会导致图像质量更高，但会牺牲推理速度。
guidance_scale （float类型，默认为5）—— 指导度量标准，如《无分类扩散指导》定义所述。 guidance_scale 是指Imagen 论文中方程2的 w。指导度量标准可通过设置 guidance_scale > 1 启用。更高的指导度量标准会鼓励生成与文本 prompt 密切相关的图像，通常以牺牲较低图像质量为代价。
negative_prompt （可选的str或list的Union类型）—— 不引导图像生成的提示或提示词。如果没有定义，必须传递 negative_prompt_embeds。在没有使用指导时（即当 guidance_scale 小于 1 时）忽略。
num_images_per_prompt （int类型，默认为1）—— 每个提示生成的图像数量。
eta (float, 默认为 0.0) — 对应于 DDIM 论文中的参数 eta (η)：[链接](https://arxiv.org/abs/2010.02502)。仅适用于 schedulers.DDIMScheduler，其他的情况将被忽略。
generator (Optional[np.random.RandomState], 默认为 None) —：一个 np.random.RandomState，用于使生成过程确定。
latents (Optional[np.ndarray], 默认为 None) — 预生成的噪声潜伏变量，从高斯分布中采样，用作图像生成的输入。可用于使用不同的提示调整相同生成。如果没有提供，将使用提供的随机 generator 生成一个潜伏张量。
prompt_embeds (Optional[np.ndarray], 默认 None) — 预生成的文本嵌入。可用于轻松调整文本输入，例如调整提示权重。如果没有提供，将根据“prompt”输入参数生成文本嵌入。
negative_prompt_embeds (Optional[np.ndarray], 默认 None) — 预生成的负文本嵌入。可用于轻松调整文本输入，例如调整提示权重。如果没有提供，将从“negative_prompt”输入参数生成负文本嵌入。
output_type (str, 默认 "pil") — 生成的图像输出格式。可在PIL: PIL.Image.Image 或 np.array 之间选择。
return_dict (bool, 默认为 True) — 是否返回一个 ~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput 而不是普通元组。
callback (可选[函数]，默认为 None) — 在推理过程中每隔 callback_steps 步调用该函数。函数将使用以下参数调用：callback(step: int, timestep: int, latents: torch.FloatTensor)。
callback_steps (int, 默认为 1) — callback 函数被调用的频率。如果没有指定，则回调将在每一步调用。
guidance_rescale (float, 默认值为 0.7) — 由 Common Diffusion Noise Schedules and Sample Steps are Flawed 提出的指导缩放因子。guidance_scale 在 Common Diffusion Noise Schedules and Sample Steps are Flawed 第 16 个公式的 φ 中定义。指导缩放因子应修正使用零终端 SNR 时的过度曝光。

返回

~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput 或 tuple

~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput 如果启用return_dict，否则为tuple。返回 tuple 时，第一个元素是生成图片的列表，第二个元素是由safety_checker定义的确定对应生成图像可能表示"不适宜工作环境" (nsfw) 内容的布尔值列表。

在调用管道进行生成时调用的函数。

类 optimum.onnxruntime.ORTLatentConsistencyModelPipeline

与 diffusers.LatentConsistencyModelPipeline 兼容的 ONNX Runtime 驱动的稳定扩散管道。

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

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

call