Transformers 4.37 中文文档（八十二）（4）-阿里云开发者社区

Transformers 4.37 中文文档（八十二）（3）https://developer.aliyun.com/article/1563226

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 时）包含根据配置 () 和输入而异的各种元素。

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时）包括根据配置（）和输入的不同元素。

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 时）包含根据配置（）和输入的不同元素。

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）包含根据配置（）和输入的不同元素。

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时）包含根据配置（）和输入的不同元素。

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

Transformers 4.37 中文文档（八十二）（5）https://developer.aliyun.com/article/1563228

Transformers 4.37 中文文档（八十二）（4）

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`

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（八十二）（4）

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

热门文章

最新文章

相关电子书

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