Optimum 文档

模型

您正在查看的是需要从源码安装。如果您想通过 pip 正常安装,请查看最新的稳定版本 (v1.27.0)。
Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

模型

通用模型类

optimum.intel.openvino.modeling_base.OVBaseModel

< >

( 模型: 模型 配置: PretrainedConfig = 无 设备: str = 'CPU' 动态形状: bool = True ov_配置: typing.Optional[typing.Dict[str, str]] = 无 模型_保存_目录: typing.Union[str, pathlib.Path, optimum.intel.openvino.utils.TemporaryDirectory, NoneType] = 无 量化_配置: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict, NoneType] = 无 **kwargs )

基础 OVModel 类。

从预训练

< >

( 模型_id: typing.Union[str, pathlib.Path] 导出: bool = False 强制_下载: bool = False 使用_auth_token: typing.Union[bool, str, NoneType] = None token: typing.Union[bool, str, NoneType] = None 缓存_目录: str = '/root/.cache/huggingface/hub' 子文件夹: str = '' 配置: typing.Optional[transformers.configuration_utils.PretrainedConfig] = None 仅本地文件: bool = False 信任_远程_代码: bool = False 版本: typing.Optional[str] = None **kwargs )

参数

  • model_id (Union[str, Path]) — 可以是:
    • 一个字符串,即托管在 huggingface.co 模型仓库中的预训练模型的模型 ID。有效的模型 ID 可以是根级别的,如 bert-base-uncased,也可以是用户或组织名称空间下的,如 dbmdz/bert-base-german-cased
    • 一个包含使用 ~OptimizedModel.save_pretrained 保存的模型目录的路径,例如 ./my_model_directory/
  • export (bool, 默认为 False) — 定义提供的 model_id 是否需要导出为目标格式。
  • force_download (bool, 默认为 True) — 是否强制(重新)下载模型权重和配置文件,如果存在缓存版本则覆盖。
  • use_auth_token (Optional[Union[bool,str]], 默认为 None) — 已弃用。请改用 token 参数。
  • token (Optional[Union[bool,str]], 默认为 None) — 用作远程文件 HTTP bearer 授权的令牌。如果为 True,将使用运行 huggingface-cli login 时生成的令牌(存储在 huggingface_hub.constants.HF_TOKEN_PATH 中)。
  • cache_dir (Optional[str], 默认为 None) — 如果不应使用标准缓存,则为下载的预训练模型配置应缓存的目录路径。
  • subfolder (str, 默认为 "") — 如果相关文件位于模型仓库的子文件夹中(本地或 huggingface.co 上),您可以在此处指定文件夹名称。
  • config (Optional[transformers.PretrainedConfig], 默认为 None) — 模型配置。
  • local_files_only (Optional[bool], 默认为 False) — 是否只查看本地文件(即不尝试下载模型)。
  • trust_remote_code (bool, 默认为 False) — 是否允许 Hub 上定义的自定义代码进行建模。此选项仅应设置为 True,用于您信任且已阅读其代码的仓库,因为它将在您的本地机器上执行 Hub 上存在的代码。
  • revision (Optional[str], 默认为 None) — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID,因为我们使用基于 git 的系统存储 huggingface.co 上的模型和其他工件,因此 revision 可以是 git 允许的任何标识符。

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

重塑

< >

( 批次大小: int 序列长度: int 高度: int = 无 宽度: int = 无 )

参数

  • batch_size (int) — 批次大小。
  • sequence_length (int) — 序列长度或通道数。
  • height (int, 可选) — 图像高度。
  • width (int, 可选) — 图像宽度。

在模型的层上传播给定的输入形状,修复模型的输入形状。

自然语言处理

以下类适用于以下自然语言处理任务。

OVModelForCausalLM

optimum.intel.OVModelForCausalLM

< >

( 模型: 模型 配置: PretrainedConfig = 无 设备: str = 'CPU' 动态形状: bool = 无 ov_配置: typing.Optional[typing.Dict[str, str]] = 无 模型_保存_目录: typing.Union[str, pathlib.Path, optimum.intel.openvino.utils.TemporaryDirectory, NoneType] = 无 量化_配置: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict, NoneType] = 无 **kwargs )

参数

  • model (openvino.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是模型配置类,包含模型的所有参数。用配置文件初始化不会加载与模型相关的权重,只加载配置。请查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • device (str, 默认为 "CPU") — 模型将优化的设备类型。生成的编译模型将包含特定于此设备的节点。
  • dynamic_shapes (bool, 默认为 True) — 当设置为 True 时,模型的所有维度都将设置为动态。默认为 False 时,模型不会动态重塑。
  • ov_config (Optional[Dict], 默认为 None) — 包含与模型编译相关信息的字典。
  • compile (bool, 默认为 True) — 当设置为 False 时,在加载步骤中禁用模型编译。在模型需要静态重塑、设备修改或启用 FP16 转换的情况下,这可能有助于避免不必要的编译。

具有因果语言建模头(与输入嵌入绑定的线性层)的 OpenVINO 模型。

此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存)

前进

< >

( 输入_ids: LongTensor 注意_mask: typing.Optional[torch.LongTensor] = 无 过去_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = 无 位置_ids: typing.Optional[torch.LongTensor] = 无 token_type_ids: typing.Optional[torch.LongTensor] = 无 **kwargs )

生成

< >

( inputs: typing.Optional[torch.Tensor] = 无 生成_配置: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = 无 logits_处理器: typing.Optional[transformers.generation.logits_process.LogitsProcessorList] = 无 停止_条件: typing.Optional[transformers.generation.stopping_criteria.StoppingCriteriaList] = 无 前缀_允许_tokens_fn: typing.Optional[typing.Callable[[int, torch.Tensor], typing.List[int]]] = 无 同步_gpus: typing.Optional[bool] = 无 助手_模型: typing.Optional[ForwardRef('PreTrainedModel')] = 无 流式传输器: typing.Optional[ForwardRef('BaseStreamer')] = 无 负数_提示_ids: typing.Optional[torch.Tensor] = 无 负数_提示_attention_mask: typing.Optional[torch.Tensor] = 无 **kwargs )

OVModelForMaskedLM

optimum.intel.OVModelForMaskedLM

< >

( 模型 = 无 配置 = 无 **kwargs )

参数

  • model (openvino.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是模型配置类,包含模型的所有参数。用配置文件初始化不会加载与模型相关的权重,只加载配置。请查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • device (str, 默认为 "CPU") — 模型将优化的设备类型。生成的编译模型将包含特定于此设备的节点。
  • dynamic_shapes (bool, 默认为 True) — 当设置为 True 时,模型的所有维度都将设置为动态。默认为 False 时,模型不会动态重塑。
  • ov_config (Optional[Dict], 默认为 None) — 包含与模型编译相关信息的字典。
  • compile (bool, 默认为 True) — 当设置为 False 时,在加载步骤中禁用模型编译。在模型需要静态重塑、设备修改或启用 FP16 转换的情况下,这可能有助于避免不必要的编译。

OpenVINO 模型,带有 MaskedLMOutput,用于掩码语言建模任务。

此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存)

前进

< >

( 输入_ids: typing.Union[torch.Tensor, numpy.ndarray] 注意_mask: typing.Union[torch.Tensor, numpy.ndarray] token_type_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = 无 **kwargs )

参数

  • input_ids (torch.Tensor) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。什么是输入 ID?
  • attention_mask (torch.Tensor), 可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择范围为 [0, 1]
  • token_type_ids (torch.Tensor, 可选) — 分段标记索引,指示输入的第一个和第二个部分。索引选择范围为 [0, 1]

OVModelForMaskedLM 的前向方法,覆盖了 __call__ 特殊方法。

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

使用 transformers.pipelines 进行掩码语言建模的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.intel import OVModelForMaskedLM

>>> tokenizer = AutoTokenizer.from_pretrained("roberta-base")
>>> model = OVModelForMaskedLM.from_pretrained("roberta-base", export=True)
>>> mask_token = tokenizer.mask_token
>>> pipe = pipeline("fill-mask", model=model, tokenizer=tokenizer)
>>> outputs = pipe("The goal of life is" + mask_token)

OVModelForSeq2SeqLM

optimum.intel.OVModelForSeq2SeqLM

< >

( 编码器: 模型 解码器: 模型 解码器_with_past: 模型 = 无 配置: PretrainedConfig = 无 设备: str = 'CPU' 动态形状: bool = True ov_配置: typing.Optional[typing.Dict[str, str]] = 无 模型_保存_目录: typing.Union[str, pathlib.Path, optimum.intel.openvino.utils.TemporaryDirectory, NoneType] = 无 量化_配置: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict] = 无 **kwargs )

参数

  • encoder (openvino.Model) — 与编码器关联的 OpenVINO Runtime 模型。
  • 解码器 (openvino.Model) — 与解码器关联的 OpenVINO Runtime 模型。
  • 带过去值的解码器 (openvino.Model) — 与带过去键值的解码器关联的 OpenVINO Runtime 模型。
  • 配置 (transformers.PretrainedConfig) — PretrainedConfig 是与模型关联的配置实例。用配置文件初始化不会加载与模型关联的权重,只加载配置。

用于 OpenVINO 推理的带语言建模头的序列到序列模型。

前进

< >

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

参数

  • 输入 ID (torch.LongTensor) — 词汇表中输入序列标记的索引,形状为 (batch_size, encoder_sequence_length)
  • 注意力掩码 (torch.LongTensor) — 用于避免对填充标记索引执行注意力的掩码,形状为 (batch_size, encoder_sequence_length)。掩码值选择在 [0, 1]
  • 解码器输入 ID (torch.LongTensor) — 词汇表中解码器输入序列标记的索引,形状为 (batch_size, decoder_sequence_length)
  • 编码器输出 (torch.FloatTensor) — 编码器 last_hidden_state 的形状为 (batch_size, encoder_sequence_length, hidden_size)
  • 过去键值 (tuple(tuple(torch.FloatTensor), *可选*) — 包含用于加速解码的注意力块的预计算键和值隐藏状态。元组的长度为 config.n_layers,每个元组包含两个形状为 (batch_size, num_heads, decoder_sequence_length, embed_size_per_head) 的张量和两个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的额外张量。

OVModelForSeq2SeqLM 的 forward 方法,覆盖了 __call__ 特殊方法。

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

文本生成示例

>>> from transformers import AutoTokenizer
>>> from optimum.intel import OVModelForSeq2SeqLM

>>> tokenizer = AutoTokenizer.from_pretrained("echarlaix/t5-small-openvino")
>>> model = OVModelForSeq2SeqLM.from_pretrained("echarlaix/t5-small-openvino")
>>> text = "He never went out without a book under his arm, and he often came back with two."
>>> inputs = tokenizer(text, return_tensors="pt")
>>> gen_tokens = model.generate(**inputs)
>>> outputs = tokenizer.batch_decode(gen_tokens)

使用 transformers.pipeline 的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.intel import OVModelForSeq2SeqLM

>>> tokenizer = AutoTokenizer.from_pretrained("echarlaix/t5-small-openvino")
>>> model = OVModelForSeq2SeqLM.from_pretrained("echarlaix/t5-small-openvino")
>>> pipe = pipeline("translation_en_to_fr", model=model, tokenizer=tokenizer)
>>> text = "He never went out without a book under his arm, and he often came back with two."
>>> outputs = pipe(text)

OVModelForQuestionAnswering

class optimum.intel.OVModelForQuestionAnswering

< >

( 模型 = 无 配置 = 无 **kwargs )

参数

  • 模型 (openvino.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • 配置 (transformers.PretrainedConfig) — PretrainedConfig 是模型配置类,包含模型的所有参数。用配置文件初始化不会加载与模型关联的权重,只加载配置。请查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • 设备 (str, 默认为 "CPU") — 模型将为其优化的设备类型。生成的编译模型将包含特定于此设备的节点。
  • 动态形状 (bool, 默认为 True) — 当设置为 True 时,模型的所有维度都将设置为动态。默认情况下,如果模型不需要动态重塑,则应设置为 False
  • OpenVINO 配置 (Optional[Dict], 默认为 None) — 包含模型编译相关信息的字典。
  • 编译 (bool, 默认为 True) — 当设置为 False 时,在加载步骤中禁用模型编译。在模型需要静态重塑、设备修改或启用 FP16 转换的情况下,这对于避免不必要的编译很有用。

带 QuestionAnsweringModelOutput 的 OpenVINO 模型,用于抽取式问答任务。

此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存)

前进

< >

( 输入_ids: typing.Union[torch.Tensor, numpy.ndarray] 注意_mask: typing.Union[torch.Tensor, numpy.ndarray] token_type_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = 无 **kwargs )

参数

  • 输入 ID (torch.Tensor) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。什么是输入 ID?
  • 注意力掩码 (torch.Tensor, 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1]
  • 标记类型 ID (torch.Tensor, 可选) — 分段标记索引,用于指示输入的第一个和第二个部分。索引选择在 [0, 1]

OVModelForQuestionAnswering 的 forward 方法,覆盖了 __call__ 特殊方法。

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

使用 transformers.pipeline 进行问答的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.intel import OVModelForQuestionAnswering

>>> tokenizer = AutoTokenizer.from_pretrained("distilbert-base-cased-distilled-squad")
>>> model = OVModelForQuestionAnswering.from_pretrained("distilbert-base-cased-distilled-squad", export=True)
>>> pipe = pipeline("question-answering", model=model, tokenizer=tokenizer)
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> outputs = pipe(question, text)

OVModelForSequenceClassification

class optimum.intel.OVModelForSequenceClassification

< >

( 模型 = 无 配置 = 无 **kwargs )

参数

  • 模型 (openvino.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • 配置 (transformers.PretrainedConfig) — PretrainedConfig 是模型配置类,包含模型的所有参数。用配置文件初始化不会加载与模型关联的权重,只加载配置。请查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • 设备 (str, 默认为 "CPU") — 模型将为其优化的设备类型。生成的编译模型将包含特定于此设备的节点。
  • 动态形状 (bool, 默认为 True) — 当设置为 True 时,模型的所有维度都将设置为动态。默认情况下,如果模型不需要动态重塑,则应设置为 False
  • OpenVINO 配置 (Optional[Dict], 默认为 None) — 包含模型编译相关信息的字典。
  • 编译 (bool, 默认为 True) — 当设置为 False 时,在加载步骤中禁用模型编译。在模型需要静态重塑、设备修改或启用 FP16 转换的情况下,这对于避免不必要的编译很有用。

带 SequenceClassifierOutput 的 OpenVINO 模型,用于序列分类任务。

此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存)

前进

< >

( 输入_ids: typing.Union[torch.Tensor, numpy.ndarray] 注意_mask: typing.Union[torch.Tensor, numpy.ndarray] token_type_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = 无 **kwargs )

参数

  • 输入 ID (torch.Tensor) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。什么是输入 ID?
  • 注意力掩码 (torch.Tensor, 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1]
  • 标记类型 ID (torch.Tensor, 可选) — 分段标记索引,用于指示输入的第一个和第二个部分。索引选择在 [0, 1]

OVModelForSequenceClassification 的 forward 方法,覆盖了 __call__ 特殊方法。

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

使用 transformers.pipeline 进行序列分类的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.intel import OVModelForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased-finetuned-sst-2-english")
>>> model = OVModelForSequenceClassification.from_pretrained("distilbert-base-uncased-finetuned-sst-2-english", export=True)
>>> pipe = pipeline("text-classification", model=model, tokenizer=tokenizer)
>>> outputs = pipe("Hello, my dog is cute")

OVModelForTokenClassification

class optimum.intel.OVModelForTokenClassification

< >

( 模型 = 无 配置 = 无 **kwargs )

参数

  • 模型 (openvino.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • 配置 (transformers.PretrainedConfig) — PretrainedConfig 是模型配置类,包含模型的所有参数。用配置文件初始化不会加载与模型关联的权重,只加载配置。请查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • 设备 (str, 默认为 "CPU") — 模型将为其优化的设备类型。生成的编译模型将包含特定于此设备的节点。
  • 动态形状 (bool, 默认为 True) — 当设置为 True 时,模型的所有维度都将设置为动态。默认情况下,如果模型不需要动态重塑,则应设置为 False
  • OpenVINO 配置 (Optional[Dict], 默认为 None) — 包含模型编译相关信息的字典。
  • 编译 (bool, 默认为 True) — 当设置为 False 时,在加载步骤中禁用模型编译。在模型需要静态重塑、设备修改或启用 FP16 转换的情况下,这对于避免不必要的编译很有用。

带 TokenClassifierOutput 的 OpenVINO 模型,用于标记分类任务。

此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存)

前进

< >

( 输入_ids: typing.Union[torch.Tensor, numpy.ndarray] 注意_mask: typing.Union[torch.Tensor, numpy.ndarray] token_type_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = 无 **kwargs )

参数

  • 输入 ID (torch.Tensor) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。什么是输入 ID?
  • 注意力掩码 (torch.Tensor, 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1]
  • 标记类型 ID (torch.Tensor, 可选) — 分段标记索引,用于指示输入的第一个和第二个部分。索引选择在 [0, 1]

OVModelForTokenClassification 的 forward 方法,覆盖了 __call__ 特殊方法。

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

使用 transformers.pipelines 进行标记分类的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.intel import OVModelForTokenClassification

>>> tokenizer = AutoTokenizer.from_pretrained("dslim/bert-base-NER")
>>> model = OVModelForTokenClassification.from_pretrained("dslim/bert-base-NER", export=True)
>>> pipe = pipeline("token-classification", model=model, tokenizer=tokenizer)
>>> outputs = pipe("My Name is Peter and I live in New York.")

音频

以下是可用于以下音频任务的类。

OVModelForAudioClassification

class optimum.intel.OVModelForAudioClassification

< >

( 模型 = 无 配置 = 无 **kwargs )

参数

  • 模型 (openvino.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • 配置 (transformers.PretrainedConfig) — PretrainedConfig 是模型配置类,包含模型的所有参数。用配置文件初始化不会加载与模型关联的权重,只加载配置。请查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • 设备 (str, 默认为 "CPU") — 模型将为其优化的设备类型。生成的编译模型将包含特定于此设备的节点。
  • 动态形状 (bool, 默认为 True) — 当设置为 True 时,模型的所有维度都将设置为动态。默认情况下,如果模型不需要动态重塑,则应设置为 False
  • OpenVINO 配置 (Optional[Dict], 默认为 None) — 包含模型编译相关信息的字典。
  • 编译 (bool, 默认为 True) — 当设置为 False 时,在加载步骤中禁用模型编译。在模型需要静态重塑、设备修改或启用 FP16 转换的情况下,这对于避免不必要的编译很有用。

带 SequenceClassifierOutput 的 OpenVINO 模型,用于音频分类任务。

此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存)

前进

< >

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

参数

  • 输入 ID (torch.Tensor) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。什么是输入 ID?
  • 注意力掩码 (torch.Tensor, 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1]
  • 标记类型 ID (torch.Tensor, 可选) — 分段标记索引,用于指示输入的第一个和第二个部分。索引选择在 [0, 1]

OVModelForAudioClassification 的 forward 方法,覆盖了 __call__ 特殊方法。

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

使用 transformers.pipelines 进行音频分类的示例

>>> from datasets import load_dataset
>>> from transformers import AutoFeatureExtractor, pipeline
>>> from optimum.intel import OVModelForAudioClassification

>>> preprocessor = AutoFeatureExtractor.from_pretrained("superb/hubert-base-superb-er")
>>> model = OVModelForAudioClassification.from_pretrained("superb/hubert-base-superb-er", export=True)
>>> pipe = pipeline("audio-classification", model=model, feature_extractor=preprocessor)
>>> dataset = load_dataset("superb", "ks", split="test")
>>> audio_file = dataset[3]["audio"]["array"]
>>> outputs = pipe(audio_file)

OVModelForAudioFrameClassification

class optimum.intel.OVModelForAudioFrameClassification

< >

( model: Model config: PretrainedConfig = None **kwargs )

参数

  • model (openvino.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。请查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • device (str, 默认为 "CPU") — 模型将为其优化的设备类型。生成的编译模型将包含特定于该设备的节点。
  • dynamic_shapes (bool, 默认为 True) — 当设置为 True 时,模型的所有维度都将设置为动态。默认情况下,如果模型不需要动态重塑,应将其设置为 False
  • ov_config (Optional[Dict], 默认为 None) — 包含模型编译相关信息的字典。
  • compile (bool, 默认为 True) — 当设置为 False 时,在加载步骤中禁用模型编译。在模型需要静态重塑、设备修改或启用 FP16 转换的情况下,这有助于避免不必要的编译。

OpenVINO 模型,顶部带有帧分类头,用于像说话人日志化这样的任务。

此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存)

用于 OpenVINO 的音频帧分类模型。

前进

< >

( input_values: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None **kwargs )

参数

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

OVModelForAudioFrameClassification 的 forward 方法,重写了 __call__ 特殊方法。

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

音频帧分类示例

>>> from transformers import AutoFeatureExtractor
>>> from optimum.intel import OVModelForAudioFrameClassification
>>> 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("anton-l/wav2vec2-base-superb-sd")
>>> model =  OVModelForAudioFrameClassification.from_pretrained("anton-l/wav2vec2-base-superb-sd", export=True)

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

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

OVModelForCTC

class optimum.intel.OVModelForCTC

< >

( model: Model config: PretrainedConfig = None **kwargs )

参数

  • model (openvino.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。请查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • device (str, 默认为 "CPU") — 模型将为其优化的设备类型。生成的编译模型将包含特定于该设备的节点。
  • dynamic_shapes (bool, 默认为 True) — 当设置为 True 时,模型的所有维度都将设置为动态。默认情况下,如果模型不需要动态重塑,应将其设置为 False
  • ov_config (Optional[Dict], 默认为 None) — 包含模型编译相关信息的字典。
  • compile (bool, 默认为 True) — 当设置为 False 时,在加载步骤中禁用模型编译。在模型需要静态重塑、设备修改或启用 FP16 转换的情况下,这有助于避免不必要的编译。

带有顶部语言建模头用于连接主义时间分类(CTC)的 Onnx 模型。

此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存)

用于 OpenVINO 的 CTC 模型。

前进

< >

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

参数

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

OVModelForCTC 的 forward 方法,重写了 __call__ 特殊方法。

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

CTC 示例

>>> from transformers import AutoFeatureExtractor
>>> from optimum.intel import OVModelForCTC
>>> from datasets import load_dataset

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

>>> processor = AutoFeatureExtractor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = OVModelForCTC.from_pretrained("facebook/hubert-large-ls960-ft", export=True)

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="np")
>>> logits = model(**inputs).logits
>>> predicted_ids = np.argmax(logits, axis=-1)

>>> transcription = processor.batch_decode(predicted_ids)

OVModelForAudioXVector

class optimum.intel.OVModelForAudioXVector

< >

( model: Model config: PretrainedConfig = None **kwargs )

参数

  • model (openvino.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。请查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • device (str, 默认为 "CPU") — 模型将为其优化的设备类型。生成的编译模型将包含特定于该设备的节点。
  • dynamic_shapes (bool, 默认为 True) — 当设置为 True 时,模型的所有维度都将设置为动态。默认情况下,如果模型不需要动态重塑,应将其设置为 False
  • ov_config (Optional[Dict], 默认为 None) — 包含模型编译相关信息的字典。
  • compile (bool, 默认为 True) — 当设置为 False 时,在加载步骤中禁用模型编译。在模型需要静态重塑、设备修改或启用 FP16 转换的情况下,这有助于避免不必要的编译。

带有 XVector 特征提取头用于说话人验证等任务的 Onnx 模型。

此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存)

用于 OpenVINO 的 Audio XVector 模型。

前进

< >

( input_values: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None **kwargs )

参数

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

OVModelForAudioXVector 的 forward 方法,重写了 __call__ 特殊方法。

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

Audio XVector 示例

>>> from transformers import AutoFeatureExtractor
>>> from optimum.intel import OVModelForAudioXVector
>>> 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("anton-l/wav2vec2-base-superb-sv")
>>> model = OVModelForAudioXVector.from_pretrained("anton-l/wav2vec2-base-superb-sv", export=True)

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

OVModelForSpeechSeq2Seq

class optimum.intel.OVModelForSpeechSeq2Seq

< >

( 编码器: 模型 解码器: 模型 解码器_with_past: 模型 = 无 配置: PretrainedConfig = 无 设备: str = 'CPU' 动态形状: bool = True ov_配置: typing.Optional[typing.Dict[str, str]] = 无 模型_保存_目录: typing.Union[str, pathlib.Path, optimum.intel.openvino.utils.TemporaryDirectory, NoneType] = 无 量化_配置: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict] = 无 **kwargs )

参数

  • encoder (openvino.Model) — 与编码器关联的 OpenVINO Runtime 模型。
  • decoder (openvino.Model) — 与解码器关联的 OpenVINO Runtime 模型。
  • decoder_with_past (openvino.Model) — 与带过去键值的解码器关联的 OpenVINO Runtime 模型。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是与模型关联的配置实例。使用配置文件初始化不会加载与模型相关的权重,只加载配置。

带有语言建模头的语音序列到序列模型,用于 OpenVINO 推理。该类正式支持 whisper、speech_to_text。

前进

< >

( input_features: 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 cache_position: typing.Optional[torch.LongTensor] = None **kwargs )

参数

  • input_features (torch.FloatTensor) — 从原始语音波形中提取的 Mel 特征。(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), *可选*, 默认为 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) 的张量。

OVModelForSpeechSeq2Seq 的 forward 方法,重写了 __call__ 特殊方法。

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

文本生成示例

>>> from transformers import AutoProcessor
>>> from optimum.intel import OVModelForSpeechSeq2Seq
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny")
>>> model = OVModelForSpeechSeq2Seq.from_pretrained("openai/whisper-tiny")

>>> 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.intel import OVModelForSpeechSeq2Seq
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny")
>>> model = OVModelForSpeechSeq2Seq.from_pretrained("openai/whisper-tiny")
>>> 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"])

计算机视觉

以下类可用于以下计算机视觉任务。

OVModelForImageClassification

class optimum.intel.OVModelForImageClassification

< >

( 模型 = 无 配置 = 无 **kwargs )

参数

  • model (openvino.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。请查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • device (str, 默认为 "CPU") — 模型将为其优化的设备类型。生成的编译模型将包含特定于该设备的节点。
  • dynamic_shapes (bool, 默认为 True) — 当设置为 True 时,模型的所有维度都将设置为动态。默认情况下,如果模型不需要动态重塑,应将其设置为 False
  • ov_config (Optional[Dict], 默认为 None) — 包含模型编译相关信息的字典。
  • compile (bool, 默认为 True) — 当设置为 False 时,在加载步骤中禁用模型编译。在模型需要静态重塑、设备修改或启用 FP16 转换的情况下,这有助于避免不必要的编译。

OpenVINO 模型,带有一个 ImageClassifierOutput 用于图像分类任务。

此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存)

前进

< >

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

参数

  • pixel_values (torch.Tensor) — 与当前批次中图像对应的像素值。像素值可以通过使用 AutoFeatureExtractor 从编码图像中获得。

OVModelForImageClassification 的 forward 方法,重写了 __call__ 特殊方法。

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

使用 transformers.pipelines 进行图像分类的示例

>>> from transformers import AutoFeatureExtractor, pipeline
>>> from optimum.intel import OVModelForImageClassification

>>> preprocessor = AutoFeatureExtractor.from_pretrained("google/vit-base-patch16-224")
>>> model = OVModelForImageClassification.from_pretrained("google/vit-base-patch16-224", export=True)
>>> model.reshape(batch_size=1, sequence_length=3, height=224, width=224)
>>> pipe = pipeline("image-classification", model=model, feature_extractor=preprocessor)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> outputs = pipe(url)
此类也可与 timm

HuggingFaceHub 上托管的模型一起使用。示例:

>>> from transformers import pipeline
>>> from optimum.intel.openvino.modeling_timm import TimmImageProcessor
>>> from optimum.intel import OVModelForImageClassification

>>> model_id = "timm/vit_tiny_patch16_224.augreg_in21k"
>>> preprocessor = TimmImageProcessor.from_pretrained(model_id)
>>> model = OVModelForImageClassification.from_pretrained(model_id, export=True)
>>> pipe = pipeline("image-classification", model=model, feature_extractor=preprocessor)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> outputs = pipe(url)

多模态

以下类可用于以下多模态任务。

OVModelForVision2Seq

class optimum.intel.OVModelForVision2Seq

< >

( encoder: Model decoder: Model decoder_with_past: Model = None config: PretrainedConfig = None **kwargs )

参数

  • encoder (openvino.Model) — 与编码器关联的 OpenVINO Runtime 模型。
  • decoder (openvino.Model) — 与解码器关联的 OpenVINO Runtime 模型。
  • decoder_with_past (openvino.Model) — 与带过去键值的解码器关联的 OpenVINO Runtime 模型。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是与模型关联的配置实例。使用配置文件初始化不会加载与模型相关的权重,只加载配置。

带有语言建模头的 VisionEncoderDecoder 序列到序列模型,用于 OpenVINO 推理。

前进

< >

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

参数

  • pixel_values (torch.FloatTensor) — 从图像中提取的特征。此张量应为形状 (batch_size, num_channels, height, width)
  • 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) 的张量和两个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

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

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

文本生成示例

>>> from transformers import AutoProcessor, AutoTokenizer
>>> from optimum.intel import OVModelForVision2Seq
>>> from PIL import Image
>>> import requests


>>> processor = AutoProcessor.from_pretrained("microsoft/trocr-small-handwritten")
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/trocr-small-handwritten")
>>> model = OVModelForVision2Seq.from_pretrained("microsoft/trocr-small-handwritten", export=True)

>>> url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.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 AutoProcessor, AutoTokenizer, pipeline
>>> from optimum.intel import OVModelForVision2Seq
>>> from PIL import Image
>>> import requests


>>> processor = AutoProcessor.from_pretrained("microsoft/trocr-small-handwritten")
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/trocr-small-handwritten")
>>> model = OVModelForVision2Seq.from_pretrained("microsoft/trocr-small-handwritten", export=True)

>>> url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.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)

OVModelForPix2Struct

class optimum.intel.OVModelForPix2Struct

< >

( 编码器: 模型 解码器: 模型 解码器_with_past: 模型 = 无 配置: PretrainedConfig = 无 设备: str = 'CPU' 动态形状: bool = True ov_配置: typing.Optional[typing.Dict[str, str]] = 无 模型_保存_目录: typing.Union[str, pathlib.Path, optimum.intel.openvino.utils.TemporaryDirectory, NoneType] = 无 量化_配置: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict] = 无 **kwargs )

参数

  • encoder (openvino.Model) — 与编码器关联的 OpenVINO Runtime 模型。
  • decoder (openvino.Model) — 与解码器关联的 OpenVINO Runtime 模型。
  • decoder_with_past (openvino.Model) — 与带过去键值的解码器关联的 OpenVINO Runtime 模型。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是与模型关联的配置实例。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。

用于 OpenVINO 推理的带语言建模头的 Pix2Struct 模型。

前进

< >

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

参数

  • flattened_patches (形状为 (batch_size, seq_length, hidden_size)torch.FloatTensor) — 展平的像素块。hidden_size 由以下公式获得:hidden_size = num_channels * patch_size * patch_size 像素块的展平过程由 Pix2StructProcessor 完成。
  • attention_mask (形状为 (batch_size, sequence_length)torch.FloatTensor, 可选) — 避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1]
  • decoder_input_ids (形状为 (batch_size, target_sequence_length)torch.LongTensor, 可选) — 解码器输入序列标记在词汇表中的索引。Pix2StructText 使用 pad_token_id 作为 decoder_input_ids 生成的起始标记。如果使用 past_key_values,可以选择仅输入最后的 decoder_input_ids(参见 past_key_values)。
  • decoder_attention_mask (形状为 (batch_size, target_sequence_length)torch.BoolTensor, 可选) — 默认行为:生成一个忽略 decoder_input_ids 中填充标记的张量。默认情况下也将使用因果掩码。
  • encoder_outputs (tuple(tuple(torch.FloatTensor), 可选) — 元组包含(last_hidden_state, 可选: hidden_states, 可选: attentions)。形状为 (batch_size, sequence_length, hidden_size)last_hidden_state 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • 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) 的张量和两个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

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

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

pix2struct 示例

>>> from transformers import AutoProcessor
>>> from optimum.intel import OVModelForPix2Struct
>>> from PIL import Image
>>> import requests

>>> processor = AutoProcessor.from_pretrained("google/pix2struct-ai2d-base")
>>> model = OVModelForPix2Struct.from_pretrained("google/pix2struct-ai2d-base", export=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)

自定义任务

OVModelForCustomTasks

class optimum.intel.OVModelForCustomTasks

< >

( model: Model config: PretrainedConfig = None **kwargs )

参数

  • model (openvino.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • device (str, 默认为 "CPU") — 将为模型优化的设备类型。生成的编译模型将包含特定于此设备的节点。
  • dynamic_shapes (bool, 默认为 True) — 当设置为 True 时,模型的所有维度都将设置为动态。默认情况下,如果模型不需要动态重塑,则应将其设置为 False
  • ov_config (Optional[Dict], 默认为 None) — 包含与模型编译相关信息的字典。
  • compile (bool, 默认为 True) — 当设置为 False 时,禁用加载步骤中的模型编译。在模型需要静态重塑、设备修改或启用 FP16 转换的情况下,这可能有助于避免不必要的编译。

用于自定义任务的 OpenVINO 模型。它可以用于利用任何单文件 OpenVINO 模型的推理加速,该模型可能使用自定义输入和输出。

此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存)

前进

< >

( **kwargs )

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

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

自定义任务示例(例如,带池化头的 Sentence Transformer)

>>> from transformers import AutoTokenizer
>>> from optimum.intel import OVModelForCustomTasks

>>> tokenizer = AutoTokenizer.from_pretrained("IlyasMoutawwakil/sbert-all-MiniLM-L6-v2-with-pooler")
>>> model = OVModelForCustomTasks.from_pretrained("IlyasMoutawwakil/sbert-all-MiniLM-L6-v2-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

OVModelForFeatureExtraction

class optimum.intel.OVModelForFeatureExtraction

< >

( 模型 = 无 配置 = 无 **kwargs )

参数

  • model (openvino.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • device (str, 默认为 "CPU") — 将为模型优化的设备类型。生成的编译模型将包含特定于此设备的节点。
  • dynamic_shapes (bool, 默认为 True) — 当设置为 True 时,模型的所有维度都将设置为动态。默认情况下,如果模型不需要动态重塑,则应将其设置为 False
  • ov_config (Optional[Dict], 默认为 None) — 包含与模型编译相关信息的字典。
  • compile (bool, 默认为 True) — 当设置为 False 时,禁用加载步骤中的模型编译。在模型需要静态重塑、设备修改或启用 FP16 转换的情况下,这可能有助于避免不必要的编译。

用于特征提取任务的 OpenVINO 模型,带有一个 BaseModelOutput。

此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存)

前进

< >

( 输入_ids: typing.Union[torch.Tensor, numpy.ndarray] 注意_mask: typing.Union[torch.Tensor, numpy.ndarray] token_type_ids: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = 无 **kwargs )

参数

  • input_ids (torch.Tensor) — 词汇表中输入序列标记的索引。索引可以通过 AutoTokenizer 获得。什么是输入 ID?
  • attention_mask (torch.Tensor), 可选) — 避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1]
  • token_type_ids (torch.Tensor, 可选) — 分段标记索引,用于指示输入的第一个和第二个部分。索引选择在 [0, 1]

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

虽然前向传播的配方需要在此函数中定义,但在此之后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

使用 transformers.pipelines 进行特征提取的示例

>>> from transformers import AutoTokenizer, pipeline
>>> from optimum.intel import OVModelForFeatureExtraction

>>> tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
>>> model = OVModelForFeatureExtraction.from_pretrained("sentence-transformers/all-MiniLM-L6-v2", export=True)
>>> pipe = pipeline("feature-extraction", model=model, tokenizer=tokenizer)
>>> outputs = pipe("My Name is Peter and I live in New York.")

文本到图像

OVStableDiffusionPipeline

class optimum.intel.OVStableDiffusionPipeline

< >

( scheduler: SchedulerMixin unet: typing.Optional[openvino._ov_api.Model] = None vae_decoder: typing.Optional[openvino._ov_api.Model] = None vae_encoder: typing.Optional[openvino._ov_api.Model] = None text_encoder: typing.Optional[openvino._ov_api.Model] = None text_encoder_2: typing.Optional[openvino._ov_api.Model] = None text_encoder_3: typing.Optional[openvino._ov_api.Model] = None transformer: typing.Optional[openvino._ov_api.Model] = None tokenizer: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None tokenizer_2: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None tokenizer_3: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None feature_extractor: typing.Optional[transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None device: str = 'CPU' compile: bool = True compile_only: bool = False dynamic_shapes: bool = True ov_config: typing.Optional[typing.Dict[str, str]] = None model_save_dir: typing.Union[str, pathlib.Path, optimum.intel.openvino.utils.TemporaryDirectory, NoneType] = None quantization_config: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict, NoneType] = None **kwargs )

OpenVINO 支持的 Stable Diffusion 管线,对应于 diffusers.StableDiffusionPipeline

前进

< >

( *args **kwargs )

OVStableDiffusionXLPipeline

class optimum.intel.OVStableDiffusionXLPipeline

< >

( scheduler: SchedulerMixin unet: typing.Optional[openvino._ov_api.Model] = None vae_decoder: typing.Optional[openvino._ov_api.Model] = None vae_encoder: typing.Optional[openvino._ov_api.Model] = None text_encoder: typing.Optional[openvino._ov_api.Model] = None text_encoder_2: typing.Optional[openvino._ov_api.Model] = None text_encoder_3: typing.Optional[openvino._ov_api.Model] = None transformer: typing.Optional[openvino._ov_api.Model] = None tokenizer: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None tokenizer_2: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None tokenizer_3: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None feature_extractor: typing.Optional[transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None device: str = 'CPU' compile: bool = True compile_only: bool = False dynamic_shapes: bool = True ov_config: typing.Optional[typing.Dict[str, str]] = None model_save_dir: typing.Union[str, pathlib.Path, optimum.intel.openvino.utils.TemporaryDirectory, NoneType] = None quantization_config: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict, NoneType] = None **kwargs )

OpenVINO 支持的 Stable Diffusion XL 管线,对应于 diffusers.StableDiffusionXLPipeline

前进

< >

( *args **kwargs )

OVLatentConsistencyModelPipeline

class optimum.intel.OVLatentConsistencyModelPipeline

< >

( scheduler: SchedulerMixin unet: typing.Optional[openvino._ov_api.Model] = None vae_decoder: typing.Optional[openvino._ov_api.Model] = None vae_encoder: typing.Optional[openvino._ov_api.Model] = None text_encoder: typing.Optional[openvino._ov_api.Model] = None text_encoder_2: typing.Optional[openvino._ov_api.Model] = None text_encoder_3: typing.Optional[openvino._ov_api.Model] = None transformer: typing.Optional[openvino._ov_api.Model] = None tokenizer: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None tokenizer_2: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None tokenizer_3: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None feature_extractor: typing.Optional[transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None device: str = 'CPU' compile: bool = True compile_only: bool = False dynamic_shapes: bool = True ov_config: typing.Optional[typing.Dict[str, str]] = None model_save_dir: typing.Union[str, pathlib.Path, optimum.intel.openvino.utils.TemporaryDirectory, NoneType] = None quantization_config: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict, NoneType] = None **kwargs )

OpenVINO 支持的 Latent Consistency Model 管线,对应于 diffusers.LatentConsistencyModelPipeline

前进

< >

( *args **kwargs )

图像到图像

OVStableDiffusionImg2ImgPipeline

class optimum.intel.OVStableDiffusionImg2ImgPipeline

< >

( scheduler: SchedulerMixin unet: typing.Optional[openvino._ov_api.Model] = None vae_decoder: typing.Optional[openvino._ov_api.Model] = None vae_encoder: typing.Optional[openvino._ov_api.Model] = None text_encoder: typing.Optional[openvino._ov_api.Model] = None text_encoder_2: typing.Optional[openvino._ov_api.Model] = None text_encoder_3: typing.Optional[openvino._ov_api.Model] = None transformer: typing.Optional[openvino._ov_api.Model] = None tokenizer: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None tokenizer_2: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None tokenizer_3: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None feature_extractor: typing.Optional[transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None device: str = 'CPU' compile: bool = True compile_only: bool = False dynamic_shapes: bool = True ov_config: typing.Optional[typing.Dict[str, str]] = None model_save_dir: typing.Union[str, pathlib.Path, optimum.intel.openvino.utils.TemporaryDirectory, NoneType] = None quantization_config: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict, NoneType] = None **kwargs )

OpenVINO 支持的稳定扩散管线,对应 diffusers.StableDiffusionImg2ImgPipeline

前进

< >

( *args **kwargs )

OVStableDiffusionXLImg2ImgPipeline

class optimum.intel.OVStableDiffusionXLImg2ImgPipeline

< >

( scheduler: SchedulerMixin unet: typing.Optional[openvino._ov_api.Model] = None vae_decoder: typing.Optional[openvino._ov_api.Model] = None vae_encoder: typing.Optional[openvino._ov_api.Model] = None text_encoder: typing.Optional[openvino._ov_api.Model] = None text_encoder_2: typing.Optional[openvino._ov_api.Model] = None text_encoder_3: typing.Optional[openvino._ov_api.Model] = None transformer: typing.Optional[openvino._ov_api.Model] = None tokenizer: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None tokenizer_2: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None tokenizer_3: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None feature_extractor: typing.Optional[transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None device: str = 'CPU' compile: bool = True compile_only: bool = False dynamic_shapes: bool = True ov_config: typing.Optional[typing.Dict[str, str]] = None model_save_dir: typing.Union[str, pathlib.Path, optimum.intel.openvino.utils.TemporaryDirectory, NoneType] = None quantization_config: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict, NoneType] = None **kwargs )

OpenVINO 支持的稳定扩散管线,对应 diffusers.StableDiffusionXLImg2ImgPipeline

前进

< >

( *args **kwargs )

Inpainting

OVStableDiffusionInpaintPipeline

class optimum.intel.OVStableDiffusionInpaintPipeline

< >

( scheduler: SchedulerMixin unet: typing.Optional[openvino._ov_api.Model] = None vae_decoder: typing.Optional[openvino._ov_api.Model] = None vae_encoder: typing.Optional[openvino._ov_api.Model] = None text_encoder: typing.Optional[openvino._ov_api.Model] = None text_encoder_2: typing.Optional[openvino._ov_api.Model] = None text_encoder_3: typing.Optional[openvino._ov_api.Model] = None transformer: typing.Optional[openvino._ov_api.Model] = None tokenizer: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None tokenizer_2: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None tokenizer_3: typing.Optional[transformers.models.clip.tokenization_clip.CLIPTokenizer] = None feature_extractor: typing.Optional[transformers.models.clip.feature_extraction_clip.CLIPFeatureExtractor] = None force_zeros_for_empty_prompt: bool = True requires_aesthetics_score: bool = False add_watermarker: typing.Optional[bool] = None device: str = 'CPU' compile: bool = True compile_only: bool = False dynamic_shapes: bool = True ov_config: typing.Optional[typing.Dict[str, str]] = None model_save_dir: typing.Union[str, pathlib.Path, optimum.intel.openvino.utils.TemporaryDirectory, NoneType] = None quantization_config: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict, NoneType] = None **kwargs )

OpenVINO 支持的稳定扩散管线,对应 diffusers.StableDiffusionInpaintPipeline

前进

< >

( *args **kwargs )

< > 在 GitHub 上更新