Transformers 文档

BLIP

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得分提高了1.6%)。BLIP在零样本方式下直接迁移到视频-语言任务时也表现出强大的泛化能力。代码、模型和数据集均已发布。

BLIP.gif

该模型由ybelkada贡献。 原始代码可以在这里找到。

资源

  • Jupyter notebook 关于如何在自定义数据集上微调BLIP以进行图像字幕生成

BlipConfig

transformers.BlipConfig

< >

( text_config = 无 vision_config = 无 projection_dim = 512 logit_scale_init_value = 2.6592 image_text_hidden_size = 256 label_smoothing = 0.0 **kwargs )

参数

  • text_config (dict, 可选) — 用于初始化 BlipTextConfig 的配置选项字典.
  • vision_config (dict, 可选) — 用于初始化 BlipVisionConfig 的配置选项字典.
  • projection_dim (int, 可选, 默认为 512) — 文本和视觉投影层的维度.
  • logit_scale_init_value (float, optional, 默认为 2.6592) — logit_scale 参数的初始值。默认值按照原始 BLIP 实现使用。
  • image_text_hidden_size (int, optional, 默认为 256) — 图像文本融合层隐藏状态的维度。
  • label_smoothing (float, 可选, 可选, 默认为 0.0) — 一个在 [0.0, 1.0] 范围内的浮点数。指定计算损失时的平滑量,其中 0.0 表示不进行平滑。目标变为原始真实值和均匀分布的混合,如 Rethinking the Inception Architecture for Computer Vision __ 中所述。默认值: :math:0.0.
  • kwargs (可选) — 关键字参数字典。

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

返回

BlipConfig

配置对象的一个实例

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

BlipTextConfig

transformers.BlipTextConfig

< >

( 词汇大小 = 30524 隐藏大小 = 768 编码器隐藏大小 = 768 中间大小 = 3072 投影维度 = 768 隐藏层数 = 12 注意力头数 = 8 最大位置嵌入 = 512 隐藏激活函数 = 'gelu' 层归一化epsilon = 1e-12 隐藏层dropout概率 = 0.0 注意力概率dropout概率 = 0.0 初始化范围 = 0.02 bos_token_id = 30522 eos_token_id = 2 pad_token_id = 0 sep_token_id = 102 是否为解码器 = True 使用缓存 = True 标签平滑 = 0.0 **kwargs )

参数

  • vocab_size (int, 可选, 默认为 30524) — Blip 文本模型的词汇量大小。定义了调用 BlipModel 时传递的 inputs_ids 可以表示的不同标记的数量。
  • hidden_size (int, optional, 默认为 768) — 编码器层和池化层的维度。
  • encoder_hidden_size (int, optional, 默认为 768) — 视觉模型中编码器层的维度。
  • intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”(即前馈)层的维度。
  • num_hidden_layers (int, optional, defaults to 12) — Transformer编码器中的隐藏层数量。
  • num_attention_heads (int, optional, defaults to 8) — Transformer编码器中每个注意力层的注意力头数。
  • max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512、1024 或 2048)。
  • hidden_act (strfunction, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持 "gelu", "relu", "selu""gelu_new" "gelu".
  • layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的epsilon值。
  • hidden_dropout_prob (float, optional, 默认为 0.0) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
  • attention_dropout (float, optional, defaults to 0.0) — 注意力概率的丢弃比率。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • bos_token_id (int, 可选, 默认为 30522) — beginning-of-sequence 标记的 id.
  • eos_token_id (int, optional, defaults to 2) — end-of-sequence 标记的 ID.
  • pad_token_id (int, 可选, 默认为 0) — padding 令牌的 ID.
  • sep_token_id (int, 可选, 默认为 102) — separator 令牌的 id.
  • is_decoder (bool, optional, defaults to True) — 模型是否用作解码器。
  • use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。
  • label_smoothing (float, optional) — 一个在 [0.0, 1.0] 范围内的浮点数。指定计算损失时的平滑量,其中 0.0 表示不平滑。目标变为原始真实值和均匀分布的混合,如 Rethinking the Inception Architecture for Computer Vision __ 中所述。默认值::math:0.0.

这是用于存储BlipTextModel配置的配置类。它用于根据指定的参数实例化一个BLIP文本模型,定义模型架构。使用默认值实例化配置将产生与基础架构使用的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

transformers.BlipVisionConfig

< >

( 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, 默认为 768) — 编码器层和池化层的维度。
  • intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”(即前馈)层的维度。
  • num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。
  • num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
  • image_size (int, optional, 默认为 384) — 每张图像的尺寸(分辨率)。
  • patch_size (int, optional, defaults to 16) — 每个补丁的大小(分辨率)。
  • hidden_act (strfunction, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持 "gelu", "relu", "selu""gelu_new" "gelu".
  • layer_norm_eps (float, optional, defaults to 1e-5) — 层归一化层使用的epsilon值。
  • attention_dropout (float, optional, defaults to 0.0) — 注意力概率的丢弃比率。
  • initializer_range (float, 可选, 默认为 1e-10) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

这是用于存储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

transformers.BlipProcessor

< >

( image_processor tokenizer **kwargs )

参数

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

构建一个BLIP处理器,它将BERT分词器和BLIP图像处理器封装成一个单一的处理器。

BlipProcessor 提供了 BlipImageProcessorBertTokenizerFast 的所有功能。更多信息请参见 __call__() 的文档字符串和 decode()

batch_decode

< >

( *args **kwargs )

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

解码

< >

( *args **kwargs )

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

BlipImageProcessor

transformers.BlipImageProcessor

< >

( do_resize: 布尔值 = 真 size: 字典[str, int] = 无 resample: 重采样 = <重采样.BICUBIC: 3> do_rescale: 布尔值 = 真 rescale_factor: 联合[int, float] = 0.00392156862745098 do_normalize: 布尔值 = 真 image_mean: 联合[float, 列表[float], 无类型] = 无 image_std: 联合[float, 列表[float], 无类型] = 无 do_convert_rgb: 布尔值 = 真 **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 (intfloat, 可选, 默认为 1/255) — 如果重新缩放图像,则使用的缩放因子。仅在 do_rescale 设置为 True 时有效。可以通过 preprocess 方法中的 rescale_factor 参数进行覆盖。
  • do_normalize (bool, 可选, 默认为 True) — 是否对图像进行归一化。可以在 preprocess 方法中通过 do_normalize 参数进行覆盖。可以在 preprocess 方法中通过 do_normalize 参数进行覆盖。
  • image_mean (floatList[float], 可选, 默认为 IMAGENET_STANDARD_MEAN) — 如果对图像进行归一化,则使用的均值。这是一个浮点数或与图像通道数长度相同的浮点数列表。可以在 preprocess 方法中通过 image_mean 参数覆盖。可以在 preprocess 方法中通过 image_mean 参数覆盖。
  • image_std (floatList[float], 可选, 默认为 IMAGENET_STANDARD_STD) — 如果对图像进行归一化,则使用的标准差。这是一个浮点数或与图像通道数长度相同的浮点数列表。可以在 preprocess 方法中通过 image_std 参数覆盖。 可以在 preprocess 方法中通过 image_std 参数覆盖。
  • do_convert_rgb (bool, optional, defaults to True) — 是否将图像转换为RGB.

构建一个BLIP图像处理器。

预处理

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), typing.List[ForwardRef('PIL.Image.Image')], typing.List[numpy.ndarray], typing.List[ForwardRef('torch.Tensor')]] do_resize: typing.Optional[bool] = None size: typing.Optional[typing.Dict[str, int]] = None resample: Resampling = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None do_convert_rgb: bool = None data_format: ChannelDimension = input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None )

参数

  • 图像 (ImageInput) — 要预处理的图像。期望输入单个或批量的图像,像素值范围在0到255之间。如果传入的图像像素值在0到1之间,请设置 do_rescale=False.
  • do_resize (bool, optional, defaults to 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, optional, defaults to self.do_rescale) — 是否将图像值缩放到 [0 - 1] 之间。
  • rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True,则用于重新缩放图像的重新缩放因子。
  • do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化处理.
  • image_mean (floatList[float], 可选, 默认为 self.image_mean) — 如果 do_normalize 设置为 True,则用于归一化图像的图像均值。
  • image_std (floatList[float], 可选, 默认为 self.image_std) — 如果 do_normalize 设置为 True,则用于归一化图像的标准差。
  • do_convert_rgb (bool, optional, defaults to self.do_convert_rgb) — 是否将图像转换为RGB.
  • return_tensors (strTensorType, 可选) — 返回的张量类型。可以是以下之一:
    • 未设置:返回一个 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 (ChannelDimensionstr, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
    • 未设置:使用输入图像的通道维度格式。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未设置,则从输入图像推断通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE: 图像格式为 (height, width)。

预处理一张图像或一批图像。

Pytorch
Hide Pytorch content

BlipModel

BlipModel 将在未来的版本中被弃用,请根据您的使用场景使用 BlipForConditionalGenerationBlipForImageTextRetrievalBlipForQuestionAnswering

transformers.BlipModel

< >

( config: BlipConfig )

参数

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

此模型将在未来的版本中被弃用。请根据您的使用场景使用BlipForConditionalGenerationBlipForQuestionAnsweringBlipForImageTextRetrieval

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

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

前进

< >

( input_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None return_loss: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) transformers.models.blip.modeling_blip.BlipOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it.

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

    什么是输入ID?

  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:
    • 1 for tokens that are not masked,
    • 0 for tokens that are masked.

    什么是注意力掩码?

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — Indices of positions of each input sequence tokens in the position embeddings. Selected in the range [0, config.max_position_embeddings - 1].

    什么是位置ID?

  • pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下,如果您提供了填充,它将被忽略。可以使用 BlipImageProcessor获取像素值。有关详细信息,请参见BlipImageProcessor.call().
  • return_loss (bool, optional) — 是否返回对比损失。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
  • return_dict (bool, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。
  • interpolate_pos_encoding (bool, 可选, 默认为 False) — 是否插值预训练的位置编码.

返回

transformers.models.blip.modeling_blip.BlipOutputtuple(torch.FloatTensor)

一个 transformers.models.blip.modeling_blip.BlipOutput 或一个由 torch.FloatTensor 组成的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种 元素,具体取决于配置()和输入。

  • loss (torch.FloatTensor 形状为 (1,)可选,当 return_lossTrue 时返回) — 图像-文本相似度的对比损失。
  • logits_per_image:(torch.FloatTensor 形状为 (image_batch_size, text_batch_size)) — image_embedstext_embeds 之间的缩放点积分数。这表示图像-文本 相似度分数。
  • logits_per_text:(torch.FloatTensor 形状为 (text_batch_size, image_batch_size)) — text_embedsimage_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: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None return_dict: typing.Optional[bool] = None ) 文本特征 (torch.FloatTensor 形状为 (batch_size, output_dim)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it.

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

    什么是输入ID?

  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:
    • 1 for tokens that are not masked,
    • 0 for tokens that are masked.

    什么是注意力掩码?

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — Indices of positions of each input sequence tokens in the position embeddings. Selected in the range [0, config.max_position_embeddings - 1].

    什么是位置ID?

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

文本特征 (torch.FloatTensor 形状为 (batch_size, output_dim)

通过将投影层应用于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: typing.Optional[torch.FloatTensor] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) 图像特征 (torch.FloatTensor 形状为 (batch_size, output_dim)

参数

  • pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下,如果您提供了填充,它将被忽略。像素值可以使用 BlipImageProcessor获取。详情请参见BlipImageProcessor.call().
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  • interpolate_pos_encoding (bool, optional, defaults to False) — 是否插值预训练的位置编码。

返回

图像特征 (torch.FloatTensor 形状为 (batch_size, output_dim)

通过将投影层应用于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

transformers.BlipTextModel

< >

( config add_pooling_layer = True )

该模型可以作为编码器(仅具有自注意力机制)以及解码器运行,在这种情况下,自注意力层之间会添加一层交叉注意力层,遵循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: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None encoder_embeds: typing.Optional[torch.Tensor] = None encoder_hidden_states: typing.Optional[torch.Tensor] = None encoder_attention_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None is_decoder: typing.Optional[bool] = False )

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

  • 1 表示 未屏蔽 的标记,
  • 0 表示被掩码的标记。 past_key_values (tuple(tuple(torch.FloatTensor)), 可选): 包含预计算的注意力块的关键和值隐藏状态。可用于加速解码。 如果使用了past_key_values,用户可以选择只输入形状为(batch_size, 1)的最后一个decoder_input_ids(那些没有将其过去的关键值状态提供给此模型的),而不是所有形状为(batch_size, sequence_length)decoder_input_ids。 use_cache (bool, 可选): 如果设置为True,则返回past_key_values关键值状态,并可用于加速解码(参见past_key_values)。

BlipVisionModel

transformers.BlipVisionModel

< >

( config: BlipVisionConfig )

前进

< >

( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下,如果您提供了填充,它将被忽略。像素值可以使用 BlipImageProcessor获取。有关详细信息,请参见BlipImageProcessor.call().
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  • interpolate_pos_encoding (bool, optional, defaults to False) — 是否插值预训练的位置编码.

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(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(形状为 (batch_size, hidden_size)torch.FloatTensor)— 序列的第一个标记(分类标记)在经过用于辅助预训练任务的层进一步处理后的最后一层隐藏状态。例如,对于BERT系列模型,这返回经过线性层和tanh激活函数处理后的分类标记。线性层的权重是在预训练期间通过下一句预测(分类)目标训练的。

  • hidden_statestuple(torch.FloatTensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回)— 由 torch.FloatTensor 组成的元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出处的隐藏状态加上可选的初始嵌入输出。

  • attentionstuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回)— 由 torch.FloatTensor 组成的元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

BlipVisionModel 的前向方法,重写了 __call__ 特殊方法。

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

BlipForConditionalGeneration

transformers.BlipForConditionalGeneration

< >

( config: BlipConfig )

参数

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

用于图像描述的BLIP模型。该模型由一个视觉编码器和一个文本解码器组成。可以选择性地将input_ids传递给模型,作为文本提示,使文本解码器继续提示。否则,解码器将从[BOS](序列开始)标记开始生成文本。将从文本输入开始生成描述。如果没有提供文本输入,解码器将仅从[BOS]标记开始。

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

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

前进

< >

( pixel_values: FloatTensor input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下,如果您提供了填充,它将被忽略。可以使用 BlipImageProcessor获取像素值。有关详细信息,请参见BlipImageProcessor.call().
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  • interpolate_pos_encoding (bool, optional, defaults to False) — 是否插值预训练的位置编码.

返回

transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutputtuple(torch.FloatTensor)

一个 transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput 或一个由 torch.FloatTensor 组成的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种 元素,取决于配置()和输入。

  • loss (torch.FloatTensor, 可选, 当提供 labels 时返回, torch.FloatTensor 形状为 (1,)) — 来自文本解码器的语言建模损失。

  • logits (torch.FloatTensor 形状为 (batch_size, sequence_length, config.vocab_size), 可选) — 文本解码器模型的语言建模头的预测分数。

  • image_embeds (torch.FloatTensor 形状为 (batch_size, output_dim), 可选) — 将视觉变换器模型应用于输入图像后获得的图像嵌入。

  • last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型最后一层输出的隐藏状态序列。

  • hidden_states (tuple(torch.FloatTensor), 可选, 当 output_hidden_states=True 时返回) — 由 torch.FloatTensor 组成的元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出)形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出处的隐藏状态加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), 可选, 当传递 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

transformers.BlipForImageTextRetrieval

< >

( config: BlipConfig )

参数

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

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

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

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

前进

< >

( input_ids: LongTensor pixel_values: FloatTensor use_itm_head: typing.Optional[bool] = True attention_mask: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) transformers.models.blip.modeling_blip.BlipTextVisionModelOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下,如果您提供了填充,它将被忽略。像素值可以使用 BlipImageProcessor获取。详情请参见BlipImageProcessor.call().
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  • interpolate_pos_encoding (bool, optional, defaults to False) — 是否插值预训练的位置编码.

返回

transformers.models.blip.modeling_blip.BlipTextVisionModelOutputtuple(torch.FloatTensor)

一个 transformers.models.blip.modeling_blip.BlipTextVisionModelOutput 或一个由 torch.FloatTensor 组成的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种 元素,具体取决于配置()和输入。

  • loss (torch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 来自文本解码器的语言建模损失。

  • image_embeds (torch.FloatTensor 形状为 (batch_size, output_dim)可选,当模型以 with_projection=True 初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。

  • last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

  • hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 由 torch.FloatTensor 组成的元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出)形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出处的隐藏状态加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 由 torch.FloatTensor 组成的元组(每一层一个)形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

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

transformers.BlipForQuestionAnswering

< >

( config: BlipConfig )

参数

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

用于视觉问答的BLIP模型。该模型由一个视觉编码器、一个文本编码器以及一个文本解码器组成。视觉编码器将编码输入图像,文本编码器将编码输入问题以及图像的编码,文本解码器将输出问题的答案。

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

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

前进

< >

( input_ids: LongTensor pixel_values: FloatTensor decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) transformers.models.blip.modeling_blip.BlipTextVisionModelOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下,如果您提供了填充,它将被忽略。像素值可以使用 BlipImageProcessor获取。详情请参见BlipImageProcessor.call().
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  • interpolate_pos_encoding (bool, optional, defaults to False) — 是否插值预训练的位置编码.

返回

transformers.models.blip.modeling_blip.BlipTextVisionModelOutputtuple(torch.FloatTensor)

一个 transformers.models.blip.modeling_blip.BlipTextVisionModelOutput 或一个由 torch.FloatTensor 组成的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种 元素,具体取决于配置()和输入。

  • loss (torch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 来自文本解码器的语言建模损失。

  • image_embeds (torch.FloatTensor 形状为 (batch_size, output_dim)可选,当模型以 with_projection=True 初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。

  • last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

  • hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 由 torch.FloatTensor 组成的元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出)形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出处的隐藏状态加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 由 torch.FloatTensor 组成的元组(每一层一个)形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

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
Hide TensorFlow content

TFBlipModel

transformers.TFBlipModel

< >

( config: BlipConfig *inputs **kwargs )

调用

< >

( 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 ) transformers.models.blip.modeling_tf_blip.TFBlipOutputtuple(tf.Tensor)

参数

  • input_ids (tf.Tensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it.

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

    什么是输入ID?

  • attention_mask (tf.Tensor of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:
    • 1 for tokens that are not masked,
    • 0 for tokens that are masked.

    什么是注意力掩码?

  • position_ids (tf.Tensor of shape (batch_size, sequence_length), optional) — Indices of positions of each input sequence tokens in the position embeddings. Selected in the range [0, config.max_position_embeddings - 1].

    什么是位置ID?

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

返回

transformers.models.blip.modeling_tf_blip.TFBlipOutputtuple(tf.Tensor)

一个 transformers.models.blip.modeling_tf_blip.TFBlipOutput 或一个 tf.Tensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含根据配置 () 和输入的各种元素。

  • loss (tf.Tensor 形状为 (1,), 可选, 当 return_lossTrue 时返回) — 图像-文本相似性的对比损失。
  • logits_per_image:(tf.Tensor 形状为 (image_batch_size, text_batch_size)) — image_embedstext_embeds 之间的缩放点积分数。这表示图像-文本相似性分数。
  • logits_per_text:(tf.Tensor 形状为 (text_batch_size, image_batch_size)) — text_embedsimage_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 ) 文本特征 (tf.Tensor 形状为 (batch_size, output_dim)

参数

  • input_ids (tf.Tensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it.

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

    什么是输入ID?

  • attention_mask (tf.Tensor of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:
    • 1 for tokens that are not masked,
    • 0 for tokens that are masked.

    什么是注意力掩码?

  • position_ids (tf.Tensor of shape (batch_size, sequence_length), optional) — Indices of positions of each input sequence tokens in the position embeddings. Selected in the range [0, config.max_position_embeddings - 1].

    什么是位置ID?

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

文本特征 (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 ) 图像特征 (tf.Tensor 形状为 (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而不是一个普通的元组。

返回

图像特征(形状为(batch_size, output_dimtf.Tensor

通过将投影层应用于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

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 of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it.

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

    什么是输入ID?

  • attention_mask (tf.Tensor of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:
    • 1 for tokens that are not masked,
    • 0 for tokens that are masked.

    什么是注意力掩码?

  • position_ids (tf.Tensor of shape (batch_size, sequence_length), optional) — Indices of positions of each input sequence tokens in the position embeddings. Selected in the range [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,用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids(那些没有将其过去的关键值状态提供给此模型的),而不是所有形状为(batch_size, sequence_length)decoder_input_ids
  • use_cache (bool, 可选) — 如果设置为 Truepast_key_values 键值状态将被返回,并可用于加速解码(参见 past_key_values)。

TFBlipTextModel 的前向方法,重写了 __call__ 特殊方法。

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

TFBlipVisionModel

transformers.TFBlipVisionModel

< >

( config: BlipVisionConfig *args **kwargs )

调用

< >

( 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 ) transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

参数

  • 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而不是一个普通的元组。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(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), 可选, 当 output_hidden_states=True 被传递或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入的输出 + 一个用于每一层的输出)形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出处的隐藏状态加上初始嵌入输出。

  • attentions (tuple(tf.Tensor), 可选, 当 output_attentions=True 被传递或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每一层一个)形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

TFBlipVisionModel 的前向方法,重写了 __call__ 特殊方法。

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

TFBlipForConditionalGeneration

transformers.TFBlipForConditionalGeneration

< >

( config: BlipConfig *args **kwargs )

参数

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

用于图像描述的BLIP模型。该模型由一个视觉编码器和一个文本解码器组成。可以选择性地将input_ids传递给模型,作为文本提示,使文本解码器继续提示。否则,解码器将从[BOS](序列开始)标记开始生成文本。将从文本输入开始生成描述。如果没有提供文本输入,解码器将仅从[BOS]标记开始。

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

该模型也是一个keras.Model子类。可以将其作为常规的TF 2.0 Keras模型使用,并参考TF 2.0文档以了解与一般使用和行为相关的所有事项。

调用

< >

( 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 ) transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutputtuple(tf.Tensor)

参数

  • 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 而不是一个普通的元组。

返回

transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutputtuple(tf.Tensor)

一个 transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutput 或一个 tf.Tensor 元组(如果 return_dict=False 被传递或当 config.return_dict=False 时),包含根据配置 () 和输入的各种元素。

  • loss (tf.Tensor, 可选, 当提供 labels 时返回, tf.Tensor 形状为 (1,)) — 来自文本解码器的语言建模损失。

  • logits (tf.Tensor 形状为 (batch_size, sequence_length, config.vocab_size), 可选) — 文本解码器模型的语言建模头的预测分数。

  • image_embeds (tf.Tensor 形状为 (batch_size, output_dim), 可选) — 将视觉变换器模型应用于输入图像后获得的图像嵌入。

  • last_hidden_state (tf.Tensor 形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型最后一层输出的隐藏状态序列。

  • hidden_states (tuple(tf.Tensor), 可选, 当 output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于 每层的输出)形状为 (batch_size, sequence_length, hidden_size)

    模型每层输出的隐藏状态加上可选的初始嵌入输出。

  • attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 时返回) — tf.Tensor 元组(每层一个)形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 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

transformers.TFBlipForImageTextRetrieval

< >

( config: BlipConfig *args **kwargs )

参数

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

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

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

该模型也是一个keras.Model子类。可以将其作为常规的TF 2.0 Keras模型使用,并参考TF 2.0文档以了解与一般使用和行为相关的所有事项。

调用

< >

( 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 ) transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutputtuple(tf.Tensor)

参数

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

返回

transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutputtuple(tf.Tensor)

一个 transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput 或一个 tf.Tensor 元组(如果 return_dict=False 被传递或当 config.return_dict=False 时)包含各种元素,具体取决于 配置 () 和输入。

  • itm_score (tf.Tensor) — 图像-文本相似度分数。

  • loss (tf.Tensor 形状为 (1,), 可选, 当提供 labels 时返回) — 来自文本解码器的语言建模损失。

  • image_embeds (tf.Tensor 形状为 (batch_size, output_dim) 可选 当模型以 with_projection=True 初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。

  • last_hidden_state (tf.Tensor 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

  • hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于 每层的输出)形状为 (batch_size, sequence_length, hidden_size)

    模型在每层输出处的隐藏状态加上可选的初始嵌入输出。

  • vision_pooler_output (tf.Tensor 形状为 (batch_size, hidden_size), 可选) — 模型仅视觉分支的最后一层隐藏状态。

  • attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每层一个)形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 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

transformers.TFBlipForQuestionAnswering

< >

( config: BlipConfig *args **kwargs )

参数

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

用于视觉问答的BLIP模型。该模型由一个视觉编码器、一个文本编码器以及一个文本解码器组成。视觉编码器将编码输入图像,文本编码器将编码输入问题以及图像的编码,文本解码器将输出问题的答案。

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

该模型也是一个keras.Model子类。可以将其作为常规的TF 2.0 Keras模型使用,并参考TF 2.0文档以了解与一般使用和行为相关的所有事项。

调用

< >

( 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 ) transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutputtuple(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.TFBlipTextVisionModelOutputtuple(tf.Tensor)

一个 transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutput 或一个 tf.Tensor 元组(如果 return_dict=False 被传递或当 config.return_dict=False 时)包含各种元素,具体取决于 配置 () 和输入。

  • loss (tf.Tensor 形状为 (1,), 可选, 当提供 labels 时返回) — 来自文本解码器的语言建模损失。

  • image_embeds (tf.Tensor 形状为 (batch_size, output_dim) 可选 当模型以 with_projection=True 初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。

  • last_hidden_state (tf.Tensor 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

  • hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于 每层的输出)形状为 (batch_size, sequence_length, hidden_size)

    模型每层输出的隐藏状态加上可选的初始嵌入输出。

  • attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每层一个)形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 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
< > Update on GitHub