Transformers 文档
GroupViT
并获得增强的文档体验
开始使用
GroupViT
概述
GroupViT 模型在 GroupViT: Semantic Segmentation Emerges from Text Supervision 中提出，作者为 Jiarui Xu, Shalini De Mello, Sifei Liu, Wonmin Byeon, Thomas Breuel, Jan Kautz, Xiaolong Wang。受 CLIP 的启发，GroupViT 是一种视觉-语言模型，可以对任何给定的词汇类别执行零样本语义分割。
论文摘要如下：
分组和识别是视觉场景理解的重要组成部分，例如，用于物体检测和语义分割。使用端到端深度学习系统，图像区域的分组通常通过来自像素级识别标签的自上而下的监督隐式发生。相反，在本文中，我们建议将分组机制带回深度网络，这使得语义分割可以在仅文本监督的情况下自动出现。我们提出了一个分层分组视觉 Transformer (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
< source >( 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
< source >( text_config: GroupViTTextConfig vision_config: GroupViTVisionConfig **kwargs ) → GroupViTConfig
从 groupvit 文本模型配置和 groupvit 视觉模型配置实例化 GroupViTConfig（或派生类）。
GroupViTTextConfig
class transformers.GroupViTTextConfig
< source >( 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, optional, defaults to 49408) — GroupViT 文本模型的词汇表大小。 定义了在调用 GroupViTModel 时传递的inputs_ids可以表示的不同 tokens 的数量。 - hidden_size (
int, optional, defaults to 256) — 编码器层和池化器层的维度。 - intermediate_size (
int, optional, defaults to 1024) — Transformer 编码器中“中间”层（即，前馈层）的维度。 - num_hidden_layers (
int, optional, defaults to 12) — Transformer 编码器中隐藏层的数量。 - num_attention_heads (
int, optional, defaults to 4) — Transformer 编码器中每个注意力层的注意力头的数量。 - max_position_embeddings (
int, optional, defaults to 77) — 此模型可能使用的最大序列长度。 通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。 - hidden_act (
strorfunction, optional, defaults to"quick_gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。 如果是字符串，则支持"gelu","relu","selu"和"gelu_new""quick_gelu"。 - layer_norm_eps (
float, optional, defaults to 1e-5) — 层归一化层使用的 epsilon 值。 - attention_dropout (
float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。 - dropout (
float, optional, defaults to 0.0) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。 - initializer_range (
float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - initializer_factor (
float, optional, defaults to 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
class transformers.GroupViTVisionConfig
< source >( hidden_size = 384 intermediate_size = 1536 depths = [6, 3, 3] num_hidden_layers = 12 num_group_tokens = [64, 8, 0] num_output_groups = [64, 8, 8] num_attention_heads = 6 image_size = 224 patch_size = 16 num_channels = 3 hidden_act = 'gelu' layer_norm_eps = 1e-05 dropout = 0.0 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 assign_eps = 1.0 assign_mlp_ratio = [0.5, 4] **kwargs )
参数
- hidden_size (
int, optional, defaults to 384) — 编码器层和池化器层的维度。 - intermediate_size (
int, optional, defaults to 1536) — Transformer 编码器中“中间”层（即，前馈层）的维度。 - depths (
List[int], optional, defaults to [6, 3, 3]) — 每个编码器块中的层数。 - num_group_tokens (
List[int], optional, defaults to [64, 8, 0]) — 每个阶段的分组 tokens 的数量。 - num_output_groups (
List[int], optional, defaults to [64, 8, 8]) — 每个阶段的输出组数，0 表示无组。 - num_attention_heads (
int, optional, defaults to 6) — Transformer 编码器中每个注意力层的注意力头的数量。 - image_size (
int, optional, defaults to 224) — 每张图片的大小（分辨率）。 - patch_size (
int, optional, defaults to 16) — 每个 patch 的大小（分辨率）。 - hidden_act (
strorfunction, optional, defaults to"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。 如果是字符串，则支持"gelu","relu","selu"和"gelu_new""quick_gelu"。 - layer_norm_eps (
float, optional, defaults to 1e-5) — 层归一化层使用的 epsilon 值。 - dropout (
float, optional, defaults to 0.0) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。 - attention_dropout (
float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。 - initializer_range (
float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的truncated_normal_initializer的标准差。 - initializer_factor (
float, optional, defaults to 1.0) — 用于初始化所有权重矩阵的因子 (应保持为 1，内部用于初始化测试)。
这是用于存储 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
< source >( config: GroupViTConfig )
参数
- config (GroupViTConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
此模型是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None return_loss: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None output_segmentation: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.groupvit.modeling_groupvit.GroupViTModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 默认情况下，如果您提供 padding，则会被忽略。可以使用 CLIPTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — Mask，用于避免在 padding token 索引上执行 attention。 Mask 值在[0, 1]中选择：- 1 表示 未被 mask 的 tokens，
- 0 表示 已被 mask 的 tokens。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。 在范围[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，可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参见返回的张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回的张量下的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 的 pooled output 获得的文本嵌入。 -
image_embeds (
torch.FloatTensor，形状为(batch_size, output_dim) — 通过将投影层应用于 GroupViTVisionModel 的 pooled output 获得的图像嵌入。 -
text_model_output (
BaseModelOutputWithPooling) — GroupViTTextModel 的输出。 -
vision_model_output (
BaseModelOutputWithPooling) — GroupViTVisionModel 的输出。
GroupViTModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应调用 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: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → text_features (torch.FloatTensor，形状为 (batch_size, output_dim)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 默认情况下，如果您提供 padding，则会被忽略。可以使用 CLIPTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — Mask，用于避免在 padding token 索引上执行 attention。 Mask 值在[0, 1]中选择：- 1 表示 未被 mask 的 tokens，
- 0 表示 已被 mask 的 tokens。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参见返回的张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回的张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
text_features (torch.FloatTensor，形状为 (batch_size, output_dim)
通过将投影层应用于 GroupViTTextModel 的 pooled output 获得的文本嵌入。
GroupViTModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应调用 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: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → image_features (torch.FloatTensor of shape (batch_size, output_dim)
参数
- pixel_values (
torch.FloatTensorof shape(batch_size, num_channels, height, width)) — 像素值。如果您提供填充，默认情况下将忽略填充。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 CLIPImageProcessor.call()。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通元组。
返回值
image_features (torch.FloatTensor of shape (batch_size, output_dim)
通过将投影层应用于 GroupViTVisionModel 的池化输出而获得的图像嵌入。
GroupViTModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应调用 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
forward
< 源代码 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: 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.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensorof shape(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供填充，默认情况下将忽略填充。索引可以使用 CLIPTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensorof shape(batch_size, sequence_length), optional) — 用于避免对填充 token 索引执行注意力的掩码。 掩码值在[0, 1]中选择：- 1 表示 **未被掩盖** 的 tokens，
- 0 表示 **被掩盖** 的 tokens。
- position_ids (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 每个输入序列 tokens 在位置嵌入中的位置索引。 在[0, config.max_position_embeddings - 1]范围内选择。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 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.FloatTensorof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 -
pooler_output (
torch.FloatTensorof shape(batch_size, hidden_size)) — 序列的第一个 token（分类 token）的最后一层隐藏状态，在通过用于辅助预训练任务的层进一步处理之后。 例如，对于 BERT 系列模型，这会返回通过线性层和 tanh 激活函数处理后的分类 token。 线性层权重通过预训练期间的下一句预测（分类）目标进行训练。 -
hidden_states (
tuple(torch.FloatTensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —torch.FloatTensor的元组（如果模型有嵌入层，则为一个用于嵌入的输出；+ 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
GroupViTTextModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应调用 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
forward
< 源代码 >( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensorof shape(batch_size, num_channels, height, width)) — 像素值。如果您提供填充，默认情况下将忽略填充。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 CLIPImageProcessor.call()。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 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.FloatTensorof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 -
pooler_output (
torch.FloatTensorof shape(batch_size, hidden_size)) — 序列的第一个 token（分类 token）的最后一层隐藏状态，在通过用于辅助预训练任务的层进一步处理之后。 例如，对于 BERT 系列模型，这会返回通过线性层和 tanh 激活函数处理后的分类 token。 线性层权重通过预训练期间的下一句预测（分类）目标进行训练。 -
hidden_states (
tuple(torch.FloatTensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —torch.FloatTensor的元组（如果模型有嵌入层，则为一个用于嵌入的输出；+ 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
GroupViTVisionModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应调用 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})
调用
< source >( 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)) — 词汇表中输入序列 tokens 的索引。可以使用 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, 可选) — 掩码，用于避免在 padding token 索引上执行 attention。 Mask 值在[0, 1]中选择：- 1 代表 未被掩码 的 tokens，
- 0 代表 被掩码 的 tokens。
- position_ids (形状为
(batch_size, sequence_length)的np.ndarray或tf.Tensor, 可选) — 位置 embeddings 中每个输入序列 tokens 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - return_loss (
bool, 可选) — 是否返回对比损失。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回的 tensors 下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。 - training (
bool, 可选, 默认为 `False`) — 是否在训练模式下使用模型（某些模块（如 dropout 模块）在训练和评估之间具有不同的行为）。
返回值
transformers.models.groupvit.modeling_tf_groupvit.TFGroupViTModelOutput 或 tuple(tf.Tensor)
一个 transformers.models.groupvit.modeling_tf_groupvit.TFGroupViTModelOutput 或一个 tf.Tensor 的 tuple (如果传递 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 的 pooled 输出而获得的文本 embeddings。 -
image_embeds (形状为
(batch_size, output_dim) 的tf.Tensor) — 通过将投影层应用于 TFGroupViTVisionModel 的 pooled 输出而获得的图像 embeddings。 -
text_model_output (
TFBaseModelOutputWithPooling) — TFGroupViTTextModel 的输出。 -
vision_model_output (
TFBaseModelOutputWithPooling) — TFGroupViTVisionModel 的输出。
TFGroupViTModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应调用 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
< source >( 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 (形状为 (batch_size, output_dim) 的 tf.Tensor)
参数
- input_ids (
np.ndarray,tf.Tensor,List[tf.Tensor]`Dict[str, tf.Tensor]或Dict[str, np.ndarray]，并且每个示例必须具有形状(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (形状为
(batch_size, sequence_length)的np.ndarray或tf.Tensor, 可选) — 掩码，用于避免在 padding token 索引上执行 attention。 Mask 值在[0, 1]中选择：- 1 代表 未被掩码 的 tokens，
- 0 代表 被掩码 的 tokens。
- position_ids (形状为
(batch_size, sequence_length)的np.ndarray或tf.Tensor, 可选) — 位置 embeddings 中每个输入序列 tokens 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回的 tensors 下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。 - training (
bool, 可选, 默认为 `False`) — 是否在训练模式下使用模型（某些模块（如 dropout 模块）在训练和评估之间具有不同的行为）。
返回值
text_features (形状为 (batch_size, output_dim) 的 tf.Tensor)
通过将投影层应用于 TFGroupViTTextModel 的 pooled 输出而获得的文本 embeddings。
TFGroupViTModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应调用 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
< source >( 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 (形状为 (batch_size, output_dim) 的 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, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回的 tensors 下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。 - training (
bool, optional, defaults to `False“) — 是否在训练模式下使用模型（dropout 模块等某些模块在训练和评估之间具有不同的行为）。
返回值
image_features (tf.Tensor，形状为 (batch_size, output_dim)
通过将投影层应用于 TFGroupViTVisionModel 的池化输出来获得的图像嵌入。
TFGroupViTModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应调用 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
调用
< source >( 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 or 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), 可选) — 用于避免在 padding 标记索引上执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
- position_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参见返回张量下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 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__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应调用 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
< source >( config: GroupViTVisionConfig *inputs **kwargs )
调用
< source >( 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 or 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, 可选) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参见返回张量下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 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__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应调用 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