Transformers 4.37 中文文档（八十七）

原文：huggingface.co/docs/transformers

GroupViT

原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/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 是一种可以对任何给定词汇类别执行零调校语义分割的视觉语言模型。

论文摘要如下：

分组和识别是视觉场景理解的重要组成部分，例如目标检测和语义分割。在端到端深度学习系统中，图像区域的分组通常是通过来自像素级别识别标签的自上而下监督隐式发生的。相反，在本文中，我们提出将分组机制重新引入深度网络中，这允许语义段仅通过文本监督自动出现。我们提出了一种分层分组视觉 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

<来源>

( 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 ) → export const metadata = 'undefined';GroupViTConfig

返回

GroupViTConfig

配置对象的一个实例

从 groupvit 文本模型配置和 groupvit 视觉模型配置实例化一个 GroupViTConfig（或派生类）。

GroupViTTextConfig

class 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, optional, defaults to 49408) — GroupViT 文本模型的词汇量。定义了在调用 GroupViTModel 时可以表示的不同标记数量。
• 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 (str或function, 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) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• 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.config

GroupViTVisionConfig

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]) — 每个阶段的组令牌数。
• 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) — 每个补丁的大小（分辨率）。
• hidden_act (str or function, 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) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• 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.config

PytorchHide Pytorch content

GroupViTModel

class transformers.GroupViTModel

< source >

( config: GroupViTConfig )

参数

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

该模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( 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 ) → export const metadata = 'undefined';transformers.models.groupvit.modeling_groupvit.GroupViTModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。 可以使用 CLIPTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：
  • 1 代表未被掩盖的标记，
  • 0 代表被掩盖的标记。

  什么是注意力掩码？

• position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参见 CLIPImageProcessor.call()。
• return_loss (bool，optional) — 是否返回对比损失。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。
• return_dict (bool，optional) — 是否返回 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,)，optional，当return_loss为True时返回） — 图像-文本相似性的对比损失。
• logits_per_image (torch.FloatTensor，形状为(image_batch_size, text_batch_size)) — image_embeds和text_embeds之间的缩放点积分数。这代表图像-文本相似性分数。
• logits_per_text (torch.FloatTensor of shape (text_batch_size, image_batch_size)) — text_embeds 和 image_embeds 之间的缩放点积分数。这代表文本-图像相似性分数。
• segmentation_logits (torch.FloatTensor of shape (batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类分数。 返回的对数不一定与传入的 pixel_values 具有相同的大小。这是为了避免进行两次插值并在用户需要将对数调整为原始图像大小时丢失一些质量。您应该始终检查您的对数形状并根据需要调整大小。
• text_embeds (torch.FloatTensor of shape (batch_size, output_dim) — 通过将 GroupViTTextModel 的池化输出应用到投影层获得的文本嵌入。
• image_embeds (torch.FloatTensor of shape (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 probabilities

get_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 ) → export const metadata = 'undefined';text_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。 可以使用 CLIPTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1] 之间：
  • 1 代表未被掩盖的标记，
  • 0 代表被掩盖的标记。

  什么是注意力掩码？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。 什么是位置 ID？
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
• return_dict (bool, optional) — 是否返回一个 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

<来源>

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';image_features (torch.FloatTensor of shape (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

class transformers.GroupViTTextModel

<来源>

( config: GroupViTTextConfig )

forward

<来源>

( 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 ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。 可以使用 CLIPTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：
  • 对于未被masked的标记，值为 1。
  • 对于被masked的标记，值为 0。

  什么是注意力掩码？

• position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• 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.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。
• pooler_output (torch.FloatTensor，形状为(batch_size, hidden_size)) — 经过用于辅助预训练任务的层进一步处理后，序列中第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
• hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。 模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在自注意力头中用于计算加权平均值的注意力 softmax 后的注意力权重。

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) states

GroupViTVisionModel

class transformers.GroupViTVisionModel

<来源>

( config: GroupViTVisionConfig )

forward

<来源>

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。默认情况下会忽略填充。可以使用 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（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列。
• pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）- 序列的第一个标记（分类标记）的最后一层隐藏状态，在通过用于辅助预训练任务的层进一步处理后。例如，对于 BERT 系列模型，这将返回通过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是从下一个句子预测（分类）目标在预训练期间训练的。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个+每一层输出的一个）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力权重在注意力 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 states

TensorFlowHide TensorFlow 内容

TFGroupViTModel

class transformers.TFGroupViTModel

<来源>

( config: GroupViTConfig *inputs **kwargs )

参数

• config（GroupViTConfig](/docs/transformers/v4.37.2/en/main_classes/model#transformers.PreTrainedModel.from_pretrained)方法以加载模型权重。

此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

TF 2.0 模型接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或
• 将所有输入作为列表、元组或字典放在第一个位置参数中。

这第二个选项在使用tf.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 ) → export const metadata = 'undefined';transformers.models.groupvit.modeling_tf_groupvit.TFGroupViTModelOutput 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()。 什么是输入 ID？
• pixel_values（形状为(batch_size, num_channels, height, width)的np.ndarray，tf.Tensor，List[tf.Tensor] Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为）-像素值。像素值可以使用 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]中选择。 什么是位置 ID？
• 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 (tf.Tensor，形状为 (1,)，可选，当 return_loss 为 True 时返回） — 图像-文本相似性的对比损失。
• logits_per_image (tf.Tensor，形状为 (image_batch_size, text_batch_size)) — image_embeds 和 text_embeds 之间的缩放点积分数。这代表了图像-文本相似性分数。
• logits_per_text (tf.Tensor，形状为 (text_batch_size, image_batch_size)) — text_embeds 和 image_embeds 之间的缩放点积分数。这代表了文本-图像相似性分数。
• segmentation_logits (tf.Tensor，形状为 (batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类分数。 返回的对数不一定与作为输入传递的 pixel_values 大小相同。这是为了避免进行两次插值并在用户需要将对数调整为原始图像大小时丢失一些质量。您应该始终检查您的对数形状并根据需要调整大小。
• text_embeds (tf.Tensor，形状为 (batch_size, output_dim) — 通过将投影层应用于 TFGroupViTTextModel 的汇聚输出获得的文本嵌入。
• image_embeds (tf.Tensor，形状为 (batch_size, output_dim) — 通过将投影层应用于 TFGroupViTVisionModel 的汇聚输出获得的图像嵌入。
• text_model_output (TFBaseModelOutputWithPooling) — TFGroupViTTextModel 的输出。
• vision_model_output (TFBaseModelOutputWithPooling) — TFGroupViTVisionModel 的输出。

TFGroupViTModel 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在之后调用 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 probabilities

get_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 ) → export const metadata = 'undefined';text_features (tf.Tensor of shape (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()。 输入 ID 是什么？
• attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择在[0, 1]范围内的掩码值：
  • 1 表示未被masked的标记，
  • 0 表示被masked的标记。

  注意力掩码是什么？

• position_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 位置 ID 是什么？
• output_attentions（可选，bool）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• output_hidden_states（可选，bool）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• return_dict（可选，bool）— 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
• training（可选，默认为False）— 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

text_features（形状为(batch_size, output_dim)的tf.Tensor）

通过将投影层应用于 TFGroupViTTextModel 的汇聚输出获得的文本嵌入。

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

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用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 ) → export const metadata = 'undefined';image_features (tf.Tensor of shape (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 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在之后调用 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

class transformers.TFGroupViTTextModel

< source >

( config: GroupViTTextConfig *inputs **kwargs )

call

< 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 ) → export const metadata = 'undefined';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()。 什么是输入 ID？
• 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]。 什么是位置 ID？
• 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（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型最后一层的隐藏状态序列。
• pooler_output（形状为(batch_size, hidden_size)的tf.Tensor）— 序列的第一个令牌（分类令牌）的最后一层隐藏状态，进一步由线性层和 Tanh 激活函数处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。 这个输出通常不是输入的语义内容的好摘要，通常最好对整个输入序列的隐藏状态进行平均或池化。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。 模型在每一层的隐藏状态加上初始嵌入输出。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

TFGroupViTTextModel 的 forward 方法，覆盖了__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) states

TFGroupViTVisionModel

class transformers.TFGroupViTVisionModel

<来源>

( config: GroupViTVisionConfig *inputs **kwargs )

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 ) → export const metadata = 'undefined';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，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的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（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）- 模型最后一层的隐藏状态序列。
• pooler_output（形状为(batch_size, hidden_size)的tf.Tensor）- 序列第一个标记（分类标记）的最后一层隐藏状态，经过线性层和 Tanh 激活函数进一步处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。 这个输出通常不是输入语义内容的好摘要，通常最好对整个输入序列的隐藏状态序列进行平均或池化。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出+一个用于每一层的输出）。 模型在每一层输出处的隐藏状态加上初始嵌入输出。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 在注意力 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

IDEFICS

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/idefics

概述

IDEFICS 模型是由 Hugo Laurençon、Lucile Saulnier、Léo Tronchon、Stas Bekman、Amanpreet Singh、Anton Lozhkov、Thomas Wang、Siddharth Karamcheti、Alexander M. Rush、Douwe Kiela、Matthieu Cord、Victor Sanh 提出的。

论文摘要如下：

在自然文档上训练的大型多模型，交替显示图像和文本，比在各种多模基准上训练的图像-文本对模型表现更好，这些基准需要对一个或多个图像进行推理以生成文本。然而，用于训练这些模型的数据集尚未发布，并且收集过程尚未完全指定。我们介绍了 OBELICS 数据集，这是一个包含来自 Common Crawl 的 141 亿个网页、3.53 亿个相关图像和 1150 亿个文本标记的开放式网络规模过滤数据集。我们描述了数据集创建过程，提出了全面的过滤规则，并对数据集内容进行了分析。为了展示 OBELISC 的可行性，我们在数据集上训练了一个拥有 800 亿参数的视觉和语言模型，并在各种多模基准上获得了竞争性能。我们发布了用于重现数据集的代码以及数据集本身。

此模型由HuggingFaceM4贡献。原始代码可以在这里找到。（TODO：目前没有公开链接）。

Transformers 中的 IDEFICS 建模代码用于微调和推理预训练的 IDEFICS 模型。

要从头开始训练一个新的 IDEFICS 模型，请使用 m4 代码库（一旦公开，将提供链接）

IdeficsConfig

class transformers.IdeficsConfig

<来源>

( vocab_size = 32000 additional_vocab_size = 0 hidden_size = 4096 intermediate_size = 11008 num_hidden_layers = 32 num_attention_heads = 32 dropout = 0.0 hidden_act = 'silu' initializer_range = 0.02 alpha_initializer = 'zeros' alphas_initializer_range = 0.0 alpha_type = 'float' rms_norm_eps = 1e-06 use_cache = True pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 tie_word_embeddings = False cross_layer_interval = 1 qk_layer_norms = False freeze_text_layers = True freeze_text_module_exceptions = [] freeze_lm_head = False freeze_vision_layers = True freeze_vision_module_exceptions = [] use_resampler = False vision_config = None perceiver_config = None **kwargs )

参数

• additional_vocab_size (int, *optional`, defaults to 0) — 模型的额外词汇量，通常用于特殊的“”标记。额外的词汇标记始终是可训练的，而常规词汇标记可以冻结或不冻结。
• vocab_size (int, optional, defaults to 32000) — Idefics 模型的词汇量。定义了在调用~IdeficsModel 时可以表示的不同标记的数量。
• hidden_size (int, optional, defaults to 4096) — 隐藏表示的维度。
• intermediate_size (int, optional, defaults to 11008) — MLP 表示的维度。
• num_hidden_layers (int, optional, defaults to 32) — Transformer 编码器中隐藏层的数量。
• num_attention_heads (int, optional, defaults to 32) — Transformer 编码器中每个注意力层的注意力头数。
• dropout (float, optional, defaults to 0.0) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
• hidden_act (str or function, optional, defaults to "silu") — 解码器中的非线性激活函数（函数或字符串）。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
• alpha_initializer (str, optional, defaults to "zeros") — alphas 的初始化类型。
• alphas_initializer_range (float, optional, defaults to 0.0) — 初始化 Gated Cross Attention 中 alphas 的 truncated_normal_initializer 的标准差。
• alpha_type (str, optional, defaults to "float") — 门控 alphas 应该是向量还是单个浮点数。
• rms_norm_eps (float, optional, defaults to 1e-6) — rms 归一化层使用的 epsilon。
• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。
• pad_token_id (int, optional, defaults to 0) — 填充标记 id。
• bos_token_id (int, optional, defaults to 1) — 流的开始标记 id。
• eos_token_id (int, optional, defaults to 2) — 流的结束标记 id。
• tie_word_embeddings(bool, optional, defaults to False) — 是否绑定权重嵌入
• cross_layer_interval (int, optional, default to 1) — 交叉注意力（从文本到图像）层的间隔。
• qk_layer_norms (bool, optional, defaults to False) — 是否在 q 和 k 之后添加层归一化
• freeze_text_layers (bool, optional, defaults to True) — 是否冻结文本层
• freeze_text_module_exceptions (bool, optional, defaults to []) — 当freeze_text_layers为True时，冻结文本层的异常
• freeze_lm_head (bool, optional, defaults to False) — 是否冻结 lm 头
• freeze_vision_layers (bool, optional, defaults to True) — 是否冻结视觉层
• freeze_vision_module_exceptions (bool, optional, defaults to []) — 当freeze_vision_layers为True时，冻结视觉层的异常
• use_resampler (bool, optional, defaults to False) — 是否使用重采样器
• vision_config (IdeficsVisionConfig, optional) — 自定义视觉配置或字典
• perceiver_config (IdeficsPerceiverConfig, optional) — 自定义感知器配置或字典

这是用于存储 IdeficsModel 配置的配置类。根据指定的参数实例化一个 Idefics 模型，定义模型架构。使用默认值实例化配置将产生类似于 Idefics-9B 的配置。

例如HuggingFaceM4/idefics-9b

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

示例：

>>> from transformers import IdeficsModel, IdeficsConfig

>>> # Initializing a Idefics idefics-9b style configuration
>>> configuration = IdeficsConfig()

>>> # Initializing a model from the idefics-9b style configuration
>>> model = IdeficsModel(configuration)

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

IdeficsModel

class transformers.IdeficsModel

< source >

( config: IdeficsConfig )

参数

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

裸的 LLaMA 模型输出原始隐藏状态，没有特定的头部。该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

该模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

由config.num_hidden_layers层组成的 Transformer 解码器。每一层都是一个IdeficsDecoderLayer

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None pixel_values: Optional = None image_encoder_embeddings: Optional = None perceiver_embeddings: Optional = None image_attention_mask: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None interpolate_pos_encoding: Optional = False return_dict: Optional = None )

参数

• input_ids（torch.LongTensor，形状为(batch_size, sequence_length)）— 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将被忽略。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（torch.Tensor，形状为(batch_size, sequence_length)，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 对于未被masked的标记，为 1。
  • 对于被masked的标记，为 0。

  什么是注意力掩码？ 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 如果使用past_key_values，可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。 如果要更改填充行为，您应该阅读modeling_opt._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。什么是位置 ID？
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用于加速顺序解码（请参见past_key_values输入）。 如果使用past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• use_cache（bool，可选）— 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

IdeficsModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

IdeficsForVisionText2Text

class transformers.IdeficsForVisionText2Text

<来源>

( config vision_model = None )

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None pixel_values: Optional = None image_encoder_embeddings: Optional = None perceiver_embeddings: Optional = None image_attention_mask: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None interpolate_pos_encoding: Optional = False return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.idefics.modeling_idefics.IdeficsCausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

• input_ids（torch.LongTensor，形状为(batch_size, sequence_length)）— 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将忽略填充。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（torch.Tensor，形状为(batch_size, sequence_length)，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：
  • 1 表示未被“掩码”的标记，
  • 0 表示被“掩码”的标记。

  什么是注意力掩码？ 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 如果使用了past_key_values，可以选择仅输入最后的decoder_input_ids（参见past_key_values）。 如果要更改填充行为，应阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

  • 1 表示头部未被“掩码”，
  • 0 表示头部被“掩码”。
• position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。什么是位置 ID？
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。 如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（即没有将其过去键值状态提供给此模型的那些）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• use_cache (bool, optional) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。 参数 — labels (torch.LongTensor of shape (batch_size, sequence_length), optional): 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]范围内，或者为-100（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有[0, ..., config.vocab_size]标签的标记。

返回值

transformers.models.idefics.modeling_idefics.IdeficsCausalLMOutputWithPast或tuple(torch.FloatTensor)

一个transformers.models.idefics.modeling_idefics.IdeficsCausalLMOutputWithPast或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False），包含根据配置（IdeficsConfig）和输入的不同元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失（用于下一个标记预测）。
• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 一个长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码。
• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 一个元组，包含形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor（如果模型有嵌入层，则为嵌入的输出+每层的输出）。 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 一个元组，包含形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
• image_hidden_states (tuple(torch.FloatTensor), optional) — 一个元组，包含形状为(batch_size, num_images, sequence_length, hidden_size)的torch.FloatTensor（用于图像嵌入的输出）。 由视觉编码器生成的模型的图像隐藏状态，以及可选的感知器

IdeficsForVisionText2Text 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在之后调用Module实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, IdeficsForVisionText2Text

>>> model = IdeficsForVisionText2Text.from_pretrained("HuggingFaceM4/idefics-9b")
>>> tokenizer = AutoTokenizer.from_pretrained("HuggingFaceM4/idefics-9b")

>>> prompt = "Hey, are you consciours? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you consciours? Can you talk to me?\nI'm not consciours, but I can talk to you."

IdeficsImageProcessor

class transformers.IdeficsImageProcessor

<来源>

( image_size: int = 224 image_mean: Union = None image_std: Union = None image_num_channels: Optional = 3 **kwargs )

参数

• image_size (int, 可选, 默认为 224) — 调整到图像大小
• image_mean (float 或 List[float], 可选, 默认为 IDEFICS_STANDARD_MEAN) — 用于归一化图像的均值。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以通过preprocess方法中的image_mean参数覆盖。可以通过preprocess方法中的image_mean参数覆盖。
• image_std (float 或 List[float], 可选, 默认为 IDEFICS_STANDARD_STD) — 用于归一化图像的标准差。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以通过preprocess方法中的image_std参数覆盖。可以通过preprocess方法中的image_std参数覆盖。
• image_num_channels (int, 可选, 默认为 3) — 图像通道数。

构建一个 Idefics 图像处理器。

preprocess

<来源>

( images: Union image_num_channels: Optional = 3 image_size: Optional = None image_mean: Union = None image_std: Union = None transform: Callable = None **kwargs )

参数

• images (ImageInput) — 要预处理的图像列表。
• image_size (int, 可选, 默认为 self.image_size) — 调整到图像大小
• image_num_channels (int, 可选, 默认为 self.image_num_channels) — 图像通道数。
• image_mean (float 或 List[float], 可选, 默认为 IDEFICS_STANDARD_MEAN) — 用于归一化图像的均值。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以通过preprocess方法中的image_mean参数覆盖。可以通过preprocess方法中的image_mean参数覆盖。
• image_std (float 或 List[float], 可选, 默认为 IDEFICS_STANDARD_STD) — 用于归一化图像的标准差。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以通过preprocess方法中的image_std参数覆盖。可以通过preprocess方法中的image_std参数覆盖。
• transform (Callable, 可选, 默认为 None) — 可以传递一个接受单个图像的自定义转换函数进行训练。例如，可以使用torchvision.Compose来组合多个转换。如果为None - 则假定为推断模式 - 然后将应用一组预设的推断特定转换到图像。

预处理一批图像。

IdeficsProcessor

class transformers.IdeficsProcessor

<来源>

( image_processor tokenizer = None image_size = 224 add_end_of_utterance_token = None **kwargs )

参数

• image_processor (IdeficsImageProcessor) — IdeficsImageProcessor 的一个实例。图像处理器是一个必需的输入。
• tokenizer (LlamaTokenizerFast) — LlamaTokenizerFast 的一个实例。分词器是一个必需的输入。
• image_size (int, 可选, 默认为 224) — 图像大小（假设为正方形图像）

构建一个 IDEFICS 处理器，将 LLama 分词器和 IDEFICS 图像处理器封装成一个处理器。

IdeficsProcessor 提供了 IdeficsImageProcessor 和 LlamaTokenizerFast 的所有功能。查看 call() 和 decode() 的文档字符串以获取更多信息。

__call__

< source >

( prompts: Union padding: Union = False truncation: Union = None max_length: Optional = None transform: Callable = None add_eos_token = False add_end_of_utterance_token = None debug = False return_tensors: Union = <TensorType.PYTORCH: 'pt'> ) → export const metadata = 'undefined';a dict with entries

参数

• prompts（Union[List[TextInput], [List[List[TextInput]]]]）— 单个提示或批处理提示的列表 - 请查看参数文档部分结束后的详细描述。
• padding（bool，str 或 PaddingStrategy，可选，默认为 False）— 选择一种策略来填充返回的序列（根据模型的填充方向和填充索引）：
  • True 或 'longest'：填充到批次中最长的序列（如果只提供了单个序列，则不进行填充）。
  • 'max_length'：填充到指定的最大长度，或者如果未提供该参数，则填充到模型的最大可接受输入长度。
  • False 或 'do_not_pad'（默认）：不填充（即，可以输出具有不同长度序列的批次）。
• max_length（int，可选）— 返回列表的最大长度和可选填充长度（见上文）。
• truncation（bool，可选）— 激活截断，将输入序列截断为比 max_length 更长的序列至 max_length。
• transform（Callable，可选）— 可以传递一个接受单个图像的自定义转换函数进行训练。例如，可以使用 torchvision.Compose 来组合多个函数。如果为 None，则将应用预设的推理特定转换集合到图像上。
• add_eos_token（bool，可选，默认为 False）— 如果为 True，则在最终提示的末尾添加 eos_token
• add_end_of_utterance_token（bool，可选）— 是否在每个提示的文本输入后自动添加 <end_of_utterance>（除非后面跟着一个图像）。如果为 None，则将检查分词器，如果在 additional_special_tokens 中找到该标记，则值将为 True。
• debug（bool，可选，默认为 False）— True 值将通过转储有用信息来帮助调试提示生成
• return_tensors（str 或 TensorType，可选，默认为 TensorType.PYTORCH）— 要返回的张量类型。可以是以下之一：
  • TensorType.PYTORCH 或 'pt'：返回类型为 torch.Tensor 的批处理。

返回

一个包含条目的字典

input_ids、attention_mask、pixel_values、image_attention_mask 可以直接传递给 model.generate

这个方法接受由文本和图像组成的批处理或非批处理提示，并将它们转换为模型训练的提示，并准备图像像素值供模型处理。

详细说明：

prompts 中的每个条目都是要原样传递的文本或将被处理的图像。

图像可以是图像对象（PIL.Image）或可以检索图像的 url。

当处理器遇到图像时，它将在提示中注入 <fake_token_around_image><image><fake_token_around_image> 条目。

例子：

checkpoint = "HuggingFaceM4/idefics-9b"
processor = AutoProcessor.from_pretrained(checkpoint)
url = "https://hips.hearstapps.com/hmg-prod/images/cute-photos-of-cats-in-grass-1593184777.jpg"
img = processor.image_processor.fetch_images([url])[0]

prompts = [
    "User:",
    img,
    "Describe this image.
t: An image of two kittens in grass.

    "User:",
    "https://hips.hearstapps.com/hmg-prod/images/dog-puns-1581708208.jpg",
    "Describe this image.
t:",
]

inputs = processor(prompts, return_tensors="pt")
generated_ids = model.generate(**inputs, max_length=100)
generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

在这个例子中，prompts 将被转换为：

<s>User:<fake_token_around_image><image><fake_token_around_image>Describe this image.
Assistant: An image of two kittens in grass.
User:<fake_token_around_image><image><fake_token_around_image>Describe this image.
Assistant:'

两个图像将使用 IdeficsImageProcessor.call() 方法进行处理，并放置在返回值的 pixel_values 字典条目中。

这个例子还说明了图像可以作为对象或文本 url 传递。可以看到第一个图像作为对象传递，第二个图像作为 url 传递。

进行训练时：

image_transform = transforms.Compose(
    [
        transforms.RandomResizedCrop(
            (w, h), scale=(0.9, 1.0), interpolation=transforms.InterpolationMode.BICUBIC
        ),
        transforms.ToTensor(),
        transforms.Normalize(mean=self.image_mean, std=self.image_std),
    ]
)
inputs = processor(prompts, transform=image_transform, return_tensors="pt")

为了帮助调试提示生成，启用debug=True，这将向您展示发生了什么。

InstructBLIP

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/instructblip

概述

InstructBLIP 模型是由 Wenliang Dai，Junnan Li，Dongxu Li，Anthony Meng Huat Tiong，Junqi Zhao，Weisheng Wang，Boyang Li，Pascale Fung，Steven Hoi 在InstructBLIP: Towards General-purpose Vision-Language Models with Instruction Tuning中提出的。InstructBLIP 利用了 BLIP-2 架构进行视觉指令调整。

论文摘要如下：

由于预训练和指令调整流程的推动，出现了可以解决各种语言领域任务的通用语言模型。然而，构建通用的视觉语言模型具有挑战性，因为额外的视觉输入引入了增加的任务差异。尽管视觉语言预训练已经得到广泛研究，但视觉语言指令调整仍然相对较少探索。在本文中，我们对基于预训练的 BLIP-2 模型的视觉语言指令调整进行了系统和全面的研究。我们收集了 26 个公开可用数据集的各种数据，将它们转换为指令调整格式，并将它们分类为两个集群，用于保留指令调整和保留零样本评估。此外，我们引入了指令感知的视觉特征提取，这是一种关键方法，使模型能够提取针对给定指令的信息特征。由此产生的 InstructBLIP 模型在所有 13 个保留数据集上实现了最先进的零样本性能，明显优于 BLIP-2 和更大的 Flamingo。我们的模型在个别下游任务（例如 ScienceQA IMG 上的 90.7%准确率）上也实现了最先进的性能。此外，我们定性地展示了 InstructBLIP 相对于同时进行的多模态模型的优势。

InstructBLIP 架构。取自原始论文。

此模型由nielsr贡献。原始代码可以在这里找到。

使用提示

InstructBLIP 使用与 BLIP-2 相同的架构，但有一个微小但重要的区别：它还将文本提示（指令）提供给 Q-Former。

InstructBlipConfig

class transformers.InstructBlipConfig

<来源>

( vision_config = None qformer_config = None text_config = None num_query_tokens = 32 **kwargs )

参数

• vision_config（dict，可选）—用于初始化 InstructBlipVisionConfig 的配置选项字典。
• qformer_config（dict，可选）—用于初始化 InstructBlipQFormerConfig 的配置选项字典。
• text_config（dict，可选）—用于初始化任何 PretrainedConfig 的配置选项字典。
• num_query_tokens（int，可选，默认为 32）—通过 Transformer 传递的查询标记数。
• kwargs（可选）—关键字参数的字典。

InstructBlipConfig 是用于存储 InstructBlipForConditionalGeneration 配置的配置类。它用于根据指定的参数实例化一个 InstructBLIP 模型，定义视觉模型、Q-Former 模型和语言模型配置。使用默认实例化配置将产生类似于 InstructBLIP Salesforce/instruct-blip-flan-t5 架构的配置。

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

示例：

>>> from transformers import (
...     InstructBlipVisionConfig,
...     InstructBlipQFormerConfig,
...     OPTConfig,
...     InstructBlipConfig,
...     InstructBlipForConditionalGeneration,
... )

>>> # Initializing a InstructBlipConfig with Salesforce/instruct-blip-flan-t5 style configuration
>>> configuration = InstructBlipConfig()

>>> # Initializing a InstructBlipForConditionalGeneration (with random weights) from the Salesforce/instruct-blip-flan-t5 style configuration
>>> model = InstructBlipForConditionalGeneration(configuration)

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

>>> # We can also initialize a InstructBlipConfig from a InstructBlipVisionConfig, InstructBlipQFormerConfig and any PretrainedConfig

>>> # Initializing InstructBLIP vision, InstructBLIP Q-Former and language model configurations
>>> vision_config = InstructBlipVisionConfig()
>>> qformer_config = InstructBlipQFormerConfig()
>>> text_config = OPTConfig()

>>> config = InstructBlipConfig.from_text_vision_configs(vision_config, qformer_config, text_config)

from_vision_qformer_text_configs

< source >

( vision_config: InstructBlipVisionConfig qformer_config: InstructBlipQFormerConfig text_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';InstructBlipConfig

返回

InstructBlipConfig

配置对象的实例

从 InstructBLIP 视觉模型、Q-Former 和语言模型配置实例化一个 InstructBlipConfig（或派生类）。

InstructBlipVisionConfig

class transformers.InstructBlipVisionConfig

< source >

( hidden_size = 1408 intermediate_size = 6144 num_hidden_layers = 39 num_attention_heads = 16 image_size = 224 patch_size = 14 hidden_act = 'gelu' layer_norm_eps = 1e-06 attention_dropout = 0.0 initializer_range = 1e-10 qkv_bias = True **kwargs )

参数

• hidden_size (int, 可选，默认为 1408) — 编码器层和池化层的维度。
• intermediate_size (int, 可选，默认为 6144) — Transformer 编码器中“中间”（即前馈）层的维度。
• num_hidden_layers (int, 可选，默认为 39) — Transformer 编码器中的隐藏层数量。
• num_attention_heads (int, 可选，默认为 16) — Transformer 编码器中每个注意力层的注意力头数。
• image_size (int, 可选，默认为 224) — 每个图像的大小（分辨率）。
• patch_size (int, 可选，默认为 14) — 每个补丁的大小（分辨率）。
• hidden_act (str或function, 可选，默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new" "gelu"。
• layer_norm_eps (float, 可选，默认为 1e-06) — 层归一化层使用的 epsilon。
• attention_dropout (float, 可选，默认为 0.0) — 注意力概率的 dropout 比率。
• initializer_range (float, 可选，默认为 1e-10) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• qkv_bias (bool, 可选，默认为True) — 是否在自注意力层中为查询和值添加偏置。

这是用于存储 InstructBlipVisionModel 配置的配置类。它用于根据指定的参数实例化一个 InstructBLIP 视觉编码器，定义模型架构。使用默认实例化配置将产生类似于 InstructBLIP Salesforce/instruct-blip-flan-t5 架构的配置。

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

示例：

>>> from transformers import InstructBlipVisionConfig, InstructBlipVisionModel

>>> # Initializing a InstructBlipVisionConfig with Salesforce/instruct-blip-flan-t5 style configuration
>>> configuration = InstructBlipVisionConfig()

>>> # Initializing a InstructBlipVisionModel (with random weights) from the Salesforce/instruct-blip-flan-t5 style configuration
>>> model = InstructBlipVisionModel(configuration)

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

InstructBlipQFormerConfig

class transformers.InstructBlipQFormerConfig

<来源>

( 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 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 position_embedding_type = 'absolute' cross_attention_frequency = 2 encoder_hidden_size = 1408 **kwargs )

参数

• vocab_size (int, optional, 默认为 30522) — Q-Former 模型的词汇量。定义了在调用模型时可以表示的不同标记数量。
• hidden_size (int, optional, 默认为 768) — 编码器层和池化层的维度。
• num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。
• num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
• intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。
• hidden_act (str或Callable, optional, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。
• hidden_dropout_prob (float, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
• attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的 dropout 比率。
• max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。
• position_embedding_type (str, optional, 默认为"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。
• cross_attention_frequency (int, optional, 默认为 2) — 向 Transformer 层添加交叉注意力的频率。
• encoder_hidden_size (int, optional, 默认为 1408) — 用于交叉注意力的隐藏状态的隐藏大小。

这是一个配置类，用于存储 InstructBlipQFormerModel 的配置。它用于根据指定的参数实例化一个 InstructBLIP Querying Transformer (Q-Former)模型，定义模型架构。使用默认值实例化配置将产生类似于 InstructBLIP Salesforce/instruct-blip-flan-t5架构的配置。配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

请注意，InstructBlipQFormerModel 与 BertLMHeadModel 非常相似，具有交错的交叉注意力。

示例：

>>> from transformers import InstructBlipQFormerConfig, InstructBlipQFormerModel

>>> # Initializing a InstructBLIP Salesforce/instruct-blip-flan-t5 style configuration
>>> configuration = InstructBlipQFormerConfig()

>>> # Initializing a model (with random weights) from the Salesforce/instruct-blip-flan-t5 style configuration
>>> model = InstructBlipQFormerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

InstructBlipProcessor

class transformers.InstructBlipProcessor

< source >

( image_processor tokenizer qformer_tokenizer )

参数

• image_processor (BlipImageProcessor) — BlipImageProcessor 的一个实例。图像处理器是必需的输入。
• tokenizer (AutoTokenizer) — [‘PreTrainedTokenizer`]的一个实例。分词器是必需的输入。
• qformer_tokenizer (AutoTokenizer) — [‘PreTrainedTokenizer`]的一个实例。Q-Former tokenizer 是必需的输入。

构建一个 InstructBLIP 处理器，将 BLIP 图像处理器和 LLaMa/T5 分词器包装成一个单一处理器。

InstructBlipProcessor 提供了 BlipImageProcessor 和 AutoTokenizer 的所有功能。查看__call__()和 decode()的文档字符串以获取更多信息。

batch_decode

< source >

( *args **kwargs )

此方法将其所有参数转发给 PreTrainedTokenizer 的 batch_decode()。有关更多信息，请参阅此方法的文档字符串。

decode

< source >

( *args **kwargs )

此方法将其所有参数转发给 PreTrainedTokenizer 的 decode()。有关更多信息，请参阅此方法的文档字符串。

InstructBlipVisionModel

class transformers.InstructBlipVisionModel

< source >

( config: InstructBlipVisionConfig )

forward

< source >

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 InstructBlipProcessor 获取。有关详细信息，请参阅InstructBlipProcessor.__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.instructblip.configuration_instructblip.InstructBlipVisionConfig'>）和输入。

• 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时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出和每一层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

InstructBlipVisionModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

InstructBlipQFormerModel

class transformers.InstructBlipQFormerModel

<来源>

( config: InstructBlipQFormerConfig )

查询变换器（Q-Former），用于 InstructBLIP。与 BLIP-2 略有修改，因为它还将指令作为输入。

forward

<来源>

( input_ids: LongTensor attention_mask: Optional = None position_ids: Optional = None query_embeds: Optional = None head_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）：编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）：避免对编码器输入的填充标记索引执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用。选择的掩码值为[0, 1]：

• 对于未被masked的标记，值为 1。
• 对于被masked的标记，值为 0。past_key_values（长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组有 4 个张量，形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)）：包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。use_cache（bool，可选）：如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

InstructBlipForConditionalGeneration

class transformers.InstructBlipForConditionalGeneration

<来源>

( config: InstructBlipConfig )

参数

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

InstructBLIP 模型用于根据图像和可选文本提示生成文本。该模型由视觉编码器、查询变换器（Q-Former）和语言模型组成。

可以选择向模型传递input_ids，作为文本提示，以使语言模型继续提示。否则，语言模型将从[BOS]（序列开始）标记开始生成文本。

此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( pixel_values: FloatTensor qformer_input_ids: FloatTensor qformer_attention_mask: Optional = None input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.instructblip.modeling_instructblip.InstructBlipForConditionalGenerationModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）—像素值。像素值可以使用 InstructBlipProcessor 获取。有关详细信息，请参阅InstructBlipProcessor.__call__()。
• qformer_input_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）—Q-Former 词汇表中输入序列标记的索引。可以选择提供输入标记作为文本提示，Q-Former 模型将对其进行编码。 可以使用 InstructBlipProcessor 获取索引。有关详细信息，请参阅InstructBlipProcessor.__call__()。 什么是输入 ID？
• qformer_attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：
  • 对于未被masked的标记为 1，
  • 对于被masked的标记为 0。

  什么是注意力掩码？

• input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 输入序列标记在语言模型词汇中的索引。输入标记可以选择作为文本提示提供，语言模型可以继续。 可以使用 InstructBlipProcessor 获取索引。有关详细信息，请参阅InstructBlipProcessor.__call__()。 什么是输入 ID？
• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：
  • 对于未被masked的标记为 1，
  • 对于被masked的标记为 0。

  什么是注意力掩码？

• decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 解码器输入序列标记在语言模型词汇中的索引。仅在使用编码器-解码器语言模型（如 T5）时相关。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是解码器输入 ID？
• decoder_attention_mask (torch.BoolTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。 仅在使用编码器-解码器语言模型（如 T5）时相关。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多细节，请参阅返回的张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多细节，请参阅返回的张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size - 1]中。所有设置为-100的标签将被忽略（被masked），损失仅计算标签在[0, ..., config.vocab_size]中的标签

返回

transformers.models.instructblip.modeling_instructblip.InstructBlipForConditionalGenerationModelOutput 或 tuple(torch.FloatTensor)

transformers.models.instructblip.modeling_instructblip.InstructBlipForConditionalGenerationModelOutput 或 torch.FloatTensor 元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（<class 'transformers.models.instructblip.configuration_instructblip.InstructBlipVisionConfig'>）和输入的各种元素。

• loss (torch.FloatTensor, optional, 当提供labels时返回，形状为(1,)) — 语言建模损失来自语言模型。
• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言模型的语言建模头的预测分数。
• vision_outputs (BaseModelOutputWithPooling) — 视觉编码器的输出。
• qformer_outputs (BaseModelOutputWithPoolingAndCrossAttentions) — Q-Former（查询变换器）的输出。
• language_model_outputs (CausalLMOutputWithPast或Seq2SeqLMOutput) — 语言模型的输出。

InstructBlipForConditionalGeneration 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import InstructBlipProcessor, InstructBlipForConditionalGeneration
>>> import torch
>>> from PIL import Image
>>> import requests

>>> model = InstructBlipForConditionalGeneration.from_pretrained("Salesforce/instructblip-vicuna-7b")
>>> processor = InstructBlipProcessor.from_pretrained("Salesforce/instructblip-vicuna-7b")

>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> model.to(device)
>>> url = "https://raw.githubusercontent.com/salesforce/LAVIS/main/docs/_static/Confusing-Pictures.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
>>> prompt = "What is unusual about this image?"
>>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device)

>>> outputs = model.generate(
...     **inputs,
...     do_sample=False,
...     num_beams=5,
...     max_length=256,
...     min_length=1,
...     top_p=0.9,
...     repetition_penalty=1.5,
...     length_penalty=1.0,
...     temperature=1,
... )
>>> generated_text = processor.batch_decode(outputs, skip_special_tokens=True)[0].strip()
>>> print(generated_text)
The unusual aspect of this image is that a man is ironing clothes on the back of a yellow SUV, which is parked in the middle of a busy city street. This is an unconventional approach to ironing clothes, as it requires the man to balance himself and his ironing equipment on top of the vehicle while navigating through traffic. Additionally, the presence of taxis and other vehicles in the scene further emphasizes the unusual nature of this situation.

generate

<来源>

( pixel_values: FloatTensor qformer_input_ids: Optional = None qformer_attention_mask: Optional = None input_ids: Optional = None attention_mask: Optional = None **generate_kwargs ) → export const metadata = 'undefined';captions (list)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 要处理的输入图像。
• qformer_input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用作输入到 Q-Former 模块的提示序列。
• qformer_attention_mask (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。
• input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用作生成提示的序列。
• attention_mask (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。

返回

字幕（列表）

一个长度为 batch_size * num_captions 的字符串列表。

覆盖generate函数以能够将模型用作有条件生成器。

KOSMOS-2

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/kosmos-2

概述

KOSMOS-2 模型是由 Zhiliang Peng、Wenhui Wang、Li Dong、Yaru Hao、Shaohan Huang、Shuming Ma、Furu Wei 在Kosmos-2: Grounding Multimodal Large Language Models to the World中提出的。

KOSMOS-2 是基于 Transformer 的因果语言模型，通过在基于网络规模的图像文本对数据集GRIT上进行下一个单词预测任务进行训练。数据集中边界框的空间坐标被转换为位置标记序列，这些标记被附加到它们各自的实体文本跨度上（例如，a snowman后跟<patch_index_0044><patch_index_0863>）。数据格式类似于将图像中的对象区域与相应标题中的文本跨度连接起来的“超链接”。

论文摘要如下：

我们介绍了 Kosmos-2，一个多模态大型语言模型（MLLM），使其能够感知对象描述（例如，边界框）并将文本与视觉世界联系起来。具体来说，我们将引用表达式表示为 Markdown 中的链接，即“文本跨度”，其中对象描述是位置标记序列。与多模态语料库一起，我们构建了大规模的基于图像文本对的数据（称为 GrIT）来训练模型。除了 MLLM 的现有功能（例如，感知一般模态，遵循指令以及执行上下文学习）之外，Kosmos-2 还将接地能力整合到下游应用中。我们在广泛的任务上评估了 Kosmos-2，包括（i）多模态接地，例如引用表达理解和短语接地，（ii）多模态引用，例如引用表达生成，（iii）感知语言任务，以及（iv）语言理解和生成。这项工作为实体 AI 的发展奠定了基础，并为语言、多模态感知、行动和世界建模的大融合提供了启示，这是通往人工通用智能的关键一步。代码和预训练模型可在aka.ms/kosmos-2上获得。

drawing

KOSMOS-2 可以处理的任务概述。摘自原始论文。

示例

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Kosmos2ForConditionalGeneration

>>> model = Kosmos2ForConditionalGeneration.from_pretrained("microsoft/kosmos-2-patch14-224")
>>> processor = AutoProcessor.from_pretrained("microsoft/kosmos-2-patch14-224")

>>> url = "https://huggingface.co/microsoft/kosmos-2-patch14-224/resolve/main/snowman.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> prompt = "<grounding> An image of"

>>> inputs = processor(text=prompt, images=image, return_tensors="pt")

>>> generated_ids = model.generate(
...     pixel_values=inputs["pixel_values"],
...     input_ids=inputs["input_ids"],
...     attention_mask=inputs["attention_mask"],
...     image_embeds=None,
...     image_embeds_position_mask=inputs["image_embeds_position_mask"],
...     use_cache=True,
...     max_new_tokens=64,
... )
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> processed_text = processor.post_process_generation(generated_text, cleanup_and_extract=False)
>>> processed_text
'<grounding> An image of<phrase> a snowman</phrase><object><patch_index_0044><patch_index_0863></object> warming himself by<phrase> a fire</phrase><object><patch_index_0005><patch_index_0911></object>.'

>>> caption, entities = processor.post_process_generation(generated_text)
>>> caption
'An image of a snowman warming himself by a fire.'

>>> entities
[('a snowman', (12, 21), [(0.390625, 0.046875, 0.984375, 0.828125)]), ('a fire', (41, 47), [(0.171875, 0.015625, 0.484375, 0.890625)])]

这个模型是由Yih-Dar SHIEH贡献的。原始代码可以在这里找到。

Kosmos2Config

class transformers.Kosmos2Config

<来源>

( text_config = None vision_config = None latent_query_num = 64 **kwargs )

参数

• text_config (dict, optional) — 用于初始化Kosmos2TextConfig的配置选项字典。
• vision_config (dict, optional) — 用于初始化Kosmos2VisionConfig的配置选项字典。
• latent_query_num (int, optional, 默认为 64) — 代表文本解码器组件中使用的图像特征的潜在查询标记数量。
• kwargs (optional) — 关键字参数字典。

这是一个配置类，用于存储 Kosmos2Model 的配置。根据指定的参数实例化 KOSMOS-2 模型，定义模型架构。使用默认值实例化配置将产生类似于 KOSMOS-2 microsoft/kosmos-2-patch14-224 架构的配置。

示例：

>>> from transformers import Kosmos2Config, Kosmos2Model

>>> # Initializing a Kosmos-2 kosmos-2-patch14-224 style configuration
>>> configuration = Kosmos2Config()

>>> # Initializing a model (with random weights) from the kosmos-2-patch14-224 style configuration
>>> model = Kosmos2Model(configuration)

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

Kosmos2ImageProcessor

Kosmos2Processor

class transformers.Kosmos2Processor

< source >

( image_processor tokenizer num_patch_index_tokens = 1024 )

参数

• image_processor (CLIPImageProcessor) — CLIPImageProcessor 的一个实例。图像处理器是必需的输入。
• tokenizer (XLMRobertaTokenizerFast) — [‘XLMRobertaTokenizerFast`]的一个实例。分词器是必需的输入。
• num_patch_index_tokens (int, 可选, 默认为 1024) — 代表补丁索引的标记数量。

构建一个 KOSMOS-2 处理器，将 KOSMOS-2 图像处理器和 KOSMOS-2 分词器包装成一个单一处理器。

Kosmos2Processor 提供了 CLIPImageProcessor 的所有功能，以及 XLMRobertaTokenizerFast 的一些功能。查看call()和decode()的文档字符串以获取更多信息。

__call__

< source >

( images: Union = None text: Union = None bboxes: Union = None num_image_tokens: Optional = 64 first_image_token_id: Optional = None add_special_tokens: bool = True add_eos_token: bool = False padding: Union = False truncation: Union = None max_length: Optional = None pad_to_multiple_of: Optional = None return_attention_mask: Optional = None return_length: bool = False verbose: bool = True return_tensors: Union = None **kwargs )

参数

• bboxes (Union[List[Tuple[int]], List[Tuple[float]], List[List[Tuple[int]]], List[List[Tuple[float]]], 可选) — 与texts相关联的边界框。
• num_image_tokens (int, 默认为 64) — 用于标记存储图像信息的占位符的(连续)位置数量。这应该与您正在使用的Kosmos2Config实例中的latent_query_num`相同。
• first_image_token_id (int, 可选) — 用于保留存储图像信息的子序列的第一个位置的标记 id。如果未设置，将默认为self.tokenizer.unk_token_id + 1。
• add_eos_token (bool, 默认为False) — 当add_special_tokens=True时，是否包含EOS标记 id 在编码中。

此方法使用 CLIPImageProcessor.call()方法为模型准备图像，并使用 XLMRobertaTokenizerFast.call()为模型准备文本。

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

本文档的其余部分显示了特定于Kosmos2Processor的参数。

Kosmos2Model

class transformers.Kosmos2Model

< source >

( config: Kosmos2Config )

参数

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

KOSMOS-2 模型用于生成文本和图像特征。该模型由一个视觉编码器和一个语言模型组成。

该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

这个模型也是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

什么是注意力掩码？

( pixel_values: Optional = None input_ids: Optional = None image_embeds_position_mask: Optional = None attention_mask: Optional = None head_mask: Optional = None past_key_values: Optional = None image_embeds: Optional = None inputs_embeds: Optional = None position_ids: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.kosmos2.modeling_kosmos2.Kosmos2ModelOutput or tuple(torch.FloatTensor)

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 CLIPImageProcessor.call()。
• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。 0 表示头部被掩盖。 1 表示头部未被掩盖，
• image_embeds — (torch.FloatTensor of shape (batch_size, latent_query_num, hidden_size), optional): 在 Kosmos2ImageToTextProjection 输出的隐藏状态序列。
  • 1 表示放置图像特征的位置，
  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。
• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1] 之间：
  • 1 表示未被掩盖的标记，
  • 0 表示被掩盖的标记。

  什么是位置 ID？

• 什么是输入 ID？
  • image_embeds_position_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于指示在序列中插入图像特征的位置的掩码。掩码值选在 [0, 1] 之间：
  • past_key_values (tuple(tuple(torch.FloatTensor))，长度为 config.n_layers，每个元组包含 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量） — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。
• <来源> 如果使用了 past_key_values，用户可以选择仅输入最后的 decoder_input_ids（即没有将其过去的键值状态提供给此模型的那些）的形状为 (batch_size, 1)，而不是所有 decoder_input_ids 的形状为 (batch_size, sequence_length)。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权，以便将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选在 [0, 1] 之间： 0 表示不适用于图像特征的位置（即文本标记）。
• use_cache (bool, optional) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（请参阅 past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量中的 attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量中的 hidden_states。
• return_dict（bool，可选） — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.models.kosmos2.modeling_kosmos2.Kosmos2ModelOutput或tuple(torch.FloatTensor)

一个transformers.models.kosmos2.modeling_kosmos2.Kosmos2ModelOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（<class 'transformers.models.kosmos2.configuration_kosmos2.Kosmos2Config'>）和输入不同元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor） — 模型最后一层的隐藏状态序列。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出+每层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
• image_embeds（形状为(batch_size, latent_query_num, hidden_size)的torch.FloatTensor，可选） — Kosmos2ImageToTextProjection输出处的隐藏状态序列。
• projection_attentions（tuple(torch.FloatTensor)，可选） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 由Kosmos2ImageToTextProjection给出的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• vision_model_output(BaseModelOutputWithPooling, 可选) — Kosmos2VisionModel的输出。
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 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，还可以使用）可用于加速顺序解码。

Kosmos2Model 的前向方法，覆盖了__call__特殊方法。

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Kosmos2Model

>>> model = Kosmos2Model.from_pretrained("microsoft/kosmos-2-patch14-224")
>>> processor = AutoProcessor.from_pretrained("microsoft/kosmos-2-patch14-224")

>>> url = "https://huggingface.co/microsoft/kosmos-2-patch14-224/resolve/main/snowman.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> text = (
...     "<grounding> An image of<phrase> a snowman</phrase><object><patch_index_0044><patch_index_0863>"
...     "</object> warming himself by<phrase> a fire</phrase><object><patch_index_0005><patch_index_0911>"
...     "</object>"
... )

>>> inputs = processor(text=text, images=image, return_tensors="pt", add_eos_token=True)

>>> last_hidden_state = model(
...     pixel_values=inputs["pixel_values"],
...     input_ids=inputs["input_ids"],
...     attention_mask=inputs["attention_mask"],
...     image_embeds_position_mask=inputs["image_embeds_position_mask"],
... ).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 91, 2048]

Kosmos2ForConditionalGeneration

class transformers.Kosmos2ForConditionalGeneration

<来源>

( config: Kosmos2Config )

参数

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

KOSMOS-2 模型用于生成文本和边界框，给定一张图片。该模型由视觉编码器和语言模型组成。

该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( pixel_values: Optional = None input_ids: Optional = None image_embeds_position_mask: Optional = None attention_mask: Optional = None head_mask: Optional = None past_key_values: Optional = None image_embeds: Optional = None inputs_embeds: Optional = None position_ids: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.kosmos2.modeling_kosmos2.Kosmos2ForConditionalGenerationModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。详细信息请参阅 CLIPImageProcessor.call()。
• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。 索引可以使用 AutoTokenizer 获取。详细信息请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• image_embeds_position_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于指示在序列中插入图像特征的位置的蒙版。蒙版值选择在[0, 1]之间：
  • 1 表示放置图像特征的位置，
  • 0 表示不用于图像特征的位置（即文本标记）。
• attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的蒙版。蒙版值选择在[0, 1]之间：
  • 1 表示未被蒙版的标记，
  • 0 表示被蒙版的标记。

  什么是注意力蒙版？

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部失效的蒙版。蒙版值选择在[0, 1]之间：
  • 1 表示头部未被蒙版，
  • 0 表示头部被蒙版。
• past_key_values (tuple(tuple(torch.FloatTensor))，长度为config.n_layers，每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的 4 个张量） — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。 如果使用past_key_values，用户可以选择仅输入最后一个decoder_input_ids（这些没有将其过去的键值状态提供给该模型）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。image_embeds — (torch.FloatTensor，形状为(batch_size, latent_query_num, hidden_size)，可选）：Kosmos2ImageToTextProjection输出的隐藏状态序列。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将很有用，而不是使用模型的内部嵌入查找矩阵。
• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID？
• use_cache (bool, optional) — 如果设置为True，将返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。
• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算从左到右的语言建模损失（下一个词预测）的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。

返回

transformers.models.kosmos2.modeling_kosmos2.Kosmos2ForConditionalGenerationModelOutput或tuple(torch.FloatTensor)

一个transformers.models.kosmos2.modeling_kosmos2.Kosmos2ForConditionalGenerationModelOutput或一个torch.FloatTensor元组（如果传入return_dict=False或config.return_dict=False）包含根据配置（<class 'transformers.models.kosmos2.configuration_kosmos2.Kosmos2Config'>）和输入的不同元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失（用于下一个标记预测）。
• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头部的预测分数（SoftMax 之前每个词汇标记的分数）。
• hidden_states (tuple(torch.FloatTensor), optional, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出+每层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor), optional, 当传入output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
• image_embeds (torch.FloatTensor of shape (batch_size, latent_query_num, hidden_size), optional) — 在Kosmos2ImageToTextProjection输出的隐藏状态序列。
• projection_attentions (tuple(torch.FloatTensor), optional) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 由Kosmos2ImageToTextProjection给出的注意力权重，在注意力 softmax 后，用于计算自注意力头中的加权平均值。
• vision_model_output(BaseModelOutputWithPooling, 可选) - Kosmos2VisionModel的输出。
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为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输入）。

Kosmos2ForConditionalGeneration 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者会处理运行前后的处理步骤，而后者会默默地忽略它们。

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Kosmos2ForConditionalGeneration

>>> model = Kosmos2ForConditionalGeneration.from_pretrained("microsoft/kosmos-2-patch14-224")
>>> processor = AutoProcessor.from_pretrained("microsoft/kosmos-2-patch14-224")

>>> url = "https://huggingface.co/microsoft/kosmos-2-patch14-224/resolve/main/snowman.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> prompt = "<grounding> An image of"

>>> inputs = processor(text=prompt, images=image, return_tensors="pt")

>>> generated_ids = model.generate(
...     pixel_values=inputs["pixel_values"],
...     input_ids=inputs["input_ids"],
...     attention_mask=inputs["attention_mask"],
...     image_embeds=None,
...     image_embeds_position_mask=inputs["image_embeds_position_mask"],
...     use_cache=True,
...     max_new_tokens=64,
... )
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> processed_text = processor.post_process_generation(generated_text, cleanup_and_extract=False)
>>> processed_text
'<grounding> An image of<phrase> a snowman</phrase><object><patch_index_0044><patch_index_0863></object> warming himself by<phrase> a fire</phrase><object><patch_index_0005><patch_index_0911></object>.'

>>> caption, entities = processor.post_process_generation(generated_text)
>>> caption
'An image of a snowman warming himself by a fire.'

>>> entities
[('a snowman', (12, 21), [(0.390625, 0.046875, 0.984375, 0.828125)]), ('a fire', (41, 47), [(0.171875, 0.015625, 0.484375, 0.890625)])]

平均值。

• vision_model_output(BaseModelOutputWithPooling, 可选) - Kosmos2VisionModel的输出。
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为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输入）。

Kosmos2ForConditionalGeneration 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者会处理运行前后的处理步骤，而后者会默默地忽略它们。

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Kosmos2ForConditionalGeneration

>>> model = Kosmos2ForConditionalGeneration.from_pretrained("microsoft/kosmos-2-patch14-224")
>>> processor = AutoProcessor.from_pretrained("microsoft/kosmos-2-patch14-224")

>>> url = "https://huggingface.co/microsoft/kosmos-2-patch14-224/resolve/main/snowman.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> prompt = "<grounding> An image of"

>>> inputs = processor(text=prompt, images=image, return_tensors="pt")

>>> generated_ids = model.generate(
...     pixel_values=inputs["pixel_values"],
...     input_ids=inputs["input_ids"],
...     attention_mask=inputs["attention_mask"],
...     image_embeds=None,
...     image_embeds_position_mask=inputs["image_embeds_position_mask"],
...     use_cache=True,
...     max_new_tokens=64,
... )
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> processed_text = processor.post_process_generation(generated_text, cleanup_and_extract=False)
>>> processed_text
'<grounding> An image of<phrase> a snowman</phrase><object><patch_index_0044><patch_index_0863></object> warming himself by<phrase> a fire</phrase><object><patch_index_0005><patch_index_0911></object>.'

>>> caption, entities = processor.post_process_generation(generated_text)
>>> caption
'An image of a snowman warming himself by a fire.'

>>> entities
[('a snowman', (12, 21), [(0.390625, 0.046875, 0.984375, 0.828125)]), ('a fire', (41, 47), [(0.171875, 0.015625, 0.484375, 0.890625)])]