Transformers 文档
BridgeTower
并获得增强的文档体验
开始使用
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 会议接受。
论文摘要如下:
近年来,采用 TWO-TOWER 架构的视觉-语言 (VL) 模型在视觉语言表征学习中占据主导地位。当前的 VL 模型要么使用轻量级的单模态编码器,并在深层跨模态编码器中学习同时提取、对齐和融合两种模态,要么将来自深层预训练单模态编码器的最后一层单模态表征馈送到顶层跨模态编码器。这两种方法都可能限制视觉语言表征学习并限制模型性能。在本文中,我们提出了 BRIDGETOWER,它引入了多个桥接层,在单模态编码器的顶层和跨模态编码器的每一层之间建立连接。这使得在跨模态编码器中,预训练单模态编码器的不同语义级别的视觉和文本表征之间能够进行有效的自下而上的跨模态对齐和融合。BRIDGETOWER 仅使用 400 万张图像进行预训练,在各种下游视觉语言任务上实现了最先进的性能。特别是在 VQAv2 test-std 数据集上,BRIDGETOWER 的准确率达到了 78.73%,在相同的预训练数据和几乎可忽略不计的额外参数和计算成本下,超过了之前的最先进模型 METER 1.09%。值得注意的是,当进一步扩展模型时,BRIDGETOWER 的准确率达到了 81.15%,超过了在数量级更大的数据集上进行预训练的模型。

此模型由 Anahita Bhiwandiwalla、Tiep Le 和 Shaoyen Tseng 贡献。原始代码可以在这里找到。
使用技巧和示例
BridgeTower 由视觉编码器、文本编码器和带有多个轻量级桥接层的跨模态编码器组成。这种方法的目标是在每个单模态编码器和跨模态编码器之间构建桥梁,以在跨模态编码器的每一层实现全面而详细的交互。原则上,可以在提出的架构中应用任何视觉、文本或跨模态编码器。
BridgeTowerProcessor 封装了 RobertaTokenizer 和 BridgeTowerImageProcessor 到单个实例中,以同时编码文本和分别准备图像。
以下示例展示了如何使用 BridgeTowerProcessor 和 BridgeTowerForContrastiveLearning 运行对比学习。
>>> 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
以下示例展示了如何使用 BridgeTowerProcessor 和 BridgeTowerForImageAndTextRetrieval 运行图像-文本检索。
>>> 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()
以下示例展示了如何使用 BridgeTowerProcessor 和 BridgeTowerForMaskedLM 运行掩码语言建模。
>>> 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.
提示
- BridgeTower 的此实现使用 RobertaTokenizer 生成文本嵌入,并使用 OpenAI 的 CLIP/ViT 模型计算视觉嵌入。
- 预训练的 bridgeTower-base 和 bridgetower 掩码语言建模和图像文本匹配的检查点已发布。
- 请参阅 表 5 了解 BridgeTower 在图像检索和其他下游任务上的性能。
- 此模型的 PyTorch 版本仅在 torch 1.10 及更高版本中可用。
BridgeTowerConfig
class 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 (
str
或function
, 可选, 默认为"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
, optional, defaults to 6) — Transformer 编码器中的隐藏层数,默认为 6。 - tie_word_embeddings (
bool
, optional, defaults toFalse
) — 是否绑定输入和输出词嵌入,默认为False
。 - init_layernorm_from_vision_encoder (
bool
, optional, defaults toFalse
) — 是否从视觉编码器初始化 LayerNorm,默认为False
。 - text_config (
dict
, optional) — 用于初始化 BridgeTowerTextConfig 的配置选项字典,可选参数。 - vision_config (
dict
, optional) — 用于初始化 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
< source >( text_config: BridgeTowerTextConfig vision_config: BridgeTowerVisionConfig **kwargs )
从 BridgeTower 文本模型配置实例化 BridgeTowerConfig (或派生类)。 返回: BridgeTowerConfig: 配置对象的一个实例
BridgeTowerTextConfig
class transformers.BridgeTowerTextConfig
< source >( 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
, optional, defaults to 50265) — 模型文本部分的词汇表大小,默认为 50265。定义了在调用 BridgeTowerModel 时传递的inputs_ids
可以表示的不同 token 的数量。 - hidden_size (
int
, optional, defaults to 768) — 编码器层和池化层的维度,默认为 768。 - num_hidden_layers (
int
, optional, defaults to 12) — Transformer 编码器中的隐藏层数,默认为 12。 - num_attention_heads (
int
, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数,默认为 12。 - intermediate_size (
int
, optional, defaults to 3072) — Transformer 编码器中“中间”(通常称为前馈)层的维度,默认为 3072。 - hidden_act (
str
orCallable
, optional, defaults to"gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串),默认为"gelu"
。如果为字符串,则支持"gelu"
,"relu"
,"silu"
和"gelu_new"
。 - hidden_dropout_prob (
float
, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率,默认为 0.1。 - attention_probs_dropout_prob (
float
, optional, defaults to 0.1) — 注意力概率的 dropout 比率,默认为 0.1。 - max_position_embeddings (
int
, optional, defaults to 514) — 模型可能使用的最大序列长度,默认为 514。通常设置为较大的值以防万一(例如,512 或 1024 或 2048)。 - type_vocab_size (
int
, optional, defaults to 2) —token_type_ids
的词汇表大小,默认为 2。 - initializer_factor (
float
, optional, defaults to 1) — 用于初始化所有权重矩阵的因子,默认为 1(应保持为 1,内部用于初始化测试)。 - layer_norm_eps (
float
, optional, defaults to 1e-05) — layer normalization 层使用的 epsilon 值,默认为 1e-05。 - position_embedding_type (
str
, optional, defaults to"absolute"
) — 位置嵌入类型,默认为"absolute"
。 可选值为"absolute"
,"relative_key"
,"relative_key_query"
。对于位置嵌入,请使用"absolute"
。有关"relative_key"
的更多信息,请参阅 Self-Attention with Relative Position Representations (Shaw et al.)。有关"relative_key_query"
的更多信息,请参阅 Improve Transformer Models with Better Relative Position Embeddings (Huang et al.) 中的方法 4。 - is_decoder (
bool
, optional, defaults toFalse
) — 模型是否用作解码器,默认为False
。如果为False
,则模型用作编码器。 - use_cache (
bool
, optional, defaults toTrue
) — 模型是否应返回最后一个键/值注意力(并非所有模型都使用)。仅在config.is_decoder=True
时相关,默认为True
。
这是用于存储 BridgeTowerModel 的文本配置的配置类。此处的默认值从 RoBERTa 复制而来。使用默认值实例化配置将产生与 bridgetower-base BridegTower/bridgetower-base 架构类似的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。有关更多信息,请阅读 PretrainedConfig 的文档。
BridgeTowerVisionConfig
class transformers.BridgeTowerVisionConfig
< source >( 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 的文档。
BridgeTowerImageProcessor
class transformers.BridgeTowerImageProcessor
< 源代码 >( do_resize: bool = True size: typing.Dict[str, int] = None size_divisor: int = 32 resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_center_crop: bool = True crop_size: typing.Dict[str, int] = 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 (
int
或float
, 可选, 默认为1/255
) — 如果重新缩放图像,则使用的缩放因子。仅当do_rescale
设置为True
时生效。可以被preprocess
方法中的rescale_factor
参数覆盖。 - do_normalize (
bool
, 可选, 默认为True
) — 是否标准化图像。可以被preprocess
方法中的do_normalize
参数覆盖。可以被preprocess
方法中的do_normalize
参数覆盖。 - image_mean (
float
或List[float]
, 可选, 默认为IMAGENET_STANDARD_MEAN
) — 如果标准化图像,则使用的均值。这是一个浮点数或浮点数列表,其长度为图像中通道的数量。可以被preprocess
方法中的image_mean
参数覆盖。可以被preprocess
方法中的image_mean
参数覆盖。 - image_std (
float
或List[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 图像处理器。
preprocess
< 源代码 >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_resize: typing.Optional[bool] = None size: typing.Optional[typing.Dict[str, int]] = None size_divisor: typing.Optional[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 do_pad: typing.Optional[bool] = None do_center_crop: typing.Optional[bool] = None crop_size: typing.Dict[str, int] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[transformers.image_utils.ChannelDimension, str, NoneType] = 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 (
float
或List[float]
, 可选, 默认为self.image_mean
) — 如果do_normalize
设置为True
,则用于标准化图像的图像均值。 - image_std (
float
或List[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 (
str
或TensorType
, 可选) — 要返回的张量类型。 可以是以下之一:- 未设置:返回
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 (
ChannelDimension
或str
, 可选, 默认为ChannelDimension.FIRST
) — 输出图像的通道维度格式。 可以是以下之一:"channels_first"
或ChannelDimension.FIRST
:(num_channels, height, width) 格式的图像。"channels_last"
或ChannelDimension.LAST
:(height, width, num_channels) 格式的图像。- 未设置:使用输入图像的通道维度格式。
- input_data_format (
ChannelDimension
或str
, 可选) — 输入图像的通道维度格式。 如果未设置,则通道维度格式将从输入图像推断。 可以是以下之一:"channels_first"
或ChannelDimension.FIRST
:(num_channels, height, width) 格式的图像。"channels_last"
或ChannelDimension.LAST
:(height, width, num_channels) 格式的图像。"none"
或ChannelDimension.NONE
:(height, width) 格式的图像。
预处理单张或批量图像。
BridgeTowerProcessor
class transformers.BridgeTowerProcessor
< source >( image_processor tokenizer )
参数
- image_processor (
BridgeTowerImageProcessor
) — BridgeTowerImageProcessor 的实例。 图像处理器是必需的输入。 - tokenizer (
RobertaTokenizerFast
) — [‘RobertaTokenizerFast`] 的实例。 分词器是必需的输入。
构建一个 BridgeTower 处理器,它将 Roberta 分词器和 BridgeTower 图像处理器包装到单个处理器中。
BridgeTowerProcessor 提供了 BridgeTowerImageProcessor 和 RobertaTokenizerFast 的所有功能。 有关更多信息,请参阅 call() 和 decode()
的文档字符串。
__call__
< source >( images text: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None audio = None videos = None **kwargs: typing_extensions.Unpack[transformers.models.bridgetower.processing_bridgetower.BridgeTowerProcessorKwargs] )
此方法使用 BridgeTowerImageProcessor.call() 方法来为模型准备图像,并使用 RobertaTokenizerFast.call() 来为模型准备文本。
有关更多信息,请参阅上述两个方法的文档字符串。
BridgeTowerModel
class transformers.BridgeTowerModel
< source >( config )
参数
- config (BridgeTowerConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。
裸 BridgeTower 模型 Transformer,输出 BridgeTowerModelOutput 对象,顶部没有任何特定的 head。此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
_ 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None image_embeds: typing.Optional[torch.FloatTensor] = None image_token_type_idx: typing.Optional[int] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None interpolate_pos_encoding: bool = False ) → transformers.models.bridgetower.modeling_bridgetower.BridgeTowerModelOutput
或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为({0})
) — 词汇表中输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID? - attention_mask (
torch.FloatTensor
,形状为({0})
,可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在[0, 1]
中选择:- 1 表示 token 未被 masking,
- 0 表示 token 已被 masking。 什么是 attention mask?
- token_type_ids (
torch.LongTensor
,形状为({0})
,可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。索引在[0, 1]
中选择:- 0 对应于 sentence A token,
- 1 对应于 sentence B token。 什么是 token 类型 ID?
- pixel_values (
torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用 BridgeTowerImageProcessor 获得。 有关详细信息,请参阅 BridgeTowerImageProcessor.call()。 - pixel_mask (
torch.LongTensor
,形状为(batch_size, height, width)
,可选) — 用于避免在 padding 像素值上执行 attention 的 Mask。Mask 值在[0, 1]
中选择:- 1 表示像素是真实的(即,未被 masking),
- 0 表示像素是 padding(即,已被 masking)。
什么是 attention mask? <../glossary.html#attention-mask>
__
- head_mask (
torch.FloatTensor
,形状为(num_heads,)
或(num_layers, num_heads)
,可选) — 用于 nullify self-attention 模块的选定 head 的 Mask。Mask 值在[0, 1]
中选择:- 1 表示 head 未被 masking,
- 0 表示 head 已被 masking。
- 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
转换为 patch embeddings 更好地控制,这将非常有用。 - image_token_type_idx (
int
,可选) —- 图像的 token 类型 ID。
- output_attentions (
bool
,可选) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息,请参阅返回的张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参阅返回的张量下的hidden_states
。 - interpolate_pos_encoding (
bool
,默认为False
) — 是否插值预训练的位置编码。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是普通元组。 - output_hidden_states (
bool
,可选) — 如果设置为True
,则 hidden states 将作为列表返回,其中包含文本、图像和跨模态组件的 hidden states。 即(hidden_states_text, hidden_states_image, hidden_states_cross_modal)
,其中每个元素都是相应模态的 hidden states 列表。hidden_states_txt/img
是对应于单模态 hidden states 的张量列表,而hidden_states_cross_modal
是包含每个桥接层的cross_modal_text_hidden_states
和cross_modal_image_hidden_states
的元组列表。 - labels (
torch.LongTensor
,形状为(batch_size,)
,可选) — 当前不支持标签。
返回值
transformers.models.bridgetower.modeling_bridgetower.BridgeTowerModelOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.bridgetower.modeling_bridgetower.BridgeTowerModelOutput
或 torch.FloatTensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),其中包含各种元素,具体取决于配置 (BridgeTowerConfig) 和输入。
-
text_features (
torch.FloatTensor
,形状为(batch_size, text_sequence_length, hidden_size)
) — 模型最后一层的文本输出端的 hidden-states 序列。 -
image_features (
torch.FloatTensor
,形状为(batch_size, image_sequence_length, hidden_size)
) — 模型最后一层的图像输出端的 hidden-states 序列。 -
pooler_output (
torch.FloatTensor
,形状为(batch_size, hidden_size x 2)
) — 文本和图像序列的第一个 token(分类 token)的最后一层 hidden-state 的串联,分别在通过用于辅助预训练任务的层进一步处理之后。 -
hidden_states (
tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —torch.FloatTensor
元组(如果模型具有嵌入层,则为嵌入输出提供一个,+ 为每层的输出提供一个),形状为(batch_size, sequence_length, hidden_size)
。 模型在每一层输出端的 Hidden-states 加上可选的初始嵌入输出。 -
attentions (
tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。attention softmax 之后的 attention 权重,用于计算 self-attention head 中的加权平均值。
BridgeTowerModel forward 方法,覆盖了 __call__
特殊方法。
尽管 forward 传递的配方需要在该函数内定义,但应该在此之后调用 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
class transformers.BridgeTowerForContrastiveLearning
< source >( config )
参数
- config (BridgeTowerConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。
BridgeTower 模型,顶部带有图像-文本对比 head,用于计算图像-文本对比损失。
此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
_ 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None image_embeds: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = True return_dict: typing.Optional[bool] = None return_loss: typing.Optional[bool] = None ) → transformers.models.bridgetower.modeling_bridgetower.BridgeTowerContrastiveOutput
或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为({0})
) — 词汇表中输入序列标记的索引。 索引可以使用 AutoTokenizer 获得。 有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID? - attention_mask (
torch.FloatTensor
,形状为({0})
,可选) — 用于避免在填充标记索引上执行注意力的掩码。 掩码值在[0, 1]
中选择:- 1 表示未被掩蔽的标记,
- 0 表示被掩蔽的标记。 什么是注意力掩码?
- token_type_ids (
torch.LongTensor
,形状为({0})
,可选) — 分段标记索引,用于指示输入的第一部分和第二部分。 索引在[0, 1]
中选择:- 0 对应于句子 A 标记,
- 1 对应于句子 B 标记。 什么是标记类型 ID?
- 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)
,可选) — 用于使自注意力模块的选定 head 失效的掩码。 掩码值在[0, 1]
中选择:- 1 表示 head 未被掩蔽,
- 0 表示 head 被掩蔽。
- 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
转换为 patch 嵌入,这将非常有用。 - image_token_type_idx (
int
,可选) —- 图像的标记类型 ID。
- output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的hidden_states
。 - interpolate_pos_encoding (
bool
,默认为False
) — 是否插值预训练的位置编码。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是普通元组。 - return_loss (
bool
,可选) — 是否返回对比损失。
返回值
transformers.models.bridgetower.modeling_bridgetower.BridgeTowerContrastiveOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.bridgetower.modeling_bridgetower.BridgeTowerContrastiveOutput
或 torch.FloatTensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种元素,具体取决于配置 (BridgeTowerConfig) 和输入。
- loss (
torch.FloatTensor
,形状为(1,)
,可选,当return_loss
为True
时返回) — 图像-文本对比损失。 - logits (
torch.FloatTensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模 head 的预测分数(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=True
或当config.output_hidden_states=True
时返回) —torch.FloatTensor
元组(如果模型具有嵌入层,则为嵌入输出提供一个,+ 为每层的输出提供一个),形状为(batch_size, sequence_length, hidden_size)
。 模型在每一层输出端的 Hidden-states 加上可选的初始嵌入输出。 - attentions (
tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。
BridgeTowerForContrastiveLearning forward 方法,覆盖了 __call__
特殊方法。
尽管 forward 传递的配方需要在该函数内定义,但应该在此之后调用 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
class transformers.BridgeTowerForMaskedLM
< source >( config )
参数
- config (BridgeTowerConfig) — 模型配置类,包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
BridgeTower 模型,顶部带有语言建模 head,就像预训练期间所做的那样。
此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
_ 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None image_embeds: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.MaskedLMOutput 或 tuple(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]
中选择:- 1 表示未被掩蔽的标记,
- 0 表示被掩蔽的标记。 什么是注意力掩码?
- token_type_ids (
torch.LongTensor
,形状为(batch_size, sequence_length)
,可选) — 分段标记索引,用于指示输入的第一部分和第二部分。 索引在[0, 1]
中选择:- 0 对应于句子 A 标记,
- 1 对应于句子 B 标记。 什么是标记类型 ID?
- 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)
,可选) — 用于使自注意力模块的选定 head 失效的掩码。 掩码值在[0, 1]
中选择:- 1 表示 head 未被掩蔽,
- 0 表示 head 被掩蔽。
- 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
转换为patch嵌入,这将非常有用。 - image_token_type_idx (
int
,可选) —- 图像的token类型ID。
- output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的hidden_states
。 - interpolate_pos_encoding (
bool
,默认为False
) — 是否插值预训练的位置编码。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (
torch.LongTensor
,形状为(batch_size, sequence_length)
,可选) — 用于计算掩码语言建模损失的标签。 索引应在[-100, 0, ..., config.vocab_size]
中(参见input_ids
文档字符串)。索引设置为-100
的token将被忽略(掩码),损失仅针对标签在[0, ..., config.vocab_size]
中的token计算。
返回值
transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.MaskedLMOutput 或 torch.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)
) — 语言建模 head 的预测分数(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=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。attention softmax 之后的 attention 权重,用于计算 self-attention head 中的加权平均值。
BridgeTowerForMaskedLM forward 方法,覆盖了 __call__
特殊方法。
尽管 forward 传递的配方需要在该函数内定义,但应该在此之后调用 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
class transformers.BridgeTowerForImageAndTextRetrieval
< source >( config )
参数
- config (BridgeTowerConfig) — 模型配置类,包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 请查看 from_pretrained() 方法来加载模型权重。
带有分类器头的BridgeTower模型转换器(位于 [CLS] token 的最终隐藏状态之上的线性层),用于图像到文本的匹配。
此模型是 PyTorch torch.nn.Module <https://pytorch.ac.cn/docs/stable/nn.html#torch.nn.Module>
_ 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None image_embeds: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为({0})
) — 词汇表中输入序列token的索引。 可以使用 AutoTokenizer 获取索引。 有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入ID? - attention_mask (
torch.FloatTensor
,形状为({0})
,可选) — 用于避免在padding token索引上执行注意力的掩码。 在[0, 1]
中选择的掩码值:- 1 表示 token 未被掩码,
- 0 表示 token 已被掩码。 什么是注意力掩码?
- token_type_ids (
torch.LongTensor
,形状为({0})
,可选) — 分段token索引,用于指示输入的第一部分和第二部分。 在[0, 1]
中选择索引:- 0 对应于 句子 A token,
- 1 对应于 句子 B token。 什么是token类型ID?
- pixel_values (
torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。 像素值可以使用 BridgeTowerImageProcessor 获取。 有关详细信息,请参见 BridgeTowerImageProcessor.call()。 - pixel_mask (
torch.LongTensor
,形状为(batch_size, height, width)
,可选) — 用于避免在padding像素值上执行注意力的掩码。 在[0, 1]
中选择的掩码值:- 1 表示像素是真实的(即,未被掩码),
- 0 表示像素是padding(即,已被掩码)。
什么是注意力掩码? <../glossary.html#attention-mask>
__
- head_mask (
torch.FloatTensor
,形状为(num_heads,)
或(num_layers, num_heads)
,可选) — 用于使自注意力模块的选定head无效的掩码。 在[0, 1]
中选择的掩码值:- 1 表示 head 未被掩码,
- 0 表示 head 已被掩码。
- 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
转换为patch嵌入,这将非常有用。 - image_token_type_idx (
int
,可选) —- 图像的token类型ID。
- output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的hidden_states
。 - interpolate_pos_encoding (
bool
,默认为False
) — 是否插值预训练的位置编码。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (
torch.LongTensor
,形状为(batch_size, 1)
,可选) — 用于计算图像-文本匹配损失的标签。0 表示配对不匹配,1 表示匹配。标签为 0 的配对将被跳过计算。
返回值
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor
的元组 (如果传递了 return_dict=False
或当 config.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=True
或当config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。attention softmax 之后的 attention 权重,用于计算 self-attention head 中的加权平均值。
BridgeTowerForImageAndTextRetrieval 的 forward 方法,覆盖了 __call__
特殊方法。
尽管 forward 传递的配方需要在该函数内定义,但应该在此之后调用 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()