前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >Transformers 4.37 中文文档(八十二)

Transformers 4.37 中文文档(八十二)

作者头像
ApacheCN_飞龙
发布2024-06-26 18:37:02
830
发布2024-06-26 18:37:02
举报
文章被收录于专栏:信数据得永生信数据得永生

原文:huggingface.co/docs/transformers

XLS-R

原始文本:huggingface.co/docs/transformers/v4.37.2/en/model_doc/xls_r

概述

XLS-R 模型由 Arun Babu、Changhan Wang、Andros Tjandra、Kushal Lakhotia、Qiantong Xu、Naman Goyal、Kritika Singh、Patrick von Platen、Yatharth Saraf、Juan Pino、Alexei Baevski、Alexis Conneau、Michael Auli 在XLS-R: Self-supervised Cross-lingual Speech Representation Learning at Scale中提出。

论文的摘要如下:

本文介绍了 XLS-R,这是一个基于 wav2vec 2.0 的大规模跨语言语音表示学习模型。我们在 128 种语言中使用多达 20 亿参数的模型进行训练,使用近 50 万小时的公开可用语音音频数据,比已知最大的先前工作的公共数据量大一个数量级。我们的评估涵盖了各种任务、领域、数据制度和语言,包括高资源和低资源语言。在 CoVoST-2 语音翻译基准测试中,我们将先前的最新技术平均提高了 7.4 BLEU,涵盖了 21 个翻译方向到英语。对于语音识别,XLS-R 在 BABEL、MLS、CommonVoice 以及 VoxPopuli 等最佳已知先前工作上的错误率平均降低了 14-34%。XLS-R 还在 VoxLingua107 语言识别上树立了新的技术水平。此外,我们展示了在足够大的模型尺寸下,跨语言预训练可以在将英语语音翻译成其他语言时胜过仅英语预训练,这种情况有利于单语预训练。我们希望 XLS-R 可以帮助改进世界上更多语言的语音处理任务。

相关的检查点可以在huggingface.co/models?other=xls_r下找到。

原始代码可以在这里找到。

使用提示

  • XLS-R 是一个语音模型,接受与语音信号的原始波形对应的浮点数组。
  • XLS-R 模型是使用连接主义时间分类(CTC)进行训练的,因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。

XLS-R 的架构基于 Wav2Vec2 模型,请参考 Wav2Vec2 的文档页面获取 API 参考。

XLSR-Wav2Vec2

原文:huggingface.co/docs/transformers/v4.37.2/en/model_doc/xlsr_wav2vec2

概述

XLSR-Wav2Vec2 模型是由 Alexis Conneau,Alexei Baevski,Ronan Collobert,Abdelrahman Mohamed,Michael Auli 在无监督跨语言表示学习语音识别中提出的。

论文摘要如下:

本文介绍了 XLSR,通过在多种语言的语音的原始波形上预训练单一模型来学习跨语言语音表示。我们构建在 wav2vec 2.0 的基础上,该模型通过解决对掩码潜在语音表示的对比任务进行训练,并共同学习跨语言共享的潜在量化。结果模型在标记数据上进行微调,实验表明跨语言预训练明显优于单语言预训练。在 CommonVoice 基准测试中,XLSR 相对音素错误率降低了 72%,相对于已知最佳结果。在 BABEL 上,我们的方法相对于类似系统改善了 16%的词错误率。我们的方法实现了一个单一的多语言语音识别模型,与强大的个体模型竞争。分析表明,潜在的离散语音表示在不同语言之间共享,对于相关语言的共享增加。我们希望通过发布在 53 种语言中预训练的大型模型 XLSR-53 来促进低资源语音理解的研究。

原始代码可以在这里找到。

使用提示

  • XLSR-Wav2Vec2 是一个语音模型,接受与语音信号的原始波形对应的浮点数组。
  • XLSR-Wav2Vec2 模型是使用连接主义时间分类(CTC)进行训练的,因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。

XLSR-Wav2Vec2 的架构基于 Wav2Vec2 模型,因此可以参考 Wav2Vec2 的文档页面。

多模型模型

ALIGN

原始文本:huggingface.co/docs/transformers/v4.37.2/en/model_doc/align

概述

ALIGN 模型在通过嘈杂文本监督扩展视觉和视觉语言表示学习中由 Chao Jia、Yinfei Yang、Ye Xia、Yi-Ting Chen、Zarana Parekh、Hieu Pham、Quoc V. Le、Yunhsuan Sung、Zhen Li、Tom Duerig 提出。ALIGN 是一个多模态视觉和语言模型。它可用于图像文本相似度和零样本图像分类。ALIGN 具有双编码器架构,其中 EfficientNet 作为其视觉编码器,BERT 作为其文本编码器,并通过对比学习学习对齐视觉和文本表示。与以往的工作不同,ALIGN 利用了一个庞大的嘈杂数据集,并表明语料库的规模可以用来实现具有简单配方的 SOTA 表示。

论文的摘要如下:

预训练表示对许多 NLP 和感知任务变得至关重要。虽然 NLP 中的表示学习已经过渡到在没有人类注释的原始文本上进行训练,但视觉和视觉语言表示仍然严重依赖于昂贵或需要专业知识的策划训练数据集。对于视觉应用,表示主要是使用具有显式类标签的数据集学习,如 ImageNet 或 OpenImages。对于视觉语言,像 Conceptual Captions、MSCOCO 或 CLIP 这样的流行数据集都涉及到一个不容易的数据收集(和清理)过程。这种昂贵的策划过程限制了数据集的规模,从而阻碍了训练模型的扩展。在本文中,我们利用了一个超过十亿个图像替代文本对的嘈杂数据集,该数据集是在 Conceptual Captions 数据集中没有昂贵的过滤或后处理步骤的情况下获得的。一个简单的双编码器架构学习使用对比损失对图像和文本对的视觉和语言表示进行对齐。我们表明,我们语料库的规模可以弥补其噪声,并导致即使使用如此简单的学习方案也能实现最先进的表示。我们的视觉表示在转移到 ImageNet 和 VTAB 等分类任务时表现出色。对齐的视觉和语言表示使零样本图像分类成为可能,并在 Flickr30K 和 MSCOCO 图像文本检索基准上取得了新的最先进结果,即使与更复杂的交叉注意力模型相比也是如此。这些表示还使得可以进行具有复杂文本和文本+图像查询的跨模态搜索。

这个模型是由Alara Dirik贡献的。原始代码未发布,这个实现是基于 Kakao Brain 根据原始论文实现的。

用法示例

ALIGN 使用 EfficientNet 获取视觉特征,使用 BERT 获取文本特征。然后,文本和视觉特征都投影到具有相同维度的潜在空间中。然后使用投影图像和文本特征之间的点积作为相似度分数。

AlignProcessor 将 EfficientNetImageProcessor 和 BertTokenizer 封装成一个单一实例,用于对文本进行编码和预处理图像。以下示例展示了如何使用 AlignProcessor 和 AlignModel 获取图像文本相似度分数。

代码语言:javascript
复制
import requests
import torch
from PIL import Image
from transformers import AlignProcessor, AlignModel

processor = AlignProcessor.from_pretrained("kakaobrain/align-base")
model = AlignModel.from_pretrained("kakaobrain/align-base")

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
candidate_labels = ["an image of a cat", "an image of a dog"]

inputs = processor(text=candidate_labels, images=image, return_tensors="pt")

with torch.no_grad():
    outputs = model(**inputs)

# this is the image-text similarity score
logits_per_image = outputs.logits_per_image

# we can take the softmax to get the label probabilities
probs = logits_per_image.softmax(dim=1)
print(probs)

资源

一系列官方 Hugging Face 和社区(由🌎表示)资源,可帮助您开始使用 ALIGN。

如果您有兴趣提交资源以包含在此处,请随时打开一个拉取请求,我们将进行审查。资源应该展示一些新内容,而不是重复现有资源。

AlignConfig

class transformers.AlignConfig

< source >

代码语言:javascript
复制
( text_config = None vision_config = None projection_dim = 640 temperature_init_value = 1.0 initializer_range = 0.02 **kwargs )

参数

  • text_config (dict, optional) — 用于初始化 AlignTextConfig 的配置选项字典。
  • vision_config (dict, optional) — 用于初始化 AlignVisionConfig 的配置选项字典。
  • projection_dim (int, optional, 默认为 640) — 文本和视觉投影层的维度。
  • temperature_init_value (float, optional, 默认为 1.0) — temperature 参数的初始值。默认值与原始 ALIGN 实现相同。
  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • kwargs (optional) — 关键字参数字典。

AlignConfig 是用于存储 AlignModel 配置的配置类。它用于根据指定的参数实例化一个 ALIGN 模型,定义文本模型和视觉模型配置。使用默认值实例化配置将产生与 ALIGN kakaobrain/align-base 架构类似的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例:

代码语言:javascript
复制
>>> from transformers import AlignConfig, AlignModel

>>> # Initializing a AlignConfig with kakaobrain/align-base style configuration
>>> configuration = AlignConfig()

>>> # Initializing a AlignModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

>>> # We can also initialize a AlignConfig from a AlignTextConfig and a AlignVisionConfig
>>> from transformers import AlignTextConfig, AlignVisionConfig

>>> # Initializing ALIGN Text and Vision configurations
>>> config_text = AlignTextConfig()
>>> config_vision = AlignVisionConfig()

>>> config = AlignConfig.from_text_vision_configs(config_text, config_vision)
from_text_vision_configs

< source >

代码语言:javascript
复制
( text_config: AlignTextConfig vision_config: AlignVisionConfig **kwargs ) → export const metadata = 'undefined';AlignConfig

返回

AlignConfig

配置对象的一个实例

从对齐文本模型配置和对齐视觉模型配置实例化一个 AlignConfig(或派生类)。

AlignTextConfig

class transformers.AlignTextConfig

< source >

代码语言:javascript
复制
( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 position_embedding_type = 'absolute' use_cache = True **kwargs )

参数

  • vocab_size (int, optional, 默认为 30522) — Align 文本模型的词汇量。定义了在调用 AlignTextModel 时可以表示的不同标记数量。
  • hidden_size (int, optional, 默认为 768) — 编码器层和池化层的维度。
  • num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。
  • num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
  • intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”(通常称为前馈)层的维度。
  • hidden_act (strCallable, optional, 默认为"gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu""relu""silu""gelu_new"
  • hidden_dropout_prob (float, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
  • attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的 dropout 比率。
  • max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一(例如 512、1024 或 2048)。
  • type_vocab_size (int, optional, 默认为 2) — 在调用 AlignTextModel 时传递的token_type_ids的词汇表大小。
  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。
  • pad_token_id (int, optional, 默认为 0) — 填充标记 id。
  • position_embedding_type (str, optional, 默认为"absolute") — 位置嵌入的类型。选择"absolute""relative_key""relative_key_query"中的一个。对于位置嵌入,请使用"absolute"。有关"relative_key"的更多信息,请参考Self-Attention with Relative Position Representations (Shaw et al.)。有关"relative_key_query"的更多信息,请参考[Improve Transformer Models with Better Relative Position Embeddings (Huang et al.)]中的Method 4 (https://arxiv.org/abs/2009.13658)。
  • use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。仅在config.is_decoder=True时相关。

这是用于存储 AlignTextModel 配置的配置类。根据指定的参数实例化一个 ALIGN 文本编码器,定义模型架构。使用默认值实例化配置将产生与 ALIGN kakaobrain/align-base架构的文本编码器类似的配置。这里的默认值是从 BERT 复制的。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例:

代码语言:javascript
复制
>>> from transformers import AlignTextConfig, AlignTextModel

>>> # Initializing a AlignTextConfig with kakaobrain/align-base style configuration
>>> configuration = AlignTextConfig()

>>> # Initializing a AlignTextModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignTextModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

AlignVisionConfig

class transformers.AlignVisionConfig

< source >

代码语言:javascript
复制
( num_channels: int = 3 image_size: int = 600 width_coefficient: float = 2.0 depth_coefficient: float = 3.1 depth_divisor: int = 8 kernel_sizes: List = [3, 3, 5, 3, 5, 5, 3] in_channels: List = [32, 16, 24, 40, 80, 112, 192] out_channels: List = [16, 24, 40, 80, 112, 192, 320] depthwise_padding: List = [] strides: List = [1, 2, 2, 2, 1, 2, 1] num_block_repeats: List = [1, 2, 2, 3, 3, 4, 1] expand_ratios: List = [1, 6, 6, 6, 6, 6, 6] squeeze_expansion_ratio: float = 0.25 hidden_act: str = 'swish' hidden_dim: int = 2560 pooling_type: str = 'mean' initializer_range: float = 0.02 batch_norm_eps: float = 0.001 batch_norm_momentum: float = 0.99 drop_connect_rate: float = 0.2 **kwargs )

参数

  • num_channels (int, optional, 默认为 3) — 输入通道数。
  • image_size (int, optional, 默认为 600) — 输入图像大小。
  • width_coefficient (float, optional, 默认为 2.0) — 每个阶段网络宽度的缩放系数。
  • depth_coefficient (float, optional, 默认为 3.1) — 每个阶段网络深度的缩放系数。
  • depth_divisor int, optional, 默认为 8) — 网络宽度的单位。
  • kernel_sizes (List[int], optional, 默认为[3, 3, 5, 3, 5, 5, 3]) — 每个块中要使用的卷积核大小列表。
  • in_channels (List[int], optional, 默认为[32, 16, 24, 40, 80, 112, 192]) — 用于卷积层中每个块的输入通道大小列表。
  • out_channels (List[int], 可选, 默认为[16, 24, 40, 80, 112, 192, 320]) — 用于卷积层中每个块中使用的输出通道大小列表。
  • depthwise_padding (List[int], 可选, 默认为[]) — 具有方形填充的块索引列表。
  • strides (List[int], 可选, 默认为[1, 2, 2, 2, 1, 2, 1]) — 用于卷积层中每个块中使用的步幅大小列表。
  • num_block_repeats (List[int], 可选, 默认为[1, 2, 2, 3, 3, 4, 1]) — 每个块重复的次数列表。
  • expand_ratios (List[int], 可选, 默认为[1, 6, 6, 6, 6, 6, 6]) — 每个块的缩放系数列表。
  • squeeze_expansion_ratio (float, 可选, 默认为 0.25) — 挤压扩展比率。
  • hidden_act (strfunction, 可选, 默认为"silu") — 每个块中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu", "relu", "selu", “gelu_new”, “silu"和"mish”。
  • hiddem_dim (int, 可选, 默认为 1280) — 分类头之前层的隐藏维度。
  • pooling_type (strfunction, 可选, 默认为"mean") — 应用于密集分类头之前的最终池化类型。可用选项为["mean", "max"]
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • batch_norm_eps (float, 可选, 默认为 1e-3) — 批量归一化层使用的 epsilon。
  • batch_norm_momentum (float, 可选, 默认为 0.99) — 批量归一化层使用的动量。
  • drop_connect_rate (float, 可选, 默认为 0.2) — 跳过连接的丢弃率。

这是一个配置类,用于存储 AlignVisionModel 的配置。根据指定的参数实例化一个 ALIGN 视觉编码器,定义模型架构。使用默认值实例化配置将产生与 ALIGN kakaobrain/align-base架构的视觉编码器类似的配置。默认值来自 EfficientNet (efficientnet-b7)

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例:

代码语言:javascript
复制
>>> from transformers import AlignVisionConfig, AlignVisionModel

>>> # Initializing a AlignVisionConfig with kakaobrain/align-base style configuration
>>> configuration = AlignVisionConfig()

>>> # Initializing a AlignVisionModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignVisionModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

AlignProcessor

class transformers.AlignProcessor

<来源>

代码语言:javascript
复制
( image_processor tokenizer )

参数

  • image_processor (EfficientNetImageProcessor) — 图像处理器是必需的输入。
  • tokenizer ([BertTokenizer, BertTokenizerFast]) — 分词器是必需的输入。

构建一个 ALIGN 处理器,将 EfficientNetImageProcessor 和 BertTokenizer/BertTokenizerFast 包装成一个同时继承图像处理器和分词器功能的单个处理器。查看__call__()和 decode()以获取更多信息。

batch_decode

<来源>

代码语言:javascript
复制
( *args **kwargs )

此方法将所有参数转发给 BertTokenizerFast 的 batch_decode()。请参考此方法的文档字符串获取更多信息。

decode

<来源>

代码语言:javascript
复制
( *args **kwargs )

此方法将所有参数转发给 BertTokenizerFast 的 decode()。请参考此方法的文档字符串获取更多信息。

AlignModel

class transformers.AlignModel

<来源>

代码语言:javascript
复制
( config: AlignConfig )

参数

  • config (AlignConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

这个模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法(例如下载或保存、调整输入嵌入大小、修剪头等)。

这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。

forward

<来源>

代码语言:javascript
复制
( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

  • input_ids (torch.LongTensor,形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。 索引可以使用 AutoTokenizer 获得。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。 什么是输入 ID? attention_mask (torch.Tensor,形状为(batch_size, sequence_length)可选): 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间:
    • 1 对应于未被掩码的标记,
    • 0 对应于被掩码的标记。

    什么是注意力掩码? position_ids (torch.LongTensor,形状为(batch_size, sequence_length)可选): 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID? token_type_ids (torch.LongTensor,形状为({0})可选): 段标记索引,指示输入的第一部分和第二部分。索引选择在[0, 1]之间:

    • 0 对应于句子 A标记,
    • 1 对应于句子 B标记。

    什么是标记类型 ID? head_mask (torch.FloatTensor,形状为(num_heads,)(num_layers, num_heads)可选): 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间:

    • 1 表示头部未被掩码
    • 0 表示头部被掩码

    inputs_embeds (torch.FloatTensor of shape ({0}, hidden_size), optional): 可选地,您可以选择直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)): 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 EfficientNetImageProcessor.call()。return_loss (bool, optional): 是否返回对比损失。output_attentions (bool, optional): 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的张量下的 attentions。output_hidden_states (bool, optional): 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的张量下的 hidden_states。return_dict (bool, optional): 是否返回 ModelOutput 而不是普通元组。

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

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

get_text_features

< source >

代码语言:javascript
复制
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';text_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。 可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID?
  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择:
    • 1 表示未被屏蔽的标记,
    • 0 表示被屏蔽的标记。

    什么是注意力掩码?

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。 什么是位置 ID?
  • token_type_ids (torch.LongTensor of shape ({0}), optional) — 段标记索引,指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:
    • 0 对应于 句子 A 标记,
    • 1 对应于 句子 B 标记。

    什么是标记类型 ID?

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值在 [0, 1] 中选择:
    • 1 表示头部未被屏蔽,
    • 0 表示头部被屏蔽。
  • inputs_embeds (torch.FloatTensor,形状为({0}, hidden_size)可选) — 可选地,您可以直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

text_features (torch.FloatTensor,形状为(batch_size, output_dim)

通过将投影层应用于 AlignTextModel 的汇聚输出获得的文本嵌入。

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

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

示例:

代码语言:javascript
复制
>>> from transformers import AutoTokenizer, AlignModel

>>> model = AlignModel.from_pretrained("kakaobrain/align-base")
>>> tokenizer = AutoTokenizer.from_pretrained("kakaobrain/align-base")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)
get_image_features

<来源>

代码语言:javascript
复制
( pixel_values: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';image_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

  • pixel_values (torch.FloatTensor,形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。如果提供,可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 EfficientNetImageProcessor.call()。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

image_features (torch.FloatTensor,形状为(batch_size, output_dim))

通过将投影层应用于 AlignVisionModel 的汇聚输出获得的图像嵌入。

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

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

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AlignModel

>>> model = AlignModel.from_pretrained("kakaobrain/align-base")
>>> processor = AutoProcessor.from_pretrained("kakaobrain/align-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="pt")

>>> image_features = model.get_image_features(**inputs)

AlignTextModel

class transformers.AlignTextModel

<来源>

代码语言:javascript
复制
( config: AlignTextConfig add_pooling_layer: bool = True )

参数

  • config (AlignConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

来自 ALIGN 的文本模型,没有顶部的头部或投影。此模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。

这个模型也是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

代码语言:javascript
复制
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下,如果提供,将忽略填充。 可以使用 AutoTokenizer 来获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID?
  • attention_mask (torch.Tensor,形状为(batch_size, sequence_length)可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中:
    • 1 表示未被掩盖的标记,
    • 0 表示被掩盖的标记。

    什么是注意力掩码?

  • position_ids (torch.LongTensor,形状为(batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID?
  • token_type_ids (torch.LongTensor,形状为({0})可选) — 指示输入的第一部分和第二部分的段标记索引。索引选择在[0, 1]中:
    • 0 对应于句子 A标记,
    • 1 对应于句子 B标记。

    什么是标记类型 ID?

  • head_mask (torch.FloatTensor,形状为(num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中:
    • 1 表示头部未被掩盖,
    • 0 表示头部被掩盖。
  • inputs_embeds (torch.FloatTensor,形状为({0}, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一个torch.FloatTensor元组(如果传递了return_dict=False或当config.return_dict=False时)包括根据配置(<class 'transformers.models.align.configuration_align.AlignTextConfig'>)和输入的不同元素。

  • last_hidden_state(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor)- 模型最后一层的隐藏状态序列。
  • pooler_output(形状为(batch_size, hidden_size)torch.FloatTensor)- 经过用于辅助预训练任务的层进一步处理后,序列的第一个标记(分类标记)的最后一层隐藏状态。例如,对于 BERT 系列模型,这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是从预训练期间的下一个句子预测(分类)目标中训练的。
  • hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=True或当config.output_hidden_states=True时返回)- 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。 模型在每一层输出处的隐藏状态加上可选的初始嵌入输出。
  • attentionstuple(torch.FloatTensor)可选,当传递output_attentions=True或当config.output_attentions=True时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。 注意力 softmax 之后的注意权重,用于计算自注意力头中的加权平均值。
  • cross_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.add_cross_attention=True或当config.output_attentions=True时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。 解码器的交叉注意力层的注意权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
  • past_key_valuestuple(tuple(torch.FloatTensor))可选,当传递use_cache=True或当config.use_cache=True时返回)- 长度为config.n_layerstuple(torch.FloatTensor)元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量,如果config.is_encoder_decoder=True还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态(自注意力块中的键和值以及可选地在交叉注意力块中使用config.is_encoder_decoder=True)可用(参见past_key_values输入)以加速顺序解码。

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

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

示例:

代码语言:javascript
复制
>>> from transformers import AutoTokenizer, AlignTextModel

>>> model = AlignTextModel.from_pretrained("kakaobrain/align-base")
>>> tokenizer = AutoTokenizer.from_pretrained("kakaobrain/align-base")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled (EOS token) states

AlignVisionModel

class transformers.AlignVisionModel

<来源>

代码语言:javascript
复制
( config: AlignVisionConfig )

参数

  • config(AlignConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

ALIGN 中的视觉模型,没有任何头部或顶部的投影。此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

此模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言:javascript
复制
( pixel_values: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention or tuple(torch.FloatTensor)

参数

  • pixel_valuestorch.FloatTensor,形状为(batch_size, num_channels, height, width))— 像素值。默认情况下将忽略填充,如果您提供填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 EfficientNetImageProcessor.call()。
  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dictbool可选)— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttentiontuple(torch.FloatTensor)

一个transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention或一个torch.FloatTensor元组(如果传递了return_dict=Falseconfig.return_dict=False时)包含各种元素,具体取决于配置(<class 'transformers.models.align.configuration_align.AlignVisionConfig'>)和输入。

  • last_hidden_statetorch.FloatTensor,形状为(batch_size, num_channels, height, width))— 模型最后一层的隐藏状态序列。
  • pooler_outputtorch.FloatTensor,形状为(batch_size, hidden_size))— 在空间维度上进行池化操作后的最后一层隐藏状态。
  • hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)— 形状为(batch_size, num_channels, height, width)torch.FloatTensor元组(如果模型具有嵌入层,则为嵌入的输出的一个+每一层的输出的一个)。 模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。

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

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

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AlignVisionModel

>>> model = AlignVisionModel.from_pretrained("kakaobrain/align-base")
>>> processor = AutoProcessor.from_pretrained("kakaobrain/align-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states

AltCLIP

原文链接:huggingface.co/docs/transformers/v4.37.2/en/model_doc/altclip

概述

AltCLIP 模型是由陈忠志、刘光、张博文、叶福龙、杨庆红、吴乐德在AltCLIP: Altering the Language Encoder in CLIP for Extended Language Capabilities中提出的。AltCLIP(改变 CLIP 中的语言编码器)是一个神经网络,训练于各种图像文本和文本文本对。通过用预训练的多语言文本编码器 XLM-R 替换 CLIP 的文本编码器,我们可以在几乎所有任务上获得与 CLIP 非常接近的性能,并扩展原始 CLIP 的能力,如多语言理解。

论文摘要如下:

在这项工作中,我们提出了一个概念简单且有效的方法来训练强大的双语多模态表示模型。从 OpenAI 发布的预训练多模态表示模型 CLIP 开始,我们将其文本编码器替换为预训练的多语言文本编码器 XLM-R,并通过包含教师学习和对比学习的两阶段训练模式来对齐两种语言和图像表示。我们通过对各种任务的评估验证了我们的方法。我们在一系列任务中取得了新的最先进表现,包括 ImageNet-CN、Flicker30k-CN 和 COCO-CN。此外,我们在几乎所有任务上与 CLIP 获得了非常接近的性能,表明可以简单地改变 CLIP 中的文本编码器以获得扩展能力,如多语言理解。

该模型由jongjyh贡献。

使用提示和示例

AltCLIP 的使用与 CLIP 非常相似,区别在于文本编码器。请注意,我们使用双向注意力而不是单向注意力,并且我们使用 XLM-R 中的[CLS]标记来表示文本嵌入。

AltCLIP 是一个多模态视觉和语言模型。它可用于图像文本相似度和零样本图像分类。AltCLIP 使用类似 ViT 的变压器来获取视觉特征,并使用双向语言模型来获取文本特征。然后将文本和视觉特征投影到具有相同维度的潜在空间中。然后使用投影图像和文本特征之间的点积作为相似分数。

为了将图像馈送到变压器编码器中,每个图像被分割成一系列固定大小且不重叠的补丁,然后进行线性嵌入。添加一个[CLS]标记作为整个图像的表示。作者还添加了绝对位置嵌入,并将结果向量序列馈送到标准变压器编码器。CLIPImageProcessor 可用于调整(或重新缩放)和规范化模型的图像。

AltCLIPProcessor 将 CLIPImageProcessor 和 XLMRobertaTokenizer 封装成一个单一实例,用于对文本进行编码和准备图像。以下示例展示了如何使用 AltCLIPProcessor 和 AltCLIPModel 获取图像文本相似度分数。

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests

>>> from transformers import AltCLIPModel, AltCLIPProcessor

>>> model = AltCLIPModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AltCLIPProcessor.from_pretrained("BAAI/AltCLIP")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="pt", padding=True)

>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = logits_per_image.softmax(dim=1)  # we can take the softmax to get the label probabilities

该模型基于CLIPModel,使用方式与原始的 CLIP 相同。

AltCLIPConfig

class transformers.AltCLIPConfig

<来源>

代码语言:javascript
复制
( text_config = None vision_config = None projection_dim = 768 logit_scale_init_value = 2.6592 **kwargs )

参数

  • text_config (dict, optional) — 用于初始化 AltCLIPTextConfig 的配置选项字典。
  • vision_config (dict, optional) — 用于初始化 AltCLIPVisionConfig 的配置选项字典。
  • projection_dim (int, optional, defaults to 768) — 文本和视觉投影层的维度。
  • logit_scale_init_value (float, optional, defaults to 2.6592) — logit_scale 参数的初始值。默认值根据原始的 CLIP 实现使用。
  • kwargs (optional) — 关键字参数的字典。

这是一个配置类,用于存储 AltCLIPModel 的配置。根据指定的参数实例化一个 AltCLIP 模型,定义模型架构。使用默认值实例化配置将产生类似于 AltCLIP BAAI/AltCLIP 架构的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例:

代码语言:javascript
复制
>>> from transformers import AltCLIPConfig, AltCLIPModel

>>> # Initializing a AltCLIPConfig with BAAI/AltCLIP style configuration
>>> configuration = AltCLIPConfig()

>>> # Initializing a AltCLIPModel (with random weights) from the BAAI/AltCLIP style configuration
>>> model = AltCLIPModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

>>> # We can also initialize a AltCLIPConfig from a AltCLIPTextConfig and a AltCLIPVisionConfig

>>> # Initializing a AltCLIPText and AltCLIPVision configuration
>>> config_text = AltCLIPTextConfig()
>>> config_vision = AltCLIPVisionConfig()

>>> config = AltCLIPConfig.from_text_vision_configs(config_text, config_vision)
from_text_vision_configs

< source >

代码语言:javascript
复制
( text_config: AltCLIPTextConfig vision_config: AltCLIPVisionConfig **kwargs ) → export const metadata = 'undefined';AltCLIPConfig

返回

AltCLIPConfig

一个配置对象的实例

从 altclip 文本模型配置和 altclip 视觉模型配置实例化一个 AltCLIPConfig(或派生类)。

AltCLIPTextConfig

class transformers.AltCLIPTextConfig

< source >

代码语言:javascript
复制
( vocab_size = 250002 hidden_size = 1024 num_hidden_layers = 24 num_attention_heads = 16 intermediate_size = 4096 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 514 type_vocab_size = 1 initializer_range = 0.02 initializer_factor = 0.02 layer_norm_eps = 1e-05 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 position_embedding_type = 'absolute' use_cache = True project_dim = 768 **kwargs )

参数

  • vocab_size (int, optional, defaults to 250002) — AltCLIP 模型的词汇表大小。定义了在调用 AltCLIPTextModel 时可以表示的不同标记数量。
  • hidden_size (int, optional, defaults to 1024) — 编码器层和池化器层的维度。
  • num_hidden_layers (int, optional, defaults to 24) — Transformer 编码器中的隐藏层数量。
  • num_attention_heads (int, optional, defaults to 16) — Transformer 编码器中每个注意力层的注意力头数量。
  • intermediate_size (int, optional, defaults to 4096) — Transformer 编码器中“中间”(通常称为前馈)层的维度。
  • hidden_act (str or Callable, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持 "gelu""relu""silu""gelu_new"
  • hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。
  • attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的丢失比率。
  • max_position_embeddings (int, optional, defaults to 514) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512、1024 或 2048)。
  • type_vocab_size (int, optional, defaults to 1) — 在调用 AltCLIPTextModel 时传递的 token_type_ids 的词汇表大小。
  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • initializer_factor (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的因子(应保持为 1,用于内部初始化测试)。
  • layer_norm_eps (float, optional, 默认为 1e-05) — 层归一化层使用的 epsilon。
  • pad_token_id (int, optional, 默认为 1) — 填充 标记的 id。
  • bos_token_id (int, optional, 默认为 0) — 序列开始 标记的 id。
  • eos_token_id (Union[int, List[int]], optional, 默认为 2) — 序列结束 标记的 id。可选择使用列表设置多个 序列结束 标记。
  • position_embedding_type (str, optional, 默认为"absolute") — 位置嵌入的类型。选择 "absolute", "relative_key", "relative_key_query" 中的一个。对于位置嵌入,请使用 "absolute"。有关 "relative_key" 的更多信息,请参考Self-Attention with Relative Position Representations (Shaw et al.)。有关 "relative_key_query" 的更多信息,请参考Improve Transformer Models with Better Relative Position Embeddings (Huang et al.) 中的 Method 4
  • use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力(不是所有模型都使用)。仅在 config.is_decoder=True 时相关。
  • project_dim (int, optional, 默认为 768) — 映射层之前教师模型的维度。

这是用于存储 AltCLIPTextModel 配置的配置类。根据指定的参数实例化一个 AltCLIP 文本模型的配置,定义模型架构。使用默认值实例化配置将产生类似于 AltCLIP BAAI/AltCLIP 架构的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例:

代码语言:javascript
复制
>>> from transformers import AltCLIPTextModel, AltCLIPTextConfig

>>> # Initializing a AltCLIPTextConfig with BAAI/AltCLIP style configuration
>>> configuration = AltCLIPTextConfig()

>>> # Initializing a AltCLIPTextModel (with random weights) from the BAAI/AltCLIP style configuration
>>> model = AltCLIPTextModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

AltCLIPVisionConfig

class transformers.AltCLIPVisionConfig

< source >

代码语言:javascript
复制
( hidden_size = 768 intermediate_size = 3072 projection_dim = 512 num_hidden_layers = 12 num_attention_heads = 12 num_channels = 3 image_size = 224 patch_size = 32 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 **kwargs )

参数

  • hidden_size (int, optional, 默认为 768) — 编码器层和池化层的维度。
  • intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”(即前馈)层的维度。
  • projection_dim (int, optional, 默认为 512) — 文本和视觉投影层的维度。
  • num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。
  • num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
  • num_channels (int, optional, 默认为 3) — 输入通道数。
  • image_size (int, optional, 默认为 224) — 每个图像的大小(分辨率)。
  • patch_size (int, optional, 默认为 32) — 每个 patch 的大小(分辨率)。
  • hidden_act (strfunction, optional, 默认为"quick_gelu") — 编码器和池化层中的非线性激活函数(函数或字符串)。如果是字符串,支持 "gelu", "relu", "selu""gelu_new" 以及 "quick_gelu"
  • layer_norm_eps (float, optional, 默认为 1e-05) — 层归一化层使用的 epsilon。
  • attention_dropoutfloat可选,默认为 0.0)— 注意力概率的 dropout 比率。
  • initializer_rangefloat可选,默认为 0.02)— 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • initializer_factorfloat可选,默认为 1.0)— 用于初始化所有权重矩阵的因子(应保持为 1,用于内部初始化测试)。

这是用于存储 AltCLIPModel 配置的配置类。它用于根据指定的参数实例化 AltCLIP 模型,定义模型架构。使用默认值实例化配置将产生类似于 AltCLIP BAAI/AltCLIP架构的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例:

代码语言:javascript
复制
>>> from transformers import AltCLIPVisionConfig, AltCLIPVisionModel

>>> # Initializing a AltCLIPVisionConfig with BAAI/AltCLIP style configuration
>>> configuration = AltCLIPVisionConfig()

>>> # Initializing a AltCLIPVisionModel (with random weights) from the BAAI/AltCLIP style configuration
>>> model = AltCLIPVisionModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

AltCLIPProcessor

class transformers.AltCLIPProcessor

<来源>

代码语言:javascript
复制
( image_processor = None tokenizer = None **kwargs )

参数

  • image_processor(CLIPImageProcessor,可选)— 图像处理器是必需的。
  • tokenizer(XLMRobertaTokenizerFast,可选)— 分词器是必需的。

构建一个 AltCLIP 处理器,将 CLIP 图像处理器和 XLM-Roberta 分词器包装成一个单一处理器。

AltCLIPProcessor 提供了 CLIPImageProcessor 和 XLMRobertaTokenizerFast 的所有功能。查看__call__()和 decode()以获取更多信息。

batch_decode

<来源>

代码语言:javascript
复制
( *args **kwargs )

此方法将其所有参数转发给 XLMRobertaTokenizerFast 的 batch_decode()。有关更多信息,请参阅此方法的文档字符串。

decode

<来源>

代码语言:javascript
复制
( *args **kwargs )

此方法将其所有参数转发给 XLMRobertaTokenizerFast 的 decode()。有关更多信息,请参阅此方法的文档字符串。

AltCLIPModel

class transformers.AltCLIPModel

<来源>

代码语言:javascript
复制
( config: AltCLIPConfig )
forward

<来源>

代码语言:javascript
复制
( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None position_ids: Optional = None token_type_ids: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.altclip.modeling_altclip.AltCLIPOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)— 词汇表中输入序列标记的索引。默认情况下将忽略填充。 可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID?
  • attention_mask (torch.Tensor,形状为(batch_size, sequence_length)可选) — 避免在填充标记索引上执行注意力的掩码。选择在[0, 1]范围内的掩码值:
    • 对于未被掩码的标记为 1,
    • 对于被掩码的标记为 0。

    什么是注意力掩码?

  • position_ids (torch.LongTensor,形状为(batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID?
  • pixel_values (torch.FloatTensor,形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 CLIPImageProcessor.call()。
  • return_loss (bool, 可选) — 是否返回对比损失。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.altclip.modeling_altclip.AltCLIPOutputtuple(torch.FloatTensor)

一个transformers.models.altclip.modeling_altclip.AltCLIPOutput或一个torch.FloatTensor元组(如果传递return_dict=False或当config.return_dict=False时),包括根据配置(<class 'transformers.models.altclip.configuration_altclip.AltCLIPConfig'>)和输入的各种元素。

  • loss (torch.FloatTensor,形状为(1,)可选,当return_lossTrue时返回) — 图像-文本相似性的对比损失。
  • logits_per_image:(torch.FloatTensor,形状为(image_batch_size, text_batch_size)) — image_embedstext_embeds之间的缩放点积分数。这代表图像-文本相似性分数。
  • logits_per_text:(torch.FloatTensor,形状为(text_batch_size, image_batch_size)) — text_embedsimage_embeds之间的缩放点积分数。这代表文本-图像相似性分数。
  • text_embeds(torch.FloatTensor,形状为(batch_size, output_dim) — 通过将投影层应用于 AltCLIPTextModel 的汇聚输出获得的文本嵌入。
  • image_embeds(torch.FloatTensor,形状为(batch_size, output_dim) — 通过将投影层应用于 AltCLIPVisionModel 的汇聚输出获得的图像嵌入。
  • text_model_output(BaseModelOutputWithPooling): AltCLIPTextModel 的输出。
  • vision_model_output(BaseModelOutputWithPooling): AltCLIPVisionModel 的输出。

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

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AltCLIPModel

>>> model = AltCLIPModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="pt", padding=True
... )
>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = logits_per_image.softmax(dim=1)  # we can take the softmax to get the label probabilities
get_text_features

<来源>

代码语言:javascript
复制
( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None token_type_ids = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';text_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)- 词汇表中输入序列标记的索引。默认情况下将忽略填充。 可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID?
  • attention_mask(形状为(batch_size, sequence_length)torch.Tensor可选)- 避免在填充令牌索引上执行注意力的掩码。选择在[0, 1]范围内的掩码值:
    • 对于未被屏蔽的标记,为 1,
    • 对于被屏蔽的标记,为 0。

    什么是注意力掩码?

  • position_ids(形状为(batch_size, sequence_length)torch.LongTensor可选)- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID?
  • output_attentionsbool可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
  • output_hidden_statesbool可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dictbool可选)- 是否返回 ModelOutput 而不是普通元组。

返回

text_features(形状为(batch_size, output_dim)torch.FloatTensor

通过将投影层应用于 AltCLIPTextModel 的汇总输出获得的文本嵌入。

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

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

示例:

代码语言:javascript
复制
>>> from transformers import AutoProcessor, AltCLIPModel

>>> model = AltCLIPModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")
>>> inputs = processor(text=["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)
get_image_features

<来源>

代码语言:javascript
复制
( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';image_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

  • pixel_values(形状为(batch_size, num_channels, height, width)torch.FloatTensor)- 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 CLIPImageProcessor.call()。
  • output_attentionsbool可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
  • output_hidden_statesbool可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dict(布尔值,可选)— 是否返回 ModelOutput 而不是普通元组。

返回

image_features(形状为(batch_size,output_dim)的 torch.FloatTensor)

通过将投影层应用于 AltCLIPVisionModel 的汇聚输出获得的图像嵌入。

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

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

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AltCLIPModel

>>> model = AltCLIPModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, return_tensors="pt")
>>> image_features = model.get_image_features(**inputs)

AltCLIPTextModel

class transformers.AltCLIPTextModel

<来源>

代码语言:javascript
复制
( config )
forward

<来源>

代码语言:javascript
复制
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None output_attentions: Optional = None return_dict: Optional = None output_hidden_states: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndProjection or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size,sequence_length)的 torch.LongTensor)— 词汇表中输入序列标记的索引。默认情况下将忽略填充。 可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID?
  • attention_mask(形状为(batch_size,sequence_length)的 torch.Tensor,可选)— 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间:
    • 1 表示“未被掩盖”的标记,
    • 0 表示“被掩盖”的标记。

    什么是注意力掩码?

  • position_ids(形状为(batch_size,sequence_length)的 torch.LongTensor,可选)— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID?
  • output_attentions(布尔值,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
  • output_hidden_states(布尔值,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dict(布尔值,可选)— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingAndProjectiontuple(torch.FloatTensor)

一个transformers.modeling_outputs.BaseModelOutputWithPoolingAndProjection或一个torch.FloatTensor元组(如果传递了return_dict=Falseconfig.return_dict=False时)包含各种元素,取决于配置(<class 'transformers.models.altclip.configuration_altclip.AltCLIPTextConfig'>)和输入。

  • last_hidden_state(形状为(batch_size,sequence_length,hidden_size)的 torch.FloatTensor)— 模型最后一层的隐藏状态序列输出。
  • pooler_output (torch.FloatTensor,形状为(batch_size, hidden_size)) — 经过用于辅助预训练任务的层进一步处理后,序列中第一个标记(分类标记)的最后一层隐藏状态。例如,对于 BERT 系列模型,这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测(分类)目标中训练的。
  • hidden_states (tuple(torch.FloatTensor)可选,当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出一个 + 每一层的输出一个)。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  • attentions (tuple(torch.FloatTensor)可选,当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。 注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
  • projection_state (tuple(torch.FloatTensor),当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size,config.project_dim)torch.FloatTensor元组。 投影层之前的文本嵌入,用于模仿教师编码器的最后隐藏状态。

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

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者会处理运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

代码语言:javascript
复制
>>> from transformers import AutoProcessor, AltCLIPTextModel

>>> model = AltCLIPTextModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")

>>> texts = ["it's a cat", "it's a dog"]

>>> inputs = processor(text=texts, padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states

AltCLIPVisionModel

class transformers.AltCLIPVisionModel

<来源>

代码语言:javascript
复制
( config: AltCLIPVisionConfig )
forward

<来源>

代码语言:javascript
复制
( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor,形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 CLIPImageProcessor.call()。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False)包括根据配置(<class 'transformers.models.altclip.configuration_altclip.AltCLIPVisionConfig'>)和输入的不同元素。

  • last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
  • pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 经过用于辅助预训练任务的层进一步处理后,序列中第一个标记(分类标记)的最后一层隐藏状态。例如,对于 BERT 系列模型,这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是从下一个句子预测(分类)目标在预训练期间训练的。
  • hidden_states (tuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出+每一层的输出)。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  • attentions (tuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。 在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

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

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是这个函数,因为前者会负责运行前处理和后处理步骤,而后者会默默地忽略它们。

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AltCLIPVisionModel

>>> model = AltCLIPVisionModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states

BLIP

原文链接:huggingface.co/docs/transformers/v4.37.2/en/model_doc/blip

概述

BLIP 模型是由 Junnan Li、Dongxu Li、Caiming Xiong 和 Steven Hoi 在BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation中提出的。

BLIP 是一个能够执行各种多模态任务的模型,包括:

  • 视觉问答
  • 图像-文本检索(图像-文本匹配)
  • 图像字幕生成

论文摘要如下:

视觉-语言预训练(VLP)已经提高了许多视觉-语言任务的性能。然而,大多数现有的预训练模型只擅长于理解型任务或生成型任务。此外,性能的提升主要是通过扩大数据集规模,使用从网络收集的带有噪声的图像-文本对来实现的,这是一种次优的监督来源。在本文中,我们提出了 BLIP,一种新的 VLP 框架,可以灵活地转移到视觉-语言理解和生成任务。BLIP 通过引导标题来有效利用嘈杂的网络数据,其中一个标题生成器生成合成标题,一个过滤器去除噪声标题。我们在各种视觉-语言任务上取得了最先进的结果,如图像-文本检索(平均召回率@1 提高了 2.7%)、图像字幕生成(CIDEr 提高了 2.8%)和 VQA(VQA 分数提高了 1.6%)。BLIP 还展示了在直接转移到视频-语言任务时的强大泛化能力。代码、模型和数据集已发布。

BLIP.gif
BLIP.gif

该模型由ybelkada贡献。原始代码可在此处找到。

资源

  • Jupyter 笔记本,介绍如何在自定义数据集上对 BLIP 进行图像字幕微调

BlipConfig

class transformers.BlipConfig

<来源>

代码语言:javascript
复制
( text_config = None vision_config = None projection_dim = 512 logit_scale_init_value = 2.6592 image_text_hidden_size = 256 **kwargs )

参数

  • text_config (dict, optional) — 用于初始化 BlipTextConfig 的配置选项字典。
  • vision_config (dict, optional) — 用于初始化 BlipVisionConfig 的配置选项字典。
  • projection_dim (int, optional, 默认为 512) — 文本和视觉投影层的维度。
  • logit_scale_init_value (float, optional, 默认为 2.6592) — logit_scale 参数的初始值。默认值与原始 BLIP 实现相同。
  • image_text_hidden_size (int, optional, 默认为 256) — 图像文本融合层隐藏状态的维度。
  • kwargs (optional) — 关键字参数的字典。

BlipConfig 是存储 BlipModel 配置的配置类。它用于根据指定的参数实例化一个 BLIP 模型,定义文本模型和视觉模型配置。使用默认值实例化配置将产生类似于 BLIP-base Salesforce/blip-vqa-base架构的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例:

代码语言:javascript
复制
>>> from transformers import BlipConfig, BlipModel

>>> # Initializing a BlipConfig with Salesforce/blip-vqa-base style configuration
>>> configuration = BlipConfig()

>>> # Initializing a BlipPModel (with random weights) from the Salesforce/blip-vqa-base style configuration
>>> model = BlipModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

>>> # We can also initialize a BlipConfig from a BlipTextConfig and a BlipVisionConfig

>>> # Initializing a BLIPText and BLIPVision configuration
>>> config_text = BlipTextConfig()
>>> config_vision = BlipVisionConfig()

>>> config = BlipConfig.from_text_vision_configs(config_text, config_vision)
from_text_vision_configs

<来源>

代码语言:javascript
复制
( text_config: BlipTextConfig vision_config: BlipVisionConfig **kwargs ) → export const metadata = 'undefined';BlipConfig

返回

BlipConfig

配置对象的一个实例

从 blip 文本模型配置和 blip 视觉模型配置实例化一个 BlipConfig(或派生类)。

BlipTextConfig

class transformers.BlipTextConfig

<来源>

代码语言:javascript
复制
( vocab_size = 30524 hidden_size = 768 encoder_hidden_size = 768 intermediate_size = 3072 projection_dim = 768 num_hidden_layers = 12 num_attention_heads = 8 max_position_embeddings = 512 hidden_act = 'gelu' layer_norm_eps = 1e-12 hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 bos_token_id = 30522 eos_token_id = 2 pad_token_id = 0 sep_token_id = 102 is_decoder = True use_cache = True **kwargs )

参数

  • vocab_size (int, optional, 默认为 30524) — Blip 文本模型的词汇量。定义了在调用 BlipModel 时可以表示的不同标记数量。
  • hidden_size (int, optional, 默认为 768) — 编码器层和池化器层的维度。
  • encoder_hidden_size (int, optional, 默认为 768) — 来自视觉模型的编码器层的维度。
  • intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”(即前馈)层的维度。
  • num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。
  • num_attention_heads (int, optional, 默认为 8) — Transformer 编码器中每个注意力层的注意力头数量。
  • max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512、1024 或 2048)。
  • hidden_act (strfunction, optional, 默认为 "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持 "gelu", "relu", "selu""gelu_new" "gelu"
  • layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。
  • hidden_dropout_prob (float, optional, 默认为 0.0) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。
  • attention_dropout (float, optional, 默认为 0.0) — 注意力概率的丢弃比率。
  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • bos_token_id (int, optional, 默认为 30522) — beginning-of-sequence 标记的 id。
  • eos_token_id (int, optional, 默认为 2) — end-of-sequence 标记的 id。
  • pad_token_id (int, optional, 默认为 0) — padding 标记的 id。
  • sep_token_id (int, optional, 默认为 102) — separator 标记的 id。
  • is_decoder (bool, optional, 默认为 True) — 模型是否用作解码器。
  • use_cache (bool, optional, 默认为 True) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。

这是用于存储 BlipTextModel 配置的配置类。它用于根据指定的参数实例化一个 BLIP 文本模型,定义模型架构。使用默认值实例化配置将产生类似于由 base architectures 使用的 BlipText 的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例:

代码语言:javascript
复制
>>> from transformers import BlipTextConfig, BlipTextModel

>>> # Initializing a BlipTextConfig with Salesforce/blip-vqa-base style configuration
>>> configuration = BlipTextConfig()

>>> # Initializing a BlipTextModel (with random weights) from the Salesforce/blip-vqa-base style configuration
>>> model = BlipTextModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

BlipVisionConfig

class transformers.BlipVisionConfig

< source >

代码语言:javascript
复制
( hidden_size = 768 intermediate_size = 3072 projection_dim = 512 num_hidden_layers = 12 num_attention_heads = 12 image_size = 384 patch_size = 16 hidden_act = 'gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 1e-10 **kwargs )

参数

  • hidden_size (int, optional, defaults to 768) — 编码器层和池化层的维度。
  • intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”(即前馈)层的维度。
  • num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数。
  • num_attention_heads (int, optional, defaults to 12) — 每个注意力层中的注意力头数。
  • image_size (int, optional, defaults to 384) — 每个图像的大小(分辨率)。
  • patch_size (int, optional, defaults to 16) — 每个 patch 的大小(分辨率)。
  • hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu""relu""selu""gelu_new"
  • layer_norm_eps (float, optional, defaults to 1e-5) — 层归一化层使用的 epsilon。
  • attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
  • initializer_range (float, optional, defaults to 1e-10) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

这是用于存储 BlipVisionModel 配置的配置类。它用于根据指定的参数实例化 BLIP 视觉模型,定义模型架构。实例化默认配置将产生类似于 Blip-base Salesforce/blip-vqa-base架构的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例:

代码语言:javascript
复制
>>> from transformers import BlipVisionConfig, BlipVisionModel

>>> # Initializing a BlipVisionConfig with Salesforce/blip-vqa-base style configuration
>>> configuration = BlipVisionConfig()

>>> # Initializing a BlipVisionModel (with random weights) from the Salesforce/blip-vqa-base style configuration
>>> model = BlipVisionModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

BlipProcessor

class transformers.BlipProcessor

< source >

代码语言:javascript
复制
( image_processor tokenizer )

参数

  • image_processor (BlipImageProcessor) — 一个 BlipImageProcessor 的实例。图像处理器是必需的输入。
  • tokenizer (BertTokenizerFast) — 一个[‘BertTokenizerFast`]的实例。此 tokenizer 是必需的输入。

构建一个 BLIP 处理器,将 BERT tokenizer 和 BLIP 图像处理器包装成单个处理器。

BlipProcessor 提供了 BlipImageProcessor 和 BertTokenizerFast 的所有功能。有关更多信息,请参阅__call__()和 decode()的文档字符串。

batch_decode

< source >

代码语言:javascript
复制
( *args **kwargs )

此方法将其所有参数转发给 BertTokenizerFast 的 batch_decode()。有关更多信息,请参阅此方法的文档字符串。

decode

< source >

代码语言:javascript
复制
( *args **kwargs )

此方法将所有参数转发给 BertTokenizerFast 的 decode()。请参考此方法的文档字符串以获取更多信息。

BlipImageProcessor

class transformers.BlipImageProcessor

<来源>

代码语言:javascript
复制
( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_convert_rgb: bool = True **kwargs )

参数

  • do_resize (bool, 可选, 默认为 True) — 是否将图像的(高度,宽度)尺寸调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。
  • size (dict, 可选, 默认为 {"height" -- 384, "width": 384}): 调整大小后的输出图像尺寸。可以被preprocess方法中的size参数覆盖。
  • resample (PILImageResampling, 可选, 默认为 Resampling.BICUBIC) — 如果调整图像大小,则要使用的重采样滤波器。仅在do_resize设置为True时才有效。可以被preprocess方法中的resample参数覆盖。
  • do_rescale (bool, 可选, 默认为 True) — 是否按指定比例rescale_factor对图像进行重新缩放。可以被preprocess方法中的do_rescale参数覆盖。
  • rescale_factor (intfloat, 可选, 默认为 1/255) — 如果重新缩放图像,则要使用的比例因子。仅在do_rescale设置为True时才有效。可以被preprocess方法中的rescale_factor参数覆盖。
  • do_normalize (bool, 可选, 默认为 True) — 是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。可以被preprocess方法中的do_normalize参数覆盖。
  • image_mean (floatList[float], 可选, 默认为 IMAGENET_STANDARD_MEAN) — 在归一化图像时使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_mean参数覆盖。可以被preprocess方法中的image_mean参数覆盖。
  • image_std (floatList[float], 可选, 默认为 IMAGENET_STANDARD_STD) — 在归一化图像时使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_std参数覆盖。可以被preprocess方法中的image_std参数覆盖。
  • do_convert_rgb (bool, 可选, 默认为 True) — 是否将图像转换为 RGB。

构建一个 BLIP 图像处理器。

preprocess

<来源>

代码语言:javascript
复制
( images: Union do_resize: Optional = None size: Optional = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None return_tensors: Union = None do_convert_rgb: bool = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

  • images (ImageInput) — 要预处理的图像。期望传入像素值范围为 0 到 255 的单个图像或图像批次。如果传入像素值在 0 到 1 之间的图像,请设置do_rescale=False
  • do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像。
  • size (Dict[str, int], 可选, 默认为 self.size) — 控制resize后图像的大小。图像的最短边被调整为size["shortest_edge"],同时保持纵横比。如果此调整后图像的最长边 > int(size["shortest_edge"] * (1333 / 800)),则再次调整图像大小,使最长边等于int(size["shortest_edge"] * (1333 / 800))
  • resample (PILImageResampling, 可选, 默认为 self.resample) — 如果调整图像大小,则要使用的重采样滤波器。仅在do_resize设置为True时才有效。
  • do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否将图像值重新缩放在[0 - 1]之间。
  • rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果do_rescale设置为True,则要按照此比例因子重新缩放图像。
  • do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。
  • image_mean (floatList[float], 可选, 默认为 self.image_mean) — 如果 do_normalize 设置为 True,用于归一化图像的图像均值。
  • image_std (floatList[float], 可选, 默认为 self.image_std) — 如果 do_normalize 设置为 True,用于归一化图像的图像标准差。
  • do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb) — 是否将图像转换为 RGB。
  • return_tensors (strTensorType, 可选) — 要返回的张量类型。可以是以下之一:
    • 未设置:返回一个 np.ndarray 列表。
    • TensorType.TENSORFLOW'tf': 返回一个类型为 tf.Tensor 的批次。
    • TensorType.PYTORCH'pt': 返回一个类型为 torch.Tensor 的批次。
    • TensorType.NUMPY'np': 返回一个类型为 np.ndarray 的批次。
    • TensorType.JAX'jax': 返回一个类型为 jax.numpy.ndarray 的批次。
  • data_format (ChannelDimensionstr, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像格式为 (通道数, 高度, 宽度)。
    • "channels_last"ChannelDimension.LAST: 图像格式为 (高度, 宽度, 通道数)。
    • 未设置:使用输入图像的通道维度格式。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未设置,则从输入图像中推断通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像格式为 (通道数, 高度, 宽度)。
    • "channels_last"ChannelDimension.LAST: 图像格式为 (高度, 宽度, 通道数)。
    • "none"ChannelDimension.NONE: 图像格式为 (高度, 宽度)。

预处理图像或图像批次。

Pytorch 隐藏 Pytorch 内容

BlipModel

class transformers.BlipModel

<来源>

代码语言:javascript
复制
( config: BlipConfig )

参数

  • config (BlipConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。

该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

该模型还是一个 PyTorch torch.nn.Module 子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言:javascript
复制
( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None position_ids: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_blip.BlipOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下,提供填充将被忽略。 可以使用 AutoProcessor 获取索引。有关详细信息,请参阅 BlipProcessor.__call__()。 什么是输入 ID?
  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length)可选) — 避免在填充标记索引上执行注意力的掩码。选择在 [0, 1] 中的掩码值:
    • 1 代表未被“掩码”的标记,
    • 0 代表被“掩码”的标记。

    什么是注意力掩码?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。 什么是位置 ID?
  • pixel_values (torch.FloatTensor,形状为 (batch_size, num_channels, height, width)) — 像素值。默认情况下会忽略填充。可以使用 BlipImageProcessor 获取像素值。详细信息请参见 BlipImageProcessor.call()。
  • return_loss (bool可选) — 是否返回对比损失。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_blip.BlipOutputtuple(torch.FloatTensor)

一个 transformers.models.blip.modeling_blip.BlipOutput 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时)包含根据配置 (<class 'transformers.models.blip.configuration_blip.BlipConfig'>) 和输入而异的各种元素。

  • loss (torch.FloatTensor,形状为 (1,)可选,当 return_lossTrue 时返回) — 图像-文本相似性的对比损失。
  • logits_per_image:(torch.FloatTensor,形状为 (image_batch_size, text_batch_size)) — image_embedstext_embeds 之间的缩放点积分数。这代表图像-文本相似性分数。
  • logits_per_text:(torch.FloatTensor,形状为 (text_batch_size, image_batch_size)) — text_embedsimage_embeds 之间的缩放点积分数。这代表文本-图像相似性分数。
  • text_embeds(torch.FloatTensor,形状为 (batch_size, output_dim) — 通过将投影层应用于 BlipTextModel 的池化输出获得的文本嵌入。
  • image_embeds(torch.FloatTensor,形状为 (batch_size, output_dim) — 通过将投影层应用于 BlipVisionModel 的池化输出获得的图像嵌入。
  • text_model_output(BaseModelOutputWithPooling): BlipTextModel 的输出。
  • vision_model_output(BaseModelOutputWithPooling): BlipVisionModel 的输出。

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

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module 实例,而不是在此处调用,因为前者会处理运行前后的处理步骤,而后者会默默地忽略它们。

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipModel

>>> model = BlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="pt", padding=True
... )

>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = logits_per_image.softmax(dim=1)  # we can take the softmax to get the label probabilities
get_text_features

< source >

代码语言:javascript
复制
( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';text_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。 可以使用 AutoProcessor 获取索引。有关详细信息,请参阅BlipProcessor.__call__()。 什么是输入 ID?
  • attention_mask(形状为(batch_size, sequence_length)torch.Tensor可选)— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]范围内:
    • 1 表示未被掩盖的标记,
    • 0 表示被掩盖的标记。

    什么是注意力掩码?

  • position_ids(形状为(batch_size, sequence_length)torch.LongTensor可选)— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID?
  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dictbool可选)— 是否返回 ModelOutput 而不是普通元组。

返回

text_features(形状为(batch_size, output_dim)torch.FloatTensor

通过将投影层应用于 BlipTextModel 的池化输出获得的文本嵌入。

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

虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

示例:

代码语言:javascript
复制
>>> from transformers import AutoProcessor, BlipModel

>>> model = BlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

>>> inputs = processor(text=["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)

get_image_features

<来源>

代码语言:javascript
复制
( pixel_values: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';image_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

  • pixel_values(形状为(batch_size, num_channels, height, width)torch.FloatTensor)— 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。
  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dictbool可选)— 是否返回 ModelOutput 而不是普通元组。

返回

image_features(形状为(batch_size, output_dim)torch.FloatTensor

通过将投影层应用于 BlipVisionModel 的池化输出获得的图像嵌入。

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

虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipModel

>>> model = BlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="pt")

>>> image_features = model.get_image_features(**inputs)

BlipTextModel

class transformers.BlipTextModel

<来源>

代码语言:javascript
复制
( config add_pooling_layer = True )

该模型可以作为编码器(仅具有自注意力)以及解码器运行,此时在自注意力层之间添加了一层交叉注意力,遵循Ashish Vaswani,Noam Shazeer,Niki Parmar,Jakob Uszkoreit,Llion Jones,Aidan N. Gomez,Lukasz Kaiser 和 Illia Polosukhin 所描述的架构。参数和is_decoder设置为True;然后预期将encoder_hidden_states作为输入传递给前向传递。

forward

<来源>

代码语言:javascript
复制
( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None is_decoder: Optional = False )

encoder_hidden_states(torch.FloatTensor可选):编码器最后一层的隐藏状态序列。如果模型配置为解码器,则在交叉注意力中使用。encoder_attention_mask(torch.FloatTensor可选):避免对编码器输入的填充标记索引执行注意力的掩码。如果模型配置为解码器,则在交叉注意力中使用。掩码值选择在[0, 1]中:

  • 对于未被masked的标记为 1,
  • 对于被masked的标记为 0。past_key_values(tuple(tuple(torch.FloatTensor))可选):包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values,用户可以选择仅输入最后的decoder_input_ids(这些没有将其过去的键值状态提供给此模型的)形状为(batch_size, 1)的而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。use_cache(bool可选):如果设置为True,将返回past_key_values键值状态,并可用于加速解码(参见past_key_values)。

BlipVisionModel

class transformers.BlipVisionModel

<来源>

代码语言:javascript
复制
( config: BlipVisionConfig )
forward

<来源>

代码语言:javascript
复制
( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

  • pixel_values(形状为(batch_size, num_channels, height, width)torch.FloatTensor)— 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。
  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的张量下的attentions
  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的张量下的hidden_states
  • return_dictbool可选)— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPooling 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组(如果传递了return_dict=False或当config.return_dict=False时)包括根据配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>)和输入的不同元素。

  • last_hidden_state(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor)— 模型最后一层的隐藏状态序列。
  • pooler_output (torch.FloatTensor,形状为(batch_size, hidden_size)) — 序列第一个标记(分类标记)的最后一层隐藏状态,经过用于辅助预训练任务的层进一步处理后的结果。例如,对于 BERT 系列模型,这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测(分类)目标中训练的。
  • hidden_states (tuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  • attentions (tuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。 注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

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

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

BlipForConditionalGeneration

class transformers.BlipForConditionalGeneration

<来源>

代码语言:javascript
复制
( config: BlipConfig )

参数

  • config (BlipConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

用于图像字幕的 BLIP 模型。该模型由视觉编码器和文本解码器组成。可以选择向模型传递input_ids,作为文本提示,以使文本解码器继续提示。否则,解码器将从[BOS](序列开始)标记开始生成文本。将从文本输入开始生成标题。如果未提供文本输入,则解码器将仅从[BOS]标记开始。

这个模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

代码语言:javascript
复制
( pixel_values: FloatTensor input_ids: Optional = None attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor,形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多细节,请参阅返回张量中的 attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多细节,请参阅返回张量中的 hidden_states
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutputtorch.FloatTensor 元组

一个 transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时)包含根据配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>)和输入的不同元素。

  • loss (torch.FloatTensor, optional, 当提供 labels 时返回,形状为 (1,)torch.FloatTensor) — 文本解码器的语言建模损失。
  • logits (torch.FloatTensor,形状为 (batch_size, sequence_length, config.vocab_size)optional) — 文本解码器模型的语言建模头的预测分数。
  • image_embeds (torch.FloatTensor,形状为 (batch_size, output_dim)optional) — 将 Vision Transformer 模型应用于输入图像后获得的图像嵌入。
  • last_hidden_state (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)optional) — 模型最后一层的隐藏状态序列。
  • hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True) — torch.FloatTensor 元组(如果模型有嵌入层,则为嵌入的输出 + 每个层的输出)的形状为 (batch_size, sequence_length, hidden_size)。 模型在每个层的输出的隐藏状态以及可选的初始嵌入输出。
  • attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 时返回) — torch.FloatTensor 元组(每个层一个)的形状为 (batch_size, num_heads, sequence_length, sequence_length)。 注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

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

虽然前向传递的方法需要在此函数内定义,但应该在此之后调用 Module 实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默忽略它们。

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipForConditionalGeneration

>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
>>> model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "A picture of"

>>> inputs = processor(images=image, text=text, return_tensors="pt")

>>> outputs = model(**inputs)

BlipForImageTextRetrieval

class transformers.BlipForImageTextRetrieval

< source >

代码语言:javascript
复制
( config: BlipConfig )

参数

  • config (BlipConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。

带有视觉和文本投影仪以及顶部分类头的 BLIP 模型。该模型用于图像文本检索的上下文。给定一张图像和一段文本,模型返回文本与图像相关的概率。

该模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。

该模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言:javascript
复制
( input_ids: LongTensor pixel_values: FloatTensor use_itm_head: Optional = True attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_blip.BlipTextVisionModelOutput or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor,形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参见 BlipImageProcessor.call()。
  • output_attentions (booloptional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
  • return_dict (booloptional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_blip.BlipTextVisionModelOutputtuple(torch.FloatTensor)

一个transformers.models.blip.modeling_blip.BlipTextVisionModelOutput或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False)包含根据配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>)和输入的不同元素。

  • loss (torch.FloatTensor,形状为(1,)optional,当提供labels时返回) — 文本解码器的语言建模损失。
  • image_embeds (torch.FloatTensor,形状为(batch_size, output_dim) optional,当模型使用with_projection=True初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。
  • last_hidden_state (torch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
  • hidden_states (tuple(torch.FloatTensor)optional,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型具有嵌入层,则为嵌入输出的输出+每层的输出)。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  • attentions (tuple(torch.FloatTensor)optional,当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。 注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

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

虽然前向传递的步骤需要在此函数内定义,但应该在之后调用Module实例,而不是在此处调用,因为前者会处理运行前和运行后的处理步骤,而后者会默默地忽略它们。

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipForImageTextRetrieval

>>> model = BlipForImageTextRetrieval.from_pretrained("Salesforce/blip-itm-base-coco")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-itm-base-coco")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "an image of a cat"

>>> inputs = processor(images=image, text=text, return_tensors="pt")
>>> outputs = model(**inputs)

BlipForQuestionAnswering

class transformers.BlipForQuestionAnswering

<来源>

代码语言:javascript
复制
( config: BlipConfig )

参数

  • config(BlipConfig)- 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

用于视觉问答的 BLIP 模型。该模型包括一个视觉编码器、一个文本编码器以及一个文本解码器。视觉编码器将对输入图像进行编码,文本编码器将对输入问题进行编码,并与图像的编码一起进行编码,文本解码器将输出问题的答案。

此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言:javascript
复制
( input_ids: LongTensor pixel_values: FloatTensor decoder_input_ids: Optional = None decoder_attention_mask: Optional = None attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_blip.BlipTextVisionModelOutput or tuple(torch.FloatTensor)

参数

  • pixel_values(形状为(batch_size, num_channels, height, width)torch.FloatTensor)- 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。
  • output_attentionsbool可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回的张量下的attentions
  • output_hidden_statesbool可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回的张量下的hidden_states
  • return_dictbool可选)- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_blip.BlipTextVisionModelOutputtuple(torch.FloatTensor)

一个transformers.models.blip.modeling_blip.BlipTextVisionModelOutput或一个torch.FloatTensor元组(如果传递return_dict=False或当config.return_dict=False时)包含根据配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>)和输入的不同元素。

  • loss(形状为(1,)torch.FloatTensor可选,当提供labels时返回)- 来自文本解码器的语言建模损失。
  • image_embeds(形状为(batch_size, output_dim)torch.FloatTensor 可选,当使用with_projection=True初始化模型时返回)- 通过将投影层应用于 pooler_output 获得的图像嵌入。
  • last_hidden_state(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor)- 模型最后一层的隐藏状态序列。
  • hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=True或当config.output_hidden_states=True时返回)- 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型具有嵌入层,则为嵌入的输出+每个层的输出)。 模型在每个层的输出处的隐藏状态以及可选的初始嵌入输出。
  • attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。 在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

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

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

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipForQuestionAnswering

>>> model = BlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-vqa-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> # training
>>> text = "How many cats are in the picture?"
>>> label = "2"
>>> inputs = processor(images=image, text=text, return_tensors="pt")
>>> labels = processor(text=label, return_tensors="pt").input_ids

>>> inputs["labels"] = labels
>>> outputs = model(**inputs)
>>> loss = outputs.loss
>>> loss.backward()

>>> # inference
>>> text = "How many cats are in the picture?"
>>> inputs = processor(images=image, text=text, return_tensors="pt")
>>> outputs = model.generate(**inputs)
>>> print(processor.decode(outputs[0], skip_special_tokens=True))
2

TensorFlow 隐藏 TensorFlow 内容

TFBlipModel

class transformers.TFBlipModel

<来源>

代码语言:javascript
复制
( config: BlipConfig *inputs **kwargs )
call

<来源>

代码语言:javascript
复制
( input_ids: tf.Tensor | None = None pixel_values: tf.Tensor | None = None attention_mask: tf.Tensor | None = None position_ids: tf.Tensor | None = None return_loss: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_tf_blip.TFBlipOutput or tuple(tf.Tensor)

参数

  • input_ids(形状为(batch_size, sequence_length)tf.Tensor) — 输入序列标记在词汇表中的索引。默认情况下,如果提供了填充,将忽略填充。 可以使用 AutoProcessor 获取索引。有关详细信息,请参阅BlipProcessor.__call__()。 什么是输入 ID?
  • attention_mask(形状为(batch_size, sequence_length)tf.Tensor可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中:
    • 1 表示未被掩码的标记,
    • 0 表示被掩码的标记。

    什么是注意力掩码?

  • position_ids(形状为(batch_size, sequence_length)tf.Tensor可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID?
  • pixel_values(形状为(batch_size, num_channels, height, width)tf.Tensor) — 像素值。默认情况下,如果提供了填充,将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。
  • return_lossbool可选) — 是否返回对比损失。
  • output_attentionsbool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
  • output_hidden_statesbool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dictbool可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.models.blip.modeling_tf_blip.TFBlipOutputtuple(tf.Tensor)

一个transformers.models.blip.modeling_tf_blip.TFBlipOutput或一个tf.Tensor元组(如果传递return_dict=Falseconfig.return_dict=False)包含根据配置(<class 'transformers.models.blip.configuration_blip.BlipConfig'>)和输入的各种元素。

  • 损失(形状为(1,)tf.Tensor可选,当return_lossTrue时返回) — 图像-文本相似性的对比损失。
  • logits_per_image:(tf.Tensor形状为(image_batch_size, text_batch_size)) — image_embedstext_embeds之间的缩放点积分数。这代表图像-文本相似性分数。
  • logits_per_text:(tf.Tensor 的形状为 (text_batch_size, image_batch_size)) — text_embedsimage_embeds 之间的缩放点积分数。这代表了文本-图像相似性分数。
  • text_embeds(tf.Tensor 的形状为 (batch_size, output_dim) — 通过将投影层应用于 BlipTextModel 的汇聚输出获得的文本嵌入。
  • image_embeds(tf.Tensor 的形状为 (batch_size, output_dim) — 通过将投影层应用于 BlipVisionModel 的汇聚输出获得的图像嵌入。
  • text_model_output(BaseModelOutputWithPooling): BlipTextModel 的输出。
  • vision_model_output(BaseModelOutputWithPooling): BlipVisionModel 的输出。

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

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module 实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipModel

>>> model = TFBlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="tf", padding=True
... )

>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = tf.nn.softmax(logits_per_image, axis=1)  # we can take the softmax to get the label probabilities
get_text_features

< source >

代码语言:javascript
复制
( input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None position_ids: tf.Tensor | None = None return_dict: Optional[bool] = None ) → export const metadata = 'undefined';text_features (tf.Tensor of shape (batch_size, output_dim)

参数

  • input_ids (tf.Tensor 的形状为 (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。默认情况下将忽略填充。 可以使用 AutoProcessor 获得索引。有关详细信息,请参阅 BlipProcessor.__call__()。 什么是输入 ID?
  • attention_mask (tf.Tensor 的形状为 (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]
    • 1 代表未被“masked”的标记,
    • 对于被masked的标记。

    什么是注意力掩码?

  • position_ids (tf.Tensor 的形状为 (batch_size, sequence_length), 可选) — 每个输入序列标记的位置在位置嵌入中的索引。选在范围 [0, config.max_position_embeddings - 1]。 什么是位置 ID?
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

text_features (tf.Tensor 的形状为 (batch_size, output_dim)

通过将投影层应用于 TFBlipTextModel 的汇聚输出获得的文本嵌入。

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

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module 实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

示例:

代码语言:javascript
复制
>>> from transformers import AutoProcessor, TFBlipModel

>>> model = TFBlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

>>> inputs = processor(text=["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="tf")
>>> text_features = model.get_text_features(**inputs)
get_image_features

< source >

代码语言:javascript
复制
( pixel_values: tf.Tensor | None = None return_dict: Optional[bool] = None ) → export const metadata = 'undefined';image_features (tf.Tensor of shape (batch_size, output_dim)

参数

  • pixel_values (tf.Tensor,形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

image_features (tf.Tensor,形状为(batch_size, output_dim)

通过将 TFBlipVisionModel 的池化输出应用于投影层获得的图像嵌入。

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

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

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipModel

>>> model = TFBlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="tf")

>>> image_features = model.get_image_features(**inputs)

TFBlipTextModel

class transformers.TFBlipTextModel

<来源>

代码语言:javascript
复制
( config add_pooling_layer = True name = None **kwargs )

该模型可以作为编码器(仅具有自注意力)以及解码器运行,此时在自注意力层之间添加了一层交叉注意力,遵循Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser 和 Illia Polosukhin 在《Attention is all you need》中描述的架构。参数is_decoder设置为True;然后期望输入到前向传递的encoder_hidden_states

调用

<来源>

代码语言:javascript
复制
( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None encoder_embeds: tf.Tensor | None = None encoder_hidden_states: tf.Tensor | None = None encoder_attention_mask: tf.Tensor | None = None past_key_values: Tuple[Tuple[tf.Tensor]] | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None is_decoder: bool = False training: bool = False )

参数

  • input_ids (tf.Tensor,形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。 可以使用 AutoProcessor 获取索引。有关详细信息,请参阅BlipProcessor.__call__()。 什么是输入 ID?
  • attention_mask (tf.Tensor,形状为(batch_size, sequence_length)可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中:
    • 对于未被masked的标记为 1,
    • 对于被masked的标记为 0。

    什么是注意力掩码?

  • position_ids (tf.Tensor,形状为(batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID?
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  • encoder_hidden_states (tf.Tensor, optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器,则在交叉注意力中使用。
  • encoder_attention_mask (tf.Tensor, optional) — 遮罩,用于避免在编码器输入的填充令牌索引上执行注意力。如果模型配置为解码器,则在交叉注意力中使用此遮罩。遮罩值选在 [0, 1] 之间:
    • 1 表示未被遮罩的令牌,
    • 0 表示被遮罩的令牌。
  • past_key_values (tuple(tuple(tf.Tensor)), optional) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用了 past_key_values,用户可以选择仅输入最后的 decoder_input_ids(那些没有将它们的过去键值状态提供给此模型的)形状为 (batch_size, 1),而不是所有 decoder_input_ids 的形状为 (batch_size, sequence_length)
  • use_cache (bool, optional) — 如果设置为 True,将返回 past_key_values 键值状态,可用于加速解码(参见 past_key_values)。

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

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module 实例,而不是在此处调用,因为前者会处理运行前处理和后处理步骤,而后者会默默地忽略它们。

TFBlipVisionModel

class transformers.TFBlipVisionModel

< source >

代码语言:javascript
复制
( config: BlipVisionConfig *args **kwargs )
call

< source >

代码语言:javascript
复制
( pixel_values: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling or tuple(tf.Tensor)

参数

  • pixel_values (tf.Tensor,形状为 (batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充,如果提供的话。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请查看返回张量下的 attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请查看返回张量下的 hidden_states
  • return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或者 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或者一个 tf.Tensor 元组(如果传递了 return_dict=False 或者 config.return_dict=False 时)包含根据配置 (<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>) 和输入不同元素。

  • last_hidden_state (tf.Tensor,形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
  • pooler_output (tf.Tensor,形状为 (batch_size, hidden_size)) — 序列中第一个令牌(分类令牌)的最后一层隐藏状态,经过线性层和 Tanh 激活函数进一步处理。线性层的权重是在预训练期间从下一个句子预测(分类)目标中训练的。 通常,此输出通常不是输入语义内容的良好摘要,您通常最好对整个输入序列的隐藏状态序列进行平均或池化。
  • hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size)。 模型在每个层的输出的隐藏状态加上初始嵌入输出。
  • attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。 在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

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

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

TFBlipForConditionalGeneration

class transformers.TFBlipForConditionalGeneration

<来源>

代码语言:javascript
复制
( config: BlipConfig *args **kwargs )

参数

  • config (BlipConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

用于图像字幕的 BLIP 模型。该模型由视觉编码器和文本解码器组成。可以选择向模型传递input_ids,这些作为文本提示,以使文本解码器继续提示。否则,解码器将从[BOS](序列开始)标记开始生成文本。将从文本输入开始生成标题。如果未提供文本输入,则解码器将仅从[BOS]标记开始。

该模型继承自 TFPreTrainedModel。查看超类文档以了解库实现的所有模型的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

该模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

call

<来源>

代码语言:javascript
复制
( pixel_values: tf.Tensor input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None labels: tf.Tensor | None = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutput or tuple(tf.Tensor)

参数

  • pixel_values (tf.Tensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dictbool可选)- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutputtuple(tf.Tensor)

一个transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutput或一个tf.Tensor元组(如果传递了return_dict=Falseconfig.return_dict=False)包含根据配置(<class 'transformers.models.blip.configuration_blip.BlipConfig'>)和输入的不同元素。

  • losstf.Tensor可选,当提供labels时返回,形状为(1,)tf.Tensor)- 来自文本解码器的语言建模损失。
  • logits(形状为(batch_size, sequence_length, config.vocab_size)tf.Tensor可选)- 文本解码器模型语言建模头的预测分数。
  • image_embeds(形状为(batch_size, output_dim)tf.Tensor可选)- 在将输入图像应用于 Vision Transformer 模型后获得的图像嵌入。
  • last_hidden_state(形状为(batch_size, sequence_length, hidden_size)tf.Tensor可选)- 模型最后一层输出的隐藏状态序列。
  • hidden_statestuple(tf.Tensor)可选,当output_hidden_states=True时返回)- 形状为(batch_size, sequence_length, hidden_size)tf.Tensor元组(如果模型有嵌入层,则为嵌入输出的一个+每层输出的一个)。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  • attentionstuple(tf.Tensor)可选,当传递output_attentions=True时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)tf.Tensor元组(每层一个)。 注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。`

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

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

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipForConditionalGeneration

>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
>>> model = TFBlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "A picture of"

>>> inputs = processor(images=image, text=text, return_tensors="tf")

>>> outputs = model(**inputs)

TFBlipForImageTextRetrieval

class transformers.TFBlipForImageTextRetrieval

<来源>

代码语言:javascript
复制
( config: BlipConfig *args **kwargs )

参数

  • config(BlipConfig)- 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

带有视觉和文本投影器以及顶部分类头的 BLIP 模型。该模型用于图像文本检索的上下文。给定一张图像和一段文本,模型返回文本与图像相关的概率。

这个模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

call

<来源>

代码语言:javascript
复制
( input_ids: tf.Tensor pixel_values: tf.Tensor | None = None use_itm_head: Optional[bool] = True attention_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput or tuple(tf.Tensor)

参数

  • pixel_values(形状为(batch_size, num_channels, height, width)tf.Tensor)— 像素值。默认情况下将忽略填充。如果提供填充,可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。
  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多细节,请参阅返回张量中的attentions
  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多细节,请参阅返回张量中的hidden_states
  • return_dictbool可选)— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutputtuple(tf.Tensor)

一个transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput或一个tf.Tensor元组(如果传递return_dict=False或当config.return_dict=False时)包含根据配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>)和输入的不同元素。

  • itm_scoretf.Tensor)— 图像文本相似性分数。
  • loss(形状为(1,)tf.Tensor可选,在提供labels时返回)— 文本解码器的语言建模损失。
  • image_embeds(形状为(batch_size, output_dim)tf.Tensor可选,在使用with_projection=True初始化模型时返回)— 通过将 pooler_output 应用到投影层获得的图像嵌入。
  • last_hidden_state(形状为(batch_size, sequence_length, hidden_size)tf.Tensor)— 模型最后一层的隐藏状态序列。
  • hidden_statestuple(tf.Tensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)— 形状为(batch_size, sequence_length, hidden_size)tf.Tensor元组。 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
  • vision_pooler_output(形状为(batch_size, hidden_size)tf.Tensor可选)— 模型视觉分支的最后一层隐藏状态。
  • attentionstuple(tf.Tensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)tf.Tensor元组。 在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
  • question_embedstf.Tensor)— 由文本投影层获得的问题嵌入。

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

虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipForImageTextRetrieval

>>> model = TFBlipForImageTextRetrieval.from_pretrained("Salesforce/blip-itm-base-coco")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-itm-base-coco")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "an image of a cat"

>>> inputs = processor(images=image, text=text, return_tensors="tf")
>>> outputs = model(**inputs)

TFBlipForQuestionAnswering

class transformers.TFBlipForQuestionAnswering

<来源>

代码语言:javascript
复制
( config: BlipConfig *args **kwargs )

参数

  • config (BlipConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

用于视觉问答的 BLIP 模型。该模型包括一个视觉编码器、一个文本编码器以及一个文本解码器。视觉编码器将对输入图像进行编码,文本编码器将对输入问题以及图像的编码进行编码,文本解码器将输出问题的答案。

该模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

该模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

call

< source >

代码语言:javascript
复制
( input_ids: tf.Tensor pixel_values: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None attention_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None labels: tf.Tensor | None = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutput or tuple(tf.Tensor)

参数

  • pixel_values (tf.Tensor,形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutputtuple(tf.Tensor)

一个transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutput或一个tf.Tensor元组(如果传递return_dict=Falseconfig.return_dict=False)包含根据配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>)和输入的各种元素。

  • loss (tf.Tensor,形状为(1,)optional,当提供labels时返回) — 来自文本解码器的语言建模损失。
  • image_embeds (tf.Tensor,形状为(batch_size, output_dim) optional,当模型使用with_projection=True初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。
  • last_hidden_state (tf.Tensor,形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
  • hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)tf.Tensor元组(一个用于嵌入的输出,如果模型有嵌入层,+ 一个用于每一层的输出)。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  • attentions (tuple(tf.Tensor), 可选的, 当传递 output_attentions=True 或者当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)tf.Tensor 元组(每层一个)。 在注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

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

虽然前向传递的步骤需要在这个函数内定义,但应该在此之后调用 Module 实例而不是这个函数,因为前者会处理运行前后的处理步骤,而后者会默默地忽略它们。

示例:

代码语言:javascript
复制
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipForQuestionAnswering

>>> model = TFBlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-vqa-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> # training
>>> text = "How many cats are in the picture?"
>>> label = "2"
>>> inputs = processor(images=image, text=text, return_tensors="tf")
>>> labels = processor(text=label, return_tensors="tf").input_ids

>>> inputs["labels"] = labels
>>> outputs = model(**inputs)
>>> loss = outputs.loss

>>> # inference
>>> text = "How many cats are in the picture?"
>>> inputs = processor(images=image, text=text, return_tensors="tf")
>>> outputs = model.generate(**inputs)
>>> print(processor.decode(outputs[0], skip_special_tokens=True))
2

onModelOutput or tuple(tf.Tensor)

代码语言:javascript
复制
参数

+   `pixel_values` (`tf.Tensor`,形状为`(batch_size, num_channels, height, width)`) — 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.`call`()。

+   `output_attentions` (`bool`, *optional*) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的`attentions`。

+   `output_hidden_states` (`bool`, *optional*) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的`hidden_states`。

+   `return_dict` (`bool`, *optional*) — 是否返回 ModelOutput 而不是普通元组。

返回

`transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutput`或`tuple(tf.Tensor)`

一个`transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutput`或一个`tf.Tensor`元组(如果传递`return_dict=False`或`config.return_dict=False`)包含根据配置(`<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>`)和输入的各种元素。

+   `loss` (`tf.Tensor`,形状为`(1,)`,*optional*,当提供`labels`时返回) — 来自文本解码器的语言建模损失。

+   `image_embeds` (`tf.Tensor`,形状为`(batch_size, output_dim)` *optional*,当模型使用`with_projection=True`初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。

+   `last_hidden_state` (`tf.Tensor`,形状为`(batch_size, sequence_length, hidden_size)`) — 模型最后一层的隐藏状态序列。

+   `hidden_states` (`tuple(tf.Tensor)`, *optional*, 当传递`output_hidden_states=True`或`config.output_hidden_states=True`时返回) — 形状为`(batch_size, sequence_length, hidden_size)`的`tf.Tensor`元组(一个用于嵌入的输出,如果模型有嵌入层,+ 一个用于每一层的输出)。

    模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

+   `attentions` (`tuple(tf.Tensor)`, *可选的*, 当传递 `output_attentions=True` 或者当 `config.output_attentions=True` 时返回) — 形状为 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `tf.Tensor` 元组(每层一个)。

    在注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

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

虽然前向传递的步骤需要在这个函数内定义,但应该在此之后调用 `Module` 实例而不是这个函数,因为前者会处理运行前后的处理步骤,而后者会默默地忽略它们。

示例:

```py
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipForQuestionAnswering

>>> model = TFBlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-vqa-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> # training
>>> text = "How many cats are in the picture?"
>>> label = "2"
>>> inputs = processor(images=image, text=text, return_tensors="tf")
>>> labels = processor(text=label, return_tensors="tf").input_ids

>>> inputs["labels"] = labels
>>> outputs = model(**inputs)
>>> loss = outputs.loss

>>> # inference
>>> text = "How many cats are in the picture?"
>>> inputs = processor(images=image, text=text, return_tensors="tf")
>>> outputs = model.generate(**inputs)
>>> print(processor.decode(outputs[0], skip_special_tokens=True))
2
本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2024-06-26,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • XLS-R
    • 概述
      • 使用提示
      • XLSR-Wav2Vec2
        • 概述
          • 使用提示
          • 多模型模型
          • ALIGN
            • 概述
              • 用法示例
                • 资源
                  • AlignConfig
                    • class transformers.AlignConfig
                  • AlignTextConfig
                    • class transformers.AlignTextConfig
                  • AlignVisionConfig
                    • class transformers.AlignVisionConfig
                  • AlignProcessor
                    • class transformers.AlignProcessor
                  • AlignModel
                    • class transformers.AlignModel
                  • AlignTextModel
                    • class transformers.AlignTextModel
                  • AlignVisionModel
                    • class transformers.AlignVisionModel
                • AltCLIP
                  • 概述
                    • 使用提示和示例
                      • AltCLIPConfig
                        • class transformers.AltCLIPConfig
                      • AltCLIPTextConfig
                        • class transformers.AltCLIPTextConfig
                      • AltCLIPVisionConfig
                        • class transformers.AltCLIPVisionConfig
                      • AltCLIPProcessor
                        • class transformers.AltCLIPProcessor
                      • AltCLIPModel
                        • class transformers.AltCLIPModel
                      • AltCLIPTextModel
                        • class transformers.AltCLIPTextModel
                      • AltCLIPVisionModel
                        • class transformers.AltCLIPVisionModel
                    • BLIP
                      • 概述
                        • 资源
                          • BlipConfig
                            • class transformers.BlipConfig
                          • BlipTextConfig
                            • class transformers.BlipTextConfig
                          • BlipVisionConfig
                            • class transformers.BlipVisionConfig
                          • BlipProcessor
                            • class transformers.BlipProcessor
                          • BlipImageProcessor
                            • class transformers.BlipImageProcessor
                          • BlipModel
                            • class transformers.BlipModel
                          • BlipTextModel
                            • class transformers.BlipTextModel
                          • BlipVisionModel
                            • class transformers.BlipVisionModel
                          • BlipForConditionalGeneration
                            • class transformers.BlipForConditionalGeneration
                          • BlipForImageTextRetrieval
                            • class transformers.BlipForImageTextRetrieval
                          • BlipForQuestionAnswering
                            • class transformers.BlipForQuestionAnswering
                          • TFBlipModel
                            • class transformers.TFBlipModel
                          • TFBlipTextModel
                            • class transformers.TFBlipTextModel
                          • TFBlipVisionModel
                            • class transformers.TFBlipVisionModel
                          • TFBlipForConditionalGeneration
                            • class transformers.TFBlipForConditionalGeneration
                          • TFBlipForImageTextRetrieval
                            • class transformers.TFBlipForImageTextRetrieval
                          • TFBlipForQuestionAnswering
                            • class transformers.TFBlipForQuestionAnswering
                        相关产品与服务
                        语音识别
                        腾讯云语音识别(Automatic Speech Recognition,ASR)是将语音转化成文字的PaaS产品,为企业提供精准而极具性价比的识别服务。被微信、王者荣耀、腾讯视频等大量业务使用,适用于录音质检、会议实时转写、语音输入法等多个场景。
                        领券
                        问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档