GroupViT
概述
GroupViT 模型由 Jiarui Xu、Shalini De Mello、Sifei Liu、Wonmin Byeon、Thomas Breuel、Jan Kautz、Xiaolong Wang 在 GroupViT: Semantic Segmentation Emerges from Text Supervision 中提出。受 CLIP 的启发，GroupViT 是一种视觉语言模型，可以在任何给定的词汇类别上执行零样本语义分割。
论文摘要如下：
分组和识别是视觉场景理解的重要组成部分，例如，用于目标检测和语义分割。对于端到端的深度学习系统，图像区域的分组通常隐式地通过来自像素级识别标签的自顶向下监督来实现。相反，在本文中，我们建议将分组机制引入深度网络，这使得语义片段能够仅通过文本监督自动出现。我们提出了一种分层分组视觉变换器 (GroupViT)，它超越了常规网格结构表示，并学习将图像区域分组到越来越大的任意形状片段中。我们通过对比损失在大型图像文本数据集上与文本编码器联合训练 GroupViT。GroupViT 仅通过文本监督，无需任何像素级标注，即可学习将语义区域分组在一起，并以零样本方式成功转移到语义分割任务中，即无需任何进一步微调。它在 PASCAL VOC 2012 上的零样本精度为 52.3% mIoU，在 PASCAL Context 数据集上为 22.4% mIoU，并且与需要更高监督级别的最先进的迁移学习方法相比具有竞争力。
该模型由 xvjiarui 贡献。TensorFlow 版本由 ariG23498 贡献，并在 Yih-Dar SHIEH、Amy Roberts 和 Joao Gante 的帮助下完成。原始代码可以在 这里 找到。
使用技巧
- 您可以在
GroupViTModel的正向传播中指定output_segmentation=True以获取输入文本的分割 logits。
资源
以下是一些官方 Hugging Face 和社区 (用 🌎 表示) 资源，可帮助您开始使用 GroupViT。
- 开始使用 GroupViT 的最快方法是查看 示例笔记本（展示了零样本分割推理）。
- 您还可以查看 HuggingFace Spaces 演示 来体验 GroupViT。
GroupViTConfig
class transformers.GroupViTConfig
< 来源 >( text_config = None vision_config = None projection_dim = 256 projection_intermediate_dim = 4096 logit_scale_init_value = 2.6592 **kwargs )
参数
- text_config (
dict, 可选) — 用于初始化 GroupViTTextConfig 的配置选项字典。 - vision_config (
dict, 可选) — 用于初始化 GroupViTVisionConfig 的配置选项字典。 - projection_dim (
int, 可选, 默认值为 256) — 文本和视觉投影层的维度。 - projection_intermediate_dim (
int, 可选, 默认值为 4096) — 文本和视觉投影层中间层的维度。 - logit_scale_init_value (
float, 可选, 默认值为 2.6592) — logit_scale 参数的初始值。默认值与原始 GroupViT 实现一致。 - kwargs (可选) — 关键字参数字典。
GroupViTConfig 是用于存储 GroupViTModel 配置的配置类。它用于根据指定的参数实例化 GroupViT 模型，定义文本模型和视觉模型配置。使用默认值实例化配置将生成类似于 GroupViT nvidia/groupvit-gcc-yfcc 架构的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
from_text_vision_configs
< 源代码 >( text_config: GroupViTTextConfig vision_config: GroupViTVisionConfig **kwargs ) → GroupViTConfig
从 groupvit 文本模型配置和 groupvit 视觉模型配置实例化 GroupViTConfig（或派生类）。
GroupViTTextConfig
类 transformers.GroupViTTextConfig
< 源代码 >( vocab_size = 49408 hidden_size = 256 intermediate_size = 1024 num_hidden_layers = 12 num_attention_heads = 4 max_position_embeddings = 77 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 dropout = 0.0 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 pad_token_id = 1 bos_token_id = 49406 eos_token_id = 49407 **kwargs )
参数
- vocab_size (
int, 可选, 默认值为 49408) — GroupViT 文本模型的词汇量大小。定义调用 GroupViTModel 时通过的inputs_ids可以表示的不同令牌数量。 - hidden_size (
int, 可选, 默认值为 256) — 编码器层和池化层的维度。 - intermediate_size (
int, 可选, 默认值为 1024) — Transformer 编码器中“中间”（即前馈）层的维度。 - num_hidden_layers (
int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数。 - num_attention_heads (
int, 可选, 默认为 4) — Transformer 编码器中每个注意力层的注意力头数。 - max_position_embeddings (
int, 可选, 默认为 77) — 该模型可能使用的最大序列长度。 通常将其设置为一个较大的值以防万一（例如，512 或 1024 或 2048）。 - hidden_act (
str或function, 可选, 默认为"quick_gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。 如果是字符串，则支持"gelu"、"relu"、"selu"和"gelu_new""quick_gelu"。 - layer_norm_eps (
float, 可选, 默认为 1e-5) — 层归一化层使用的 epsilon。 - attention_dropout (
float, 可选, 默认为 0.0) — 注意力概率的 dropout 比例。 - dropout (
float, 可选, 默认为 0.0) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。 - initializer_factor (
float, 可选, 默认为 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1，在内部用于初始化测试）。
这是用于存储 GroupViTTextModel 配置的配置类。 它用于根据指定的参数实例化 GroupViT 模型，定义模型架构。 使用默认值实例化配置将生成类似于 GroupViT nvidia/groupvit-gcc-yfcc 架构的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import GroupViTTextConfig, GroupViTTextModel
>>> # Initializing a GroupViTTextModel with nvidia/groupvit-gcc-yfcc style configuration
>>> configuration = GroupViTTextConfig()
>>> model = GroupViTTextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configGroupViTVisionConfig
这是一个配置类，用于存储GroupViTVisionModel的配置。它用于根据指定参数实例化GroupViT模型，定义模型架构。使用默认值实例化配置将产生与GroupViT nvidia/groupvit-gcc-yfcc 架构类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import GroupViTVisionConfig, GroupViTVisionModel
>>> # Initializing a GroupViTVisionModel with nvidia/groupvit-gcc-yfcc style configuration
>>> configuration = GroupViTVisionConfig()
>>> model = GroupViTVisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configGroupViTModel
class transformers.GroupViTModel
< 源代码 >( config: GroupViTConfig )
参数
- config (GroupViTConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看from_pretrained()方法加载模型权重。
此模型是一个 PyTorch torch.nn.Module 子类。将其用作普通的 PyTorch 模块，并参考 PyTorch 文档了解与一般使用和行为相关的所有事宜。
正向传播
< 源代码 >( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None position_ids: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None output_segmentation: Optional = None return_dict: Optional = None ) → transformers.models.groupvit.modeling_groupvit.GroupViTModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充，默认情况下将忽略填充。可以使用 CLIPTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length)，可选) — 掩码，用于避免对填充标记索引执行注意力。在[0, 1]中选择掩码值：- 1 代表未掩码的标记，
- 0 代表掩码的标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记位置的索引。在[0, config.max_position_embeddings - 1]范围内选择。 - pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 CLIPImageProcessor.call()。 - return_loss (
bool，可选) — 是否返回对比损失。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
返回值
transformers.models.groupvit.modeling_groupvit.GroupViTModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.groupvit.modeling_groupvit.GroupViTModelOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置 (<class 'transformers.models.groupvit.configuration_groupvit.GroupViTConfig'>) 和输入而变化的各种元素。
-
loss (
torch.FloatTensor形状为(1,)，可选，当return_loss为True时返回) — 用于图像-文本相似度的对比损失。 -
logits_per_image (
torch.FloatTensor形状为(image_batch_size, text_batch_size)) —image_embeds和text_embeds之间的缩放点积分数。这表示图像-文本相似度分数。 -
logits_per_text (
torch.FloatTensor形状为(text_batch_size, image_batch_size)) —text_embeds和image_embeds之间的缩放点积分数。这表示文本-图像相似度分数。 -
segmentation_logits (
torch.FloatTensor形状为(batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类分数。返回的 logits 的大小不一定与作为输入传递的
pixel_values相同。这是为了避免进行两次插值，并在用户需要将 logits 调整为原始图像大小作为后处理时损失一些质量。您应该始终检查 logits 形状并根据需要调整大小。 -
text_embeds (
torch.FloatTensor形状为(batch_size, output_dim) — 通过将投影层应用于 GroupViTTextModel 的池化输出而获得的文本嵌入。 -
image_embeds (
torch.FloatTensor形状为(batch_size, output_dim) — 通过将投影层应用于 GroupViTVisionModel 的池化输出而获得的图像嵌入。 -
text_model_output (
BaseModelOutputWithPooling) — GroupViTTextModel 的输出。 -
vision_model_output (
BaseModelOutputWithPooling) — GroupViTVisionModel 的输出。
GroupViTModel 正向方法覆盖了 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是它，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, GroupViTModel
>>> model = GroupViTModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> processor = AutoProcessor.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(
... text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="pt", padding=True
... )
>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image # this is the image-text similarity score
>>> probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilitiesget_text_features
< source >( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → text_features (torch.FloatTensor 形状为 (batch_size, output_dim)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 输入序列词元的词汇表索引。如果您提供填充，默认情况下将忽略填充。索引可以使用 CLIPTokenizer 获取。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 掩码以避免对填充词元索引执行注意力。在[0, 1]中选择的掩码值：- 1 表示未被掩码的词元，
- 0 表示被掩码的词元。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列词元位置的索引。在[0, config.max_position_embeddings - 1]范围内选择。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
text_features (torch.FloatTensor 形状为 (batch_size, output_dim)
通过将投影层应用于 GroupViTTextModel 的池化输出获得的文本嵌入。
GroupViTModel 正向方法覆盖了 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是它，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import CLIPTokenizer, GroupViTModel
>>> model = GroupViTModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> tokenizer = CLIPTokenizer.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> 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: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → image_features (torch.FloatTensor 形状为 (batch_size, output_dim)
参数
- pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下，如果您提供填充，它将被忽略。可以使用 AutoImageProcessor 获取像素值。详情请见 CLIPImageProcessor.call()。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。更多详情请见返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。更多详情请见返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
image_features (torch.FloatTensor 形状为 (batch_size, output_dim)
通过将投影层应用于 GroupViTVisionModel 的池化输出获得的图像嵌入。
GroupViTModel 正向方法覆盖了 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是它，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, GroupViTModel
>>> model = GroupViTModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> processor = AutoProcessor.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> 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)GroupViTTextModel
正向传播
< 源代码 >( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。默认情况下，如果您提供填充，它将被忽略。可以使用 CLIPTokenizer 获取索引。更多详情请见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 掩码以避免对填充标记索引执行注意力。在[0, 1]中选择掩码值：- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length)，可选) — 输入序列中每个 token 在位置嵌入中的位置索引。在范围内选择[0, config.max_position_embeddings - 1]。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参见返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参见返回张量中的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个简单的元组。
返回值
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），包含根据配置 (<class 'transformers.models.groupvit.configuration_groupvit.GroupViTTextConfig'>) 和输入的不同元素。
-
last_hidden_state (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
pooler_output (
torch.FloatTensor形状为(batch_size, hidden_size)) — 序列第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层的进一步处理。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类 token。线性层权重在预训练期间从下一句预测（分类）目标中训练得到。 -
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 后的注意力权重，用于计算自注意力头中的加权平均值。
The GroupViTTextModel 正向方法，覆盖 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是它，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import CLIPTokenizer, GroupViTTextModel
>>> tokenizer = CLIPTokenizer.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> model = GroupViTTextModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> 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) statesGroupViTVisionModel
正向传播
< source >( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。如果您提供填充，则默认情况下会忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参见 CLIPImageProcessor.call()。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False），包括根据配置（<class 'transformers.models.groupvit.configuration_groupvit.GroupViTVisionConfig'>）和输入的不同元素。
-
last_hidden_state (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
pooler_output (
torch.FloatTensor形状为(batch_size, hidden_size)) — 序列第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层的进一步处理。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类 token。线性层权重在预训练期间从下一句预测（分类）目标中训练得到。 -
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 后的注意力权重，用于计算自注意力头中的加权平均值。
该 GroupViTVisionModel 前向方法覆盖了 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是它，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, GroupViTVisionModel
>>> processor = AutoProcessor.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> model = GroupViTVisionModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> 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 statesTFGroupViTModel
class transformers.TFGroupViTModel
< 源代码 >( config: GroupViTConfig *inputs **kwargs )
参数
- config (GroupViTConfig) — 模型配置类，包含模型的所有参数。用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法来加载模型权重。
此模型继承自 TFPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头等）。
此模型也是一个 keras.Model 子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解有关一般用法和行为的所有事项。
TF 2.0 模型接受两种格式的输入
- 将所有输入作为关键字参数（类似于 PyTorch 模型），或者
- 将所有输入作为第一个位置参数中的列表、元组或字典。
第二个选项在使用 keras.Model.fit 方法时很有用，该方法目前需要在模型调用函数的第一个参数中包含所有张量：model(inputs)。
如果您选择第二个选项，您可以使用三种可能性来收集第一个位置参数中的所有输入张量
- 一个包含
input_ids的单个张量，其他什么都没有：model(input_ids) - 一个长度可变的列表，其中包含一个或多个输入张量，按照文档字符串中给出的顺序排列：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
call
< 源代码 >( input_ids: TFModelInputType | None = None pixel_values: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None return_loss: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None output_segmentation: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → transformers.models.groupvit.modeling_tf_groupvit.TFGroupViTModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
np.ndarray,tf.Tensor,List[tf.Tensor]`Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例必须具有形状(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- pixel_values (
np.ndarray,tf.Tensor,List[tf.Tensor]Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例必须具有形状(batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参见 CLIPImageProcessor.call()。 - attention_mask (形状为
(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选) — 用于避免对填充标记索引执行注意的掩码。在[0, 1]中选择的掩码值：- 1 表示未掩码的标记，
- 0 表示掩码的标记。
- position_ids (形状为
(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - return_loss (
bool，可选) — 是否返回对比损失。 - output_attentions (
bool，可选) — 是否返回所有注意层的注意张量。有关详细信息，请参见返回张量下的attentions。此参数只能在急切模式下使用，在图形模式下，将使用配置文件中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参见返回张量下的hidden_states。此参数只能在急切模式下使用，在图形模式下，将使用配置文件中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图形模式下，该值始终设置为 True。 - training (
bool，可选，默认值为False“) — 是否以训练模式使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为。
返回值
transformers.models.groupvit.modeling_tf_groupvit.TFGroupViTModelOutput 或 tuple(tf.Tensor)
一个 transformers.models.groupvit.modeling_tf_groupvit.TFGroupViTModelOutput 或 tf.Tensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False 时），包括根据配置（<class 'transformers.models.groupvit.configuration_groupvit.GroupViTConfig'>）和输入而变化的各种元素。
-
loss (形状为
(1,)的tf.Tensor，可选，在return_loss为True时返回) — 用于图像-文本相似度的对比损失。 -
logits_per_image (形状为
(image_batch_size, text_batch_size)的tf.Tensor) —image_embeds和text_embeds之间的比例点积分数。这表示图像-文本相似度分数。 -
logits_per_text (形状为
(text_batch_size, image_batch_size)的tf.Tensor) —text_embeds和image_embeds之间的比例点积分数。这表示文本-图像相似度分数。 -
segmentation_logits (形状为
(batch_size, config.num_labels, logits_height, logits_width)的tf.Tensor) — 每个像素的分类分数。返回的 logits 的大小不一定与作为输入传递的
pixel_values相同。这是为了避免进行两次插值，并在用户需要将 logits 调整为原始图像大小作为后处理时损失一些质量。您应该始终检查 logits 形状并根据需要调整大小。 -
text_embeds (形状为
(batch_size, output_dim) 的tf.Tensor) — 通过将投影层应用于 TFGroupViTTextModel 的合并输出而获得的文本嵌入。 -
image_embeds (形状为
(batch_size, output_dim) 的tf.Tensor) — 通过将投影层应用于 TFGroupViTVisionModel 的合并输出而获得的图像嵌入。 -
text_model_output (
TFBaseModelOutputWithPooling) — TFGroupViTTextModel 的输出。 -
vision_model_output (
TFBaseModelOutputWithPooling) — TFGroupViTVisionModel 的输出。
TFGroupViTModel 正向方法，覆盖
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是它，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFGroupViTModel
>>> import tensorflow as tf
>>> model = TFGroupViTModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> processor = AutoProcessor.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(
... text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="tf", padding=True
... )
>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image # this is the image-text similarity score
>>> probs = tf.math.softmax(logits_per_image, axis=1) # we can take the softmax to get the label probabilitiesget_text_features
< 源代码 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → text_features (tf.Tensor 形状为 (batch_size, output_dim)
参数
- input_ids (
np.ndarray,tf.Tensor,List[tf.Tensor]`Dict[str, tf.Tensor]或Dict[str, np.ndarray]并且每个样本必须具有形状(batch_size, sequence_length)) — 输入序列词元在词汇表中的索引。索引可以通过 AutoTokenizer 获取。详细信息请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor形状为(batch_size, sequence_length), 可选) — 用于避免对填充词元索引进行注意力的掩码。掩码值在[0, 1]中选择：- 1 代表 **未掩码** 的词元，
- 0 代表 **掩码** 的词元。
- position_ids (
np.ndarray或tf.Tensor形状为(batch_size, sequence_length), 可选) — 输入序列词元在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参见返回张量中的attentions。此参数仅可在 Eager 模式下使用，在 Graph 模式下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参见返回张量中的hidden_states。此参数仅可在 Eager 模式下使用，在 Graph 模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在 Eager 模式下使用，在 Graph 模式下该值始终设置为 True。 - training (
bool, 可选, 默认值为 `False“) — 是否以训练模式使用模型（某些模块如 dropout 模块在训练和评估之间具有不同的行为）。
返回值
text_features (tf.Tensor 形状为 (batch_size, output_dim)
通过将投影层应用于 TFGroupViTTextModel 的池化输出而获得的文本嵌入。
TFGroupViTModel 正向方法，覆盖
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是它，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import CLIPTokenizer, TFGroupViTModel
>>> model = TFGroupViTModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> tokenizer = CLIPTokenizer.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="tf")
>>> text_features = model.get_text_features(**inputs)get_image_features
< 源代码 >( pixel_values: TFModelInputType | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → image_features (tf.Tensor 形状为 (batch_size, output_dim)
参数
- pixel_values (
np.ndarray,tf.Tensor,List[tf.Tensor],Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例必须具有形状(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 CLIPImageProcessor.call()。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。此参数只能在急切模式下使用，在图模式下，将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量中的hidden_states。此参数只能在急切模式下使用，在图模式下，将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式下，该值将始终设置为 True。 - training (
bool, 可选，默认值为 `False“) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
返回值
image_features (tf.Tensor 形状为 (batch_size, output_dim)
通过将投影层应用于 TFGroupViTVisionModel 的池化输出获得的图像嵌入。
TFGroupViTModel 正向方法，覆盖
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是它，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFGroupViTModel
>>> model = TFGroupViTModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> processor = AutoProcessor.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, return_tensors="tf")
>>> image_features = model.get_image_features(**inputs)TFGroupViTTextModel
call
< 源代码 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
参数
- input_ids (
np.ndarray,tf.Tensor,List[tf.Tensor]`Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例必须具有形状(batch_size, sequence_length)) — 输入序列标记在词典中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 掩码，用于避免对填充标记索引执行注意力。掩码值选择在[0, 1]中：- 1 表示未掩码的标记。
- 0 表示已掩码的标记。
- position_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择在[0, config.max_position_embeddings - 1]范围内。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参见返回张量中的attentions。此参数仅可在急切模式下使用，在图模式下，将使用配置中的值代替。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参见返回张量中的hidden_states。此参数仅可在急切模式下使用，在图模式下，将使用配置中的值代替。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下，该值将始终设置为 True。 - training (
bool，可选，默认值为 `False“) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
返回值
transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个 tf.Tensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），包含根据配置 (<class 'transformers.models.groupvit.configuration_groupvit.GroupViTTextConfig'>) 和输入而不同的各种元素。
-
last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出处的隐藏状态序列。 -
pooler_output (
tf.Tensor，形状为(batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，经过线性层和 Tanh 激活函数的进一步处理。线性层权重在预训练期间从下一个句子预测（分类）目标中训练得到。此输出通常不是输入语义内容的良好摘要，你通常可以对整个输入序列的隐藏状态序列进行平均或池化操作。
-
hidden_states (
tuple(tf.Tensor)，可选，在传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（一个用于嵌入输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor)，可选，在传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
TFGroupViTTextModel 正向方法覆盖了 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是它，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import CLIPTokenizer, TFGroupViTTextModel
>>> tokenizer = CLIPTokenizer.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> model = TFGroupViTTextModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="tf")
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output # pooled (EOS token) statesTFGroupViTVisionModel
class transformers.TFGroupViTVisionModel
< 源代码 >( config: GroupViTVisionConfig *inputs
call
< 源代码 >( pixel_values: TFModelInputType | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
参数
- pixel_values (
np.ndarray,tf.Tensor,List[tf.Tensor],Dict[str, tf.Tensor]或Dict[str, np.ndarray]并且每个示例必须具有形状(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参见 CLIPImageProcessor.call()。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数只能在急切模式下使用，在图模式下，将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数只能在急切模式下使用，在图模式下，将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是一个简单的元组。此参数可以在急切模式下使用，在图模式下，值始终设置为 True。 - training (
bool, 可选，默认值为 `False“) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
返回值
transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含取决于配置 (<class 'transformers.models.groupvit.configuration_groupvit.GroupViTVisionConfig'>) 和输入的各种元素。
-
last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出处的隐藏状态序列。 -
pooler_output (
tf.Tensor，形状为(batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，经过线性层和 Tanh 激活函数的进一步处理。线性层权重在预训练期间从下一个句子预测（分类）目标中训练得到。此输出通常不是输入语义内容的良好摘要，你通常可以对整个输入序列的隐藏状态序列进行平均或池化操作。
-
hidden_states (
tuple(tf.Tensor)，可选，在传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（一个用于嵌入输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor)，可选，在传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
TFGroupViTVisionModel 正向方法，覆盖了 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是它，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFGroupViTVisionModel
>>> processor = AutoProcessor.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> model = TFGroupViTVisionModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output # pooled CLS states