Transformers文档

BLIP

贡献
概念指南
API
Hugging Face's logo
加入 Hugging Face 社区

并获取增强的文档体验

开始使用

BLIP

概述

BLIP模型由李俊楠、李东旭、向春泥、候斯廷在《BLIP: 针对统一视觉-语言理解和生成的自举式语言-图像预训练》(https://arxiv.org/abs/2201.12086)中提出。

BLIP是一种能够执行包括以下多种多模态任务的模型

  • 视觉问答
  • 图像-文本检索(图像-文本匹配)
  • 图像字幕化

论文的摘要如下

视觉-语言预训练(VLP)已经推进了许多视觉-语言任务的性能。然而,大多数现有的预训练模型只在基于理解的任务或基于生成的任务中表现出色。此外,性能的提升主要通过对从网络收集的含噪图像-文本对进行数据集的扩展而实现,这并非最理想的监督来源。在本文中,我们提出了BLIP,一个新的VLP框架,它可以灵活地转移到视觉-语言理解和生成任务中。BLIP通过自举式地生成和过滤标题来有效地利用含噪的网页数据,其中标题生成器生成合成标题,过滤器则消除含噪标题。我们在广泛的视觉-语言任务上取得了最先进的成果,如图像-文本检索(平均召回率@1提高了+2.7%),图像字幕化(CIDEr提高了+2.8%),以及VQA(VQA分数提高了+1.6%)。此外,BLIP在直接迁移到零样本方式下的视频-语言任务中表现出强大的泛化能力。代码、模型和数据集现已发布。

BLIP.gif

此模型由ybelkada提供。原始代码可在此处找到。

资源

BlipConfig

transformers.BlipConfig

< >

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

参数

  • vision_config (dict, 可选) — 初始化 BlipVisionConfig 所使用的配置选项的字典。
  • projection_dim (int, 可选, 默认为 512) — 文本和视觉投影层的维度。
  • logit_scale_init_value (float, 可选, 默认为 2.6592) — logit_scale 参数的初始值。默认值根据原始 BLIP 实现。
  • image_text_hidden_size (int, 可选, 默认为 256) — 图文融合层隐藏状态的维度。
  • label_smoothing (浮点数,可选,可选,默认为 0.0) — 一个位于 [0.0, 1.0] 之间的浮点数。指定计算损失时平滑的数量,其中 0.0 表示不进行平滑。目标成为原始真实值和均匀分布的混合,具体描述见 Rethinking the Inception Architecture for Computer Vision <https://arxiv.org/abs/1512.00567>。默认::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标记id = 30522 eos标记id = 2 pad标记id = 0 sep标记id = 102 是否为解码器 = True 使用缓存 = True 标签平滑 = 0.0 kwargs )

参数

  • vocab_sizeint可选,默认为30524)—— Blip 文本模型的词汇量。定义了在调用 BlipModel 时通过 inputs_ids 传入的不同标记的数量。
  • hidden_sizeint可选,默认为768)—— 编码器层和池化层的维度。
  • encoder_hidden_sizeint可选,默认为768)—— 视觉模型编码器层的维度。
  • intermediate_size (int, 可选,默认3072) — Transformer编码器中“中间”层(即前馈层)的维度。
  • num_hidden_layers (int, 可选,默认12) — Transformer编码器中的隐藏层数。
  • num_attention_heads (int, 可选,默认8) — Transformer编码器中每个注意力层使用的注意力头数。
  • hidden_dropout_prob (float, 可选, 默认为 0.0) — 嵌入层、编码器和池器中所有全连接层的dropout概率。
  • attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的dropout比例。
  • initializer_range (float, 可选, 默认为 0.02) — 所有权重矩阵初始化时truncated_normal_initializer的标准差。
  • bos_token_id (int, 可选, 默认值为 30522) — 代码序列开始标记的 id。
  • eos_token_id (int, 可选, 默认值为 2) — 代码序列结束标记的 id。
  • pad_token_id (int, 可选, 默认值为 0) — 填充标记的 id。
  • sep_token_id (int, 可选, 默认值为 102) — 分隔标记的 id。
  • is_decoder (bool, 可选, 默认为 True) — 模型是否作为解码器使用。
  • use_cache (bool, 可选, 默认为 True) — 模型是否返回最后的键/值注意力(并非所有模型都使用)。
  • label_smoothing (float, 可选) — 一个位于 [0.0, 1.0] 之间的浮点数。指定在计算损失时的平滑量,其中 0.0 表示没有平滑。目标将变为原始真实值和均匀分布的混合,如《重新思考计算机视觉的 Inception 架构》[https://arxiv.org/abs/1512.00567] 中所述。默认值::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, 可选, 默认为768) — 编码层和池化层的维度。
  • intermediate_size (int, 可选, 默认为3072) — Transformer编码器中“中间层”(即前馈层)的维度。
  • num_hidden_layers (int, 可选, 默认为12) — Transformer编码器中隐藏层的数量。
  • num_attention_headsint可选,默认为12) — Transformer编码器每个注意力层的注意力头数。
  • image_sizeint可选,默认为384) — 每个图像的大小(分辨率)。
  • patch_sizeint可选,默认为16) — 每个补丁的大小(分辨率)。
  • hidden_act (strfunction,可选,默认为 "gelu") — 编码器和解码器中的非线性激活函数(函数或字符串)。如果是字符串,支持 "gelu""relu""selu""gelu_new"
  • layer_norm_eps (float,可选,默认为 1e-5) — 层归一化层使用的 ε。
  • attention_dropout (float,可选,默认为 0.0) — 注意力概率的 dropout 比率。
  • initializer_range (float, 可选,默认为 1e-10) — 所有权重矩阵初始化时的截断正态分布的均值标准差。

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

配置对象继承自 PretrainedConfig 并可用于控制模型输出。有关更多信息,请参阅 PretrainedConfig 的文档。

示例

>>> from transformers import BlipVisionConfig, BlipVisionModel

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

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

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

BlipProcessor

transformers.BlipProcessor

< >

( image_processor tokenizer **kwargs )

参数

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

构建一个包含 BERT 分词器和 BLIP 图像处理器的 BLIP 处理器。

BlipProcessor 提供了 BlipImageProcessorBertTokenizerFast 所有的功能。请参阅 __call__()decode() 方法以获取更多信息。

batch_decode

< >

( *args **kwargs )

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

decode

< >

( *args **kwargs )

此方法将所有参数传递给BertTokenizerFast的decode()方法。请参阅此方法的文档字符串获取更多信息。

BlipImageProcessor

transformers.BlipImageProcessor

< >

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

参数

  • do_resizebool可选,默认为 True)—是否调整图像的(高度,宽度)尺寸到指定的size。可以在preprocess方法中的do_resize参数中进行覆盖。
  • sizedict可选,默认为 { "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, optional, defaults to True) — 是否对图像进行归一化。可以通过preprocess方法中的do_normalize参数进行覆盖。也可以通过preprocess方法中的do_normalize参数进行覆盖。
  • image_mean (float or List[float], optional, defaults to IMAGENET_STANDARD_MEAN) — 如果对图像进行归一化,所使用的均值。它是一个浮点数或浮点数列表,其长度对应于图像通道数。可以通过preprocess方法中的image_mean参数进行覆盖。也可以通过preprocess方法中的image_mean参数进行覆盖。
  • image_std (float or List[float], optional, defaults to IMAGENET_STANDARD_STD) — 如果对图像进行归一化,所使用的标准差。它是一个浮点数或浮点数列表,其长度对应于图像通道数。可以通过preprocess方法中的image_std参数进行覆盖。也可以通过preprocess方法中的image_std参数进行覆盖。
  • — do_convert_rgb (bool, 可选,默认为 True) — 是否将图像转换为 RGB。

构建 BLIP 图像处理器。

预处理

< >

( images: 并集 do_resize: 可选 = None size: 可选 = None resample: 重采样 = None do_rescale: 可选 = None rescale_factor: 可选 = None do_normalize: 可选 = None image_mean: 并集 = None image_std: 并集 = None return_tensors: 并集 = None do_convert_rgb: bool = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: 并集 = None )

参数

  • images (ImageInput) — 预处理图像。期望单个或批量的图像,像素值范围为0到255。如果传入像素值在0到1之间的图像,设置do_rescale=False
  • do_resize (bool, 可选self.do_resize) — 是否调整图像大小。
  • sizeDict[str, int],可选,默认为self.size) — 控制resize后的图像大小。保持长宽比,将图像最短的边调整到size["shortest_edge"]。如果调整后的图像最长边大于int(size["shortest_edge"] * (1333 / 800)),则再次调整图像,使最长边等于int(size["shortest_edge"] * (1333 / 800))
  • resamplePILImageResampling,可选,默认为self.resample) — 如果调整图像大小,则使用的重采样滤波器。仅当do_resize设置为True时生效。
  • do_rescalebool,可选,默认为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, 可选,默认为 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 的批次。
  • (HTML 标签开始)data_formatChannelDimensionstr可选,默认为 ChannelDimension.FIRST)——输出图像的通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
    • 未设置:使用输入图像的通道维度格式。
    (HTML 标签结束)
  • (HTML 标签开始)input_data_formatChannelDimensionstr可选)——输入图像的通道维度格式。如果未设置,则从输入图像推断通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE:图像格式为 (height, width)。
    (HTML 标签结束)

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

Pytorch
隐藏 Pytorch 内容

BlipModel

BlipModel 在未来的版本中将不再被支持,请根据您的使用情况使用 BlipForConditionalGenerationBlipForImageTextRetrievalBlipForQuestionAnswering

transformers.BlipModel

< >

( config: BlipConfig )

参数

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

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

此模型继承了 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 interpolate_pos_encoding: bool = False ) transformers.models.blip.modeling_blip.BlipOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 序列中的词汇索引。如果提供填充,默认会忽略填充部分。

    索引可以通过 AutoProcessor 获取。详情请见 BlipProcessor.__call__()`

    什么是输入ID?

  • return_loss (bool, 可选) — 是否返回对比损失。
  • 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)

A transformers.models.blip.modeling_blip.BlipOutput 或一个包含 torch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False),这取决于配置(<class 'transformers.models.blip.configuration_blip.BlipConfig'>)和输入。

  • loss (torch.FloatTensor 形状为 (1,)可选,当 return_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

参数

  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), 可选) — 避免对填充标记索引执行注意力的掩码。选定的掩码值在 [0, 1] 范围内:

    • 1 表示 未屏蔽 的标记;
    • 0 表示 屏蔽 的标记。

    什么是注意掩码?

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]

    什么是位置 ID?

  • output_attentions (bool, 可选) — 是否返回所有注意层 attention 张量。请参考返回的张量中的 attentions 获取更多详细内容。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息,请参阅返回的张量下的hidden_states。ActionListenerEnd
  • return_dict (bool, 可选) — 是否返回ModelOutput而不是普通元组。

返回

text_features (torch.FloatTensor of shape (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: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) ActionListenerStart>image_features (torch.FloatTensor of shape (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, 可选) — 是否返回所有层的隐藏状态。有关详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回一个transformers.utils.ModelOutput对象,而不是一个普通的元组。
    注意:此处为代码格式化后的输出,未进行完全翻译,具体内容请以实际文档为准。
  • interpolate_pos_encoding (bool, 可选, 默认为 false) — 是否对预训练的位置编码进行插值。
    注意:此处为代码格式化后的输出,未进行完全翻译,具体内容请以实际文档为准。

返回

image_features (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描述的《注意力就是你需要的所有》。将is_decoder设置为True;正向传输时则期望输入encoder_hidden_states

forward

< >

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

encoder_hidden_states (torch.FloatTensor, 可选): 编码器最后一个层的隐藏状态的序列。如果在配置为解码器时使用,将用于跨注意力。encoder_attention_mask (torch.FloatTensor, 可选): 避免对编码器输入中填充token索引执行注意力的掩码。如果在配置为解码器时使用,将用于跨注意力。掩码值选在[0, 1]

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

BlipVisionModel

transformers.BlipVisionModel

< >

( config: BlipVisionConfig )

forward

< >

( pixel_values: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None interpolate_pos_encoding: 布尔 = False ) transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor 形状 (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, 可选,默认值 false) — 是否对预训练的位置编码进行插值。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

A transformers.modeling_outputs.BaseModelOutputWithPooling或一个由torch.FloatTensor元组成的内容,具体取决于配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>)和输入(如果传递了return_dict=False或当config.return_dict=False)。

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

  • 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

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 interpolate_pos_encoding: bool = False ) transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor 形状为 (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, 可选,默认为 False) — 是否插值预训练的位置编码。

返回

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

一个 transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput 或一个元组,包含的元素取决于配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>)和输入(如果 return_dict=False 被传递或当 config.return_dict=False 时)。

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

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

  • image_embeds (torch.FloatTensor 形状为 (batch_size, output_dim),可选) — 在对输入图像应用视觉 Transformer 模型后获得图像嵌入。

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

  • hidden_statestuple(torch.FloatTensor)可选,在 output_hidden_states=True 时返回) — 由形状为 (batch_size, sequence_length, hidden_size)torch.FloatTensor 组成的元组(如果模型有嵌入层,则为嵌入层的输出 + 每层的输出)。

    每个层的模型输出隐藏状态以及可选的初始嵌入输出。

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

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

BlipForConditionalGeneration 的 forward 方法覆盖了 __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 interpolate_pos_encoding: bool = False ) transformers.models.blip.modeling_blip.BlipTextVisionModelOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor for shape (batch_size, num_channels, height, width)) — 像素值。如果提供了填充,默认会忽略它。可以使用 BlipImageProcessor 获取像素值。有关详情,请参阅 BlipImageProcessor.call()
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多的细节请查看返回值张量下的
    hidden_states
  • return_dict (bool, 可选) — 是否以ModelOutput形式返回,而不是原始元组。
  • interpolate_pos_encoding (bool, 可选, 默认为False) — 是否对预训练的位置编码进行插值。

返回

模型输出:transformers.models.blip.modeling_blip.BlipTextVisionModelOutput 或者 tuple(torch.FloatTensor)

一个 transformers.models.blip.modeling_blip.BlipTextVisionModelOutput 或者一个由 torch.FloatTensor 组成的元组(如果传递了 return_dict=False 或当配置文件 config.return_dict=False 时),根据配置(例如<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>)和输入变量包含不同的元素。

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

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

  • 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 时返回) — 形状为 (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后的注意力权重,用于计算自注意力头中的加权和。

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 文档获取关于一般使用和行为的所有相关信息。

forward

< >

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

参数

  • pixel_values(《torch.FloatTensor》形如 (batch_size, num_channels, height, width))—— 像素值。提供填充时默认将忽略填充。可以使用 BlipImageProcessor 来获取像素值。详细信息请参见 BlipImageProcessor.call()
  • output_attentions(《bool”,可选)—— 是否返回所有注意力层的数据。详细信息请参见返回的张量下的代码 attentions
  • output_hidden_states(《bool”,可选)—— 是否返回所有层的隐藏状态。详细信息请参见返回的张量下的代码 hidden_states
  • return_dict (bool, optional) — 是否返回ModelOutput而非普通元组。
  • optional) — 是否插值预训练的位置编码,默认为False。 默认值。

返回

模型输出:transformers.models.blip.modeling_blip.BlipTextVisionModelOutput 或者 tuple(torch.FloatTensor)

一个 transformers.models.blip.modeling_blip.BlipTextVisionModelOutput 或者一个由 torch.FloatTensor 组成的元组(如果传递了 return_dict=False 或当配置文件 config.return_dict=False 时),根据配置(例如<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>)和输入变量包含不同的元素。

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

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

  • 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 时返回) — 形状为 (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》的`forward`方法覆盖了特殊的`__call__`方法。

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

示例

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

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

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

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

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

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

TFBlipModel

class transformers.TFBlipModel

< >

( config: BlipConfig *inputs **kwargs )

调用

< >

( 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 形状为 (batch_size, sequence_length)) — 输入序列中词汇的索引。如果提供了填充,默认会忽略填充。

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

    什么是输入ID?

  • attention_mask (tf.Tensor 形状为 (batch_size, sequence_length)可选) — 避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1]

    • 1 表示 未掩码 的标记,
    • 0 表示 掩码 的标记。

    什么是注意力掩码?

  • position_idstf.Tensor 形状为 (batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。

    位置ID是什么?

  • pixel_valuestf.Tensor 形状为 (batch_size, num_channels, height, width)) — 像素值。如果您提供它,默认情况下将忽略填充。可以使用 BlipImageProcessor 获得像素值。有关详细信息,请参阅 BlipImageProcessor.call()。<-- HTML_TAG_END -->
  • return_lossbool可选) — 是否返回对比损失。<-- HTML_TAG_END -->
  • 输出注意力 (bool可选) — 是否返回所有注意力层的注意力张量。详细信息请参阅返回张量下的 attentions
  • 输出隐藏状态 (bool可选) — 是否返回所有层的隐藏状态。详细信息请参阅返回张量下的 hidden_states
  • 返回字典 (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时),这些元素取决于配置(<class 'transformers.models.blip.configuration_blip.BlipConfig'>)和输入。

  • lossshape=(1,)的tf.Tensor,可选,当return_loss=True时返回) — 图像-文本相似度的对比损失。
  • logits_per_image:代表图像嵌入和文本嵌入之间缩放点积得分的(image_batch_size, text_batch_size)形状的tf.Tensor。此代表图像-文本相似度得分。
  • 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 ) 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;
    • 对于 掩码 的标记,为 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 而不是普通元组。

返回

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 ) image_features (tf.Tensor of shape (batch_size, output_dim)

参数

  • pixel_values (tf.Tensor 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 而不是普通元组。

返回

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

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描述的《注意力就是你需要的所有》。将is_decoder设置为True;正向传输时则期望输入encoder_hidden_states

调用

< >

参数

  • attention_mask (tf.Tensor of shape (batch_size, sequence_length), 可选) — 避免对所有填充token索引执行注意力操作的掩码。掩码值在[0, 1]之间:
    • 1 对于未掩码的token:
    • 0 对于已掩码的token。
    什么是注意力掩码?
  • position_ids (tf.Tensor of shape (batch_size, sequence_length), 可选) — 每个输入序列token位置嵌入的索引。在范围[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, 可选) —— 编码器最后一层的隐藏状态的序列。在模型配置为解码器时用于交叉注意力。
  • encoder_attention_masktf.Tensor可选) — 用于避免对编码器输入中的填充标记索引执行注意力的掩码。如果模型配置为解码器,则会使用此掩码进行交叉注意力。掩码值选中 [0, 1]

    • 1 对应于 未掩码 的标记,
    • 0 对应于 掩码 的标记。
  • past_key_valuestuple(tuple(tf.Tensor))可选) — 包含注意力块预先计算的关键和值隐藏状态。可以用于加速解码。如果使用 past_key_values,则用户可以选择性地输入仅包含 decoder_input_ids 的最后一个(没有给定此模型以前的关键值状态)形状为(batch_size, 1),而不是形状为(batch_size, sequence_length)的 decoder_input_ids 的所有内容。
  • use_cachebool可选) — 如果设置为 True,将返回 past_key_values 的键值状态,并可用于加速解码(见 past_key_values)。

TFBlipTextModel 的 forward 方法覆盖了 __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.TFBaseModelOutputWithPooling or tuple(tf.Tensor)

参数

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

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

A transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个包含 tf.Tensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False)各种元素取决于配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>)和输入。

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

  • pooler_output (tf.Tensor 的形状为 (batch_size, hidden_size)) —— 序列中第一个标记的最后一层隐藏状态(分类标记),通过线性层和Tanh激活函数进一步处理。线性层的权重是从预训练时的下一个句子预测(分类)目标训练得到的。

    此输出通常 不是 输入语义内容的良好摘要,通常更好的做法是对整个输入序列的隐藏状态序列进行平均或池化。

  • hidden_states (tuple(tf.Tensor)optional,在传递 output_hidden_states=True 时返回或当 config.output_hidden_states=True 时返回) —— 一个形如 (batch_size, sequence_length, hidden_size)tf.Tensor 的元组(一个用于嵌入输出的输出,一个用于每层的输出)。

    模型在每个层输出的隐藏状态以及初始嵌入输出。

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

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

参数

  • 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时),这些元素取决于配置(<class 'transformers.models.blip.configuration_blip.BlipConfig'>)和输入。

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

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

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

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

  • 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的元组(每个层一个)。

    注意力软化的权重,用于在自注意力头部计算加权平均值。

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 的shape为 (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.TFBlipImageTextMatchingModelOutputtuple(tf.Tensor)

A transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput 或一个包含各种元素(根据配置 <class 'transformers.models.blip.configuration_blip.BlipVisionConfig'> 和输入)的 tf.Tensor 元组(如果传递了 return_dict=Falseconfig.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)optional,在传递 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

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.TFBlipTextVisionModelOutput or tuple(tf.Tensor)

参数

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

返回

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

A 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,)可选,当提供 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)optional,在传递 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
< > 在 GitHub 上更新