Transformers

( 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, 可选) — 特殊图像 token 的 token 索引。
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: typing.Optional[transformers.configuration_utils.PretrainedConfig] = 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) — 每个补丁的大小（分辨率）。
hidden_act (str 或 function, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，支持 "gelu"、"relu"、"selu" 和 "gelu_new" "gelu"。layer_norm_eps (float, 可选, 默认为 1e-5): 层归一化层使用的 epsilon。
attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
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

class 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 可以表示的不同 token 的数量。
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) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。
max_position_embeddings (int, 可选, 默认为 512) — 该模型可能使用的最大序列长度。通常为了以防万一设置为较大值（例如 512 或 1024 或 2048）。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon。
pad_token_id (int, optional, defaults to 0) — 用于填充标记的索引。
position_embedding_type (str, optional, defaults to "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, defaults to 2) — 向 Transformer 层添加交叉注意的频率。
encoder_hidden_size (int, optional, defaults to 1408) — 用于交叉注意的隐藏状态的隐藏大小。
use_qformer_text_input (bool, optional, defaults to 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, optional) — 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 )

参数

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

裸 Blip 2 模型，输出原始隐藏状态，顶部没有任何特定头部。

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

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

forward

( 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 (形状为 (batch_size, num_channels, image_size, image_size) 的 torch.FloatTensor，可选) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获得。有关详细信息，请参阅 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 处理图像）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。
interpolate_pos_encoding (bool, defaults to False) — 是否插值预训练的位置编码。

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

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或 torch.FloatTensor 的元组（如果传入 return_dict=False 或 config.return_dict=False），包含根据配置 (Blip2Config) 和输入的不同元素。

last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
pooler_output (形状为 (batch_size, hidden_size) 的 torch.FloatTensor) — 经过用于辅助预训练任务的层进一步处理后，序列的第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 家族模型，这会在经过线性层和 tanh 激活函数处理后返回分类标记。线性层权重在预训练期间根据下一句预测（分类）目标进行训练。
hidden_states (tuple(torch.FloatTensor), 可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个）。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每个层一个）。

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

Blip2VisionModel 的 forward 方法，重写了 __call__ 特殊方法。

尽管前向传播的实现需要在该函数中定义，但之后应调用 Module 实例而不是直接调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

Blip2QFormerModel

class transformers.Blip2QFormerModel

( config: Blip2QFormerConfig )

参数

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

BLIP-2 查询 Transformer (Q-Former)。

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

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

forward

( 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[tuple[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 ) → transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或 tuple(torch.FloatTensor)

参数

query_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor) — 用于注意力计算的隐藏状态。如果是交叉注意力，将用于查询（即，键和值将使用 encoder_hidden_states）。
query_length (int, 可选) — 查询的长度，通常基于查询标记的数量。如果未提供值，query_length 将由 query_embeds 推断。
attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor，可选) — 遮罩，用于避免在填充标记索引上执行注意力。遮罩值选择为 [0, 1]：
- 1 表示标记未被遮罩，
- 0 表示标记被遮罩。
什么是注意力遮罩？
head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 torch.FloatTensor，可选) — 用于使自注意力模块的选定头部无效的遮罩。遮罩值选择为 [0, 1]：
- 1 表示头部未被遮罩，
- 0 表示头部被遮罩。
encoder_hidden_states (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor，可选) — 编码器最后一层输出的隐藏状态序列。如果模型配置为解码器，则用于交叉注意力。
encoder_attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor，可选) — 用于避免在编码器输入填充标记索引上执行注意力的遮罩。如果模型配置为解码器，则此遮罩在交叉注意力中使用。遮罩值选择为 [0, 1]：
- 1 表示标记未被遮罩，
- 0 表示标记被遮罩。
past_key_values (tuple[tuple[torch.FloatTensor]], 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

允许两种格式：
- 一个 Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也被称为传统缓存格式。
模型将输出与输入相同的缓存格式。如果未传入 past_key_values，将返回传统缓存格式。

如果使用 past_key_values，用户可以选择仅输入最后一个 input_ids（那些没有将过去的键值状态提供给此模型的）形状为 (batch_size, 1)，而不是所有 input_ids 形状为 (batch_size, sequence_length)。
use_cache (bool, 可选) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。

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

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或 torch.FloatTensor 的元组（如果传入 return_dict=False 或 config.return_dict=False），包含根据配置 (Blip2Config) 和输入的不同元素。

last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
pooler_output (形状为 (batch_size, hidden_size) 的 torch.FloatTensor) — 经过用于辅助预训练任务的层进一步处理后，序列的第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 家族模型，这会在经过线性层和 tanh 激活函数处理后返回分类标记。线性层权重在预训练期间根据下一句预测（分类）目标进行训练。
hidden_states (tuple(torch.FloatTensor), 可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个）。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每个层一个）。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=True 和 config.add_cross_attention=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每个层一个）。

解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
past_key_values (Cache, 可选，当传入 use_cache=True 或 config.use_cache=True 时返回) — 它是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

包含预先计算的隐藏状态（自注意力块和可选的交叉注意力块中的键和值，如果 config.is_encoder_decoder=True），可用于加速顺序解码（参见 past_key_values 输入）。

Blip2QFormerModel 的 forward 方法，重写了 __call__ 特殊方法。

Blip2Model

class transformers.Blip2Model

( config: Blip2Config )

参数

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

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

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

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

forward

( 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 **kwargs: typing_extensions.Unpack[transformers.models.blip_2.modeling_blip_2.KwargsForCausalLM] ) → transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (形状为 (batch_size, num_channels, image_size, image_size) 的 torch.FloatTensor) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获得。有关详细信息，请参阅 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 处理图像）。
input_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 语言模型词汇表中输入序列标记的索引。可以可选地提供输入标记作为文本提示，语言模型可以继续。

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

什么是输入 ID？
attention_mask (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 遮罩，用于避免在填充标记索引上执行注意力。遮罩值选择为 [0, 1]：
- 1 表示标记未被遮罩，
- 0 表示标记被遮罩。
什么是注意力遮罩？
decoder_input_ids (形状为 (batch_size, target_sequence_length) 的 torch.LongTensor，可选) — 解码器输入序列标记在词汇表中的索引。

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

什么是解码器输入 ID？
decoder_attention_mask (形状为 (batch_size, target_sequence_length) 的 torch.BoolTensor，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。默认情况下也将使用因果遮罩。

仅当使用编码器-解码器语言模型（如 T5）时才相关。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的 hidden_states。
labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算遮罩语言模型损失的标签。索引应为 [0, ..., config.vocab_size] 或 -100 (参见 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略（遮罩），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。
return_dict (bool, optional) — 是否返回 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 时），包含根据配置 (Blip2Config) 和输入而变化的各种元素。

loss (torch.FloatTensor, 可选, 当提供 labels 时返回, 形状为 (1,) 的 torch.FloatTensor) — 语言模型的语言建模损失。
logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言模型的语言建模头部预测分数。
vision_outputs (torch.FloatTensor, 可选, 默认为 None) — 视觉编码器的输出。
qformer_outputs (tuple[torch.FloatTensor], 可选, 默认为 None) — Q-Former（查询 Transformer）的输出。
language_model_outputs (CausalLMOutputWithPast 或 Seq2SeqLMOutput) — 语言模型的输出。

Blip2Model 前向方法，覆盖 __call__ 特殊方法。

示例

>>> 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)

获取文本特征

( 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 **kwargs: typing_extensions.Unpack[transformers.models.blip_2.modeling_blip_2.KwargsForCausalLM] ) → text_outputs (CausalLMOutputWithPast, 或 tuple(torch.FloatTensor) 如果 return_dict=False)

参数

input_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。

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

什么是输入 ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 遮罩，用于避免在填充标记索引上执行注意力。遮罩值在 [0, 1] 中选择：
- 1 表示**未遮罩**的标记，
- 0 表示**已遮罩**的标记。
什么是注意力遮罩？
decoder_input_ids (torch.LongTensor，形状为 (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，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。默认情况下也将使用因果遮罩。
labels (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于计算遮罩语言模型损失的标签。索引应为 [0, ..., config.vocab_size] 或 -100 (参见 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略（遮罩），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。
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 则包含隐藏状态。

示例

>>> 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)

获取图像特征

( 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 元组)

参数

pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息，请参阅 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 处理图像）。
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，则还包含隐藏状态。

示例

>>> 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)

获取 Q-Former 特征

( 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 元组)

参数

pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息，请参阅 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 处理图像）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。
interpolate_pos_encoding (bool, 默认为 False) — 是否对预训练的位置编码进行插值。

vision_outputs (BaseModelOutputWithPooling 或 torch.FloatTensor 元组)

示例

>>> 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 模型，用于在给定图像和可选文本提示的情况下生成文本。该模型由一个视觉编码器、一个查询转换器（Q-Former）和一个语言模型组成。

可以选择向模型传递 input_ids 作为文本提示，以便语言模型继续提示。否则，语言模型将从 [BOS] (序列开始) token 开始生成文本。

请注意，Flan-T5 检查点无法转换为 float16。它们使用 bfloat16 预训练。

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

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

forward

( 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 **kwargs: typing_extensions.Unpack[transformers.models.blip_2.modeling_blip_2.KwargsForCausalLM] ) → transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, image_size, image_size)) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息，请参阅 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 处理图像）。
input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 语言模型词汇表中输入序列标记的索引。可以可选地提供输入标记作为文本提示，语言模型可以继续生成。

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

什么是输入 ID？
attention_mask (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 遮罩，用于避免在填充标记索引上执行注意力。遮罩值在 [0, 1] 中选择：
- 1 表示**未遮罩**的标记，
- 0 表示**已遮罩**的标记。
什么是注意力遮罩？
decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。

可以使用 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。
labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算遮罩语言模型损失的标签。索引应为 [0, ..., config.vocab_size] 或 -100 (参见 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略（遮罩），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。
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)

loss (torch.FloatTensor, 可选, 当提供 labels 时返回, 形状为 (1,) 的 torch.FloatTensor) — 语言模型的语言建模损失。
logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言模型的语言建模头部预测分数。
vision_outputs (torch.FloatTensor, 可选, 默认为 None) — 视觉编码器的输出。
qformer_outputs (tuple[torch.FloatTensor], 可选, 默认为 None) — Q-Former（查询 Transformer）的输出。
language_model_outputs (CausalLMOutputWithPast 或 Seq2SeqLMOutput) — 语言模型的输出。

Blip2ForConditionalGeneration 前向方法，覆盖 __call__ 特殊方法。

示例

准备处理器、模型和图像输入

>>> 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)
two

生成

( 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 (列表)

参数

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 (列表)

一个字符串列表，长度为 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: 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, image_size, image_size)) — 对应输入图像的张量。像素值可以使用 {image_processor_class} 获取。详情请参见 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 处理图像）。
input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 语言模型词汇表中输入序列标记的索引。可以可选地提供输入标记作为文本提示，语言模型可以继续。

索引可以使用 Blip2Processor 获取。详情请参见 Blip2Processor.__call__()。

什么是输入 ID？
attention_mask (torch.LongTensor，形状为 (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 时），其中包含根据配置 (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 (<class '~modeling_outputs.BaseModelOutputWithPooling'>.text_model_output，默认为 None) — Blip2QFormerModel 的输出。
vision_model_output (<class '~modeling_outputs.BaseModelOutputWithPooling'>.vision_model_output，默认为 None) — Blip2VisionModel 的输出。

Blip2ForImageTextRetrieval 的前向方法，覆盖 __call__ 特殊方法。

示例

>>> 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: 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.Tensor，形状为 (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.Tensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
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 时），其中包含根据配置 (Blip2Config) 和输入而定的各种元素。

text_embeds (torch.FloatTensor，形状为 (batch_size, output_dim) 可选，当模型以 with_projection=True 初始化时返回) — 通过对池化输出应用投影层获得的文本嵌入。
last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选，默认为 None) — 模型最后一层输出的隐藏状态序列。
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__ 特殊方法。

示例

>>> 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