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
( 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__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用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(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 whenoutput_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
( 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