标签：None Transformers -- FloatTensor torch 37 hidden Optional size

Transformers 4.37 中文文档（四十一）

原文：huggingface.co/docs/transformers

AltCLIP

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

概述

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

论文摘要如下：

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

该模型由jongjyh贡献。

使用提示和示例

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

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

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

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

>>> from PIL import Image
>>> import requests

>>> from transformers import AltCLIPModel, AltCLIPProcessor

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

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

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

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

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

AltCLIPConfig

`class transformers.AltCLIPConfig`

<来源>

( text_config = None vision_config = None projection_dim = 768 logit_scale_init_value = 2.6592 **kwargs )

参数

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

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

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

示例：

>>> from transformers import AltCLIPConfig, AltCLIPModel

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

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

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

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

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

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

`from_text_vision_configs`

< source >

( text_config: AltCLIPTextConfig vision_config: AltCLIPVisionConfig **kwargs ) → export const metadata = 'undefined';AltCLIPConfig

AltCLIPConfig

一个配置对象的实例

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

AltCLIPTextConfig

`class transformers.AltCLIPTextConfig`

< source >

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

参数

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

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

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

示例：

>>> from transformers import AltCLIPTextModel, AltCLIPTextConfig

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

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

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

AltCLIPVisionConfig

`class transformers.AltCLIPVisionConfig`

< source >

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

参数

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

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

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

示例：

>>> from transformers import AltCLIPVisionConfig, AltCLIPVisionModel

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

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

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

AltCLIPProcessor

`class transformers.AltCLIPProcessor`

<来源>

( image_processor = None tokenizer = None **kwargs )

参数

image_processor（CLIPImageProcessor，可选）— 图像处理器是必需的。
tokenizer（XLMRobertaTokenizerFast，可选）— 分词器是必需的。

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

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

`batch_decode`

<来源>

( *args **kwargs )

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

`decode`

<来源>

( *args **kwargs )

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

AltCLIPModel

`class transformers.AltCLIPModel`

<来源>

( config: AltCLIPConfig )

`forward`

<来源>

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

参数

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

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

什么是输入 ID？
attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。选择在[0, 1]范围内的掩码值：
- 对于未被掩码的标记为 1，
- 对于被掩码的标记为 0。
什么是注意力掩码？
position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

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

transformers.models.altclip.modeling_altclip.AltCLIPOutput或tuple(torch.FloatTensor)

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

loss (torch.FloatTensor，形状为(1,)，可选，当return_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) — 通过将投影层应用于 AltCLIPTextModel 的汇聚输出获得的文本嵌入。
image_embeds(torch.FloatTensor，形状为(batch_size, output_dim) — 通过将投影层应用于 AltCLIPVisionModel 的汇聚输出获得的图像嵌入。
text_model_output(BaseModelOutputWithPooling): AltCLIPTextModel 的输出。
vision_model_output(BaseModelOutputWithPooling): AltCLIPVisionModel 的输出。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AltCLIPModel

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

`get_text_features`

<来源>

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

参数

input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 避免在填充令牌索引上执行注意力的掩码。选择在[0, 1]范围内的掩码值：
- 对于未被屏蔽的标记，为 1，
- 对于被屏蔽的标记，为 0。
什么是注意力掩码？
position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

什么是位置 ID？
output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

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

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

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

示例：

>>> from transformers import AutoProcessor, AltCLIPModel

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

`get_image_features`

<来源>

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';image_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

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

image_features（形状为（batch_size，output_dim）的 torch.FloatTensor）

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

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AltCLIPModel

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

AltCLIPTextModel

`class transformers.AltCLIPTextModel`

<来源>

( config )

`forward`

<来源>

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

参数

input_ids（形状为（batch_size，sequence_length）的 torch.LongTensor）— 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

什么是输入 ID？
attention_mask（形状为（batch_size，sequence_length）的 torch.Tensor，可选）— 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：
- 1 表示“未被掩盖”的标记，
- 0 表示“被掩盖”的标记。
什么是注意力掩码？
position_ids（形状为（batch_size，sequence_length）的 torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

什么是位置 ID？
output_attentions（布尔值，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（布尔值，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（布尔值，可选）— 是否返回 ModelOutput 而不是普通元组。

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

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

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

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

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
projection_state (tuple(torch.FloatTensor)，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size,config.project_dim)的torch.FloatTensor元组。

投影层之前的文本嵌入，用于模仿教师编码器的最后隐藏状态。

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

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

示例：

>>> from transformers import AutoProcessor, AltCLIPTextModel

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

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

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

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

AltCLIPVisionModel

`class transformers.AltCLIPVisionModel`

<来源>

( config: AltCLIPVisionConfig )

`forward`

<来源>

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

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

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

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

last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 经过用于辅助预训练任务的层进一步处理后，序列中第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是从下一个句子预测（分类）目标在预训练期间训练的。
hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AltCLIPVisionModel

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

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

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

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

BLIP

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

概述

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

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

视觉问答
图像-文本检索（图像-文本匹配）
图像字幕生成

论文摘要如下：

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

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

资源

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

BlipConfig

`class transformers.BlipConfig`

<来源>

( text_config = None vision_config = None projection_dim = 512 logit_scale_init_value = 2.6592 image_text_hidden_size = 256 **kwargs )

参数

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

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

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

示例：

>>> from transformers import BlipConfig, BlipModel

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

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

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

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

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

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

`from_text_vision_configs`

<来源>

( text_config: BlipTextConfig vision_config: BlipVisionConfig **kwargs ) → export const metadata = 'undefined';BlipConfig

BlipConfig

配置对象的一个实例

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

BlipTextConfig

`class transformers.BlipTextConfig`

<来源>

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

参数

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

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

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

示例：

>>> from transformers import BlipTextConfig, BlipTextModel

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

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

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

BlipVisionConfig

`class transformers.BlipVisionConfig`

< source >

( hidden_size = 768 intermediate_size = 3072 projection_dim = 512 num_hidden_layers = 12 num_attention_heads = 12 image_size = 384 patch_size = 16 hidden_act = 'gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 1e-10 **kwargs )

参数

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

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

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

示例：

>>> from transformers import BlipVisionConfig, BlipVisionModel

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

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

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

BlipProcessor

`class transformers.BlipProcessor`

< source >

( image_processor tokenizer )

参数

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

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

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

`batch_decode`

< source >

( *args **kwargs )

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

`decode`

< source >

( *args **kwargs )

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

BlipImageProcessor

`class transformers.BlipImageProcessor`

<来源>

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_convert_rgb: bool = True **kwargs )

参数

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

构建一个 BLIP 图像处理器。

`preprocess`

<来源>

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

参数

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

预处理图像或图像批次。

Pytorch 隐藏 Pytorch 内容

BlipModel

`class transformers.BlipModel`

<来源>

( config: BlipConfig )

参数

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

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

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

`forward`

<来源>

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

参数

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

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

什么是输入 ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。选择在 [0, 1] 中的掩码值：
- 1 代表未被“掩码”的标记，
- 0 代表被“掩码”的标记。
什么是注意力掩码？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

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

transformers.models.blip.modeling_blip.BlipOutput 或 tuple(torch.FloatTensor)

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

loss (torch.FloatTensor，形状为 (1,)，可选，当 return_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) — 通过将投影层应用于 BlipTextModel 的池化输出获得的文本嵌入。
image_embeds(torch.FloatTensor，形状为 (batch_size, output_dim) — 通过将投影层应用于 BlipVisionModel 的池化输出获得的图像嵌入。
text_model_output(BaseModelOutputWithPooling): BlipTextModel 的输出。
vision_model_output(BaseModelOutputWithPooling): BlipVisionModel 的输出。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipModel

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

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

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

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

`get_text_features`

< source >

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';text_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

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

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

什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]范围内：
- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
什么是注意力掩码？
position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

什么是位置 ID？
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

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

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

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

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

示例：

>>> from transformers import AutoProcessor, BlipModel

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

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

get_image_features

<来源>

( pixel_values: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';image_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

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

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

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipModel

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

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

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

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

BlipTextModel

`class transformers.BlipTextModel`

<来源>

( config add_pooling_layer = True )

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

`forward`

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None is_decoder: Optional = False )

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

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

BlipVisionModel

`class transformers.BlipVisionModel`

<来源>

( config: BlipVisionConfig )

`forward`

<来源>

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

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

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

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

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层的隐藏状态序列。
pooler_output (torch.FloatTensor，形状为(batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=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 之后，用于计算自注意力头中的加权平均值。

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

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

BlipForConditionalGeneration

`class transformers.BlipForConditionalGeneration`

<来源>

( config: BlipConfig )

参数

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

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

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

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

`forward`

<来源>

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

参数

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

transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput 或 torch.FloatTensor 元组

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

loss (torch.FloatTensor, optional, 当提供 labels 时返回，形状为 (1,) 的 torch.FloatTensor) — 文本解码器的语言建模损失。
logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.vocab_size)，optional) — 文本解码器模型的语言建模头的预测分数。
image_embeds (torch.FloatTensor，形状为 (batch_size, output_dim)，optional) — 将 Vision Transformer 模型应用于输入图像后获得的图像嵌入。
last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，optional) — 模型最后一层的隐藏状态序列。
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True) — torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入的输出 + 每个层的输出）的形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipForConditionalGeneration

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

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

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

>>> outputs = model(**inputs)

BlipForImageTextRetrieval

`class transformers.BlipForImageTextRetrieval`

< source >

( config: BlipConfig )

参数

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

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

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

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

forward

<来源>

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

参数

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

transformers.models.blip.modeling_blip.BlipTextVisionModelOutput 或 tuple(torch.FloatTensor)

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

loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回） — 文本解码器的语言建模损失。
image_embeds (torch.FloatTensor，形状为(batch_size, output_dim) optional，当模型使用with_projection=True初始化时返回） — 通过将投影层应用于 pooler_output 获得的图像嵌入。
last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)） — 模型最后一层的隐藏状态序列。
hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出的输出+每层的输出）。

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

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

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipForImageTextRetrieval

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

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

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

BlipForQuestionAnswering

`class transformers.BlipForQuestionAnswering`

<来源>

( config: BlipConfig )

参数

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

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

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

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

`forward`

<来源>

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

参数

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

transformers.models.blip.modeling_blip.BlipTextVisionModelOutput或tuple(torch.FloatTensor)

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

loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 来自文本解码器的语言建模损失。
image_embeds（形状为(batch_size, output_dim)的torch.FloatTensor 可选，当使用with_projection=True初始化模型时返回）- 通过将投影层应用于 pooler_output 获得的图像嵌入。
last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列。
hidden_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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipForQuestionAnswering

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

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

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

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

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

TensorFlow 隐藏 TensorFlow 内容

TFBlipModel

`class transformers.TFBlipModel`

<来源>

( config: BlipConfig *inputs **kwargs )

`call`

<来源>

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

参数

input_ids（形状为(batch_size, sequence_length)的tf.Tensor） — 输入序列标记在词汇表中的索引。默认情况下，如果提供了填充，将忽略填充。

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

什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选） — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：
- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
什么是注意力掩码？
position_ids（形状为(batch_size, sequence_length)的tf.Tensor，可选） — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是位置 ID？
pixel_values（形状为(batch_size, num_channels, height, width)的tf.Tensor） — 像素值。默认情况下，如果提供了填充，将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息，请参阅 BlipImageProcessor.call()。
return_loss（bool，可选） — 是否返回对比损失。
output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选） — 是否返回一个 ModelOutput 而不是一个普通元组。

transformers.models.blip.modeling_tf_blip.TFBlipOutput或tuple(tf.Tensor)

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

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

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipModel

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

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

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

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

`get_text_features`

< source >

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

参数

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

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

什么是输入 ID？
attention_mask (tf.Tensor 的形状为 (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：
- 1 代表未被“masked”的标记，
- 对于被masked的标记。
什么是注意力掩码？
position_ids (tf.Tensor 的形状为 (batch_size, sequence_length), 可选) — 每个输入序列标记的位置在位置嵌入中的索引。选在范围 [0, config.max_position_embeddings - 1]。

什么是位置 ID？
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

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

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

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

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

示例：

>>> from transformers import AutoProcessor, TFBlipModel

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

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

`get_image_features`

< source >

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

参数

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

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

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

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipModel

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

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

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

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

TFBlipTextModel

`class transformers.TFBlipTextModel`

<来源>

( config add_pooling_layer = True name = None **kwargs )

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

调用

<来源>

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

参数

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

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

什么是输入 ID？
attention_mask (tf.Tensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：
- 对于未被masked的标记为 1，
- 对于被masked的标记为 0。
什么是注意力掩码？
position_ids (tf.Tensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

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

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

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

TFBlipVisionModel

`class transformers.TFBlipVisionModel`

< source >

( config: BlipVisionConfig *args **kwargs )

`call`

< source >

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

参数

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

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

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

last_hidden_state (tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
pooler_output (tf.Tensor，形状为 (batch_size, hidden_size)) — 序列中第一个令牌（分类令牌）的最后一层隐藏状态，经过线性层和 Tanh 激活函数进一步处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。

通常，此输出通常不是输入语义内容的良好摘要，您通常最好对整个输入序列的隐藏状态序列进行平均或池化。
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size)。

模型在每个层的输出的隐藏状态加上初始嵌入输出。
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。

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

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

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

TFBlipForConditionalGeneration

`class transformers.TFBlipForConditionalGeneration`

<来源>

( config: BlipConfig *args **kwargs )

参数

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

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

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

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

`call`

<来源>

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

参数

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

transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutput 或 tuple(tf.Tensor)

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

loss（tf.Tensor，可选，当提供labels时返回，形状为(1,)的tf.Tensor）- 来自文本解码器的语言建模损失。
logits（形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor，可选）- 文本解码器模型语言建模头的预测分数。
image_embeds（形状为(batch_size, output_dim)的tf.Tensor，可选）- 在将输入图像应用于 Vision Transformer 模型后获得的图像嵌入。
last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）- 模型最后一层输出的隐藏状态序列。
hidden_states（tuple(tf.Tensor)，可选，当output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（如果模型有嵌入层，则为嵌入输出的一个+每层输出的一个）。

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

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

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipForConditionalGeneration

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

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

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

>>> outputs = model(**inputs)

TFBlipForImageTextRetrieval

`class transformers.TFBlipForImageTextRetrieval`

<来源>

( config: BlipConfig *args **kwargs )

参数

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

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

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

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

`call`

<来源>

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

参数

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

transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput或tuple(tf.Tensor)

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

itm_score（tf.Tensor）— 图像文本相似性分数。
loss（形状为(1,)的tf.Tensor，可选，在提供labels时返回）— 文本解码器的语言建模损失。
image_embeds（形状为(batch_size, output_dim)的tf.Tensor，可选，在使用with_projection=True初始化模型时返回）— 通过将 pooler_output 应用到投影层获得的图像嵌入。
last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型最后一层的隐藏状态序列。
hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组。

模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
vision_pooler_output（形状为(batch_size, hidden_size)的tf.Tensor，可选）— 模型视觉分支的最后一层隐藏状态。
attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。

在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
question_embeds（tf.Tensor）— 由文本投影层获得的问题嵌入。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipForImageTextRetrieval

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

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

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

TFBlipForQuestionAnswering

`class transformers.TFBlipForQuestionAnswering`

<来源>

( config: BlipConfig *args **kwargs )

参数

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

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

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

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

`call`

< source >

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

参数

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

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

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

loss (tf.Tensor，形状为(1,)，optional，当提供labels时返回) — 来自文本解码器的语言建模损失。
image_embeds (tf.Tensor，形状为(batch_size, output_dim) optional，当模型使用with_projection=True初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。
last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每一层的输出）。

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

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

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

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

示例：

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

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

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

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

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

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

BLIP-2

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/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 利用冻结的预训练图像编码器和大型语言模型（LLMs），通过在它们之间训练一个轻量级的 12 层 Transformer 编码器，实现了各种视觉-语言任务的最先进性能。值得注意的是，BLIP-2 在零样本 VQAv2 上比Flamingo（一个 80 亿参数模型）提高了 8.7%，并且可训练参数数量减少了 54 倍。

论文摘要如下：

由于大规模模型的端到端训练，视觉-语言预训练的成本变得越来越高。本文提出了 BLIP-2，一种通用且高效的预训练策略，从现成的冻结预训练图像编码器和冻结大型语言模型中引导视觉-语言预训练。BLIP-2 通过轻量级的 Querying Transformer 消除了模态差异，该模型经过两个阶段的预训练。第一阶段从冻结图像编码器引导视觉-语言表示学习。第二阶段从冻结语言模型引导视觉-语言生成学习。尽管可训练参数数量明显少于现有方法，但 BLIP-2 在各种视觉-语言任务上实现了最先进的性能。例如，我们的模型在零样本 VQAv2 上比 Flamingo80B 提高了 8.7%，并且可训练参数数量减少了 54 倍。我们还展示了模型的新兴能力，即零样本图像到文本生成，可以遵循自然语言指令。

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

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

使用提示

BLIP-2 可用于在给定图像和可选文本提示的情况下进行条件文本生成。在推理时，建议使用 generate 方法。
可以使用 Blip2Processor 来为模型准备图像，并将预测的标记 ID 解码回文本。

资源

官方 Hugging Face 和社区（由

标签：None,Transformers,--,FloatTensor,torch,37,hidden,Optional,size
From： https://www.cnblogs.com/apachecn/p/18262307

Transformers--4-37-中文文档-四十一-

Transformers 4.37 中文文档（四十一）

AltCLIP

概述

使用提示和示例

AltCLIPConfig

class transformers.AltCLIPConfig

from_text_vision_configs

AltCLIPTextConfig

class transformers.AltCLIPTextConfig

AltCLIPVisionConfig

class transformers.AltCLIPVisionConfig

AltCLIPProcessor

class transformers.AltCLIPProcessor

batch_decode

decode

AltCLIPModel

class transformers.AltCLIPModel

forward

get_text_features

get_image_features

AltCLIPTextModel

class transformers.AltCLIPTextModel

forward

AltCLIPVisionModel

class transformers.AltCLIPVisionModel

forward

BLIP

概述

资源

BlipConfig

class transformers.BlipConfig

from_text_vision_configs

BlipTextConfig

class transformers.BlipTextConfig

BlipVisionConfig

class transformers.BlipVisionConfig

BlipProcessor

class transformers.BlipProcessor

batch_decode

decode

BlipImageProcessor

class transformers.BlipImageProcessor

preprocess

BlipModel

class transformers.BlipModel

forward

get_text_features

BlipTextModel

class transformers.BlipTextModel

forward

BlipVisionModel

class transformers.BlipVisionModel

forward

BlipForConditionalGeneration

class transformers.BlipForConditionalGeneration

forward

BlipForImageTextRetrieval

class transformers.BlipForImageTextRetrieval

BlipForQuestionAnswering

class transformers.BlipForQuestionAnswering

forward

TFBlipModel

class transformers.TFBlipModel

call

get_text_features

get_image_features

TFBlipTextModel

class transformers.TFBlipTextModel

TFBlipVisionModel

class transformers.TFBlipVisionModel

call

TFBlipForConditionalGeneration

class transformers.TFBlipForConditionalGeneration

call

TFBlipForImageTextRetrieval

class transformers.TFBlipForImageTextRetrieval

call

TFBlipForQuestionAnswering

class transformers.TFBlipForQuestionAnswering

`class transformers.AltCLIPConfig`

`from_text_vision_configs`

`class transformers.AltCLIPTextConfig`

`class transformers.AltCLIPVisionConfig`

`class transformers.AltCLIPProcessor`

`batch_decode`

`decode`

`class transformers.AltCLIPModel`

`forward`

`get_text_features`

`get_image_features`

`class transformers.AltCLIPTextModel`

`forward`

`class transformers.AltCLIPVisionModel`

`forward`

`class transformers.BlipConfig`

`from_text_vision_configs`

`class transformers.BlipTextConfig`

`class transformers.BlipVisionConfig`

`class transformers.BlipProcessor`

`batch_decode`

`decode`

`class transformers.BlipImageProcessor`

`preprocess`

`class transformers.BlipModel`

`forward`

`get_text_features`

`class transformers.BlipTextModel`

`forward`

`class transformers.BlipVisionModel`

`forward`

`class transformers.BlipForConditionalGeneration`

`forward`

`class transformers.BlipForImageTextRetrieval`

`class transformers.BlipForQuestionAnswering`

`forward`

`class transformers.TFBlipModel`

`call`

`get_text_features`

`get_image_features`

`class transformers.TFBlipTextModel`

`class transformers.TFBlipVisionModel`

`call`

`class transformers.TFBlipForConditionalGeneration`

`call`

`class transformers.TFBlipForImageTextRetrieval`

`call`

`class transformers.TFBlipForQuestionAnswering`

`call`