Hugging Face 的徽标

Transformers 文档

BLIP-2

Hugging Face's logo
加入 Hugging Face 社区

并获得增强文档体验

开始使用

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 利用了冻结的预训练图像编码器和大型语言模型 (LLM)，通过在它们之间训练一个轻量级的 12 层 Transformer 编码器，在各种视觉语言任务上取得了最先进的性能。最值得注意的是，BLIP-2 在零样本 VQAv2 上比拥有 800 亿个参数的 Flamingo 模型提高了 8.7%，同时可训练参数减少了 54 倍。

论文的摘要如下：

由于大型模型的端到端训练，视觉和语言预训练的成本变得越来越高昂。本文提出了 BLIP-2，这是一种通用且高效的预训练策略，它从现成的冻结预训练图像编码器和冻结的大型语言模型中引导视觉语言预训练。BLIP-2 通过一个轻量级的查询 Transformer 来弥合模态差距，该 Transformer 分两阶段进行预训练。第一阶段从冻结的图像编码器中引导视觉语言表示学习。第二阶段从冻结的语言模型中引导视觉到语言的生成学习。尽管 BLIP-2 的可训练参数明显少于现有方法，但它在各种视觉语言任务上都取得了最先进的性能。例如，我们的模型在零样本 VQAv2 上的表现优于 Flamingo80B 8.7%，同时可训练参数减少了 54 倍。我们还展示了模型在零样本图像到文本生成方面的潜在能力，该能力可以遵循自然语言指令。

drawing BLIP-2 架构。摘自 原始论文。

该模型由 nielsr 贡献。原始代码可以在 这里 找到。

使用技巧

  • BLIP-2 可用于根据图像和可选的文本提示生成条件文本。在推理时，建议使用 generate 方法。
  • 可以使用 Blip2Processor 为模型准备图像，并将预测的令牌 ID 解码回文本。

资源

以下是官方 Hugging Face 和社区 (🌎 标示) 资源列表，可帮助您开始使用 BLIP-2。

  • 用于 BLIP-2 的图像字幕、视觉问答 (VQA) 和类似聊天的演示笔记本可以在 这里 找到。

如果您想提交要包含在此处的资源，请随时提交 Pull Request，我们会进行审核！理想情况下，该资源应该展示新的内容，而不是重复现有的资源。

Blip2Config

class transformers.Blip2Config

< >

( 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 的查询令牌数量。
  • image_text_hidden_size (int, 可选, 默认为 256) — 图像-文本融合层的隐藏状态维度。
  • image_token_index (int, 可选) — 特殊图像令牌的令牌索引。
  • 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

 < >

( vision_config: Blip2VisionConfig qformer_config: Blip2QFormerConfig text_config: Optional = None **kwargs ) → Blip2Config

参数

  • vision_config (dict) — 用于初始化 Blip2VisionConfig 的配置选项字典。
  • qformer_config (dict) — 用于初始化 Blip2QFormerConfig 的配置选项字典。
  • text_config (dict, 可选) — 用于初始化任何 PretrainedConfig 的配置选项字典。

返回

Blip2Config

配置对象的实例

从 BLIP-2 视觉模型、Q-Former 和语言模型配置实例化 Blip2Config （或派生类）。

Blip2VisionConfig

class transformers.Blip2VisionConfig

< >

( 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, 可选, 默认为 6144) — Transformer 编码器中“中间”（即前馈）层的维度。
  • num_hidden_layers (int, 可选, 默认为 39) — Transformer 编码器中的隐藏层数。
  • num_attention_heads (int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。
  • image_size (int, 可选, 默认为 224) — 每个图像的大小（分辨率）。
  • patch_size (int, 可选, 默认为 14) — 每个 patch 的大小（分辨率）。
  • hidden_act (str 或 function, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。 如果是字符串，则支持 "gelu"、"relu"、"selu" 和 "gelu_new" "gelu"。 layer_norm_eps (float, 可选, 默认为 1e-5): 层归一化层使用的 epsilon。
  • attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比例。
  • qkv_bias (bool, 可选, 默认为 True) — 是否在自注意力层中的查询和值中添加偏差。

这是一个用于存储 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

< >

( 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, 可选, 默认为 30522) — Q-Former 模型的词汇量大小。定义了调用模型时可以由 inputs_ids 表示的不同令牌数量。
  • hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
  • num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。
  • num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
  • intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。
  • hidden_act (str 或 Callable, 可选, 默认值 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。 如果是字符串，则支持 "gelu"、"relu"、"silu" 和 "gelu_new"。
  • hidden_dropout_prob (float, 可选, 默认值 0.1) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。
  • attention_probs_dropout_prob (float, 可选, 默认值 0.1) — 注意概率的丢弃率。
  • max_position_embeddings (int, 可选, 默认值 512) — 此模型可能用到的最大序列长度。 通常将此设置为一个较大的值，以防万一（例如，512 或 1024 或 2048）。
  • initializer_range (float, 可选, 默认值 0.02) — 用于初始化所有权重矩阵的截断正态初始化的标准差。
  • layer_norm_eps (float, 可选, 默认值 1e-12) — 层归一化层使用的 epsilon。
  • position_embedding_type (str, 可选, 默认值 "absolute") — 位置嵌入的类型。 选择 "absolute"、"relative_key"、"relative_key_query" 之一。 对于位置嵌入，使用 "absolute"。 有关 "relative_key" 的更多信息，请参阅 具有相对位置表示的自注意力（Shaw 等人）。 有关 "relative_key_query" 的更多信息，请参阅 使用更好的相对位置嵌入改进 Transformer 模型（Huang 等人） 中的 方法 4。
  • cross_attention_frequency (int, 可选, 默认值 2) — 将交叉注意力添加到 Transformer 层的频率。
  • encoder_hidden_size (int, 可选, 默认值 1408) — 交叉注意力的隐藏状态的隐藏大小。
  • use_qformer_text_input (bool, 可选, 默认值 False) — 是否使用 BERT 风格的嵌入。

这是用于存储 Blip2QFormerModel 配置的配置类。 它用于根据指定的参数实例化 BLIP-2 查询 Transformer（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

class transformers.Blip2Processor

< >

( image_processor tokenizer num_query_tokens = None **kwargs )

参数

  • image_processor (BlipImageProcessor) — BlipImageProcessor 实例。图像处理器是必需的输入。
  • tokenizer (AutoTokenizer) — [‘PreTrainedTokenizer`]. 分词器是必需的输入。
  • num_query_tokens (int, 可选) — Qformer 用作查询的令牌数，应与模型配置中的相同。

构建一个 BLIP-2 处理器，它将 BLIP 图像处理器和 OPT/T5 分词器包装到一个处理器中。

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

batch_decode

< >

( *args **kwargs )

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

decode

< >

( *args **kwargs )

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

Blip2VisionModel

class transformers.Blip2VisionModel

< >

( config: Blip2VisionConfig )

forward

< >

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) → transformers.modeling_outputs.BaseModelOutputWithPooling or 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, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个简单的元组。
  • interpolate_pos_encoding (bool, 可选，默认为 False) — 是否插值预训练的位置编码。

返回

transformers.modeling_outputs.BaseModelOutputWithPooling or 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 (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

  • pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 序列第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层的进一步处理。例如，对于 BERT 家族模型，这将返回经过线性层和 tanh 激活函数处理后的分类 token。线性层权重在预训练期间从下一个句子预测（分类）目标中训练得到。

  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

The Blip2VisionModel 正向方法，覆盖了 __call__ 特殊方法。

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

Blip2QFormerModel

class transformers.Blip2QFormerModel

< >

( config: Blip2QFormerConfig )

在 BLIP-2 中使用的查询变换器 (Q-Former)。

forward

< >

( query_embeds: FloatTensor query_length: Optional = None attention_mask: Optional = None head_mask: 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 )

encoder_hidden_states (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)，可选): 编码器最后一层输出的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。encoder_attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length)，可选): 用于避免在编码器输入的填充令牌索引上执行注意力的掩码。如果模型配置为解码器，则此掩码用于交叉注意力。在 [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，用户可以选择仅输入形状为 (batch_size, 1) 的最后一个 decoder_input_ids（那些没有为此模型提供过去键值状态的），而不是形状为 (batch_size, sequence_length) 的所有 decoder_input_ids。use_cache (bool，可选): 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。

Blip2Model

class transformers.Blip2Model

< >

( config: Blip2Config )

参数

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

用于生成文本和图像特征的 BLIP-2 模型。该模型包括视觉编码器、查询变换器 (Q-Former) 和语言模型。

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

该模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解有关一般用法和行为的所有事项。

forward

< >

( pixel_values: FloatTensor input_ids: FloatTensor attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) → transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput or 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__()。

    什么是输入 ID？

  • 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) — 是否插值预训练的位置编码。

返回

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 时返回，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 正向方法，覆盖 __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

 < >

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → text_outputs (CausalLMOutputWithPast, or tuple(torch.FloatTensor) if 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), 可选) — 掩码，用于避免对填充词元索引执行注意力。在 [0, 1] 中选择的掩码值：
  • decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), 可选) — 解码器输入序列词元的词汇索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID？

    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, or tuple(torch.FloatTensor) if return_dict=False)

语言模型输出。如果 return_dict=True，则输出为 CausalLMOutputWithPast，其中包含语言模型 logits、过去的键值以及 output_hidden_states=True 时的隐藏状态。

Blip2Model 正向方法，覆盖 __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

< >

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) → vision_outputs (BaseModelOutputWithPooling 或 torch.FloatTensor 元组)

参数

  • pixel_values (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素值。可以使用 Blip2Processor 获取像素值。有关详细信息，请参见 Blip2Processor.__call__()。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参见返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参见返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是简单的元组。
  • interpolate_pos_encoding (bool, 可选，默认为 False) — 是否插值预训练的位置编码。

返回

vision_outputs (BaseModelOutputWithPooling 或 torch.FloatTensor 元组)

视觉模型输出。如果 return_dict=True，则输出为 BaseModelOutputWithPooling，其中包含图像特征、池化的图像特征以及如果 output_hidden_states=True 则包含隐藏状态。

Blip2Model 正向方法，覆盖 __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

< >

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) → vision_outputs (BaseModelOutputWithPooling 或 torch.FloatTensor 元组)

参数

  • pixel_values (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素值。可以使用 Blip2Processor 获取像素值。有关详细信息，请参见 Blip2Processor.__call__()。
  • input_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 输入序列令牌在语言模型词汇表中的索引。可以选择提供输入令牌作为文本提示，语言模型可以继续。

    可以使用 Blip2Processor 获取索引。有关详细信息，请参见 Blip2Processor.__call__()。

    什么是输入 ID？

  • attention_mask (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 掩码，避免对填充令牌索引执行注意力。在 [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) — 是否插值预训练的位置编码。

返回

vision_outputs (BaseModelOutputWithPooling 或 torch.FloatTensor 元组)

视觉模型输出。如果 return_dict=True，则输出为 BaseModelOutputWithPooling，其中包含图像特征、池化的图像特征以及如果 output_hidden_states=True 则包含隐藏状态。

Blip2Model 正向方法，覆盖 __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

class transformers.Blip2ForConditionalGeneration

 < >

( config: Blip2Config )

参数

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

BLIP-2 模型，用于根据图像和可选文本提示生成文本。该模型由视觉编码器、查询 Transformer (Q-Former) 和语言模型组成。

可以选择向模型传递 input_ids，用作文本提示，以使语言模型继续提示。否则，语言模型将从 [BOS]（序列开头）词元开始生成文本。

请注意，Flan-T5 检查点不能转换为 float16。它们使用 bfloat16 进行预训练。

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

该模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解有关一般用法和行为的所有事项。

forward

 <

参数

  • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。像素值可以通过 Blip2Processor 获取。有关详细信息，请参见 Blip2Processor.__call__()。
  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 语言模型词汇表中输入序列标记的索引。可以可选地提供输入标记作为文本提示，语言模型可以继续。

    索引可以通过 Blip2Processor 获取。有关详细信息，请参见 Blip2Processor.__call__()。

    什么是输入 ID？

  • 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) — 是否插值预训练的位置编码。

返回

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 时返回，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 的 forward 方法，覆盖了 __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

生成

< >

( pixel_values: FloatTensor input_ids: Optional = None attention_mask: Optional = None interpolate_pos_encoding: bool = False **generate_kwargs ) → captions (list)

参数

  • 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) — 避免对填充令牌索引执行注意的掩码

返回

captions (list)

长度为 batch_size * num_captions 的字符串列表。

覆盖 generate 函数，以便能够将模型用作条件生成器。

Blip2ForImageTextRetrieval

class transformers.Blip2ForImageTextRetrieval

< >

( config: Blip2Config )

参数

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

带有视觉和文本投影器的 BLIP-2 模型，顶部有一个分类头。 该模型在图像-文本检索的背景下使用。 给定图像和文本，该模型返回文本与图像相关的概率。

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

该模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解有关一般用法和行为的所有事项。

forward

< >

( pixel_values: FloatTensor input_ids: LongTensor attention_mask: Optional = None use_image_text_matching_head: Optional = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.blip_2.modeling_blip_2.Blip2ImageTextMatchingModelOutput or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor of shape (batch_size, num_
  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)，可选) — 输入序列标记在语言模型词汇表中的索引。 可以选择提供输入标记以用作文本提示，语言模型可以继续。

    索引可以通过 Blip2Processor 获取。 有关详细信息，请参阅 Blip2Processor.__call__()。

    什么是输入 ID？

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

虽然正向传递的配方需要在此函数内定义，但应该随后调用 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

< >

( config: Blip2Config )

参数

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

带有投影层的 BLIP-2 文本模型（在池化输出之上添加线性层）。

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

该模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解有关一般用法和行为的所有事项。

forward

< >

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = 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] 中选择掩码值：
  • 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 (torch.FloatTensor of shape (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 正向方法，覆盖了 __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

class transformers.Blip2VisionModelWithProjection

< >

( config: Blip2Config )

参数

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

带有投影层的 BLIP-2 视觉模型（在池化输出之上添加一个线性层）。

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

该模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解有关一般用法和行为的所有事项。

forward

< >

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.blip_2.modeling_blip_2.Blip2VisionModelOutput or 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, 可选) — 是否返回所有层的隐藏状态。 有关详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  • interpolate_pos_encoding (bool, 可选，默认为 False) — 是否插值预训练的位置编码。

返回

transformers.models.blip_2.modeling_blip_2.Blip2VisionModelOutput or tuple(torch.FloatTensor)

transformers.models.blip_2.modeling_blip_2.Blip2VisionModelOutput 或 torch.FloatTensor 的元组（如果传递 return_dict=False 或当 config.return_dict=False 时），包含取决于配置 (<class 'transformers.models.blip_2.configuration_blip_2.Blip2Config'>) 和输入的不同元素。

  • image_embeds (torch.FloatTensor of shape (batch_size, output_dim) 可选，当模型使用 with_projection=True 初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。

  • last_hidden_state (torch.FloatTensor of shape (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 之后的注意力权重，用于计算自注意力头中的加权平均值。

The 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])
< > 在 GitHub 上更新

←BLIP BridgeTower→