Transformers 4.37 中文文档（八十二）（4）https://developer.aliyun.com/article/1563227
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）包含根据配置（）和输入的各种元素。
损失（形状为(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
( 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
( 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
( config: BlipVisionConfig *args **kwargs )
call
( 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 时）包含根据配置 () 和输入不同元素。
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 whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — Tuple oftf.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 whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftf.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.Tensorof 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）包含根据配置（）和输入的不同元素。
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时）包含根据配置（）和输入的不同元素。
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
( 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）包含根据配置()和输入的各种元素。
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
onModelOutput 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` 实例而不是这个函数，因为前者会处理运行前后的处理步骤，而后者会默默地忽略它们。 示例： ```py >>> 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
