BLIP-2
概述
BLIP-2模型由Junnan Li、Dongxu Li、Silvio Savarese和Steven Hoi在BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models中提出。BLIP-2通过训练一个轻量级的12层Transformer编码器,利用冻结的预训练图像编码器和大型语言模型(LLMs),在各种视觉-语言任务上实现了最先进的性能。最值得注意的是,BLIP-2在零样本VQAv2上比拥有800亿参数的Flamingo模型提高了8.7%,且可训练参数减少了54倍。
论文的摘要如下:
由于大规模模型的端到端训练,视觉与语言预训练的成本变得越来越高。本文提出了BLIP-2,这是一种通用且高效的预训练策略,它从现成的冻结预训练图像编码器和冻结大型语言模型中引导视觉语言预训练。BLIP-2通过一个轻量级的查询转换器(Querying Transformer)弥合了模态差距,该转换器在两个阶段进行预训练。第一阶段从冻结的图像编码器中引导视觉语言表示学习。第二阶段从冻结的语言模型中引导视觉到语言的生成学习。尽管BLIP-2的可训练参数数量显著少于现有方法,但在各种视觉语言任务上仍达到了最先进的性能。例如,我们的模型在零样本VQAv2上比Flamingo80B高出8.7%,且可训练参数数量减少了54倍。我们还展示了模型在零样本图像到文本生成方面的新兴能力,能够遵循自然语言指令。
![drawing](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/blip2_architecture.jpg)
使用提示
- BLIP-2 可以用于在给定图像和可选文本提示的情况下进行条件文本生成。在推理时,建议使用
generate
方法。 - 可以使用Blip2Processor来为模型准备图像,并将预测的标记ID解码回文本。
[!注意] BLIP模型在发布v4.46版本后,将会发出警告,提示需要添加
processor.num_query_tokens = {{num_query_tokens}}
并扩展模型嵌入层以添加特殊的标记。如果您拥有模型检查点,强烈建议您将这些属性添加到处理器中;如果不属于您,请提交PR。添加这些属性意味着BLIP将为每张图像添加所需的查询标记数量,并在文本中扩展相应数量的
占位符。通常每张图像大约需要500个标记,因此请确保文本未被截断,否则在合并嵌入时会出现失败。 这些属性可以从模型配置中获取,如
model.config.num_query_tokens
,模型嵌入扩展可以通过此链接完成。
资源
一份官方的Hugging Face和社区(由🌎表示)资源列表,帮助您开始使用BLIP-2。
- 用于图像描述、视觉问答(VQA)和类似聊天对话的BLIP-2演示笔记本可以在这里找到。
如果您有兴趣提交资源以包含在此处,请随时打开一个 Pull Request,我们将进行审核!理想情况下,资源应展示一些新内容,而不是重复现有资源。
Blip2Config
类 transformers.Blip2Config
< source >( vision_config = None qformer_config = None text_config = None num_query_tokens = 32 image_text_hidden_size = 256 image_token_index = None **kwargs )
参数
- vision_config (
dict
, 可选) — 用于初始化 Blip2VisionConfig 的配置选项字典. - qformer_config (
dict
, optional) — 用于初始化 Blip2QFormerConfig 的配置选项字典。 - text_config (
dict
, optional) — 用于初始化任何 PretrainedConfig 的配置选项字典。 - num_query_tokens (
int
, 可选, 默认为 32) — 通过 Transformer 传递的查询令牌的数量。 - image_text_hidden_size (
int
, optional, 默认为 256) — 图像文本融合层隐藏状态的维度。 - image_token_index (
int
, optional) — 特殊图像令牌的令牌索引。 - kwargs (可选) — 关键字参数字典。
Blip2Config 是用于存储 Blip2ForConditionalGeneration 配置的配置类。它用于根据指定的参数实例化一个 BLIP-2 模型,定义视觉模型、Q-Former 模型和语言模型的配置。使用默认值实例化配置将产生与 BLIP-2 Salesforce/blip2-opt-2.7b 架构类似的配置。
配置对象继承自PretrainedConfig,可用于控制模型输出。阅读PretrainedConfig的文档以获取更多信息。
示例:
>>> from transformers import (
... Blip2VisionConfig,
... Blip2QFormerConfig,
... OPTConfig,
... Blip2Config,
... Blip2ForConditionalGeneration,
... )
>>> # Initializing a Blip2Config with Salesforce/blip2-opt-2.7b style configuration
>>> configuration = Blip2Config()
>>> # Initializing a Blip2ForConditionalGeneration (with random weights) from the Salesforce/blip2-opt-2.7b style configuration
>>> model = Blip2ForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> # We can also initialize a Blip2Config from a Blip2VisionConfig, Blip2QFormerConfig and any PretrainedConfig
>>> # Initializing BLIP-2 vision, BLIP-2 Q-Former and language model configurations
>>> vision_config = Blip2VisionConfig()
>>> qformer_config = Blip2QFormerConfig()
>>> text_config = OPTConfig()
>>> config = Blip2Config.from_text_vision_configs(vision_config, qformer_config, text_config)
from_vision_qformer_text_configs
< source >( vision_config: Blip2VisionConfig qformer_config: Blip2QFormerConfig text_config: typing.Optional[transformers.configuration_utils.PretrainedConfig] = None **kwargs ) → Blip2Config
参数
- vision_config (
dict
) — 用于初始化 Blip2VisionConfig 的配置选项字典。 - qformer_config (
dict
) — 用于初始化Blip2QFormerConfig的配置选项字典. - text_config (
dict
, optional) — 用于初始化任何 PretrainedConfig 的配置选项字典。
返回
配置对象的一个实例
从BLIP-2视觉模型、Q-Former和语言模型配置中实例化一个Blip2Config(或派生类)。
Blip2VisionConfig
类 transformers.Blip2VisionConfig
< source >( hidden_size = 1408 intermediate_size = 6144 num_hidden_layers = 39 num_attention_heads = 16 image_size = 224 patch_size = 14 hidden_act = 'gelu' layer_norm_eps = 1e-06 attention_dropout = 0.0 initializer_range = 1e-10 qkv_bias = True **kwargs )
参数
- hidden_size (
int
, 可选, 默认为 1408) — 编码器层和池化层的维度。 - intermediate_size (
int
, optional, 默认为 6144) — Transformer 编码器中“中间”(即前馈)层的维度。 - num_hidden_layers (
int
, optional, 默认为 39) — Transformer 编码器中的隐藏层数量。 - num_attention_heads (
int
, optional, defaults to 16) — Transformer编码器中每个注意力层的注意力头数量。 - image_size (
int
, optional, defaults to 224) — 每张图片的大小(分辨率)。 - patch_size (
int
, optional, defaults to 14) — 每个补丁的大小(分辨率)。 - hidden_act (
str
或function
, 可选, 默认为"gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
,"relu"
,"selu"
和"gelu_new"
"gelu"
。layer_norm_eps (float
, 可选, 默认为 1e-5): 层归一化层使用的 epsilon 值。 - attention_dropout (
float
, optional, defaults to 0.0) — 注意力概率的丢弃比率。 - initializer_range (
float
, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。 - qkv_bias (
bool
, optional, defaults toTrue
) — 是否在自注意力层中的查询和值中添加偏置。
这是用于存储Blip2VisionModel配置的配置类。它用于根据指定的参数实例化BLIP-2视觉编码器,定义模型架构。实例化配置默认值将产生与BLIP-2 Salesforce/blip2-opt-2.7b架构类似的配置。
配置对象继承自PretrainedConfig,可用于控制模型输出。阅读PretrainedConfig的文档以获取更多信息。
示例:
>>> from transformers import Blip2VisionConfig, Blip2VisionModel
>>> # Initializing a Blip2VisionConfig with Salesforce/blip2-opt-2.7b style configuration
>>> configuration = Blip2VisionConfig()
>>> # Initializing a Blip2VisionModel (with random weights) from the Salesforce/blip2-opt-2.7b style configuration
>>> model = Blip2VisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
Blip2QFormerConfig
类 transformers.Blip2QFormerConfig
< source >( 词汇大小 = 30522 隐藏大小 = 768 隐藏层数 = 12 注意力头数 = 12 中间大小 = 3072 隐藏激活函数 = 'gelu' 隐藏层丢弃概率 = 0.1 注意力概率丢弃概率 = 0.1 最大位置嵌入 = 512 初始化范围 = 0.02 层归一化epsilon = 1e-12 填充标记ID = 0 位置嵌入类型 = 'absolute' 交叉注意力频率 = 2 编码器隐藏大小 = 1408 使用QFormer文本输入 = False **kwargs )
参数
- vocab_size (
int
, optional, 默认为 30522) — Q-Former 模型的词汇量大小。定义了调用模型时传递的inputs_ids
可以表示的不同标记的数量。 - 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 (
str
或Callable
, 可选, 默认为"gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"silu"
和"gelu_new"
。 - hidden_dropout_prob (
float
, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。 - attention_probs_dropout_prob (
float
, optional, defaults to 0.1) — 注意力概率的丢弃比率。 - max_position_embeddings (
int
, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512、1024或2048)。 - initializer_range (
float
, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float
, optional, defaults to 1e-12) — 层归一化层使用的epsilon值。 - position_embedding_type (
str
, 可选, 默认为"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.) 中的 方法 4。 - cross_attention_frequency (
int
, optional, 默认为 2) — 在 Transformer 层中添加交叉注意力的频率。 - encoder_hidden_size (
int
, optional, defaults to 1408) — 交叉注意力的隐藏状态的隐藏大小。 - use_qformer_text_input (
bool
, 可选, 默认为False
) — 是否使用BERT风格的嵌入.
这是用于存储Blip2QFormerModel配置的配置类。它用于根据指定的参数实例化一个BLIP-2查询转换器(Q-Former)模型,定义模型架构。使用默认值实例化配置将产生与BLIP-2 Salesforce/blip2-opt-2.7b架构类似的配置。配置对象继承自PretrainedConfig,可用于控制模型输出。更多信息请阅读PretrainedConfig的文档。
请注意,Blip2QFormerModel 与 BertLMHeadModel 非常相似,具有交错的交叉注意力。
示例:
>>> from transformers import Blip2QFormerConfig, Blip2QFormerModel
>>> # Initializing a BLIP-2 Salesforce/blip2-opt-2.7b style configuration
>>> configuration = Blip2QFormerConfig()
>>> # Initializing a model (with random weights) from the Salesforce/blip2-opt-2.7b style configuration
>>> model = Blip2QFormerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
Blip2Processor
类 transformers.Blip2Processor
< source >( image_processor tokenizer num_query_tokens = 无 **kwargs )
参数
- image_processor (
BlipImageProcessor
) — 一个 BlipImageProcessor 的实例。图像处理器是一个必需的输入。 - tokenizer (
AutoTokenizer
) — 一个 [‘PreTrainedTokenizer`] 的实例。tokenizer 是一个必需的输入。 - num_query_tokens (
int
, optional) — Qformer 用作查询的令牌数量,应与模型配置中的相同。
构建一个BLIP-2处理器,它将BLIP图像处理器和OPT/T5分词器封装到一个单一的处理器中。
BlipProcessor 提供了 BlipImageProcessor 和 AutoTokenizer 的所有功能。更多信息请参见 __call__()
的文档字符串和 decode()。
此方法将其所有参数转发给PreTrainedTokenizer的batch_decode()。请参考该方法的文档字符串以获取更多信息。
此方法将其所有参数转发给PreTrainedTokenizer的decode()。请参考该方法的文档字符串以获取更多信息。
Blip2视觉模型
前进
< source >( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用Blip2Processor获取。详情请参见Blip2Processor.__call__()
。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。 - interpolate_pos_encoding (
bool
, optional, defaults toFalse
) — 是否插值预训练的位置编码.
返回
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个由
torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种
元素,具体取决于配置(
)和输入。
-
last_hidden_state (
torch.FloatTensor
形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层输出的隐藏状态序列。 -
pooler_output (
torch.FloatTensor
形状为(batch_size, hidden_size)
) — 序列的第一个标记(分类标记)在经过用于辅助预训练任务的层进一步处理后的最后一层隐藏状态。例如,对于BERT系列模型,这返回经过线性层和tanh激活函数处理后的分类标记。线性层的权重是在预训练期间通过下一个句子预测(分类)目标训练的。 -
hidden_states (
tuple(torch.FloatTensor)
, 可选, 当传递了output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 由torch.FloatTensor
组成的元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出)形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出处的隐藏状态加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
, 可选, 当传递了output_attentions=True
或当config.output_attentions=True
时返回) — 由torch.FloatTensor
组成的元组(每一层一个)形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力softmax后的注意力权重,用于计算自注意力头中的加权平均值。
Blip2VisionModel 的前向方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
Blip2QFormerModel
查询转换器(Q-Former),用于BLIP-2。
前进
< source >( query_embeds: FloatTensor query_length: typing.Optional[int] = None attention_mask: typing.Optional[torch.FloatTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[torch.FloatTensor] = None encoder_attention_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None )
encoder_hidden_states (torch.FloatTensor
of shape (batch_size, sequence_length, hidden_size)
, optional
):
编码器最后一层输出的隐藏状态序列。如果模型配置为解码器,则在交叉注意力中使用。
encoder_attention_mask (torch.FloatTensor
of shape (batch_size, sequence_length)
, optional
):
用于避免对编码器输入的填充标记索引执行注意力的掩码。如果模型配置为解码器,则在交叉注意力中使用此掩码。掩码值在 [0, 1]
中选择:
- 1 表示 未屏蔽 的标记,
- 0 表示被掩码的标记。
past_key_values (
tuple(tuple(torch.FloatTensor))
长度为config.n_layers
,每个元组包含4个张量: 形状(batch_size, num_heads, sequence_length - 1, embed_size_per_head)
): 包含预计算的注意力块中的键和值隐藏状态。可用于加速解码。如果使用了past_key_values
,用户可以选择仅输入最后一个decoder_input_ids
(那些没有将其过去键值状态提供给此模型的)形状为(batch_size, 1)
,而不是所有形状为(batch_size, sequence_length)
的decoder_input_ids
。 use_cache (bool
,optional
): 如果设置为True
,则返回past_key_values
键值状态,并可用于加速解码(参见past_key_values
)。
Blip2Model
类 transformers.Blip2Model
< source >( config: Blip2Config )
参数
- config (Blip2Config) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
BLIP-2 模型用于生成文本和图像特征。该模型由视觉编码器、查询转换器(Q-Former)和语言模型组成。
该模型继承自PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。
前进
< source >( pixel_values: FloatTensor input_ids: FloatTensor attention_mask: typing.Optional[torch.LongTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput
或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用Blip2Processor获取。详情请参见Blip2Processor.__call__()
。 - input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — Indices of input sequence tokens in the vocabulary of the language model. Input tokens can optionally be provided to serve as text prompt, which the language model can continue.可以使用Blip2Processor获取索引。详情请参见
Blip2Processor.__call__()
。 - attention_mask (
torch.Tensor
of shape(batch_size, sequence_length)
, optional) — Mask to avoid performing attention on padding token indices. Mask values selected in[0, 1]
:- 1 for tokens that are not masked,
- 0 for tokens that are masked.
- decoder_input_ids (
torch.LongTensor
of shape(batch_size, target_sequence_length)
, optional) — Indices of decoder input sequence tokens in the vocabulary of the language model. Only relevant in case an encoder-decoder language model (like T5) is used.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是解码器输入ID?
- decoder_attention_mask (
torch.BoolTensor
of shape(batch_size, target_sequence_length)
, optional) — Default behavior: generate a tensor that ignores pad tokens indecoder_input_ids
. Causal mask will also be used by default.仅在使用编码器-解码器语言模型(如T5)时相关。
- output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。 - interpolate_pos_encoding (
bool
, optional, defaults toFalse
) — 是否插值预训练的位置编码.
返回
transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput
或一个由
torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种
元素,取决于配置(
)和输入。
- loss (
torch.FloatTensor
, 可选, 当提供labels
时返回,torch.FloatTensor
形状为(1,)
) — 来自语言模型的语言建模损失。 - logits (
torch.FloatTensor
形状为(batch_size, sequence_length, config.vocab_size)
) — 语言模型的语言建模头的预测分数。 - vision_outputs (
BaseModelOutputWithPooling
) — 视觉编码器的输出。 - qformer_outputs (
BaseModelOutputWithPoolingAndCrossAttentions
) — Q-Former(查询变换器)的输出。 - language_model_outputs (
CausalLMOutputWithPast
或Seq2SeqLMOutput
) — 语言模型的输出。
Blip2Model 的 forward 方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from PIL import Image
>>> import requests
>>> from transformers import Blip2Processor, Blip2Model
>>> import torch
>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b", torch_dtype=torch.float16)
>>> model.to(device)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> prompt = "Question: how many cats are there? Answer:"
>>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device, torch.float16)
>>> outputs = model(**inputs)
get_text_features
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.Tensor] = None decoder_attention_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → text_outputs (CausalLMOutputWithPast
, 或 tuple(torch.FloatTensor)
如果 return_dict=False
)
参数
- 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 表示被掩码的标记。 什么是注意力掩码?
- decoder_input_ids (
torch.LongTensor
of shape(batch_size, target_sequence_length)
, optional) — Indices of decoder input sequence tokens in the vocabulary.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
T5 使用
pad_token_id
作为decoder_input_ids
生成的起始标记。如果使用了past_key_values
,则可以选择只输入最后一个decoder_input_ids
(参见past_key_values
)。要了解更多关于如何为预训练准备
decoder_input_ids
的信息,请查看T5 训练. - decoder_attention_mask (
torch.BoolTensor
of shape(batch_size, target_sequence_length)
, 可选) — 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。默认情况下也会使用因果掩码。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。
返回
text_outputs (CausalLMOutputWithPast
, 或 tuple(torch.FloatTensor)
如果 return_dict=False
)
语言模型的输出。如果 return_dict=True
,输出是一个 CausalLMOutputWithPast
,其中包含语言模型的逻辑值、过去的键值以及如果 output_hidden_states=True
时的隐藏状态。
Blip2Model 的 forward 方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> import torch
>>> from transformers import AutoTokenizer, Blip2Model
>>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> inputs = tokenizer(["a photo of a cat"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)
get_image_features
< source >( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → 视觉输出 (BaseModelOutputWithPooling
或 torch.FloatTensor
的元组)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用Blip2Processor获取。详情请参见Blip2Processor.__call__()
。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。 - interpolate_pos_encoding (
bool
, optional, defaults toFalse
) — 是否插值预训练的位置编码.
返回
视觉输出 (BaseModelOutputWithPooling
或 torch.FloatTensor
的元组)
视觉模型的输出。如果 return_dict=True
,输出是一个 BaseModelOutputWithPooling
,其中包含图像特征、池化图像特征以及如果 output_hidden_states=True
时的隐藏状态。
Blip2Model 的 forward 方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Blip2Model
>>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> 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_outputs = model.get_image_features(**inputs)
get_qformer_features
< source >( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → 视觉输出 (BaseModelOutputWithPooling
或 torch.FloatTensor
的元组)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用Blip2Processor获取。详情请参见Blip2Processor.__call__()
。 - input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — Indices of input sequence tokens in the vocabulary of the language model. Input tokens can optionally be provided to serve as text prompt, which the language model can continue.可以使用Blip2Processor获取索引。详情请参见
Blip2Processor.__call__()
。 - attention_mask (
torch.Tensor
of shape(batch_size, sequence_length)
, optional) — Mask to avoid performing attention on padding token indices. Mask values selected in[0, 1]
:- 1 for tokens that are not masked,
- 0 for tokens that are masked.
- decoder_input_ids (
torch.LongTensor
of shape(batch_size, target_sequence_length)
, optional) — Indices of decoder input sequence tokens in the vocabulary of the language model. Only relevant in case an encoder-decoder language model (like T5) is used.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是解码器输入ID?
- decoder_attention_mask (
torch.BoolTensor
of shape(batch_size, target_sequence_length)
, optional) — Default behavior: generate a tensor that ignores pad tokens indecoder_input_ids
. Causal mask will also be used by default.仅在使用编码器-解码器语言模型(如T5)时相关。
- output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。 - interpolate_pos_encoding (
bool
, optional, defaults toFalse
) — 是否插值预训练的位置编码。
返回
视觉输出 (BaseModelOutputWithPooling
或 torch.FloatTensor
的元组)
视觉模型的输出。如果 return_dict=True
,输出是一个 BaseModelOutputWithPooling
,其中包含图像特征、池化图像特征以及如果 output_hidden_states=True
时的隐藏状态。
Blip2Model 的 forward 方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from transformers import Blip2Processor, Blip2Model
>>> processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, return_tensors="pt")
>>> qformer_outputs = model.get_qformer_features(**inputs)
Blip2ForConditionalGeneration
类 transformers.Blip2ForConditionalGeneration
< source >( config: Blip2Config )
参数
- config (Blip2Config) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
BLIP-2 模型用于根据图像和可选的文本提示生成文本。该模型由视觉编码器、查询变换器(Q-Former)和语言模型组成。
可以选择性地将input_ids
传递给模型,作为文本提示,使语言模型继续生成提示内容。否则,语言模型将从[BOS](序列开始)标记开始生成文本。
请注意,Flan-T5检查点不能转换为float16。它们是使用bfloat16进行预训练的。
该模型继承自PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。
前进
< source >( pixel_values: FloatTensor input_ids: FloatTensor attention_mask: typing.Optional[torch.LongTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput
或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用Blip2Processor获取。详情请参见Blip2Processor.__call__()
。 - input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — Indices of input sequence tokens in the vocabulary of the language model. Input tokens can optionally be provided to serve as text prompt, which the language model can continue.可以使用Blip2Processor获取索引。详情请参见
Blip2Processor.__call__()
。 - attention_mask (
torch.Tensor
of shape(batch_size, sequence_length)
, optional) — Mask to avoid performing attention on padding token indices. Mask values selected in[0, 1]
:- 1 for tokens that are not masked,
- 0 for tokens that are masked.
- decoder_input_ids (
torch.LongTensor
of shape(batch_size, target_sequence_length)
, optional) — Indices of decoder input sequence tokens in the vocabulary of the language model. Only relevant in case an encoder-decoder language model (like T5) is used.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是解码器输入ID?
- decoder_attention_mask (
torch.BoolTensor
of shape(batch_size, target_sequence_length)
, optional) — Default behavior: generate a tensor that ignores pad tokens indecoder_input_ids
. Causal mask will also be used by default.仅在使用编码器-解码器语言模型(如T5)时相关。
- output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。 - interpolate_pos_encoding (
bool
, optional, defaults toFalse
) — 是否插值预训练的位置编码。
返回
transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput
或一个由
torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种
元素,取决于配置(
)和输入。
- loss (
torch.FloatTensor
, 可选, 当提供labels
时返回,torch.FloatTensor
形状为(1,)
) — 来自语言模型的语言建模损失。 - logits (
torch.FloatTensor
形状为(batch_size, sequence_length, config.vocab_size)
) — 语言模型的语言建模头的预测分数。 - vision_outputs (
BaseModelOutputWithPooling
) — 视觉编码器的输出。 - qformer_outputs (
BaseModelOutputWithPoolingAndCrossAttentions
) — Q-Former(查询变换器)的输出。 - language_model_outputs (
CausalLMOutputWithPast
或Seq2SeqLMOutput
) — 语言模型的输出。
Blip2ForConditionalGeneration 的前向方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
准备处理器、模型和图像输入
>>> from PIL import Image
>>> import requests
>>> from transformers import Blip2Processor, Blip2ForConditionalGeneration
>>> import torch
>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> model = Blip2ForConditionalGeneration.from_pretrained(
... "Salesforce/blip2-opt-2.7b", load_in_8bit=True, device_map={"": 0}, torch_dtype=torch.float16
... ) # doctest: +IGNORE_RESULT
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
图像字幕生成(不提供文本提示):
>>> inputs = processor(images=image, return_tensors="pt").to(device, torch.float16)
>>> generated_ids = model.generate(**inputs)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
>>> print(generated_text)
two cats laying on a couch
视觉问答(提示 = 问题):
>>> prompt = "Question: how many cats are there? Answer:"
>>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device="cuda", dtype=torch.float16)
>>> generated_ids = model.generate(**inputs)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
>>> print(generated_text)
two
请注意,int8推理也通过bitsandbytes支持。 这大大减少了模型使用的内存量,同时保持了相同的性能。
>>> model = Blip2ForConditionalGeneration.from_pretrained(
... "Salesforce/blip2-opt-2.7b", load_in_8bit=True, device_map={"": 0}, torch_dtype=torch.bfloat16
... ) # doctest: +IGNORE_RESULT
>>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device="cuda", dtype=torch.bfloat16)
>>> generated_ids = model.generate(**inputs)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
>>> print(generated_text)
two
生成
< source >( pixel_values: FloatTensor input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None interpolate_pos_encoding: bool = False **generate_kwargs ) → 标题 (列表)
参数
- pixel_values (
torch.FloatTensor
of shape (batch_size, num_channels, height, width)) — 要处理的输入图像。 - input_ids (
torch.LongTensor
of shape (batch_size, sequence_length), optional) — 用于生成提示的序列。 - attention_mask (
torch.LongTensor
of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码
返回
字幕(列表)
长度为 batch_size * num_captions 的字符串列表。
重写 generate
函数,以便能够将模型用作条件生成器。
Blip2ForImageTextRetrieval
class transformers.Blip2ForImageTextRetrieval
< source >( config: Blip2Config )
参数
- config (Blip2Config) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
BLIP-2 模型包含视觉和文本投影器,以及顶部的分类头。该模型用于图像-文本检索的上下文中。给定一张图像和一段文本,模型返回文本与图像相关的概率。
该模型继承自PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。
前进
< source >( pixel_values: FloatTensor input_ids: LongTensor attention_mask: typing.Optional[torch.LongTensor] = None use_image_text_matching_head: typing.Optional[bool] = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.blip_2.modeling_blip_2.Blip2ImageTextMatchingModelOutput
或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用Blip2Processor获取。详情请参见Blip2Processor.__call__()
。 - input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — Indices of input sequence tokens in the vocabulary of the language model. Input tokens can optionally be provided to serve as text prompt, which the language model can continue.可以使用Blip2Processor获取索引。详情请参见
Blip2Processor.__call__()
。 - attention_mask (
torch.Tensor
of shape(batch_size, sequence_length)
, optional) — Mask to avoid performing attention on padding token indices. Mask values selected in[0, 1]
:- 1 for tokens that are not masked,
- 0 for tokens that are masked.
- use_image_text_matching_head (
bool
, optional) — 是否返回图像-文本匹配或对比分数。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。
返回
transformers.models.blip_2.modeling_blip_2.Blip2ImageTextMatchingModelOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.blip_2.modeling_blip_2.Blip2ImageTextMatchingModelOutput
或一个由
torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种
元素,具体取决于配置(
)和输入。
- loss (
torch.FloatTensor
形状为(1,)
,可选,当return_loss
为True
时返回) — 图像-文本相似性的对比损失。 - logits_per_image (
torch.FloatTensor
形状为(image_batch_size, text_batch_size)
) —image_embeds
和text_embeds
之间的缩放点积分数。这表示图像-文本 相似性分数。 - logits_per_text (
torch.FloatTensor
形状为(text_batch_size, image_batch_size)
) —text_embeds
和image_embeds
之间的缩放点积分数。这表示文本-图像 相似性分数。 - text_embeds (
torch.FloatTensor
形状为(batch_size, output_dim
) — 通过将投影层应用于池化输出获得的文本嵌入。 - image_embeds (
torch.FloatTensor
形状为(batch_size, output_dim
) — 通过将投影层应用于池化输出获得的图像嵌入。 - text_model_output (
BaseModelOutputWithPooling
) — Blip2QFormerModel 的输出。 - vision_model_output (
BaseModelOutputWithPooling
) — Blip2VisionModel 的输出。
Blip2ForImageTextRetrieval 的前向方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Blip2ForImageTextRetrieval
>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> model = Blip2ForImageTextRetrieval.from_pretrained("Salesforce/blip2-itm-vit-g", torch_dtype=torch.float16)
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-itm-vit-g")
>>> model.to(device)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "two cats laying on a pink blanket"
>>> inputs = processor(images=image, text=text, return_tensors="pt").to(device, torch.float16)
>>> itm_out = model(**inputs, use_image_text_matching_head=True)
>>> logits_per_image = torch.nn.functional.softmax(itm_out.logits_per_image, dim=1)
>>> probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilities
>>> print(f"{probs[0][0]:.1%} that image 0 is not '{text}'")
26.9% that image 0 is not 'two cats laying on a pink blanket'
>>> print(f"{probs[0][1]:.1%} that image 0 is '{text}'")
73.0% that image 0 is 'two cats laying on a pink blanket'
>>> texts = ["a photo of a cat", "a photo of a dog"]
>>> inputs = processor(images=image, text=texts, return_tensors="pt").to(device, torch.float16)
>>> itc_out = model(**inputs, use_image_text_matching_head=False)
>>> logits_per_image = itc_out.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
>>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'")
55.3% that image 0 is 'a photo of a cat'
>>> print(f"{probs[0][1]:.1%} that image 0 is '{texts[1]}'")
44.7% that image 0 is 'a photo of a dog'
Blip2TextModelWithProjection
类 transformers.Blip2TextModelWithProjection
< source >( config: Blip2Config )
参数
- config (Blip2Config) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
BLIP-2 文本模型,顶部有一个投影层(在池化输出之上的线性层)。
该模型继承自PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。
前进
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.blip_2.modeling_blip_2.Blip2TextModelOutput
或 tuple(torch.FloatTensor)
参数
- 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]
之间。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.models.blip_2.modeling_blip_2.Blip2TextModelOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.blip_2.modeling_blip_2.Blip2TextModelOutput
或一个由
torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种
元素,具体取决于配置(
)和输入。
-
text_embeds (
torch.FloatTensor
形状为(batch_size, output_dim)
可选,当模型使用with_projection=True
初始化时返回) — 通过将投影层应用于 pooler_output 获得的文本嵌入。 -
last_hidden_state (
torch.FloatTensor
形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层输出的隐藏状态序列。 -
hidden_states (
tuple(torch.FloatTensor)
, 可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 由torch.FloatTensor
组成的元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出)形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出处的隐藏状态加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
, 可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 由torch.FloatTensor
组成的元组(每一层一个)形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
Blip2TextModelWithProjection 的 forward 方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> import torch
>>> from transformers import AutoProcessor, Blip2TextModelWithProjection
>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> model = Blip2TextModelWithProjection.from_pretrained(
... "Salesforce/blip2-itm-vit-g", torch_dtype=torch.float16
... )
>>> model.to(device)
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-itm-vit-g")
>>> inputs = processor(text=["a photo of a cat", "a photo of a dog"], return_tensors="pt").to(device)
>>> outputs = model(**inputs)
>>> text_embeds = outputs.text_embeds
>>> print(text_embeds.shape)
torch.Size([2, 7, 256])
Blip2VisionModelWithProjection
类 transformers.Blip2VisionModelWithProjection
< source >( config: Blip2Config )
参数
- config (Blip2Config) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
BLIP-2 视觉模型,顶部有一个投影层(在池化输出之上的线性层)。
该模型继承自PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。
前进
< source >( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.blip_2.modeling_blip_2.Blip2VisionModelOutput
或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用Blip2Processor获取。详情请参见Blip2Processor.__call__()
。 - output_attentions (
bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。 - interpolate_pos_encoding (
bool
, optional, defaults toFalse
) — 是否插值预训练的位置编码.
返回
transformers.models.blip_2.modeling_blip_2.Blip2VisionModelOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.blip_2.modeling_blip_2.Blip2VisionModelOutput
或一个由
torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种
元素,具体取决于配置(
)和输入。
-
image_embeds (
torch.FloatTensor
形状为(batch_size, output_dim)
可选,当模型以with_projection=True
初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。 -
last_hidden_state (
torch.FloatTensor
形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层输出的隐藏状态序列。 -
hidden_states (
tuple(torch.FloatTensor)
, 可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 由torch.FloatTensor
组成的元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出)形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出处的隐藏状态加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
, 可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 由torch.FloatTensor
组成的元组(每一层一个)形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
Blip2VisionModelWithProjection 的前向方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Blip2VisionModelWithProjection
>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-itm-vit-g")
>>> model = Blip2VisionModelWithProjection.from_pretrained(
... "Salesforce/blip2-itm-vit-g", torch_dtype=torch.float16
... )
>>> model.to(device)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, return_tensors="pt").to(device, torch.float16)
>>> outputs = model(**inputs)
>>> image_embeds = outputs.image_embeds
>>> print(image_embeds.shape)
torch.Size([1, 32, 256])