对齐
概述
ALIGN模型是由Chao Jia、Yinfei Yang、Ye Xia、Yi-Ting Chen、Zarana Parekh、Hieu Pham、Quoc V. Le、Yunhsuan Sung、Zhen Li、Tom Duerig在Scaling Up Visual and Vision-Language Representation Learning With Noisy Text Supervision中提出的。ALIGN是一个多模态视觉和语言模型。它可以用于图像-文本相似度和零样本图像分类。ALIGN采用双编码器架构,其中EfficientNet作为视觉编码器,BERT作为文本编码器,并通过对比学习来对齐视觉和文本表示。与之前的工作不同,ALIGN利用了一个大规模噪声数据集,并展示了通过简单的配方,语料库的规模可以用来实现SOTA表示。
论文的摘要如下:
预训练的表示对于许多自然语言处理(NLP)和感知任务变得越来越重要。尽管NLP中的表示学习已经转向无需人工注释的原始文本训练,但视觉和视觉-语言表示仍然严重依赖于需要昂贵成本或专家知识的精心策划的训练数据集。对于视觉应用,表示主要通过使用具有明确类别标签的数据集(如ImageNet或OpenImages)来学习。对于视觉-语言,流行的数据集如Conceptual Captions、MSCOCO或CLIP都涉及复杂的数据收集(和清理)过程。这种昂贵的策划过程限制了数据集的规模,从而阻碍了训练模型的扩展。在本文中,我们利用了一个包含超过十亿个图像-文本对的数据集,这些数据是在Conceptual Captions数据集中无需昂贵过滤或后处理步骤获得的。一个简单的双编码器架构通过对比损失学习对齐图像和文本对的视觉和语言表示。我们展示了我们语料库的规模可以弥补其噪声,并导致即使在这种简单的学习方案下也能达到最先进的表示。我们的视觉表示在转移到分类任务(如ImageNet和VTAB)时表现出色。对齐的视觉和语言表示使得零样本图像分类成为可能,并且在Flickr30K和MSCOCO图像-文本检索基准测试中设定了新的最先进结果,即使与更复杂的交叉注意力模型相比也是如此。这些表示还支持使用复杂文本和文本+图像查询进行跨模态搜索。
该模型由Alara Dirik贡献。 原始代码未发布,此实现基于Kakao Brain根据原始论文的实现。
使用示例
ALIGN 使用 EfficientNet 获取视觉特征,使用 BERT 获取文本特征。然后将文本和视觉特征投影到具有相同维度的潜在空间。投影后的图像和文本特征之间的点积被用作相似度分数。
AlignProcessor 将 EfficientNetImageProcessor 和 BertTokenizer 包装成一个实例,以便同时编码文本和预处理图像。以下示例展示了如何使用 AlignProcessor 和 AlignModel 获取图像-文本相似度分数。
import requests
import torch
from PIL import Image
from transformers import AlignProcessor, AlignModel
processor = AlignProcessor.from_pretrained("kakaobrain/align-base")
model = AlignModel.from_pretrained("kakaobrain/align-base")
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
candidate_labels = ["an image of a cat", "an image of a dog"]
inputs = processor(images=image ,text=candidate_labels, return_tensors="pt")
with torch.no_grad():
outputs = model(**inputs)
# this is the image-text similarity score
logits_per_image = outputs.logits_per_image
# we can take the softmax to get the label probabilities
probs = logits_per_image.softmax(dim=1)
print(probs)
资源
一份官方的Hugging Face和社区(由🌎表示)资源列表,帮助您开始使用ALIGN。
- 一篇关于ALIGN和COYO-700M数据集的博客文章。
- 一个零样本图像分类 demo。
- Model card 的
kakaobrain/align-base
模型。
如果您有兴趣提交资源以包含在此处,请随时打开一个Pull Request,我们将对其进行审查。理想情况下,资源应展示一些新的内容,而不是重复现有的资源。
AlignConfig
类 transformers.AlignConfig
< source >( text_config = None vision_config = None projection_dim = 640 temperature_init_value = 1.0 initializer_range = 0.02 **kwargs )
参数
- text_config (
dict
, 可选) — 用于初始化 AlignTextConfig 的配置选项字典。 - vision_config (
dict
, optional) — 用于初始化 AlignVisionConfig 的配置选项字典。 - projection_dim (
int
, optional, 默认为 640) — 文本和视觉投影层的维度。 - temperature_init_value (
float
, optional, defaults to 1.0) — temperature 参数的初始值。默认值按照原始 ALIGN 实现使用。 - initializer_range (
float
, 可选, 默认值为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - kwargs (可选) — 关键字参数字典。
AlignConfig 是用于存储 AlignModel 配置的配置类。它用于根据指定的参数实例化一个 ALIGN 模型,定义文本模型和视觉模型的配置。 使用默认值实例化配置将产生与 ALIGN kakaobrain/align-base 架构类似的配置。
配置对象继承自PretrainedConfig,可用于控制模型输出。阅读PretrainedConfig的文档以获取更多信息。
示例:
>>> from transformers import AlignConfig, AlignModel
>>> # Initializing a AlignConfig with kakaobrain/align-base style configuration
>>> configuration = AlignConfig()
>>> # Initializing a AlignModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> # We can also initialize a AlignConfig from a AlignTextConfig and a AlignVisionConfig
>>> from transformers import AlignTextConfig, AlignVisionConfig
>>> # Initializing ALIGN Text and Vision configurations
>>> config_text = AlignTextConfig()
>>> config_vision = AlignVisionConfig()
>>> config = AlignConfig.from_text_vision_configs(config_text, config_vision)
from_text_vision_configs
< source >( text_config: AlignTextConfig vision_config: AlignVisionConfig **kwargs ) → AlignConfig
从对齐文本模型配置和对齐视觉模型配置实例化一个AlignConfig(或派生类)。
AlignTextConfig
类 transformers.AlignTextConfig
< source >( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 position_embedding_type = 'absolute' use_cache = True **kwargs )
参数
- vocab_size (
int
, 可选, 默认为 30522) — Align Text 模型的词汇表大小。定义了调用 AlignTextModel 时传递的inputs_ids
可以表示的不同标记的数量。 - hidden_size (
int
, 可选, 默认为 768) — 编码器层和池化层的维度。 - num_hidden_layers (
int
, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。 - num_attention_heads (
int
, optional, defaults to 12) — Transformer编码器中每个注意力层的注意力头数量。 - intermediate_size (
int
, optional, 默认为 3072) — Transformer 编码器中“中间”(通常称为前馈)层的维度。 - hidden_act (
str
或Callable
, 可选, 默认为"gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"silu"
和"gelu_new"
。 - hidden_dropout_prob (
float
, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。 - attention_probs_dropout_prob (
float
, optional, defaults to 0.1) — 注意力概率的丢弃比例。 - max_position_embeddings (
int
, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512、1024 或 2048)。 - type_vocab_size (
int
, 可选, 默认为 2) — 调用 AlignTextModel 时传递的token_type_ids
的词汇大小. - initializer_range (
float
, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float
, optional, defaults to 1e-12) — 层归一化层使用的epsilon值。 - pad_token_id (
int
, optional, defaults to 0) — 填充标记id. - position_embedding_type (
str
, optional, defaults to"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.) 中的 Method 4。 - use_cache (
bool
, 可选, 默认为True
) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。仅在config.is_decoder=True
时相关。
这是用于存储AlignTextModel配置的配置类。它用于根据指定的参数实例化一个ALIGN文本编码器,定义模型架构。使用默认值实例化配置将产生类似于ALIGN kakaobrain/align-base架构的文本编码器的配置。这里的默认值是从BERT复制的。
配置对象继承自PretrainedConfig,可用于控制模型输出。阅读PretrainedConfig的文档以获取更多信息。
示例:
>>> from transformers import AlignTextConfig, AlignTextModel
>>> # Initializing a AlignTextConfig with kakaobrain/align-base style configuration
>>> configuration = AlignTextConfig()
>>> # Initializing a AlignTextModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignTextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
AlignVisionConfig
类 transformers.AlignVisionConfig
< source >( num_channels: int = 3 image_size: int = 600 width_coefficient: float = 2.0 depth_coefficient: float = 3.1 depth_divisor: int = 8 kernel_sizes: typing.List[int] = [3, 3, 5, 3, 5, 5, 3] in_channels: typing.List[int] = [32, 16, 24, 40, 80, 112, 192] out_channels: typing.List[int] = [16, 24, 40, 80, 112, 192, 320] depthwise_padding: typing.List[int] = [] strides: typing.List[int] = [1, 2, 2, 2, 1, 2, 1] num_block_repeats: typing.List[int] = [1, 2, 2, 3, 3, 4, 1] expand_ratios: typing.List[int] = [1, 6, 6, 6, 6, 6, 6] squeeze_expansion_ratio: float = 0.25 hidden_act: str = 'swish' hidden_dim: int = 2560 pooling_type: str = 'mean' initializer_range: float = 0.02 batch_norm_eps: float = 0.001 batch_norm_momentum: float = 0.99 drop_connect_rate: float = 0.2 **kwargs )
参数
- num_channels (
int
, optional, 默认为 3) — 输入通道的数量。 - image_size (
int
, optional, 默认为 600) — 输入图像的大小。 - width_coefficient (
float
, optional, 默认为 2.0) — 每个阶段网络宽度的缩放系数。 - depth_coefficient (
float
, optional, 默认为 3.1) — 每个阶段网络深度的缩放系数。 - depth_divisor
int
, 可选, 默认为 8) — 网络宽度的单位。 - kernel_sizes (
List[int]
, 可选, 默认为[3, 3, 5, 3, 5, 5, 3]
) — 用于每个块中的内核大小列表。 - in_channels (
List[int]
, 可选, 默认为[32, 16, 24, 40, 80, 112, 192]
) — 用于每个块中卷积层的输入通道大小的列表。 - out_channels (
List[int]
, 可选, 默认为[16, 24, 40, 80, 112, 192, 320]
) — 用于每个块中卷积层的输出通道大小列表。 - depthwise_padding (
List[int]
, optional, defaults to[]
) — 具有方形填充的块索引列表。 - strides (
List[int]
, 可选, 默认为[1, 2, 2, 2, 1, 2, 1]
) — 用于每个块中卷积层的步幅大小列表。 - num_block_repeats (
List[int]
, 可选, 默认为[1, 2, 2, 3, 3, 4, 1]
) — 每个块重复次数的列表。 - expand_ratios (
List[int]
, 可选, 默认为[1, 6, 6, 6, 6, 6, 6]
) — 每个块的缩放系数列表。 - squeeze_expansion_ratio (
float
, optional, defaults to 0.25) — 挤压扩展比率. - hidden_act (
str
或function
, 可选, 默认为"silu"
) — 每个块中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
,"relu"
,"selu",
“gelu_new”,
“silu”和
“mish”`。 - hidden_dim (
int
, optional, 默认为 1280) — 分类头之前的层的隐藏维度。 - pooling_type (
str
或function
, 可选, 默认为"mean"
) — 在应用密集分类头之前要应用的最终池化类型。可用的选项是 ["mean"
,"max"
] - initializer_range (
float
, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - batch_norm_eps (
float
, optional, defaults to 1e-3) — 批归一化层使用的epsilon值。 - batch_norm_momentum (
float
, optional, defaults to 0.99) — 批量归一化层使用的动量。 - drop_connect_rate (
float
, optional, 默认为 0.2) — 跳过连接的丢弃率。
这是用于存储AlignVisionModel配置的配置类。它用于根据指定的参数实例化ALIGN视觉编码器,定义模型架构。使用默认值实例化配置将产生与ALIGN视觉编码器kakaobrain/align-base架构相似的配置。默认值是从EfficientNet(efficientnet-b7)复制的。
配置对象继承自PretrainedConfig,可用于控制模型输出。阅读PretrainedConfig的文档以获取更多信息。
示例:
>>> from transformers import AlignVisionConfig, AlignVisionModel
>>> # Initializing a AlignVisionConfig with kakaobrain/align-base style configuration
>>> configuration = AlignVisionConfig()
>>> # Initializing a AlignVisionModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignVisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
AlignProcessor
类 transformers.AlignProcessor
< source >( image_processor tokenizer )
参数
- image_processor (EfficientNetImageProcessor) — 图像处理器是一个必需的输入。
- tokenizer ([
BertTokenizer
,BertTokenizerFast
]) — tokenizer 是一个必需的输入。
构建一个ALIGN处理器,该处理器将EfficientNetImageProcessor和
BertTokenizer/BertTokenizerFast封装成一个单一的处理器,继承图像处理器和
分词器的功能。有关更多信息,请参见__call__()
和decode()。
传递kwargs的首选方式是作为每个模态的字典,请参见下面的使用示例。
from transformers import AlignProcessor
from PIL import Image
model_id = "kakaobrain/align-base"
processor = AlignProcessor.from_pretrained(model_id)
processor(
images=your_pil_image,
text=["What is that?"],
images_kwargs = {"crop_size": {"height": 224, "width": 224}},
text_kwargs = {"padding": "do_not_pad"},
common_kwargs = {"return_tensors": "pt"},
)
此方法将其所有参数转发给BertTokenizerFast的batch_decode()。请参考该方法的文档字符串以获取更多信息。
此方法将其所有参数转发给BertTokenizerFast的decode()。请参考该方法的文档字符串以获取更多信息。
对齐模型
类 transformers.AlignModel
< source >( config: AlignConfig )
参数
- config (AlignConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
该模型继承自PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。
前进
< source >( input_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None return_loss: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None )
参数
- input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) — Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
什么是输入ID? attention_mask (
torch.Tensor
形状为(batch_size, sequence_length)
, 可选): 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]
中选择:- 1 for tokens that are not masked,
- 0 for tokens that are masked.
什么是注意力掩码? position_ids (
torch.LongTensor
形状为(batch_size, sequence_length)
, 可选): 每个输入序列标记在位置嵌入中的位置索引。选择范围在[0, config.max_position_embeddings - 1]
。什么是位置ID? token_type_ids (
torch.LongTensor
形状为({0})
, 可选): 段标记索引,用于指示输入的第一部分和第二部分。索引在[0, 1]
中选择:- 0 corresponds to a sentence A token,
- 1 corresponds to a sentence B token.
什么是token type IDs? head_mask (
torch.FloatTensor
形状为(num_heads,)
或(num_layers, num_heads)
, 可选): 用于屏蔽自注意力模块中选定头部的掩码。掩码值在[0, 1]
中选择:- 1 indicates the head is not masked,
- 0 indicates the head is masked.
inputs_embeds (
torch.FloatTensor
形状为({0}, hidden_size)
, 可选): 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望对如何将input_ids
索引转换为相关向量有更多控制,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 pixel_values (torch.FloatTensor
形状为(batch_size, num_channels, height, width)
): 像素值。如果您提供了填充,默认情况下将被忽略。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 EfficientNetImageProcessor.call()。 return_loss (bool
, 可选): 是否返回对比损失。 output_attentions (bool
, 可选): 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 output_hidden_states (bool
, 可选): 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 return_dict (bool
, 可选): 是否返回 ModelOutput 而不是普通元组。
AlignModel 的前向方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
get_text_features
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → 文本特征 (torch.FloatTensor
形状为 (batch_size, output_dim
)
参数
- input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) — Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor
of shape(batch_size, sequence_length)
, optional) — Mask to avoid performing attention on padding token indices. Mask values selected in[0, 1]
:- 1 for tokens that are not masked,
- 0 for tokens that are masked.
- position_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — Indices of positions of each input sequence tokens in the position embeddings. Selected in the range[0, config.max_position_embeddings - 1]
. - token_type_ids (
torch.LongTensor
of shape({0})
, optional) — Segment token indices to indicate first and second portions of the inputs. Indices are selected in[0, 1]
:- 0 corresponds to a sentence A token,
- 1 corresponds to a sentence B token.
- head_mask (
torch.FloatTensor
形状为(num_heads,)
或(num_layers, num_heads)
, 可选) — 用于屏蔽自注意力模块中选定的头部的掩码。掩码值在[0, 1]
中选择:- 1 表示头部 未被屏蔽,
- 0 表示头部 被屏蔽.
- inputs_embeds (
torch.FloatTensor
of shape({0}, hidden_size)
, optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望对如何将input_ids
索引转换为相关向量有更多控制,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。
返回
文本特征 (torch.FloatTensor
形状为 (batch_size, output_dim
)
通过将投影层应用于AlignTextModel的池化输出获得的文本嵌入。
AlignModel 的前向方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, AlignModel
>>> model = AlignModel.from_pretrained("kakaobrain/align-base")
>>> tokenizer = AutoTokenizer.from_pretrained("kakaobrain/align-base")
>>> inputs = tokenizer(["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
< source >( pixel_values: typing.Optional[torch.FloatTensor] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → 图像特征 (torch.FloatTensor
形状为 (batch_size, output_dim
)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。默认情况下,如果您提供了填充,它将被忽略。可以使用 AutoImageProcessor获取像素值。有关详细信息,请参见EfficientNetImageProcessor.call(). - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。
返回
图像特征 (torch.FloatTensor
形状为 (batch_size, output_dim
)
通过将投影层应用于AlignVisionModel的池化输出获得的图像嵌入。
AlignModel 的前向方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AlignModel
>>> model = AlignModel.from_pretrained("kakaobrain/align-base")
>>> processor = AutoProcessor.from_pretrained("kakaobrain/align-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)
AlignTextModel
类 transformers.AlignTextModel
< source >( config: AlignTextConfig add_pooling_layer: bool = True )
参数
- config (AlignConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
来自ALIGN的文本模型,没有任何头部或顶部的投影。 该模型继承自PreTrainedModel。请查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。
前进
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) — Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it.可以使用AutoTokenizer获取索引。详情请参见PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor
of shape(batch_size, sequence_length)
, optional) — Mask to avoid performing attention on padding token indices. Mask values selected in[0, 1]
:- 1 for tokens that are not masked,
- 0 for tokens that are masked.
- position_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — Indices of positions of each input sequence tokens in the position embeddings. Selected in the range[0, config.max_position_embeddings - 1]
. - token_type_ids (
torch.LongTensor
of shape({0})
, optional) — Segment token indices to indicate first and second portions of the inputs. Indices are selected in[0, 1]
:- 0 corresponds to a sentence A token,
- 1 corresponds to a sentence B token.
- head_mask (
torch.FloatTensor
形状为(num_heads,)
或(num_layers, num_heads)
, 可选) — 用于屏蔽自注意力模块中选定的头部的掩码。掩码值在[0, 1]
中选择:- 1 表示头部 未被屏蔽,
- 0 表示头部 被屏蔽.
- inputs_embeds (
torch.FloatTensor
of shape({0}, hidden_size)
, optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望对如何将input_ids
索引转换为相关向量有更多控制权,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一个由
torch.FloatTensor
组成的元组(如果传递了 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
时返回) — 由torch.FloatTensor
组成的元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出处的隐藏状态加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
, 可选, 当传递了output_attentions=True
或当config.output_attentions=True
时返回) — 由torch.FloatTensor
组成的元组(每一层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力权重在注意力softmax之后,用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor)
, 可选, 当传递了output_attentions=True
和config.add_cross_attention=True
或当config.output_attentions=True
时返回) — 由torch.FloatTensor
组成的元组(每一层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的交叉注意力层的注意力权重,在注意力softmax之后,用于计算交叉注意力头中的加权平均值。
-
past_key_values (
tuple(tuple(torch.FloatTensor))
, 可选, 当传递了use_cache=True
或当config.use_cache=True
时返回) — 由tuple(torch.FloatTensor)
组成的元组,长度为config.n_layers
,每个元组包含2个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量,并且如果config.is_encoder_decoder=True
,则还包含2个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的额外张量。包含预先计算的隐藏状态(自注意力块中的键和值,并且如果
config.is_encoder_decoder=True
,则还包含交叉注意力块中的键和值),可用于(参见past_key_values
输入)加速顺序解码。
AlignTextModel 的 forward 方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, AlignTextModel
>>> model = AlignTextModel.from_pretrained("kakaobrain/align-base")
>>> tokenizer = AutoTokenizer.from_pretrained("kakaobrain/align-base")
>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output # pooled (EOS token) states
AlignVisionModel
class transformers.AlignVisionModel
< source >( config: AlignVisionConfig )
参数
- config (AlignConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
来自ALIGN的视觉模型,没有任何头部或顶部的投影。 该模型继承自PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、修剪头部等)。
该模型也是一个PyTorch torch.nn.Module 子类。 将其作为常规的PyTorch模块使用,并参考PyTorch文档以获取与一般使用和行为相关的所有信息。
前进
< source >( pixel_values: typing.Optional[torch.FloatTensor] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention
或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。默认情况下,如果您提供填充,它将被忽略。像素值可以使用 AutoImageProcessor获取。详情请参见EfficientNetImageProcessor.call(). - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。
返回
transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention
或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention
或一个由
torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种
元素,取决于配置(
)和输入。
-
last_hidden_state (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
) — 模型最后一层输出的隐藏状态序列。 -
pooler_output (
torch.FloatTensor
形状为(batch_size, hidden_size)
) — 在空间维度上进行池化操作后的最后一层隐藏状态。 -
hidden_states (
tuple(torch.FloatTensor)
, 可选, 当传递了output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 由torch.FloatTensor
组成的元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出)形状为(batch_size, num_channels, height, width)
。模型在每一层输出处的隐藏状态加上可选的初始嵌入输出。
AlignVisionModel 的前向方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AlignVisionModel
>>> model = AlignVisionModel.from_pretrained("kakaobrain/align-base")
>>> processor = AutoProcessor.from_pretrained("kakaobrain/align-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")
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output # pooled CLS states