Hugging Face 的标志

Optimum 文档

模型

您正在查看 main 版本，它需要从源代码安装。如果您想要常规 pip 安装，请查看最新的稳定版本 (v1.24.0)。
Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

模型

通用模型类

class optimum.intel.openvino.modeling_base.OVBaseModel

< >

( model: Model config: PretrainedConfig = None device: str = 'CPU' 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 )

基础 OVModel 类。

from_pretrained

< >

( model_id: typing.Union[str, pathlib.Path] export: bool = False force_download: bool = False use_auth_token: typing.Union[str, bool, NoneType] = None token: typing.Union[str, bool, NoneType] = None cache_dir: str = '/root/.cache/huggingface/hub' subfolder: str = '' config: typing.Optional[transformers.configuration_utils.PretrainedConfig] = None local_files_only: bool = False trust_remote_code: bool = False revision: 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 允许的任何标识符。

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

reshape

< >

( batch_size: int sequence_length: int height: int = None width: int = None )

参数

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

在模型的层上传播给定的输入形状，固定模型的输入形状。

自然语言处理

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

OVModelForCausalLM

class optimum.intel.OVModelForCausalLM

< >

( model: Model config: PretrainedConfig = None device: str = 'CPU' 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 )

参数

  • model (openvino.runtime.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。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存）

forward

 < >

( input_ids: LongTensor attention_mask: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None position_ids: typing.Optional[torch.LongTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None **kwargs )

generate

 < >

( inputs: typing.Optional[torch.Tensor] = None generation_config: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None logits_processor: typing.Optional[transformers.generation.logits_process.LogitsProcessorList] = None stopping_criteria: typing.Optional[transformers.generation.stopping_criteria.StoppingCriteriaList] = None prefix_allowed_tokens_fn: typing.Optional[typing.Callable[[int, torch.Tensor], typing.List[int]]] = None synced_gpus: typing.Optional[bool] = None assistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = None streamer: typing.Optional[ForwardRef('BaseStreamer')] = None negative_prompt_ids: typing.Optional[torch.Tensor] = None negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None **kwargs )

OVModelForMaskedLM

class optimum.intel.OVModelForMaskedLM

 < >

( model = None config = None **kwargs )

参数

  • model (openvino.runtime.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 转换的情况下，这对于避免不必要的编译非常有用。

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

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

forward

 < >

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

参数

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

OVModelForMaskedLM forward 方法，覆盖了 __call__ 特殊方法。

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

class optimum.intel.OVModelForSeq2SeqLM

 < >

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

参数

  • encoder (openvino.runtime.Model) — 与编码器关联的 OpenVINO Runtime 模型。
  • decoder (openvino.runtime.Model) — 与解码器关联的 OpenVINO Runtime 模型。
  • decoder_with_past (openvino.runtime.Model) — 与具有 past 键值的解码器关联的 OpenVINO Runtime 模型。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是与模型关联的配置的一个实例。使用配置文件初始化不会加载与模型关联的权重，而只会加载配置。

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

forward

< >

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

参数

  • input_ids (torch.LongTensor) — 词汇表中输入序列 tokens 的索引，形状为 (batch_size, encoder_sequence_length)。
  • attention_mask (torch.LongTensor) — 用于避免对 padding token 索引执行 attention 的 Mask，形状为 (batch_size, encoder_sequence_length)。Mask 值在 [0, 1] 中选择。
  • decoder_input_ids (torch.LongTensor) — 词汇表中解码器输入序列 tokens 的索引，形状为 (batch_size, decoder_sequence_length)。
  • encoder_outputs (torch.FloatTensor) — 编码器的 last_hidden_state，形状为 (batch_size, encoder_sequence_length, hidden_size)。
  • past_key_values (tuple(tuple(torch.FloatTensor), *optional*) — 包含用于加速解码的 attention 块的预计算 key 和 value 隐藏状态。该 tuple 的长度为 config.n_layers，其中每个 tuple 具有 2 个形状为 (batch_size, num_heads, decoder_sequence_length, embed_size_per_head) 的 tensors 和 2 个额外的形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的 tensors。

The OVModelForSeq2SeqLM forward 方法覆盖了 __call__ 特殊方法。

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

< >

( model = None config = None **kwargs )

参数

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

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

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

forward

< >

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

参数

  • input_ids (torch.Tensor) — 词汇表中输入序列 tokens 的索引。可以使用 AutoTokenizer 获取索引。什么是输入 IDs？
  • attention_mask (torch.Tensor), optional) — 用于避免对 padding token 索引执行 attention 的 Mask。Mask 值在 [0, 1] 中选择：
  • token_type_ids (torch.Tensor, optional) — 用于指示输入的第一部分和第二部分的 Segment token 索引。索引在 [0, 1] 中选择：

The OVModelForQuestionAnswering forward 方法覆盖了 __call__ 特殊方法。

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

< >

( model = None config = None **kwargs )

参数

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

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

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

forward

< >

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

参数

  • input_ids (torch.Tensor) — 词汇表中输入序列 tokens 的索引。 索引可以使用 AutoTokenizer 获取。 什么是输入 IDs？
  • attention_mask (torch.Tensor), optional) — 用于避免在 padding token 索引上执行 attention 的掩码。 在 [0, 1] 中选择的掩码值：
  • token_type_ids (torch.Tensor, optional) — 分段 token 索引，用于指示输入的第一个和第二个部分。 索引在 [0, 1] 中选择：

OVModelForSequenceClassification forward 方法，覆盖了 __call__ 特殊方法。

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

< >

( model = None config = None **kwargs )

参数

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

用于 token 分类任务的 OpenVINO 模型，带有 TokenClassifierOutput。

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

forward

< >

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

参数

  • input_ids (torch.Tensor) — 词汇表中输入序列 tokens 的索引。 索引可以使用 AutoTokenizer 获取。 什么是输入 IDs？
  • attention_mask (torch.Tensor), optional) — 用于避免在 padding token 索引上执行 attention 的掩码。 在 [0, 1] 中选择的掩码值：
  • token_type_ids (torch.Tensor, optional) — 分段 token 索引，用于指示输入的第一个和第二个部分。 索引在 [0, 1] 中选择：

OVModelForTokenClassification forward 方法，覆盖了 __call__ 特殊方法。

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

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

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

< >

( model = None config = None **kwargs )

参数

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

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

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

forward

< >

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

参数

  • input_ids (torch.Tensor) — 词汇表中输入序列 tokens 的索引。可以使用 AutoTokenizer 获取索引。什么是输入 IDs？
  • attention_mask (torch.Tensor), 可选) — 用于避免在 padding token 索引上执行 attention 的掩码。在 [0, 1] 中选择掩码值：
  • token_type_ids (torch.Tensor, 可选) — 分段 token 索引，用于指示输入的第一部分和第二部分。在 [0, 1] 中选择索引：

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

虽然 forward 传递的配方需要在该函数中定义，但之后应该调用 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.runtime.Model) — 是用于运行 OpenVINO Runtime 推理的主类。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • device (str, defaults to "CPU") — 模型将为其优化的设备类型。生成的编译模型将包含特定于此设备的节点。
  • dynamic_shapes (bool, defaults to True) — 当设置为 True 时，模型的所有维度都将设置为动态。应设置为 False 以使模型默认情况下不被动态重塑。
  • ov_config (Optional[Dict], defaults to None) — 包含与模型编译相关信息的字典。
  • compile (bool, defaults to True) — 当设置为 False 时，禁用加载步骤中的模型编译。在需要静态重塑模型、修改设备或启用 FP16 转换的情况下，这对于避免不必要的编译非常有用。

OpenVINO 模型，顶部带有用于诸如说话人分离等任务的帧分类头。

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

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

forward

< >

( 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__ 特殊方法。

虽然 forward 传递的配方需要在该函数中定义，但之后应该调用 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.runtime.Model) — 是用于运行 OpenVINO Runtime 推理的主类。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 ~intel.openvino.modeling.OVBaseModel.from_pretrained 方法以加载模型权重。
  • device (str, defaults to "CPU") — 模型将为其优化的设备类型。生成的编译模型将包含特定于此设备的节点。
  • dynamic_shapes (bool, defaults to True) — 当设置为 True 时，模型的所有维度都将设置为动态。应设置为 False 以使模型默认情况下不被动态重塑。
  • ov_config (Optional[Dict], defaults to None) — 包含与模型编译相关信息的字典。
  • compile (bool, defaults to True) — 当设置为 False 时，禁用加载步骤中的模型编译。在需要静态重塑模型、修改设备或启用 FP16 转换的情况下，这对于避免不必要的编译非常有用。

Onnx 模型，顶部带有用于 Connectionist Temporal Classification (CTC) 的语言建模头。

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

用于 OpenVINO 的 CTC 模型。

forward

< >

( 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__ 特殊方法。

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

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

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

用于 OpenVINO 的 Audio XVector 模型。

forward

< >

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

参数

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

OVModelForAudioXVector 的 forward 方法，覆盖了 __call__ 特殊方法。

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

< >

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

参数

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

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

forward

< >

( 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) — 形状为 (batch_size, encoder_sequence_length, hidden_size) 的编码器 last_hidden_state。
  • past_key_values (tuple(tuple(torch.FloatTensor), *optional*, defaults to None) — 包含用于加速解码的注意力块的预计算键和值隐藏状态。元组的长度为 config.n_layers，每个元组都有 2 个形状为 (batch_size, num_heads, decoder_sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

OVModelForSpeechSeq2Seq 的 forward 方法，覆盖了 __call__ 特殊方法。

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

< >

( model = None config = None **kwargs )

参数

  • model (openvino.runtime.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。
  • device (str, defaults to "CPU") — The device type for which the model will be optimized for. The resulting compiled model will contains nodes specific to this device.
  • dynamic_shapes (bool, defaults to True) — All the model’s dimension will be set to dynamic when set to True. Should be set to False for the model to not be dynamically reshaped by default.
  • ov_config (Optional[Dict], defaults to None) — The dictionnary containing the informations related to the model compilation.
  • compile (bool, defaults to True) — Disable the model compilation during the loading step when set to False. Can be useful to avoid unnecessary compilation, in the case where the model needs to be statically reshaped, the device modified or if FP16 conversion is enabled.

OpenVINO Model with a ImageClassifierOutput for image classification tasks.

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

forward

< >

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

参数

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

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

虽然 forward 传递的配方需要在该函数中定义，但之后应该调用 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](https://github.com/huggingface/pytorch-image-models) 一起使用

托管在 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.runtime.Model) — 与编码器关联的 OpenVINO Runtime 模型。
  • decoder (openvino.runtime.Model) — 与解码器关联的 OpenVINO Runtime 模型。
  • decoder_with_past (openvino.runtime.Model) — 与具有过去键值的解码器关联的 OpenVINO Runtime 模型。
  • config (transformers.PretrainedConfig) — PretrainedConfig 是与模型关联的配置的实例。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。

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

forward

< >

( 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，每个元组有 2 个形状为 (batch_size, num_heads, decoder_sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

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

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

< >

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

参数

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

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

forward

< >

( flattened_patches: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None **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，可选) — 用于避免对填充标记索引执行注意力的掩码。
  • 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, optional: hidden_states, optional: attentions)。形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state 是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中使用。
  • past_key_values (tuple(tuple(torch.FloatTensor), *optional*, defaults to None) — 包含用于加速解码的注意力模块的预计算的键和值隐藏状态。该元组的长度为 config.n_layers，每个元组有 2 个形状为 (batch_size, num_heads, decoder_sequence_length, embed_size_per_head) 的张量，以及 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

OVModelForPix2Struct 的 forward 方法，覆盖了 __call__ 特殊方法。

虽然 forward 传递的配方需要在该函数中定义，但之后应该调用 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.runtime.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。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存）

forward

< >

( **kwargs )

OVModelForCustomTasks 的 forward 方法，覆盖了 __call__ 特殊方法。

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

自定义任务示例（例如，带有池化器头的句子转换器）

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

< >

( model = None config = None **kwargs )

参数

  • model (openvino.runtime.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 转换的情况下，这可能有助于避免不必要的编译。

具有 BaseModelOutput 的 OpenVINO 模型，用于特征提取任务。

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

forward

< >

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

参数

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

OVModelForFeatureExtraction 的 forward 方法，覆盖了 __call__ 特殊方法。

虽然 forward 传递的配方需要在该函数中定义，但之后应该调用 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 的稳定扩散管线，对应于 diffusers.StableDiffusionPipeline。

forward

< >

( *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 的稳定扩散管线，对应于 diffusers.StableDiffusionXLPipeline。

forward

< >

( *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 的稳定扩散管线，对应于 diffusers.LatentConsistencyModelPipeline。

forward

< >

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

forward

< >

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

forward

< >

( *args **kwargs )

图像修复

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。

forward

< >

( *args **kwargs )

< > 在 GitHub 上更新

←支持的模型 Notebooks→