Transformers 文档

BridgeTower

Hugging Face's logo
加入 Hugging Face 社区

并获得增强文档体验的访问权限

开始使用

BridgeTower

概述

BridgeTower 模型是由 Xiao Xu、Chenfei Wu、Shachar Rosenman、Vasudev Lal、Wanxiang Che 和 Nan Duan 在 BridgeTower: Building Bridges Between Encoders in Vision-Language Representative Learning 中提出的。该模型的目标是在每个单模态编码器和跨模态编码器之间建立桥梁,以便在跨模态编码器的每一层进行全面而详细的交互,从而在各种下游任务中实现卓越的性能,且几乎没有额外的性能和计算成本。

这篇论文已被 AAAI'23 会议接收。

以下是该论文的摘要:

近年来,采用双塔架构的视觉语言 (VL) 模型在视觉语言表征学习中占据主导地位。目前的 VL 模型要么使用轻量级的单模态编码器,并在深度跨模态编码器中学习同时提取、对齐和融合两种模态,要么将来自深度预训练单模态编码器的最后一层单模态表征馈送到顶层跨模态编码器中。这两种方法都可能限制视觉语言表征学习并限制模型性能。在本文中,我们提出了 BRIDGETOWER,它引入了多个桥接层,在单模态编码器的顶层和跨模态编码器的每一层之间建立连接。这使得预训练单模态编码器不同语义级别的视觉和文本表征能够在跨模态编码器中进行有效的自底向上跨模态对齐和融合。仅使用 4M 图像进行预训练,BRIDGETOWER 就在各种下游视觉语言任务中实现了最先进的性能。特别是在 VQAv2 test-std 集上,BRIDGETOWER 实现了 78.73% 的准确率,在相同的预训练数据和几乎可以忽略不计的额外参数和计算成本的情况下,比之前最先进的模型 METER 高出 1.09%。值得注意的是,当进一步扩展模型时,BRIDGETOWER 实现了 81.15% 的准确率,超过了在数量级更大的数据集上预训练的模型。

绘图 BridgeTower 架构。取自原始论文。

该模型由 Anahita BhiwandiwallaTiep LeShaoyen Tseng 贡献。原始代码可以在这里找到 这里

使用技巧和示例

BridgeTower 由一个视觉编码器、一个文本编码器和一个带有多个轻量级桥接层的跨模态编码器组成。这种方法的目标是在每个单模态编码器和跨模态编码器之间建立桥梁,以便在跨模态编码器的每一层进行全面而详细的交互。原则上,可以在建议的架构中应用任何视觉、文本或跨模态编码器。

BridgeTowerProcessorRobertaTokenizerBridgeTowerImageProcessor 包装成一个实例,分别对文本进行编码和准备图像。

以下示例演示如何使用 BridgeTowerProcessorBridgeTowerForContrastiveLearning 运行对比学习。

>>> from transformers import BridgeTowerProcessor, BridgeTowerForContrastiveLearning
>>> import requests
>>> from PIL import Image

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> texts = ["An image of two cats chilling on a couch", "A football player scoring a goal"]

>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-large-itm-mlm-itc")
>>> model = BridgeTowerForContrastiveLearning.from_pretrained("BridgeTower/bridgetower-large-itm-mlm-itc")

>>> # forward pass
>>> scores = dict()
>>> for text in texts:
...     # prepare inputs
...     encoding = processor(image, text, return_tensors="pt")
...     outputs = model(**encoding)
...     scores[text] = outputs

以下示例演示如何使用 BridgeTowerProcessorBridgeTowerForImageAndTextRetrieval 运行图文检索。

>>> from transformers import BridgeTowerProcessor, BridgeTowerForImageAndTextRetrieval
>>> import requests
>>> from PIL import Image

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> texts = ["An image of two cats chilling on a couch", "A football player scoring a goal"]

>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")
>>> model = BridgeTowerForImageAndTextRetrieval.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")

>>> # forward pass
>>> scores = dict()
>>> for text in texts:
...     # prepare inputs
...     encoding = processor(image, text, return_tensors="pt")
...     outputs = model(**encoding)
...     scores[text] = outputs.logits[0, 1].item()

以下示例演示如何使用 BridgeTowerProcessorBridgeTowerForMaskedLM 运行掩码语言建模。

>>> from transformers import BridgeTowerProcessor, BridgeTowerForMaskedLM
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000360943.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
>>> text = "a <mask> looking out of the window"

>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")
>>> model = BridgeTowerForMaskedLM.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")

>>> # prepare inputs
>>> encoding = processor(image, text, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**encoding)

>>> results = processor.decode(outputs.logits.argmax(dim=-1).squeeze(0).tolist())

>>> print(results)
.a cat looking out of the window.

提示

BridgeTowerConfig

transformers.BridgeTowerConfig

< >

( share_cross_modal_transformer_layers = True hidden_act = 'gelu' hidden_size = 768 initializer_factor = 1 layer_norm_eps = 1e-05 share_link_tower_layers = False link_tower_type = 'add' num_attention_heads = 12 num_hidden_layers = 6 tie_word_embeddings = False init_layernorm_from_vision_encoder = False text_config = None vision_config = None **kwargs )

参数

  • share_cross_modal_transformer_layers (bool, 可选, 默认为 True) — 是否共享跨模态 Transformer 层。
  • hidden_act (strfunction, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。
  • hidden_size (int, 可选, 默认为 768) — 编码器层和池化器层的维度。
  • initializer_factor (float, 可选, 默认为 1) — 初始化所有权重矩阵的因子(应保持为 1,内部用于初始化测试)。
  • layer_norm_eps (float, 可选, 默认为 1e-05) — 层归一化层使用的 epsilon。
  • share_link_tower_layers (bool, 可选, 默认为 False) — 桥接/链接塔层是否共享。
  • link_tower_type (str, 可选, 默认为 "add") — 桥接/链接层的类型。
  • num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
  • num_hidden_layers (int, 可选, 默认为 6) — Transformer 编码器中的隐藏层数。
  • tie_word_embeddings (bool, 可选, 默认为 False) — 是否绑定输入和输出嵌入。
  • init_layernorm_from_vision_encoder (bool, 可选, 默认为 False) — 是否从视觉编码器初始化 LayerNorm。
  • text_config (dict, 可选) — 用于初始化 BridgeTowerTextConfig 的配置选项字典。
  • vision_config (dict, 可选) — 用于初始化 BridgeTowerVisionConfig 的配置选项字典。

这是用于存储 BridgeTowerModel 配置的配置类。它用于根据指定的参数实例化 BridgeTower 模型,定义模型架构。使用默认值实例化配置将产生与 bridgetower-base BridgeTower/bridgetower-base 架构类似的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以了解更多信息。

示例

>>> from transformers import BridgeTowerModel, BridgeTowerConfig

>>> # Initializing a BridgeTower BridgeTower/bridgetower-base style configuration
>>> configuration = BridgeTowerConfig()

>>> # Initializing a model from the BridgeTower/bridgetower-base style configuration
>>> model = BridgeTowerModel(configuration)

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

from_text_vision_configs

< >

( text_config: BridgeTowerTextConfig vision_config: BridgeTowerVisionConfig **kwargs )

从 BridgeTower 文本模型配置实例化 BridgeTowerConfig(或派生类)。 返回: BridgeTowerConfig:配置对象的实例

BridgeTowerTextConfig

transformers.BridgeTowerTextConfig

< >

( vocab_size = 50265 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 initializer_factor = 1 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 514 type_vocab_size = 1 layer_norm_eps = 1e-05 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 position_embedding_type = 'absolute' use_cache = True **kwargs )

参数

  • vocab_size (int, 可选, 默认为 50265) — 模型文本部分的词汇量大小。定义了在调用 BridgeTowerModel 时传递的 inputs_ids 可以表示的不同标记的数量。
  • hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
  • num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中隐藏层的数量。
  • num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
  • intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”(通常称为前馈)层的维度。
  • hidden_act (strCallable可选,默认为 "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串,则支持 "gelu""relu""silu""gelu_new"
  • hidden_dropout_prob (float可选,默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
  • attention_probs_dropout_prob (float可选,默认为 0.1) — 注意力概率的 dropout 比率。
  • max_position_embeddings (int可选,默认为 514) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512 或 1024 或 2048)。
  • type_vocab_size (int可选,默认为 2) — token_type_ids 的词汇表大小。
  • initializer_factor (float可选,默认为 1) — 初始化所有权重矩阵的因子(应保持为 1,在内部用于初始化测试)。
  • layer_norm_eps (float可选,默认为 1e-05) — 层归一化层使用的 epsilon。
  • position_embedding_type (str, 可选, 默认为 "absolute") — 位置嵌入的类型。选择 "absolute""relative_key""relative_key_query" 之一。对于位置嵌入,请使用 "absolute"。有关 "relative_key" 的更多信息,请参阅 具有相对位置表示的自注意力(Shaw 等人)。有关 "relative_key_query" 的更多信息,请参阅 使用更好的相对位置嵌入改进 Transformer 模型(Huang 等人) 中的*方法 4*。
  • is_decoder (bool, 可选, 默认为 False) — 模型是否用作解码器。如果为 False,则模型用作编码器。
  • use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后一次键/值注意力(并非所有模型都使用)。仅在 config.is_decoder=True 时相关。

这是用于存储 BridgeTowerModel 的文本配置的配置类。此处的默认值是从 RoBERTa 复制的。使用默认值实例化配置将产生与 bridgetower-base BridegTower/bridgetower-base 架构类似的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以了解更多信息。

示例

>>> from transformers import BridgeTowerTextConfig

>>> # Initializing a BridgeTower BridgeTower/bridgetower-base style configuration for the text model
>>> configuration = BridgeTowerTextConfig()

>>> # Accessing the configuration
>>> configuration

BridgeTowerVisionConfig

transformers.BridgeTowerVisionConfig

< >

( hidden_size = 768 num_hidden_layers = 12 num_channels = 3 patch_size = 16 image_size = 288 initializer_factor = 1 layer_norm_eps = 1e-05 stop_gradient = False share_layernorm = True remove_last_layer = False **kwargs )

参数

  • hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
  • num_hidden_layers (int, 可选, 默认为 12) — 视觉编码器模型中的隐藏层数。
  • patch_size (int, 可选, 默认为 16) — 每个图像块的大小(分辨率)。
  • image_size (int, 可选, 默认为 288) — 每个图像的大小(分辨率)。
  • initializer_factor (float, 可选, 默认为 1) — 初始化所有权重矩阵的因子(应保持为 1,在内部用于初始化测试)。
  • layer_norm_eps (float, 可选, 默认为 1e-05) — 层归一化层使用的 epsilon。
  • stop_gradient (bool, 可选, 默认为 False) — 是否停止梯度训练。
  • share_layernorm (bool, 可选, 默认为 True) — LayerNorm 层是否共享。
  • remove_last_layer (bool, 可选, 默认为 False) — 是否从视觉编码器中移除最后一层。

这是用于存储 BridgeTowerModel 视觉配置的配置类。使用默认值实例化配置将产生与 bridgetower-base BridgeTower/bridgetower-base 架构类似的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以了解更多信息。

示例

>>> from transformers import BridgeTowerVisionConfig

>>> # Initializing a BridgeTower BridgeTower/bridgetower-base style configuration for the vision model
>>> configuration = BridgeTowerVisionConfig()

>>> # Accessing the configuration
>>> configuration

BridgeTowerImageProcessor

transformers.BridgeTowerImageProcessor

< >

( do_resize: bool = True size: Dict = None size_divisor: int = 32 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_center_crop: bool = True crop_size: Dict = None do_pad: bool = True **kwargs )

参数

  • do_resize (bool, 可选, 默认为 True) — 是否将图像的(高度、宽度)维度调整为指定的 size。可以在 preprocess 方法中通过 do_resize 参数覆盖。
  • size (Dict[str, int] 可选, 默认为 {'shortest_edge' -- 288}): 将输入的较短边调整为 size["shortest_edge"]。较长边将被限制在 int((1333 / 800) * size["shortest_edge"]) 以下,同时保持纵横比。仅在 do_resize 设置为 True 时生效。可以在 preprocess 方法中通过 size 参数覆盖。
  • size_divisor (int可选,默认为 32) — 确保高度和宽度均可被此大小整除的大小。仅在 do_resize 设置为 True 时生效。可以通过 preprocess 方法中的 size_divisor 参数覆盖。
  • 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_center_crop (bool可选,默认为 True) — 是否对图像进行中心裁剪。可以通过 preprocess 方法中的 do_center_crop 参数覆盖。
  • crop_size (Dict[str, int]可选) — 应用中心裁剪时所需的输出大小。仅在 do_center_crop 设置为 True 时生效。可以通过 preprocess 方法中的 crop_size 参数覆盖。如果未设置,则默认为 size
  • do_pad (bool可选,默认为 True) — 是否将图像填充到批次中图像的 (max_height, max_width)。可以通过 preprocess 方法中的 do_pad 参数覆盖。

构建一个 BridgeTower 图像处理器。

预处理

< >

( images: Union do_resize: Optional = None size: Optional = None size_divisor: Optional = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None do_center_crop: Optional = None crop_size: Dict = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None )

参数

  • images (ImageInput) — 要预处理的图像。期望单个或批量图像的像素值范围为 0 到 255。如果传入像素值介于 0 和 1 之间的图像,请设置 do_rescale=False
  • do_resize (bool可选,默认为 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))
  • size_divisor (int可选,默认为 self.size_divisor) — 图像将调整大小为该值的倍数。
  • resample (PILImageResampling可选,默认为 self.resample) — 如果调整图像大小,则使用重采样过滤器。仅在 do_resize 设置为 True 时才生效。
  • do_rescale (bool可选,默认为 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_pad (bool可选,默认为 self.do_pad) — 是否将图像填充到批次中的 (max_height, max_width)。如果为 True,还会创建一个像素掩码并返回。
  • do_center_crop (bool可选,默认为 self.do_center_crop) — 是否对图像进行中心裁剪。如果输入大小沿任何边缘小于 crop_size,则图像将用 0 填充,然后进行中心裁剪。
  • crop_size (Dict[str, int]可选,默认为 self.crop_size) — 中心裁剪后图像的大小。如果图像的一条边小于 crop_size,它将用零填充,然后裁剪
  • 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) 格式。

预处理图像或图像批次。

BridgeTowerProcessor

transformers.BridgeTowerProcessor

< >

( image_processor tokenizer )

参数

  • image_processor (BridgeTowerImageProcessor) — BridgeTowerImageProcessor 的实例。图像处理器是必需的输入。
  • tokenizer (RobertaTokenizerFast) — [‘RobertaTokenizerFast`] 的实例。分词器是必需的输入。

构造一个 BridgeTower 处理器,它将 Roberta 分词器和 BridgeTower 图像处理器包装到单个处理器中。

BridgeTowerProcessor 提供了 BridgeTowerImageProcessorRobertaTokenizerFast 的所有功能。有关更多信息,请参阅 call()decode() 的文档字符串。

__call__

< >

( images text: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True return_tensors: Union = None **kwargs )

此方法使用 BridgeTowerImageProcessor.call() 方法为模型准备图像,并使用 RobertaTokenizerFast.call() 为模型准备文本。

请参阅上述两种方法的文档字符串以获取更多信息。

BridgeTowerModel

transformers.BridgeTowerModel

< >

( config )

参数

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

BridgeTower 模型的裸模型,输出 BridgeTowerModelOutput 对象,顶部没有任何特定头部。此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>_ 子类。像使用常规 PyTorch 模块一样使用它,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

前向传播

< >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None image_token_type_idx: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) transformers.models.bridgetower.modeling_bridgetower.BridgeTowerModelOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 ({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()什么是输入 ID?
  • attention_mask (torch.FloatTensor 形状为 ({0}), 可选) — 掩码以避免对填充标记索引执行注意力。在 [0, 1] 中选择的掩码值:

  • token_type_ids (torch.LongTensor 形状为 ({0}), 可选) — 段标记索引,指示输入的第一部分和第二部分。在 [0, 1] 中选择的索引:

  • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。可以使用 BridgeTowerImageProcessor 获取像素值。有关详细信息,请参阅 BridgeTowerImageProcessor.call()
  • pixel_mask (torch.LongTensor 形状为 (batch_size, height, width), 可选) — 掩码以避免对填充像素值执行注意力。在 [0, 1] 中选择的掩码值:

    • 真实像素(即未屏蔽)为 1,
    • 填充像素(即已屏蔽)为 0。 什么是注意力掩码? <../glossary.html#attention-mask>__
  • head_mask (torch.FloatTensor 形状为 (num_heads,)(num_layers, num_heads)可选) — 用于将自注意力模块的选定头部置零的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示头部未被屏蔽
    • 0 表示头部已被屏蔽
  • inputs_embeds (torch.FloatTensor 形状为 ({0}, hidden_size)可选) — 或者,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量,这将非常有用。
  • image_embeds (torch.FloatTensor 形状为 (batch_size, num_patches, hidden_size)可选) — 或者,您可以选择直接传递嵌入表示,而不是传递 pixel_values。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 pixel_values 转换为补丁嵌入,这将非常有用。
  • image_token_type_idx (int, 可选) —

    • 图像的标记类型 ID。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。
  • output_hidden_states (bool, 可选) — 如果设置为 True,则隐藏状态将作为列表返回,其中包含文本、图像和跨模态组件各自的隐藏状态。即 (hidden_states_text, hidden_states_image, hidden_states_cross_modal),其中每个元素是相应模态的隐藏状态列表。hidden_states_txt/img 是与单模态隐藏状态对应的张量列表,hidden_states_cross_modal 是包含每个桥接层的 cross_modal_text_hidden_statescross_modal_image_hidden_states 的元组列表。
  • labels (torch.LongTensor 形状为 (batch_size,), 可选) — 目前不支持标签。

返回值

transformers.models.bridgetower.modeling_bridgetower.BridgeTowerModelOutputtuple(torch.FloatTensor)

transformers.models.bridgetower.modeling_bridgetower.BridgeTowerModelOutputtorch.FloatTensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False)包含各种元素,具体取决于配置(BridgeTowerConfig)和输入。

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

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

  • pooler_output (torch.FloatTensor 形状为 (batch_size, hidden_size x 2)) — 分别连接文本和图像序列(分类标记)第一个标记的最后一层隐藏状态,在经过用于辅助预训练任务的层进一步处理后。

  • hidden_states (tuple(torch.FloatTensor), 可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型具有嵌入层,则一个用于嵌入的输出 + 一个用于每层的输出),形状为 (batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。

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

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

BridgeTowerModel 前向方法,覆盖 __call__ 特殊方法。

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

示例

>>> from transformers import BridgeTowerProcessor, BridgeTowerModel
>>> from PIL import Image
>>> import requests

>>> # prepare image and text
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "hello world"
>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-base")
>>> model = BridgeTowerModel.from_pretrained("BridgeTower/bridgetower-base")

>>> inputs = processor(image, text, return_tensors="pt")
>>> outputs = model(**inputs)
>>> outputs.keys()
odict_keys(['text_features', 'image_features', 'pooler_output'])

BridgeTowerForContrastiveLearning

transformers.BridgeTowerForContrastiveLearning

< >

( config )

参数

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

BridgeTower 模型,顶部带有图像-文本对比头,用于计算图像-文本对比损失。

此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>_ 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以了解与一般用法和行为相关的所有内容。

前向传播

< >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = True return_dict: Optional = None return_loss: Optional = None ) transformers.models.bridgetower.modeling_bridgetower.BridgeTowerContrastiveOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 ({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()什么是输入 ID?
  • attention_mask (torch.FloatTensor 形状为 ({0}), 可选) — 掩码以避免对填充标记索引执行注意力。在 [0, 1] 中选择的掩码值:

  • token_type_ids (torch.LongTensor 形状为 ({0}), 可选) — 段标记索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

  • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。像素值可以通过 BridgeTowerImageProcessor 获取。有关详细信息,请参阅 BridgeTowerImageProcessor.call()
  • pixel_mask (torch.LongTensor 形状为 (batch_size, height, width)可选) — 避免对填充像素值执行注意力的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示真实的像素(即未被掩码),
    • 0 表示填充像素(即被掩码)。什么是注意力掩码? <../glossary.html#attention-mask>__
  • head_mask (torch.FloatTensor 形状为 (num_heads,)(num_layers, num_heads)可选) — 用于将自注意力模块的选定头部置零的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示头部未被掩码
    • 0 表示头部被掩码
  • inputs_embeds (torch.FloatTensor 形状为 ({0}, hidden_size)可选) — 或者,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量,则此选项很有用。
  • image_embeds (torch.FloatTensor 形状为 (batch_size, num_patches, hidden_size)可选) — 或者,您可以选择直接传递嵌入表示,而不是传递 pixel_values。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 pixel_values 转换为补丁嵌入,则此选项很有用。
  • image_token_type_idx (int可选) —

    • 图像的标记类型 ID。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。
  • return_loss (bool, 可选) — 是否返回对比损失。

返回值

transformers.models.bridgetower.modeling_bridgetower.BridgeTowerContrastiveOutputtuple(torch.FloatTensor)

一个 transformers.models.bridgetower.modeling_bridgetower.BridgeTowerContrastiveOutput 或一个 torch.FloatTensor 的元组(如果传入 return_dict=False 或当 config.return_dict=False 时)包含各种元素,具体取决于配置 (BridgeTowerConfig) 和输入。

  • loss (torch.FloatTensor 形状为 (1,), 可选, 当 return_lossTrue 时返回) — 图像-文本对比损失。
  • logits (torch.FloatTensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数(SoftMax 之前的每个词汇标记的分数)。
  • text_embeds (torch.FloatTensor), 可选, 当模型使用 with_projection=True 初始化时返回) — 通过将投影层应用于 pooler_output 获得的文本嵌入。
  • image_embeds (torch.FloatTensor), 可选, 当模型使用 with_projection=True 初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。
  • cross_embeds (torch.FloatTensor), 可选, 当模型使用 with_projection=True 初始化时返回) — 通过将投影层应用于 pooler_output 获得的文本-图像跨模态嵌入。
  • hidden_states (tuple(torch.FloatTensor), 可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型具有嵌入层,则一个用于嵌入的输出 + 一个用于每层的输出),形状为 (batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
  • attentions (tuple(torch.FloatTensor), 可选,当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

BridgeTowerForContrastiveLearning 的前向方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import BridgeTowerProcessor, BridgeTowerForContrastiveLearning
>>> import requests
>>> from PIL import Image
>>> import torch

>>> image_urls = [
...     "https://farm4.staticflickr.com/3395/3428278415_81c3e27f15_z.jpg",
...     "http://images.cocodataset.org/val2017/000000039769.jpg",
... ]
>>> texts = ["two dogs in a car", "two cats sleeping on a couch"]
>>> images = [Image.open(requests.get(url, stream=True).raw) for url in image_urls]

>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-large-itm-mlm-itc")
>>> model = BridgeTowerForContrastiveLearning.from_pretrained("BridgeTower/bridgetower-large-itm-mlm-itc")

>>> inputs = processor(images, texts, padding=True, return_tensors="pt")
>>> loss = model(**inputs, return_loss=True).loss

>>> inputs = processor(images, texts[::-1], padding=True, return_tensors="pt")
>>> loss_swapped = model(**inputs, return_loss=True).loss

>>> print("Loss", round(loss.item(), 4))
Loss 0.0019

>>> print("Loss with swapped images", round(loss_swapped.item(), 4))
Loss with swapped images 2.126

BridgeTowerForMaskedLM

transformers.BridgeTowerForMaskedLM

< >

( config )

参数

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

BridgeTower 模型,顶部有一个语言建模头,就像在预训练期间所做的那样。

此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>_ 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以了解与一般用法和行为相关的所有内容。

前向传播

< >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) transformers.modeling_outputs.MaskedLMOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor ,形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()什么是输入 ID?
  • attention_mask (torch.FloatTensor ,形状为 (batch_size, sequence_length)可选) — 掩码,用于避免对填充标记索引执行注意力。掩码值在 [0, 1] 中选择:

  • token_type_ids (torch.LongTensor 形状为 (batch_size, sequence_length)可选) — 段落标记索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

  • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。可以使用 BridgeTowerImageProcessor 获取像素值。有关详细信息,请参阅 BridgeTowerImageProcessor.call()
  • pixel_mask (torch.LongTensor 形状为 (batch_size, height, width)可选) — 掩码,用于避免对填充像素值执行注意力。掩码值在 [0, 1] 中选择:

    • 1 表示真实的像素(即未掩码),
    • 0 表示填充像素(即已掩码)。什么是注意力掩码? <../glossary.html#attention-mask>__
  • head_mask (torch.FloatTensor 形状为 (num_heads,)(num_layers, num_heads)可选) — 用于将自注意力模块的选定头部置零的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示头部未掩码
    • 0 表示头部已掩码
  • inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)可选) — 或者,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量,这将非常有用。
  • image_embeds (torch.FloatTensor 形状为 (batch_size, num_patches, hidden_size)可选) — 或者,您可以选择直接传递嵌入表示,而不是传递 pixel_values。如果您希望更好地控制如何将 pixel_values 转换为补丁嵌入,这将非常有用。
  • image_token_type_idx (int, 可选) —

    • 图像的标记类型 ID。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  • labels (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 中(请参阅 input_ids 文档字符串)索引设置为 -100 的标记将被忽略(掩码),损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算

返回值

transformers.modeling_outputs.MaskedLMOutputtuple(torch.FloatTensor)

transformers.modeling_outputs.MaskedLMOutputtorch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时)包含根据配置(BridgeTowerConfig)和输入的不同元素。

  • loss (torch.FloatTensor 形状为 (1,), 可选, 当提供 labels 时返回) — 掩码语言建模 (MLM) 损失。

  • logits (torch.FloatTensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数(SoftMax 之前的每个词汇标记的分数)。

  • 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=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

BridgeTowerForMaskedLM 前向方法,覆盖 __call__ 特殊方法。

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

示例

>>> from transformers import BridgeTowerProcessor, BridgeTowerForMaskedLM
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000360943.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
>>> text = "a <mask> looking out of the window"

>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")
>>> model = BridgeTowerForMaskedLM.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")

>>> # prepare inputs
>>> encoding = processor(image, text, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**encoding)

>>> results = processor.decode(outputs.logits.argmax(dim=-1).squeeze(0).tolist())

>>> print(results)
.a cat looking out of the window.

BridgeTowerForImageAndTextRetrieval

transformers.BridgeTowerForImageAndTextRetrieval

< >

( config )

参数

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

BridgeTower 模型变压器,顶部带有分类器头([CLS] 标记的最终隐藏状态顶部的线性层),用于图像到文本匹配。

此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>_ 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以了解与一般用法和行为相关的所有内容。

前向传播

< >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) transformers.modeling_outputs.SequenceClassifierOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 ({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()什么是输入 ID?
  • attention_mask (torch.FloatTensor 形状为 ({0}), 可选) — 掩码以避免对填充标记索引执行注意力。在 [0, 1] 中选择的掩码值:

  • token_type_ids (torch.LongTensor 形状为 ({0})可选) — 段落标记索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

  • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 BridgeTowerImageProcessor 获取。有关详细信息,请参阅 BridgeTowerImageProcessor.call()
  • pixel_mask (torch.LongTensor 形状为 (batch_size, height, width)可选) — 掩码,用于避免对填充像素值执行注意力。掩码值在 [0, 1] 中选择:

    • 1 表示真实的像素(即未被掩码),
    • 0 表示填充像素(即被掩码)。 什么是注意力掩码? <../glossary.html#attention-mask>__
  • head_mask (torch.FloatTensor 形状为 (num_heads,)(num_layers, num_heads)可选) — 掩码,用于将自注意力模块的选定头部置零。掩码值在 [0, 1] 中选择:

    • 1 表示头部未被掩码
    • 0 表示头部被掩码
  • inputs_embeds (torch.FloatTensor 形状为 ({0}, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您想比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量,这将非常有用。
  • image_embeds (torch.FloatTensor 形状为 (batch_size, num_patches, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 pixel_values。如果您想比模型的内部嵌入查找矩阵更好地控制如何将 pixel_values 转换为补丁嵌入,这将非常有用。
  • image_token_type_idx (int可选) —

    • 图像的标记类型 ID。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通的元组。
  • labels (torch.LongTensor 形状为 (batch_size, 1)可选) — 用于计算图文匹配损失的标签。0 表示配对不匹配,1 表示配对匹配。标签为 0 的配对将被跳过计算。

返回值

transformers.modeling_outputs.SequenceClassifierOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 的元组(如果传入 return_dict=Falseconfig.return_dict=False 时)包含根据配置 (BridgeTowerConfig) 和输入的不同元素。

  • loss (torch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 分类(如果 config.num_labels==1 则为回归)损失。

  • logits (torch.FloatTensor 形状为 (batch_size, config.num_labels)) — 分类(如果 config.num_labels==1 则为回归)分数(SoftMax 之前)。

  • 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=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

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

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

示例

>>> from transformers import BridgeTowerProcessor, BridgeTowerForImageAndTextRetrieval
>>> import requests
>>> from PIL import Image

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> texts = ["An image of two cats chilling on a couch", "A football player scoring a goal"]

>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")
>>> model = BridgeTowerForImageAndTextRetrieval.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")

>>> # forward pass
>>> scores = dict()
>>> for text in texts:
...     # prepare inputs
...     encoding = processor(image, text, return_tensors="pt")
...     outputs = model(**encoding)
...     scores[text] = outputs.logits[0, 1].item()
< > 在 GitHub 上更新