模型 - Hugging Face 机器学习平台

class optimum.onnxruntime.ORTModel

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

参数

- config (PretrainedConfig — 模型的配置。—
- session (~onnxruntime.InferenceSession) — 运行模型的 ONNX Runtime 推理会话。—
- use_io_binding (bool, 可选, 默认为 True) — 是否在 **ONNX Runtime 中使用 I/O 绑定 —
与 CUDAExecutionProvider**, 这可以根据任务显著加快推理速度。—
- model_save_dir (Path) — 导出到 ONNX 的模型保存目录。—
默认情况下，如果加载的模型是本地模型，则使用原始模型所在的目录。否则，将使用 —
缓存目录。—

使用 ONNX Runtime 实现模型的基本类。

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

类属性

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

can_generate

< source 源 >

( )

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

from_pretrained

< source 源 >

( model_id: typing.Union[str, pathlib.Path] config: typing.Optional[ForwardRef('PretrainedConfig')] = None export: bool = False subfolder: str = '' revision: str = 'main' force_download: bool = False local_files_only: bool = False trust_remote_code: bool = False cache_dir: str = '/root/.cache/huggingface/hub' token: typing.Union[str, bool, NoneType] = None provider: str = 'CPUExecutionProvider' providers: typing.Optional[typing.Sequence[str]] = None provider_options: typing.Union[typing.Sequence[typing.Dict[str, typing.Any]], typing.Dict[str, typing.Any], NoneType] = None session_options: typing.Optional[onnxruntime.capi.onnxruntime_pybind11_state.SessionOptions] = 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) — 如果不应使用标准缓存，则下载的预训练模型配置应缓存到的目录路径。
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/。
providers (Optional[Sequence[str]], 默认为 None) — 用于加载模型的执行提供程序列表。此参数优先于 provider 参数。
provider_options (Optional[Dict[str, Any]], 默认为 None) — 与所使用的提供程序对应的提供程序选项字典。有关每个提供程序的可用选项，请参阅：https://runtime.onnx.org.cn/docs/api/c/group___global.html。
session_options (Optional[onnxruntime.SessionOptions], 默认为 None) — 用于加载模型的 ONNX Runtime 会话选项。
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，该 ONNX 处理不重用和重用过去键值的解码。如果从本地仓库加载并找到合并的解码器，此选项默认为 True。当使用 export=True 导出时，默认为 False。应将此选项设置为 True 以最小化内存使用。

返回

ORTModel

已加载的 ORTModel 模型。

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

class optimum.onnxruntime.ORTModelForCausalLM

< source 源 >

( *args config: PretrainedConfig = None session: InferenceSession = None use_io_binding: typing.Optional[bool] = None generation_config: typing.Optional[ForwardRef('GenerationConfig')] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None **kwargs )

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

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

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

forward

< source 源 >

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

参数

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

ORTModelForCausalLM 的 forward 方法，覆盖了 __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)

class optimum.onnxruntime.ORTModelForMaskedLM

< source 源 >

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

ONNX 模型，带有 MaskedLMOutput 用于掩码语言建模任务。此类别正式支持 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 return_dict: bool = True **kwargs )

参数

input_ids (形状为 (batch_size, sequence_length) 的 Union[torch.Tensor, np.ndarray, None]，默认为 None) — 输入序列标记在词汇表中的索引。索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode 和 PreTrainedTokenizer.__call__。什么是输入 ID？
attention_mask (形状为 (batch_size, sequence_length) 的 Union[torch.Tensor, np.ndarray, None]，默认为 None) — 避免对填充标记索引执行注意力机制的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 未被掩码 的标记，
- 0 表示 被掩码 的标记。什么是注意力掩码？
token_type_ids (形状为 (batch_size, sequence_length) 的 Union[torch.Tensor, np.ndarray, None]，默认为 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

< source >

( *args config: PretrainedConfig = None encoder_session: InferenceSession = None decoder_session: InferenceSession = None decoder_with_past_session: typing.Optional[ForwardRef('InferenceSession')] = None use_io_binding: typing.Optional[bool] = None generation_config: typing.Optional[ForwardRef('GenerationConfig')] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None **kwargs )

用于ONNX Runtime推理的序列到序列模型，带有一个语言建模头。此类官方支持bart、blenderbot、blenderbot-small、longt5、m2m_100、marian、mbart、mt5、pegasus、t5。

该模型继承自~onnxruntime.modeling_ort.ORTModelForConditionalGeneration，请查看其文档以了解该库为其所有模型实现的通用方法（如下载或保存）。

此类应使用onnxruntime.modeling_ort.ORTModelForConditionalGeneration.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) — 输入序列令牌在词汇表中的索引，形状为(batch_size, encoder_sequence_length)。
attention_mask (torch.LongTensor) — 用于避免对填充令牌索引执行注意力操作的掩码，形状为(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)

class optimum.onnxruntime.ORTModelForSequenceClassification

< source >

( *args config: PretrainedConfig = None session: InferenceSession = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = 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 return_dict: bool = True **kwargs )

参数

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

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)

class optimum.onnxruntime.ORTModelForTokenClassification

< source >

( *args config: PretrainedConfig = None session: InferenceSession = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = 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

< 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 return_dict: bool = True **kwargs )

参数

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

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

尽管需要在函数内部定义前向传播的配方，但之后应该调用 Module 实例，而不是该实例，因为前者负责运行预处理和后处理步骤，而后者则静默忽略它们。

令牌分类示例

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

( *args config: PretrainedConfig = None session: InferenceSession = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = 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

< 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 return_dict: bool = True **kwargs )

参数

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

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

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

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

ONNX 模型，带有用于 SQuAD 等抽取式问答任务的 QuestionAnsweringModelOutput。此类官方支持 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 return_dict: bool = True **kwargs )

参数

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

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

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

( *args config: PretrainedConfig = None session: InferenceSession = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = 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] return_dict: bool = True **kwargs )

参数

pixel_values (Union[torch.Tensor, np.ndarray, None]，形状为(batch_size, num_channels, height, width)，默认为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)

class optimum.onnxruntime.ORTModelForSemanticSegmentation

< source >

( *args config: PretrainedConfig = None session: InferenceSession = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = 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] return_dict: bool = True **kwargs )

参数

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

ORTModelForSemanticSegmentation的forward方法覆盖了__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)

class optimum.onnxruntime.ORTModelForAudioClassification

< source >

( *args config: PretrainedConfig = None session: InferenceSession = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = 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 return_dict: bool = True **kwargs )

参数

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

ORTModelForAudioClassification的forward方法覆盖了__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"])

class optimum.onnxruntime.ORTModelForAudioFrameClassification

< source >

( *args config: PretrainedConfig = None session: InferenceSession = None use_io_binding: typing.Optional[bool] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = 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 return_dict: bool = True **kwargs )

参数

input_values (torch.Tensor，形状为(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()

Optimum

模型

通用模型类

ORTModel

class optimum.onnxruntime.ORTModel

can_generate

from_pretrained

自然语言处理

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

稳定扩散

ORTDiffusionPipeline

class optimum.utils.dummy_diffusers_objects.ORTDiffusionPipeline

__call__

ORTStableDiffusionPipeline

class optimum.utils.dummy_diffusers_objects.ORTStableDiffusionPipeline

__call__

ORTStableDiffusionImg2ImgPipeline

class optimum.utils.dummy_diffusers_objects.ORTStableDiffusionImg2ImgPipeline

__call__

ORTStableDiffusionInpaintPipeline

class optimum.utils.dummy_diffusers_objects.ORTStableDiffusionInpaintPipeline

__call__

ORTStableDiffusionXLPipeline

call

call

call

call

call

call

call