模型
通用模型类
类 optimum.intel.openvino.modeling_base.OVBaseModel
< 源代码 >( model: Model config: PretrainedConfig = None device: str = 'CPU' dynamic_shapes: bool = True ov_config: typing.Union[typing.Dict[str, str], NoneType] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.TemporaryDirectory, NoneType] = None quantization_config: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict, NoneType] = None **kwargs )
OVModel基类。
从预训练的
< source >( model_id: typing.Union[str, pathlib.Path] config: PretrainedConfig use_auth_token: typing.Union[bool, str, NoneType] = None token: typing.Union[bool, str, NoneType] = None revision: typing.Optional[str] = None force_download: bool = False cache_dir: str = '/root/.cache/huggingface/hub' file_name: typing.Optional[str] = None subfolder: str = '' from_onnx: bool = False local_files_only: bool = False load_in_8bit: bool = False quantization_config: typing.Union[optimum.intel.openvino.configuration.OVWeightQuantizationConfig, typing.Dict] = None **kwargs )
参数
- model_id (
str或Path) — 加载模型的目录。可以是：- 存储在 huggingface.co 模型库中的预训练模型的 ID。
- 包含模型权重的目录路径。
- use_auth_token (可选[Union[bool, str]], 默认为
None) — 已废弃。请使用token代替。 - token (可选[Union[bool, str]], 默认为
None) — 用作远程文件 HTTP 带证授权的令牌。如果为True，将使用运行huggingface-cli login时的令牌（存储在~/.huggingface）。 - 修订版 (
str，可选)- 要使用的特定模型版本。它可以是分支名称、标签名称或提交标识符。 - cache_dir (
Union[str, Path]，可选) - 如果不使用标准缓存，则将预先训练的模型配置缓存的目录路径。 - force_download (
bool，默认为False) - 是否强制重新下载模型权重和配置文件，覆盖缓存版本（如果存在于）。 - file_name (
str, 可选) — 要加载的模型的文件名。将覆盖默认文件名，允许以不同的名称加载模型。 - local_files_only (
bool, 可选, 默认值False) — 是否只查看本地文件（即不尝试下载模型）。 - load_in_8bit (
bool, 可选, 默认值False) — 是否应用 8 位权重量化和。
从目录或 HF Hub 加载模型及其配置文件。
reshape
< source >( batches_size: int sequence_length: int height: int = None width: int = None )
将给定的输入尺寸传播到模型的层中，固定模型的输入尺寸。
自然语言处理
以下类可用于以下自然语言处理任务。
OVModelForCausalLM
类 optimum.intel.OVModelForCausalLM
< 资源 >( model: Model config: 预训练配置 = None device: str = 'CPU' dynamic_shapes: bool = True ov_config: typing.Union[typing.Dict[str, str], NoneType] = None model_save_dir: typing.Union[str, pathlib.Path, tempfile.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转换时。
topping with OpenVINO 模型具有因果语言模型头（线性层与输入嵌入关联的权重）。
此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。有关库为所有模型实现的通用方法（如下载或保存）的文档，请检查超类文档。
forward
< source >( 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 **kwargs )
生成
< 源代码 >( 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.Union[typing.Callable[[int, torch.Tensor], typing.List[int]], NoneType] = 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
类别 optimum.intel.OVModelForMaskedLM
< source >( model = None config = None **kwargs )
参数
- model (
openvino.runtime.Model) — 是用于运行 OpenVINO 运行时推理的主要类。 - 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 转换的情况下，这可能很有用，以避免不必要的编译。
适用于遮蔽语言建模任务的带有遮蔽LMOutput功能的OpenVINO模型。
此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。有关库为所有模型实现的通用方法（如下载或保存）的文档，请检查超类文档。
forward
< source >( 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), 可选) — 避免在填充标记索引上进行注意力操作的掩码。掩码值选择的范围在[0, 1]：- 1 对于未掩码的标记,
- 0 对于掩码的标记。 什么是注意力掩码？
- token_type_ids (
torch.Tensor, 可选) — 标记类型索引，用于指示输入的第一部分和第二部分。索引范围在[0, 1]：- 1 对于句子 A 的标记,
- 0 对于句子 B 的标记。 什么是标记类型 ID？
OVModelForMaskedLM forward 方法，重写了 __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
< 源 >( encoder: 模型 decoder: 模型 decoder_with_past: 模型 = None config: 预训练配置 = None **kwargs )
为 OpenVINO 推理设计的具有语言模型头部的序列到序列模型。
forward
< source >( 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) — 输入序列的标记索引，用于词汇表，形状为(batch_size, encoder_sequence_length)。 - attention_mask (
torch.LongTensor) — 用于避免在填充token索引上执行注意力的掩码，形状为(batch_size, encoder_sequence_length)。掩码值选择在[0, 1]之间。 - decoder_input_ids (
torch.LongTensor) — 解码输入序列词汇表中的token索引，形状为(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*)— 包含用于加速解码的注意力块预计算的键和值隐藏状态。元组的长度是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 的前进方法覆盖了特殊方法 __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
类 optimum.intel.OVModelForQuestionAnswering
< 来源 >( model = None config = None **kwargs )
参数
- model (
openvino.runtime.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。 - config (
transformers.PretrainedConfig) — PretrainedConfig是与模型的参数相关的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只有配置。查看《code>~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 转换的情况下，这可能很有用。
具有 QuestionAnsweringModelOutput 的 OpenVINO 模型，用于提取式问答任务。
此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。有关库为所有模型实现的通用方法（如下载或保存）的文档，请检查超类文档。
forward
< source >( 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), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]:- 1 表示 未掩码 的标记，
- 0 表示 掩码 的标记。 什么是注意力掩码？
- token_type_ids (
torch.Tensor, 可选) — 段落标记索引，用于标记输入的第一段和第二段。索引选择在[0, 1]范围内：- 1 对应 句子 A 的标记，
- 0 对应 句子 B 的标记。 什么是标记类型 ID？
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
类 optimum.intel.OVModelForSequenceClassification
< source >( model = None config = None **kwargs )
参数
- model (
openvino.runtime.Model) — 是执行 OpenVINO 运行时推理的主类。 - 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模型，具有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 )
参数
- token_type_ids (torch.Tensor, 可选) — 段落标记索引，用于指示输入的第一部分和第二部分。索引选择在 [0, 1]：
- 1 对应为 句子 A 的标记，
- 0 对应为 句子 B 的标记。 什么是标记类型 ID?
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
< source >( 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 转换时非常有用，以避免不必要的编译。
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) — 输入序列令牌在最常用的词汇表中的索引。索引可以通过AutoTokenizer获取。 什么是输入 ID？ - attention_mask (
torch.Tensor), 可选) — 用于避免在填充令牌索引上执行注意力的掩码。掩码值取自[0, 1]：- 1 表示未被掩码的令牌，
- 0 表示被掩码的令牌。 什么是注意掩码？
- token_type_ids (
torch.Tensor, 可选) — 段落标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]范围内选择：- 1 代表 句子 A 的标记;
- 0 代表 句子 B 的标记。 什么是标记类型 ID？
OVModelForTokenClassification 面向方法覆盖了 __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
类 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, 默认为"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_values : typing.Union[torch.Tensor, numpy.ndarray] attention_mask : typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None **kwargs )
参数
- input_ids (
torch.Tensor) — 词汇表中的输入序列标记索引。索引可以通过使用AutoTokenizer获取。 什么是输入 ID? - attention_mask (
torch.Tensor), 可选) — 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]范围内：- 1 表示 未掩码 的标记,
- 0 表示 掩码 的标记。 什么是注意力掩码？
- token_type_ids (
torch.Tensor, 可选) — 用于表示输入的第一和第二部分的段标记索引。索引在[0, 1]范围内选择：- 1 表示 句子 A,
- 0 表示 句子 B。 什么是标记类型 ID？
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
< source >( 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时，在加载步骤禁用模型编译。在模型需要静态 reshaped、设备修改或启用 FP16 转换的情况下，这可能很有用。
带有顶部帧分类头部用于 Speaker Diarization 等任务的 OpenVINO 模型。
此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。有关库为所有模型实现的通用方法（如下载或保存）的文档，请检查超类文档。
OpenVINO 的音频帧分类模型。
forward
< source >( input_values: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None **kwargs )
参数
- input_values (
torch.Tensorof shape(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
类 optimum.intel.OVModelForCTC
< source >( model: Model config: PretrainedConfig = None **kwargs )
参数
- 模型 (
openvino.runtime.Model) — 是用于运行 OpenVINO Runtime 推理的主要类。 - 配置 (
transformers.PretrainedConfig) — PretrainedConfig 是包含模型所有参数的模型配置类。使用配置文件初始化不加载与模型相关的权重，只加载配置。请查看~intel.openvino.modeling.OVBaseModel.from_pretrained方法以加载模型权重。 - 设备 (
str，默认为"CPU") — 模型将对其进行优化的设备类型。生成的编译模型将包含针对此设备的特定节点。 - dynamic_shapes (
bool, 默认值为True) — 当设置为True时，模型的维度将全部设置为动态。若要将模型默认设置为非动态重塑，则需要设置为False。 - ov_config (
Optional[Dict], 默认值为None) — 包含与模型编译相关的信息的字典。 - compile (
bool, 默认值为True) — 当设置为False时，将禁用在加载步骤中的模型编译。在某些情况下，例如模型需要静态重塑、设备修改或启用 FP16 转换时，这可以避免不必要的编译。
Connectionist Temporal Classification (CTC) 顶部带有语言模型头的 Onnx 模型。
此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。有关库为所有模型实现的通用方法（如下载或保存）的文档，请检查超类文档。
OpenVINO 的 CTC 模型。
forward
< source >( input_values: typing.Optional[torch.Tensor] = None attention_mask: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None **kwargs )
参数
- input_values (
torch.Tensorof shape(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
类 optimum.intel.OVModelForAudioXVector
< source >( 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) — 包含与模型编译相关的信息的字典。 - 编译 (
bool，默认为True) — 当设置为False时，在加载步骤中禁用模型编译。在需要静态重塑模型、修改设备或启用 FP16 转换的情况下，这可能很有用。
适用于语音验证等任务的，在 Onnx 模型顶部有 XVector 特征提取头的模型。
此模型继承自 optimum.intel.openvino.modeling.OVBaseModel。有关库为所有模型实现的通用方法（如下载或保存）的文档，请检查超类文档。
为 OpenVINO 设计的音频 XVector 模型。
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。
OVModelForAudioXVector 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传递的配方需要在这个函数内定义，但应该调用 Module 实例之后，而不是这个实例，因为前者会处理预处理和后处理步骤，而后者会静默忽略它们。
音频 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
类 optimum.intel.OVModelForSpeechSeq2Seq
< 来源 >( encoder: 模型 decoder: 模型 decoder_with_past: 模型 = None config: 预训练配置 = None **kwargs )
参数
- encoder (
openvino.runtime.Model) — 与编码器关联的OpenVINO运行时模型。 - decoder (
openvino.runtime.Model) — 与解码器关联的OpenVINO运行时模型。 - decoder_with_past (
openvino.runtime.Model) — 与带有过去键值的解码器关联的 OpenVINO 运行时模型。 - 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) — 从原始语音波形中提取的梅尔特征。(batch_size, feature_size, encoder_sequence_length)。 - decoder_input_ids (
torch.LongTensor) — 解码输入序列标记的索引，形状为(batch_size, decoder_sequence_length)的词汇。 - encoder_outputs （
torch.FloatTensor） — 编码器的last_hidden_state，形状为(batch_size, encoder_sequence_length, hidden_size)。 - past_key_values （
tuple(tuple(torch.FloatTensor), *optional*, defaults to None)— 包含用于加快解码过程的前计算的关键和值隐藏状态。元组的长度为config.n_layers，每个元组包含 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
类 optimum.intel.OVModelForImageClassification
< source >( model = None config = None **kwargs )
参数
- model (
openvino.runtime.Model) —— 是用于执行 OpenVINO 运行时推理的主要类。 - 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
< source >( pixel_values: typing.Union[torch.Tensor, numpy.ndarray] **kwargs )
参数
- pixel_values （
torch.Tensor） — 当前批次的图像对应的像素值。像素值可以通过使用AutoFeatureExtractor从编码的图像中获取。
OVModelForImageClassification 前向方法，重写了 __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)托管在 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
类 optimum.intel.OVModelForVision2Seq
< source >( encoder: 模型 decoder: 模型 decoder_with_past: 模型 = None config: 预训练配置 = 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
< source >( 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 toNone)包含用于加速解码的注意力块预先计算的关键和值隐藏状态。元组长度为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 的 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
类 optimum.intel.OVModelForPix2Struct
< source >( encoder: 模型 decoder: 模型 decoder_with_past: 模型 = None config: 预训练配置 = None **kwargs )
参数
- 编码器 (
openvino.runtime.Model) — 与编码器关联的OpenVINO Runtime模型。 - 解码器 (
openvino.runtime.Model) — 与解码器关联的OpenVINO Runtime模型。 - decoder_with_past (
openvino.runtime.Model) — 与具有过去关键值的解码器关联的OpenVINO Runtime模型。 - config (
transformers.PretrainedConfig) — PretrainedConfig 是与模型关联的配置实例。使用配置文件初始化不会加载与模型关联的权重，只有配置。
为 OpenVINO 推理设计的带有语言建模头的 Pix2Struct 模型。
forward
< source >( 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 )
参数
- 平铺的像素块 (
torch.FloatTensor形状(batch_size, seq_length, hidden_size)) — 展平的像素块。其中hidden_size由以下公式计算得到：hidden_size=num_channelspatch_sizepatch_size展平像素块的过程由Pix2StructProcessor完成。 - 注意力掩码 (
torch.FloatTensor形状(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力操作。 - 解码器输入ID (
torch.LongTensor形状(batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。Pix2StructText 使用pad_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可选地仅输入最后一个decoder_input_ids（见past_key_values）。 - decoder_attention_mask (
torch.BoolTensor形状(batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略decoder_input_ids中的填充标记的张量。默认情况下还会使用因果掩码。 - encoder_outputs (
tuple(tuple(torch.FloatTensor)，可选) — 包含：（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state形状(batch_size, 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)的额外张量。
OVModelForPix2Struct 前向方法，覆盖了 __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
类 optimum.intel.OVModelForCustomTasks
< source >( model: Model config: PretrainedConfig = None **kwargs )
参数
- model (
openvino.runtime.Model) — 是用于运行 OpenVINO 运行时推理的主要类。 - 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。有关库为所有模型实现的通用方法（如下载或保存）的文档，请检查超类文档。
OVModelForCustomTasks 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在这个函数内定义，但应该调用 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_outputOVModelForFeatureExtraction
类 optimum.intel.OVModelForFeatureExtraction
< 源 >( model = None config = None **kwargs )
参数
- 模型 (
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
< source >( 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, 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]中：- 1 代表 未掩码 的标记，
- 0 代表 掩码 的标记。 注意掩码是什么？
- token_type_ids (
torch.Tensor, 可选) — 段落标记索引，用于指示输入的第一部分和第二部分。索引选择在[0, 1]中：- 1 代表 句子A，
- 0 代表 句子B。 标记类型ID是什么？
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.")forward
( *args **kwargs )
OVStableDiffusionXLPipeline
class optimum.intel.OVStableDiffusionXLPipeline
< source >( *args add_watermarker: typing.Optional[bool] = None **kwargs )
OVLatentConsistencyModelPipeline
图像到图像
OVStableDiffusionImg2ImgPipeline
OVStableDiffusionXLImg2ImgPipeline
类 optimum.intel.OVStableDiffusionXLImg2ImgPipeline
< 源代码 >( *args add_watermarker: typing.Optional[bool] = None **kwargs )