模型 - 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://onnxruntime.ai/docs/execution-providers/。
providers (Optional[Sequence[str]], 預設為 None) — 用於載入模型的執行提供程式列表。此引數優先於 provider 引數。
provider_options (Optional[Dict[str, Any]], 預設為 None) — 與所使用的提供程式對應的提供程式選項字典。有關每個提供程式的可用選項，請參閱：https://onnxruntime.ai/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