Transformers 文档
BLIP-2
并获取增强的文档体验
开始使用
BLIP-2
概述
BLIP-2 模型在 BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models 这篇论文中被提出，作者是 Junnan Li, Dongxu Li, Silvio Savarese, Steven Hoi。BLIP-2 通过训练一个轻量级的 12 层 Transformer 编码器连接冻结的预训练图像编码器和大型语言模型 (LLM)，从而利用它们，并在各种视觉-语言任务上实现了最先进的性能。最值得注意的是，BLIP-2 在 zero-shot VQAv2 上的性能比 Flamingo 这个 800 亿参数的模型提升了 8.7%，而可训练参数却减少了 54 倍。
以下是论文的摘要
由于大规模模型的端到端训练，视觉和语言预训练的成本变得越来越高昂。本文提出了 BLIP-2，这是一种通用且高效的预训练策略，它从现成的冻结预训练图像编码器和冻结大型语言模型引导视觉-语言预训练。BLIP-2 通过一个轻量级的查询 Transformer 弥合了模态差距，该 Transformer 分两个阶段进行预训练。第一阶段从冻结的图像编码器引导视觉-语言表示学习。第二阶段从冻结的语言模型引导视觉到语言的生成学习。尽管可训练参数明显少于现有方法，但 BLIP-2 在各种视觉-语言任务上都实现了最先进的性能。例如，我们的模型在 zero-shot VQAv2 上的性能比 Flamingo80B 高出 8.7%，而可训练参数减少了 54 倍。我们还展示了该模型在 zero-shot 图像到文本生成方面的新兴能力，它可以遵循自然语言指令。
BLIP-2 架构。摘自原始论文。 使用技巧
- BLIP-2 可以用于在给定图像和可选文本提示的情况下生成条件文本。在推理时，建议使用
generate方法。 - 可以使用 Blip2Processor 来准备模型的图像，并将预测的 tokens ID 解码回文本。
[!NOTE] 在 v4.46 版本之后的 BLIP 模型会引发关于添加
processor.num_query_tokens = {{num_query_tokens}}和扩展模型嵌入层以添加特殊的<image>token 的警告。强烈建议如果您拥有模型检查点，则将属性添加到 processor，或者如果它不是您拥有的，则打开 PR。添加这些属性意味着 BLIP 将添加每个图像所需的查询 token 数量，并使用与查询 token 数量一样多的<image>占位符扩展文本。通常每个图像大约有 500 个 token，因此请确保文本没有被截断，否则在合并嵌入时会出现故障。这些属性可以从模型配置中获得，如model.config.num_query_tokens，模型嵌入扩展可以通过遵循 此链接 完成。
资源
官方 Hugging Face 和社区 (🌎 表示) 资源列表，可帮助您开始使用 BLIP-2。
- BLIP-2 用于图像描述、视觉问答 (VQA) 和类似聊天的对话的演示 notebook 可以在这里找到。
如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将对其进行审核！资源最好展示一些新的东西，而不是重复现有资源。
Blip2Config
class 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, 可选) — 用于初始化 Blip2QFormerConfig 的配置选项字典。 - text_config (
dict, 可选) — 用于初始化任何 PretrainedConfig 的配置选项字典。 - num_query_tokens (
int, 可选, 默认为 32) — 通过 Transformer 传递的查询 token 的数量。 - image_text_hidden_size (
int, 可选, 默认为 256) — 图像-文本融合层隐藏状态的维度。 - image_token_index (
int, optional) — 特殊图像令牌的令牌索引。 - kwargs (optional) — 关键字参数字典。
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
class 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, optional, defaults to 1408) — 编码器层和池化器层的维度。 - intermediate_size (
int, optional, defaults to 6144) — Transformer 编码器中“中间”（即，前馈）层的维度。 - num_hidden_layers (
int, optional, defaults to 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, optional, defaults to"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持"gelu"、"relu"、"selu"和"gelu_new""gelu"。 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 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - 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.configBlip2QFormerConfig
class transformers.Blip2QFormerConfig
< source >( 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 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 position_embedding_type = 'absolute' cross_attention_frequency = 2 encoder_hidden_size = 1408 use_qformer_text_input = False **kwargs )
参数
- vocab_size (
int, optional, defaults to 30522) — Q-Former 模型的词汇表大小。定义了调用模型时传递的inputs_ids可以表示的不同令牌的数量。 - hidden_size (
int, optional, defaults to 768) — 编码器层和池化器层的维度。 - num_hidden_layers (
int, optional, defaults to 12) — Transformer 编码器中的隐藏层数。 - num_attention_heads (
int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。 - intermediate_size (
int, optional, defaults to 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。 - hidden_act (
str或Callable, 可选, 默认为"gelu") — 编码器和pooler中的非线性激活函数（函数或字符串）。如果为字符串，则支持"gelu","relu","silu"和"gelu_new"。 - hidden_dropout_prob (
float, 可选, 默认为 0.1) — 嵌入层、编码器和pooler中所有全连接层的dropout概率。 - attention_probs_dropout_prob (
float, 可选, 默认为 0.1) — 注意力概率的dropout比率。 - max_position_embeddings (
int, 可选, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。 - layer_norm_eps (
float, 可选, 默认为 1e-12) — layer normalization 层使用的 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, 可选, 默认为 2) — 向 Transformer 层添加 cross-attention 的频率。 - encoder_hidden_size (
int, 可选, 默认为 1408) — 用于 cross-attention 的隐藏状态的隐藏大小。 - use_qformer_text_input (
bool, 可选, 默认为False) — 是否使用 BERT 风格的嵌入。
这是用于存储 Blip2QFormerModel 配置的配置类。它用于根据指定的参数实例化 BLIP-2 查询 Transformer (Q-Former) 模型，定义模型架构。使用默认值实例化配置将产生与 BLIP-2 Salesforce/blip2-opt-2.7b 架构类似的配置。配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
请注意，Blip2QFormerModel 与 BertLMHeadModel 非常相似，只是具有交错的 cross-attention。
示例
>>> 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.configBlip2Processor
class transformers.Blip2Processor
< source >( image_processor tokenizer num_query_tokens = None **kwargs )
参数
- image_processor (
BlipImageProcessor) — BlipImageProcessor 的一个实例。图像处理器是必需的输入。 - tokenizer (
AutoTokenizer) — [‘PreTrainedTokenizer`] 的一个实例。tokenizer 是必需的输入。 - num_query_tokens (
int, 可选) — Qformer 用作查询的令牌数量，应与模型配置中的数量相同。
构建一个 BLIP-2 处理器，它将 BLIP 图像处理器和 OPT/T5 tokenizer 包装到单个处理器中。
BlipProcessor 提供了 BlipImageProcessor 和 AutoTokenizer 的所有功能。有关更多信息，请参阅 __call__() 和 decode() 的文档字符串。
此方法将其所有参数转发到 PreTrainedTokenizer 的 batch_decode()。有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发到 PreTrainedTokenizer 的 decode()。有关更多信息，请参阅此方法的文档字符串。
Blip2VisionModel
forward
< 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，形状为(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, 可选, 默认为False) — 是否插值预训练的位置编码。
返回值
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor 的元组 (如果在传递 return_dict=False 时或当 config.return_dict=False 时)，其中包含各种元素，具体取决于配置 (<class 'transformers.models.blip_2.configuration_blip_2.Blip2VisionConfig'>) 和输入。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最后一层的输出的隐藏状态序列。 -
pooler_output (形状为
(batch_size, hidden_size)的torch.FloatTensor) — 序列的第一个 token (分类 token) 的最后一层隐藏状态，在通过用于辅助预训练任务的层进一步处理之后。 例如，对于 BERT 系列模型，这会返回通过线性层和 tanh 激活函数处理后的分类 token。 线性层权重是通过预训练期间的下一句预测（分类）目标训练的。 -
hidden_states (
tuple(torch.FloatTensor), 可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有 embedding 层，则为 embedding 的输出，+ 每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，加上可选的初始 embedding 输出。
-
attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
Blip2VisionModel 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
Blip2QFormerModel
Querying Transformer (Q-Former)，用于 BLIP-2。
forward
< 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 (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, optional): 编码器最后一层的输出的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。 encoder_attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor, optional): 用于避免在编码器输入的 padding token 索引上执行注意力的 mask。如果模型配置为解码器，则此 mask 在交叉注意力中使用。Mask 值在 [0, 1] 中选择
- 1 代表 未被 mask 的 token，
- 0 代表 被 mask 的 token。 past_key_values (长度为
config.n_layers的tuple(tuple(torch.FloatTensor))，每个 tuple 包含 4 个形状为：(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的 tensor): 包含注意力块的预计算的 key 和 value 隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后一次的decoder_input_ids(那些没有将其 past key value 状态提供给此模型的) ，形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 use_cache (bool,optional): 如果设置为True，则返回past_key_valueskey value 状态，并且可以用于加速解码（请参阅past_key_values）。
Blip2Model
class transformers.Blip2Model
< source >( config: Blip2Config )
参数
- config (Blip2Config) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
用于生成文本和图像特征的 BLIP-2 模型。该模型由视觉编码器、Querying Transformer (Q-Former) 和语言模型组成。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embedding 大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规使用和行为相关的所有事项。
forward
< 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 (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 像素值。像素值可以使用 Blip2Processor 获得。有关详细信息，请参阅Blip2Processor.__call__()。 - input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 语言模型的词汇表中输入序列 token 的索引。可以选择性地提供输入 token 作为文本提示，语言模型可以继续。索引可以使用 Blip2Processor 获得。有关详细信息，请参阅
Blip2Processor.__call__()。 - attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor, 可选) — 用于避免在 padding token 索引上执行注意力的 Mask。Mask 值在[0, 1]中选择:- 1 代表 未被 mask 的 token，
- 0 代表 被 mask 的 token。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)的torch.LongTensor, 可选) — 解码器输入序列 token 在语言模型词汇表中的索引。仅在使用编码器-解码器语言模型（如 T5）时相关。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？
- decoder_attention_mask (形状为
(batch_size, target_sequence_length)的torch.BoolTensor, 可选) — 默认行为：生成一个忽略decoder_input_ids中 pad token 的 tensor。默认情况下，也将使用因果 mask。仅在使用编码器-解码器语言模型（如 T5）时相关。
- output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力 tensor。 有关更多详细信息，请参见返回的 tensor 下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回的 tensor 下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - interpolate_pos_encoding (
bool, 可选, 默认为False) — 是否插值预训练的位置编码。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并且可以用于加速解码（请参阅past_key_values）。
返回值
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 时)，其中包含各种元素，具体取决于配置 (<class 'transformers.models.blip_2.configuration_blip_2.Blip2VisionConfig'>) 和输入。
- loss (
torch.FloatTensor, 可选，当提供labels时返回, 形状为(1,)的torch.FloatTensor) — 来自语言模型的语言建模损失。 - logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言模型语言建模头的预测分数。 - vision_outputs (
BaseModelOutputWithPooling) — 视觉编码器的输出。 - qformer_outputs (
BaseModelOutputWithPoolingAndCrossAttentions) — Q-Former (Querying Transformer) 的输出。 - language_model_outputs (
CausalLMOutputWithPast或Seq2SeqLMOutput) — 语言模型的输出。
Blip2Model 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数中定义，但应该在之后调用 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, or tuple(torch.FloatTensor) if return_dict=False)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 IDs？ - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — Mask，用于避免在 padding token 索引上执行 attention。 Mask 值在[0, 1]中选择：- 1 表示 未被 mask 的 tokens，
- 0 表示 被 mask 的 tokens。 什么是 attention masks？
- decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 词汇表中 decoder 输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
T5 使用
pad_token_id作为decoder_input_ids生成的起始 token。 如果使用past_key_values，则可以选择仅输入最后一个decoder_input_ids（请参阅past_key_values）。要了解有关如何准备用于预训练的
decoder_input_ids的更多信息，请查看 T5 Training。 - decoder_attention_mask (
torch.BoolTensor，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个 tensor，该 tensor 忽略decoder_input_ids中的 pad tokens。 默认情况下，还将使用因果 mask。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参见返回 tensors 下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回 tensors 下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是纯 tuple。
返回值
text_outputs (CausalLMOutputWithPast，或者如果 return_dict=False，则为 tuple(torch.FloatTensor))
语言模型输出。 如果 return_dict=True，则输出为 CausalLMOutputWithPast，其中包含语言模型 logits、过去的 key values 以及 hidden states（如果 output_hidden_states=True）。
Blip2Model 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数中定义，但应该在之后调用 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 ) → vision_outputs (BaseModelOutputWithPooling 或者 torch.FloatTensor 的 tuple)
参数
- pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。 像素值可以使用 Blip2Processor 获得。 有关详细信息，请参阅Blip2Processor.__call__()。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参见返回 tensors 下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回 tensors 下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是纯 tuple。 - interpolate_pos_encoding (
bool, 可选, 默认为False) — 是否插值预训练的位置编码。
返回值
vision_outputs (BaseModelOutputWithPooling 或者 torch.FloatTensor 的 tuple)
视觉模型输出。 如果 return_dict=True，则输出为 BaseModelOutputWithPooling，其中包含图像特征、池化的图像特征以及 hidden states（如果 output_hidden_states=True）。
Blip2Model 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数中定义，但应该在之后调用 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 ) → vision_outputs (BaseModelOutputWithPooling 或者 torch.FloatTensor 的 tuple)
参数
- pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。 像素值可以使用 Blip2Processor 获得。 有关详细信息，请参阅Blip2Processor.__call__()。 - input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 语言模型词汇表中输入序列 tokens 的索引。 可以选择性地提供输入 tokens 作为文本提示，语言模型可以继续提示。索引可以使用 Blip2Processor 获得。 有关详细信息，请参阅
Blip2Processor.__call__()。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — Mask，用于避免在 padding token 索引上执行 attention。 Mask 值在[0, 1]中选择：- 1 表示 未被 mask 的 tokens，
- 0 表示 被 mask 的 tokens。
- decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 语言模型词汇表中 decoder 输入序列 tokens 的索引。 仅在使用了 encoder-decoder 语言模型（如 T5）的情况下相关。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是 decoder 输入 IDs？
- decoder_attention_mask (
torch.BoolTensor，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个 tensor，该 tensor 忽略decoder_input_ids中的 pad tokens。 默认情况下，还将使用因果 mask。仅在使用了 encoder-decoder 语言模型（如 T5）的情况下相关。
- output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参见返回 tensors 下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回 tensors 下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是纯 tuple。 - interpolate_pos_encoding (
bool, 可选, 默认为False) — 是否插值预训练的位置编码。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。
返回值
vision_outputs (BaseModelOutputWithPooling 或者 torch.FloatTensor 的 tuple)
视觉模型输出。 如果 return_dict=True，则输出为 BaseModelOutputWithPooling，其中包含图像特征、池化的图像特征以及 hidden states（如果 output_hidden_states=True）。
Blip2Model 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数中定义，但应该在之后调用 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
class transformers.Blip2ForConditionalGeneration
< source >( config: Blip2Config )
参数
- config (Blip2Config) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
BLIP-2 模型用于生成给定图像和可选文本提示的文本。该模型由视觉编码器、查询 Transformer (Q-Former) 和语言模型组成。
可以选择性地将 input_ids 传递给模型，作为文本提示，使语言模型继续提示。否则，语言模型将从 [BOS]（序列开始）令牌开始生成文本。
请注意，Flan-T5 检查点无法转换为 float16。它们是使用 bfloat16 预训练的。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embedding 大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规使用和行为相关的所有事项。
forward
< 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 use_cache: typing.Optional[bool] = None ) → transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 Blip2Processor 获得。有关详细信息，请参阅Blip2Processor.__call__()。 - input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 语言模型词汇表中输入序列标记的索引。可以选择性地提供输入标记作为文本提示，语言模型可以继续。索引可以使用 Blip2Processor 获得。有关详细信息，请参阅
Blip2Processor.__call__()。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 掩码，用于避免对填充标记索引执行注意力机制。掩码值在[0, 1]中选择：- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
- decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 解码器输入序列标记在语言模型词汇表中的索引。仅在使用编码器-解码器语言模型（如 T5）时相关。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？
- decoder_attention_mask (
torch.BoolTensor，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的填充标记。默认情况下，也将使用因果掩码。仅在使用编码器-解码器语言模型（如 T5）时相关。
- output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。 - interpolate_pos_encoding (
bool，可选，默认为False) — 是否插值预训练的位置编码。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。
返回值
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 时)，其中包含各种元素，具体取决于配置 (<class 'transformers.models.blip_2.configuration_blip_2.Blip2VisionConfig'>) 和输入。
- loss (
torch.FloatTensor, 可选，当提供labels时返回, 形状为(1,)的torch.FloatTensor) — 来自语言模型的语言建模损失。 - logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言模型语言建模头的预测分数。 - vision_outputs (
BaseModelOutputWithPooling) — 视觉编码器的输出。 - qformer_outputs (
BaseModelOutputWithPoolingAndCrossAttentions) — Q-Former (Querying Transformer) 的输出。 - language_model_outputs (
CausalLMOutputWithPast或Seq2SeqLMOutput) — 语言模型的输出。
Blip2ForConditionalGeneration 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数中定义，但应该在之后调用 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请注意，通过 bitsandbytes 也支持 int8 推理。这大大减少了模型使用的内存量，同时保持了相同的性能。
>>> 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)
twogenerate
< 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 ) → captions (list)
参数
- pixel_values (
torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 要处理的输入图像。 - input_ids (
torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用作生成的提示的序列。 - attention_mask (
torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 掩码，用于避免对填充标记索引执行注意力机制
返回值
captions (list)
长度为 batch_size * num_captions 的字符串列表。
覆盖 generate 函数，以便能够将模型用作条件生成器。
Blip2ForImageTextRetrieval
class transformers.Blip2ForImageTextRetrieval
< source >( config: Blip2Config )
参数
- config (Blip2Config) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
BLIP-2 模型具有视觉和文本投影器，以及顶部的分类头。该模型用于图像-文本检索的上下文中。给定图像和文本，模型返回文本与图像相关的概率。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embedding 大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规使用和行为相关的所有事项。
forward
< 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，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 Blip2Processor 获得。有关详细信息，请参阅Blip2Processor.__call__()。 - input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 语言模型词汇表中输入序列标记的索引。输入标记可以选择性地提供作为文本提示，语言模型可以继续。索引可以使用 Blip2Processor 获得。有关详细信息，请参阅
Blip2Processor.__call__()。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 掩码，用于避免在填充标记索引上执行注意力机制。掩码值在[0, 1]中选择：- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- use_image_text_matching_head (
bool，可选) — 是否返回图像-文本匹配或对比得分。 - 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 时)，包含各种元素，具体取决于配置 (<class 'transformers.models.blip_2.configuration_blip_2.Blip2Config'>) 和输入。
- 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__ 特殊方法。
虽然 forward 传递的配方需要在该函数中定义，但应该在之后调用 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
class transformers.Blip2TextModelWithProjection
< source >( config: Blip2Config )
参数
- config (Blip2Config) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
带有顶部投影层的 BLIP-2 文本模型（池化输出顶部的线性层）。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embedding 大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规使用和行为相关的所有事项。
forward
< 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，形状为(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]中选择。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的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 时)，包含各种元素，具体取决于配置 (<class 'transformers.models.blip_2.configuration_blip_2.Blip2Config'>) 和输入。
-
text_embeds (
torch.FloatTensor，形状为(batch_size, output_dim)可选 当使用with_projection=True初始化模型时返回) — 通过将投影层应用于 pooler_output 而获得的文本嵌入。 -
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最后一层的输出的隐藏状态序列。 -
hidden_states (
tuple(torch.FloatTensor), 可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有 embedding 层，则为 embedding 的输出，+ 每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，加上可选的初始 embedding 输出。
-
attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
Blip2TextModelWithProjection 的前向方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数中定义，但应该在之后调用 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
class transformers.Blip2VisionModelWithProjection
< source >( config: Blip2Config )
参数
- config (Blip2Config) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
带有顶部投影层的 BLIP-2 视觉模型（池化输出顶部的线性层）。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embedding 大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规使用和行为相关的所有事项。
forward
< 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，形状为(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, 可选, 默认为False) — 是否插值预训练的位置编码。
返回值
transformers.models.blip_2.modeling_blip_2.Blip2VisionModelOutput or tuple(torch.FloatTensor)
A transformers.models.blip_2.modeling_blip_2.Blip2VisionModelOutput or a tuple of torch.FloatTensor (if return_dict=False is passed or when config.return_dict=False) comprising various elements depending on the configuration (<class 'transformers.models.blip_2.configuration_blip_2.Blip2Config'>) and inputs.
-
image_embeds (
torch.FloatTensor，形状为(batch_size, output_dim)，可选，当模型使用with_projection=True初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。 -
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最后一层的输出的隐藏状态序列。 -
hidden_states (
tuple(torch.FloatTensor), 可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有 embedding 层，则为 embedding 的输出，+ 每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，加上可选的初始 embedding 输出。
-
attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
The Blip2VisionModelWithProjection forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数中定义，但应该在之后调用 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])