Transformers--4-37-中文文档-四十一-

Transformers 4.37 中文文档（四十一）

原文：huggingface.co/docs/transformers

AltCLIP

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/altclip

概述

AltCLIP 模型是由陈忠志、刘光、张博文、叶福龙、杨庆红、吴乐德在AltCLIP: Altering the Language Encoder in CLIP for Extended Language Capabilities中提出的。AltCLIP（改变 CLIP 中的语言编码器）是一个神经网络，训练于各种图像文本和文本文本对。通过用预训练的多语言文本编码器 XLM-R 替换 CLIP 的文本编码器，我们可以在几乎所有任务上获得与 CLIP 非常接近的性能，并扩展原始 CLIP 的能力，如多语言理解。

论文摘要如下：

在这项工作中，我们提出了一个概念简单且有效的方法来训练强大的双语多模态表示模型。从 OpenAI 发布的预训练多模态表示模型 CLIP 开始，我们将其文本编码器替换为预训练的多语言文本编码器 XLM-R，并通过包含教师学习和对比学习的两阶段训练模式来对齐两种语言和图像表示。我们通过对各种任务的评估验证了我们的方法。我们在一系列任务中取得了新的最先进表现，包括 ImageNet-CN、Flicker30k-CN 和 COCO-CN。此外，我们在几乎所有任务上与 CLIP 获得了非常接近的性能，表明可以简单地改变 CLIP 中的文本编码器以获得扩展能力，如多语言理解。

该模型由jongjyh贡献。

使用提示和示例

AltCLIP 的使用与 CLIP 非常相似，区别在于文本编码器。请注意，我们使用双向注意力而不是单向注意力，并且我们使用 XLM-R 中的[CLS]标记来表示文本嵌入。

AltCLIP 是一个多模态视觉和语言模型。它可用于图像文本相似度和零样本图像分类。AltCLIP 使用类似 ViT 的变压器来获取视觉特征，并使用双向语言模型来获取文本特征。然后将文本和视觉特征投影到具有相同维度的潜在空间中。然后使用投影图像和文本特征之间的点积作为相似分数。

为了将图像馈送到变压器编码器中，每个图像被分割成一系列固定大小且不重叠的补丁，然后进行线性嵌入。添加一个[CLS]标记作为整个图像的表示。作者还添加了绝对位置嵌入，并将结果向量序列馈送到标准变压器编码器。CLIPImageProcessor 可用于调整（或重新缩放）和规范化模型的图像。

AltCLIPProcessor 将 CLIPImageProcessor 和 XLMRobertaTokenizer 封装成一个单一实例，用于对文本进行编码和准备图像。以下示例展示了如何使用 AltCLIPProcessor 和 AltCLIPModel 获取图像文本相似度分数。

>>> from PIL import Image
>>> import requests

>>> from transformers import AltCLIPModel, AltCLIPProcessor

>>> model = AltCLIPModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AltCLIPProcessor.from_pretrained("BAAI/AltCLIP")

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

该模型基于CLIPModel，使用方式与原始的 CLIP 相同。

AltCLIPConfig

class transformers.AltCLIPConfig

<来源>

( text_config = None vision_config = None projection_dim = 768 logit_scale_init_value = 2.6592 **kwargs )

参数

  • text_config (dict, optional) — 用于初始化 AltCLIPTextConfig 的配置选项字典。

  • vision_config (dict, optional) — 用于初始化 AltCLIPVisionConfig 的配置选项字典。

  • projection_dim (int, optional, defaults to 768) — 文本和视觉投影层的维度。

  • logit_scale_init_value (float, optional, defaults to 2.6592) — logit_scale 参数的初始值。默认值根据原始的 CLIP 实现使用。

  • kwargs (optional) — 关键字参数的字典。

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

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

示例：

>>> from transformers import AltCLIPConfig, AltCLIPModel

>>> # Initializing a AltCLIPConfig with BAAI/AltCLIP style configuration
>>> configuration = AltCLIPConfig()

>>> # Initializing a AltCLIPModel (with random weights) from the BAAI/AltCLIP style configuration
>>> model = AltCLIPModel(configuration)

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

>>> # We can also initialize a AltCLIPConfig from a AltCLIPTextConfig and a AltCLIPVisionConfig

>>> # Initializing a AltCLIPText and AltCLIPVision configuration
>>> config_text = AltCLIPTextConfig()
>>> config_vision = AltCLIPVisionConfig()

>>> config = AltCLIPConfig.from_text_vision_configs(config_text, config_vision)

from_text_vision_configs

< source >

( text_config: AltCLIPTextConfig vision_config: AltCLIPVisionConfig **kwargs ) → export const metadata = 'undefined';AltCLIPConfig

返回

AltCLIPConfig

一个配置对象的实例

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

AltCLIPTextConfig

class transformers.AltCLIPTextConfig

< source >

( vocab_size = 250002 hidden_size = 1024 num_hidden_layers = 24 num_attention_heads = 16 intermediate_size = 4096 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 514 type_vocab_size = 1 initializer_range = 0.02 initializer_factor = 0.02 layer_norm_eps = 1e-05 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 position_embedding_type = 'absolute' use_cache = True project_dim = 768 **kwargs )

参数

  • vocab_size (int, optional, defaults to 250002) — AltCLIP 模型的词汇表大小。定义了在调用 AltCLIPTextModel 时可以表示的不同标记数量。

  • hidden_size (int, optional, defaults to 1024) — 编码器层和池化器层的维度。

  • num_hidden_layers (int, optional, defaults to 24) — Transformer 编码器中的隐藏层数量。

  • num_attention_heads (int, optional, defaults to 16) — Transformer 编码器中每个注意力层的注意力头数量。

  • intermediate_size (int, optional, defaults to 4096) — Transformer 编码器中“中间”（通常称为前馈）层的维度。

  • hidden_act (str or Callable, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"silu" 和 "gelu_new"。

  • hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。

  • attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的丢失比率。

  • max_position_embeddings (int, optional, defaults to 514) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512、1024 或 2048）。

  • type_vocab_size (int, optional, defaults to 1) — 在调用 AltCLIPTextModel 时传递的 token_type_ids 的词汇表大小。

  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

  • initializer_factor (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的因子（应保持为 1，用于内部初始化测试）。

  • layer_norm_eps (float, optional, 默认为 1e-05) — 层归一化层使用的 epsilon。

  • pad_token_id (int, optional, 默认为 1) — 填充 标记的 id。

  • bos_token_id (int, optional, 默认为 0) — 序列开始 标记的 id。

  • eos_token_id (Union[int, List[int]], optional, 默认为 2) — 序列结束 标记的 id。可选择使用列表设置多个 序列结束 标记。

  • 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。

  • use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力（不是所有模型都使用）。仅在 config.is_decoder=True 时相关。

  • project_dim (int, optional, 默认为 768) — 映射层之前教师模型的维度。

这是用于存储 AltCLIPTextModel 配置的配置类。根据指定的参数实例化一个 AltCLIP 文本模型的配置，定义模型架构。使用默认值实例化配置将产生类似于 AltCLIP BAAI/AltCLIP 架构的配置。

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

示例：

>>> from transformers import AltCLIPTextModel, AltCLIPTextConfig

>>> # Initializing a AltCLIPTextConfig with BAAI/AltCLIP style configuration
>>> configuration = AltCLIPTextConfig()

>>> # Initializing a AltCLIPTextModel (with random weights) from the BAAI/AltCLIP style configuration
>>> model = AltCLIPTextModel(configuration)

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

AltCLIPVisionConfig

class transformers.AltCLIPVisionConfig

< source >

( hidden_size = 768 intermediate_size = 3072 projection_dim = 512 num_hidden_layers = 12 num_attention_heads = 12 num_channels = 3 image_size = 224 patch_size = 32 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 **kwargs )

参数

  • hidden_size (int, optional, 默认为 768) — 编码器层和池化层的维度。

  • intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

  • projection_dim (int, optional, 默认为 512) — 文本和视觉投影层的维度。

  • num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。

  • num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。

  • num_channels (int, optional, 默认为 3) — 输入通道数。

  • image_size (int, optional, 默认为 224) — 每个图像的大小（分辨率）。

  • patch_size (int, optional, 默认为 32) — 每个 patch 的大小（分辨率）。

  • hidden_act (str 或 function, optional, 默认为"quick_gelu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "selu" 和 "gelu_new" 以及 "quick_gelu"。

  • layer_norm_eps (float, optional, 默认为 1e-05) — 层归一化层使用的 epsilon。

  • attention_dropout（float，可选，默认为 0.0）— 注意力概率的 dropout 比率。

  • initializer_range（float，可选，默认为 0.02）— 用于初始化所有权重矩阵的截断正态初始化器的标准差。

  • initializer_factor（float，可选，默认为 1.0）— 用于初始化所有权重矩阵的因子（应保持为 1，用于内部初始化测试）。

这是用于存储 AltCLIPModel 配置的配置类。它用于根据指定的参数实例化 AltCLIP 模型，定义模型架构。使用默认值实例化配置将产生类似于 AltCLIP BAAI/AltCLIP架构的配置。

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

示例：

>>> from transformers import AltCLIPVisionConfig, AltCLIPVisionModel

>>> # Initializing a AltCLIPVisionConfig with BAAI/AltCLIP style configuration
>>> configuration = AltCLIPVisionConfig()

>>> # Initializing a AltCLIPVisionModel (with random weights) from the BAAI/AltCLIP style configuration
>>> model = AltCLIPVisionModel(configuration)

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

AltCLIPProcessor

class transformers.AltCLIPProcessor

<来源>

( image_processor = None tokenizer = None **kwargs )

参数

  • image_processor（CLIPImageProcessor，可选）— 图像处理器是必需的。

  • tokenizer（XLMRobertaTokenizerFast，可选）— 分词器是必需的。

构建一个 AltCLIP 处理器，将 CLIP 图像处理器和 XLM-Roberta 分词器包装成一个单一处理器。

AltCLIPProcessor 提供了 CLIPImageProcessor 和 XLMRobertaTokenizerFast 的所有功能。查看__call__()和 decode()以获取更多信息。

batch_decode

<来源>

( *args **kwargs )

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

decode

<来源>

( *args **kwargs )

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

AltCLIPModel

class transformers.AltCLIPModel

<来源>

( config: AltCLIPConfig )

forward

<来源>

( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None position_ids: Optional = None token_type_ids: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.altclip.modeling_altclip.AltCLIPOutput or tuple(torch.FloatTensor)

参数

  • input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

    什么是输入 ID？

  • attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。选择在[0, 1]范围内的掩码值：

    • 对于未被掩码的标记为 1，

    • 对于被掩码的标记为 0。

    什么是注意力掩码？

  • position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

    什么是位置 ID？

  • pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 CLIPImageProcessor.call()。

  • return_loss (bool, 可选) — 是否返回对比损失。

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.altclip.modeling_altclip.AltCLIPOutput或tuple(torch.FloatTensor)

一个transformers.models.altclip.modeling_altclip.AltCLIPOutput或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时），包括根据配置(<class 'transformers.models.altclip.configuration_altclip.AltCLIPConfig'>)和输入的各种元素。

  • 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之间的缩放点积分数。这代表文本-图像相似性分数。

  • text_embeds(torch.FloatTensor，形状为(batch_size, output_dim) — 通过将投影层应用于 AltCLIPTextModel 的汇聚输出获得的文本嵌入。

  • image_embeds(torch.FloatTensor，形状为(batch_size, output_dim) — 通过将投影层应用于 AltCLIPVisionModel 的汇聚输出获得的图像嵌入。

  • text_model_output(BaseModelOutputWithPooling): AltCLIPTextModel 的输出。

  • vision_model_output(BaseModelOutputWithPooling): AltCLIPVisionModel 的输出。

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

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

示例：

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

>>> model = AltCLIPModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")
>>> 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

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None token_type_ids = 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（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

    什么是输入 ID？

  • attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 避免在填充令牌索引上执行注意力的掩码。选择在[0, 1]范围内的掩码值：

    • 对于未被屏蔽的标记，为 1，

    • 对于被屏蔽的标记，为 0。

    什么是注意力掩码？

  • position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

    什么是位置 ID？

  • output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

text_features（形状为(batch_size, output_dim)的torch.FloatTensor）

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

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

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

示例：

>>> from transformers import AutoProcessor, AltCLIPModel

>>> model = AltCLIPModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")
>>> inputs = processor(text=["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（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 CLIPImageProcessor.call()。

  • output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict（布尔值，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

image_features（形状为（batch_size，output_dim）的 torch.FloatTensor）

通过将投影层应用于 AltCLIPVisionModel 的汇聚输出获得的图像嵌入。

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

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

示例：

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

>>> model = AltCLIPModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")
>>> 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)

AltCLIPTextModel

class transformers.AltCLIPTextModel

<来源>

( config )

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None output_attentions: Optional = None return_dict: Optional = None output_hidden_states: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndProjection or tuple(torch.FloatTensor)

参数

  • input_ids（形状为（batch_size，sequence_length）的 torch.LongTensor）— 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

    什么是输入 ID？

  • attention_mask（形状为（batch_size，sequence_length）的 torch.Tensor，可选）— 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

    • 1 表示“未被掩盖”的标记，

    • 0 表示“被掩盖”的标记。

    什么是注意力掩码？

  • position_ids（形状为（batch_size，sequence_length）的 torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

    什么是位置 ID？

  • output_attentions（布尔值，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states（布尔值，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict（布尔值，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingAndProjection或tuple(torch.FloatTensor)

一个transformers.modeling_outputs.BaseModelOutputWithPoolingAndProjection或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，取决于配置（<class 'transformers.models.altclip.configuration_altclip.AltCLIPTextConfig'>）和输入。

  • last_hidden_state（形状为（batch_size，sequence_length，hidden_size）的 torch.FloatTensor）— 模型最后一层的隐藏状态序列输出。

  • 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 后的注意力权重，用于计算自注意力头中的加权平均值。

  • projection_state (tuple(torch.FloatTensor)，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size,config.project_dim)的torch.FloatTensor元组。

    投影层之前的文本嵌入，用于模仿教师编码器的最后隐藏状态。

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

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

示例：

>>> from transformers import AutoProcessor, AltCLIPTextModel

>>> model = AltCLIPTextModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")

>>> texts = ["it's a cat", "it's a dog"]

>>> inputs = processor(text=texts, padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states

AltCLIPVisionModel

class transformers.AltCLIPVisionModel

<来源>

( config: AltCLIPVisionConfig )

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 (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 CLIPImageProcessor.call()。

  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包括根据配置（<class 'transformers.models.altclip.configuration_altclip.AltCLIPVisionConfig'>）和输入的不同元素。

  • last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

  • pooler_output (torch.FloatTensor of shape (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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> model = AltCLIPVisionModel.from_pretrained("BAAI/AltCLIP")
>>> processor = AutoProcessor.from_pretrained("BAAI/AltCLIP")

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

BLIP

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/blip

概述

BLIP 模型是由 Junnan Li、Dongxu Li、Caiming Xiong 和 Steven Hoi 在BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation中提出的。

BLIP 是一个能够执行各种多模态任务的模型，包括：

  • 视觉问答

  • 图像-文本检索（图像-文本匹配）

  • 图像字幕生成

论文摘要如下：

视觉-语言预训练（VLP）已经提高了许多视觉-语言任务的性能。然而，大多数现有的预训练模型只擅长于理解型任务或生成型任务。此外，性能的提升主要是通过扩大数据集规模，使用从网络收集的带有噪声的图像-文本对来实现的，这是一种次优的监督来源。在本文中，我们提出了 BLIP，一种新的 VLP 框架，可以灵活地转移到视觉-语言理解和生成任务。BLIP 通过引导标题来有效利用嘈杂的网络数据，其中一个标题生成器生成合成标题，一个过滤器去除噪声标题。我们在各种视觉-语言任务上取得了最先进的结果，如图像-文本检索（平均召回率@1 提高了 2.7%）、图像字幕生成（CIDEr 提高了 2.8%）和 VQA（VQA 分数提高了 1.6%）。BLIP 还展示了在直接转移到视频-语言任务时的强大泛化能力。代码、模型和数据集已发布。

BLIP.gif

该模型由ybelkada贡献。原始代码可在此处找到。

资源

  • Jupyter 笔记本，介绍如何在自定义数据集上对 BLIP 进行图像字幕微调

BlipConfig

class transformers.BlipConfig

<来源>

( text_config = None vision_config = None projection_dim = 512 logit_scale_init_value = 2.6592 image_text_hidden_size = 256 **kwargs )

参数

  • text_config (dict, optional) — 用于初始化 BlipTextConfig 的配置选项字典。

  • vision_config (dict, optional) — 用于初始化 BlipVisionConfig 的配置选项字典。

  • projection_dim (int, optional, 默认为 512) — 文本和视觉投影层的维度。

  • logit_scale_init_value (float, optional, 默认为 2.6592) — logit_scale 参数的初始值。默认值与原始 BLIP 实现相同。

  • image_text_hidden_size (int, optional, 默认为 256) — 图像文本融合层隐藏状态的维度。

  • kwargs (optional) — 关键字参数的字典。

BlipConfig 是存储 BlipModel 配置的配置类。它用于根据指定的参数实例化一个 BLIP 模型，定义文本模型和视觉模型配置。使用默认值实例化配置将产生类似于 BLIP-base Salesforce/blip-vqa-base架构的配置。

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

示例：

>>> from transformers import BlipConfig, BlipModel

>>> # Initializing a BlipConfig with Salesforce/blip-vqa-base style configuration
>>> configuration = BlipConfig()

>>> # Initializing a BlipPModel (with random weights) from the Salesforce/blip-vqa-base style configuration
>>> model = BlipModel(configuration)

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

>>> # We can also initialize a BlipConfig from a BlipTextConfig and a BlipVisionConfig

>>> # Initializing a BLIPText and BLIPVision configuration
>>> config_text = BlipTextConfig()
>>> config_vision = BlipVisionConfig()

>>> config = BlipConfig.from_text_vision_configs(config_text, config_vision)

from_text_vision_configs

<来源>

( text_config: BlipTextConfig vision_config: BlipVisionConfig **kwargs ) → export const metadata = 'undefined';BlipConfig

返回

BlipConfig

配置对象的一个实例

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

BlipTextConfig

class transformers.BlipTextConfig

<来源>

( vocab_size = 30524 hidden_size = 768 encoder_hidden_size = 768 intermediate_size = 3072 projection_dim = 768 num_hidden_layers = 12 num_attention_heads = 8 max_position_embeddings = 512 hidden_act = 'gelu' layer_norm_eps = 1e-12 hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 bos_token_id = 30522 eos_token_id = 2 pad_token_id = 0 sep_token_id = 102 is_decoder = True use_cache = True **kwargs )

参数

  • vocab_size (int, optional, 默认为 30524) — Blip 文本模型的词汇量。定义了在调用 BlipModel 时可以表示的不同标记数量。

  • hidden_size (int, optional, 默认为 768) — 编码器层和池化器层的维度。

  • encoder_hidden_size (int, optional, 默认为 768) — 来自视觉模型的编码器层的维度。

  • intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

  • num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。

  • num_attention_heads (int, optional, 默认为 8) — Transformer 编码器中每个注意力层的注意力头数量。

  • max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512、1024 或 2048）。

  • hidden_act (str 或 function, optional, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "selu" 和 "gelu_new" "gelu"。

  • layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。

  • hidden_dropout_prob (float, optional, 默认为 0.0) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。

  • attention_dropout (float, optional, 默认为 0.0) — 注意力概率的丢弃比率。

  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

  • bos_token_id (int, optional, 默认为 30522) — beginning-of-sequence 标记的 id。

  • eos_token_id (int, optional, 默认为 2) — end-of-sequence 标记的 id。

  • pad_token_id (int, optional, 默认为 0) — padding 标记的 id。

  • sep_token_id (int, optional, 默认为 102) — separator 标记的 id。

  • is_decoder (bool, optional, 默认为 True) — 模型是否用作解码器。

  • use_cache (bool, optional, 默认为 True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

这是用于存储 BlipTextModel 配置的配置类。它用于根据指定的参数实例化一个 BLIP 文本模型，定义模型架构。使用默认值实例化配置将产生类似于由 base architectures 使用的 BlipText 的配置。

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

示例：

>>> from transformers import BlipTextConfig, BlipTextModel

>>> # Initializing a BlipTextConfig with Salesforce/blip-vqa-base style configuration
>>> configuration = BlipTextConfig()

>>> # Initializing a BlipTextModel (with random weights) from the Salesforce/blip-vqa-base style configuration
>>> model = BlipTextModel(configuration)

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

BlipVisionConfig

class transformers.BlipVisionConfig

< source >

( hidden_size = 768 intermediate_size = 3072 projection_dim = 512 num_hidden_layers = 12 num_attention_heads = 12 image_size = 384 patch_size = 16 hidden_act = 'gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 1e-10 **kwargs )

参数

  • hidden_size (int, optional, defaults to 768) — 编码器层和池化层的维度。

  • intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

  • num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数。

  • num_attention_heads (int, optional, defaults to 12) — 每个注意力层中的注意力头数。

  • image_size (int, optional, defaults to 384) — 每个图像的大小（分辨率）。

  • patch_size (int, optional, defaults to 16) — 每个 patch 的大小（分辨率）。

  • hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。

  • layer_norm_eps (float, optional, defaults to 1e-5) — 层归一化层使用的 epsilon。

  • attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。

  • initializer_range (float, optional, defaults to 1e-10) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

这是用于存储 BlipVisionModel 配置的配置类。它用于根据指定的参数实例化 BLIP 视觉模型，定义模型架构。实例化默认配置将产生类似于 Blip-base Salesforce/blip-vqa-base架构的配置。

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

示例：

>>> from transformers import BlipVisionConfig, BlipVisionModel

>>> # Initializing a BlipVisionConfig with Salesforce/blip-vqa-base style configuration
>>> configuration = BlipVisionConfig()

>>> # Initializing a BlipVisionModel (with random weights) from the Salesforce/blip-vqa-base style configuration
>>> model = BlipVisionModel(configuration)

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

BlipProcessor

class transformers.BlipProcessor

< source >

( image_processor tokenizer )

参数

  • image_processor (BlipImageProcessor) — 一个 BlipImageProcessor 的实例。图像处理器是必需的输入。

  • tokenizer (BertTokenizerFast) — 一个[‘BertTokenizerFast`]的实例。此 tokenizer 是必需的输入。

构建一个 BLIP 处理器，将 BERT tokenizer 和 BLIP 图像处理器包装成单个处理器。

BlipProcessor 提供了 BlipImageProcessor 和 BertTokenizerFast 的所有功能。有关更多信息，请参阅__call__()和 decode()的文档字符串。

batch_decode

< source >

( *args **kwargs )

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

decode

< source >

( *args **kwargs )

此方法将所有参数转发给 BertTokenizerFast 的 decode()。请参考此方法的文档字符串以获取更多信息。

BlipImageProcessor

class transformers.BlipImageProcessor

<来源>

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_convert_rgb: bool = True **kwargs )

参数

  • do_resize (bool, 可选, 默认为 True) — 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。

  • size (dict, 可选, 默认为 {"height" -- 384, "width": 384}): 调整大小后的输出图像尺寸。可以被preprocess方法中的size参数覆盖。

  • resample (PILImageResampling, 可选, 默认为 Resampling.BICUBIC) — 如果调整图像大小，则要使用的重采样滤波器。仅在do_resize设置为True时才有效。可以被preprocess方法中的resample参数覆盖。

  • do_rescale (bool, 可选, 默认为 True) — 是否按指定比例rescale_factor对图像进行重新缩放。可以被preprocess方法中的do_rescale参数覆盖。

  • rescale_factor (int 或 float, 可选, 默认为 1/255) — 如果重新缩放图像，则要使用的比例因子。仅在do_rescale设置为True时才有效。可以被preprocess方法中的rescale_factor参数覆盖。

  • do_normalize (bool, 可选, 默认为 True) — 是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。可以被preprocess方法中的do_normalize参数覆盖。

  • image_mean (float 或 List[float], 可选, 默认为 IMAGENET_STANDARD_MEAN) — 在归一化图像时使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_mean参数覆盖。可以被preprocess方法中的image_mean参数覆盖。

  • image_std (float 或 List[float], 可选, 默认为 IMAGENET_STANDARD_STD) — 在归一化图像时使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_std参数覆盖。可以被preprocess方法中的image_std参数覆盖。

  • do_convert_rgb (bool, 可选, 默认为 True) — 是否将图像转换为 RGB。

构建一个 BLIP 图像处理器。

preprocess

<来源>

( images: Union do_resize: Optional = None size: Optional = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None return_tensors: Union = None do_convert_rgb: bool = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

  • images (ImageInput) — 要预处理的图像。期望传入像素值范围为 0 到 255 的单个图像或图像批次。如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。

  • do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像。

  • size (Dict[str, int], 可选, 默认为 self.size) — 控制resize后图像的大小。图像的最短边被调整为size["shortest_edge"]，同时保持纵横比。如果此调整后图像的最长边 > int(size["shortest_edge"] * (1333 / 800))，则再次调整图像大小，使最长边等于int(size["shortest_edge"] * (1333 / 800))。

  • resample (PILImageResampling, 可选, 默认为 self.resample) — 如果调整图像大小，则要使用的重采样滤波器。仅在do_resize设置为True时才有效。

  • do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否将图像值重新缩放在[0 - 1]之间。

  • rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果do_rescale设置为True，则要按照此比例因子重新缩放图像。

  • do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。

  • image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 如果 do_normalize 设置为 True，用于归一化图像的图像均值。

  • image_std (float 或 List[float], 可选, 默认为 self.image_std) — 如果 do_normalize 设置为 True，用于归一化图像的图像标准差。

  • do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb) — 是否将图像转换为 RGB。

  • return_tensors (str 或 TensorType, 可选) — 要返回的张量类型。可以是以下之一：

    • 未设置：返回一个 np.ndarray 列表。

    • TensorType.TENSORFLOW 或 'tf': 返回一个类型为 tf.Tensor 的批次。

    • TensorType.PYTORCH 或 'pt': 返回一个类型为 torch.Tensor 的批次。

    • TensorType.NUMPY 或 'np': 返回一个类型为 np.ndarray 的批次。

    • TensorType.JAX 或 'jax': 返回一个类型为 jax.numpy.ndarray 的批次。

  • data_format (ChannelDimension 或 str, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：

    • "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (通道数, 高度, 宽度)。

    • "channels_last" 或 ChannelDimension.LAST: 图像格式为 (高度, 宽度, 通道数)。

    • 未设置：使用输入图像的通道维度格式。

  • input_data_format (ChannelDimension 或 str, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：

    • "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (通道数, 高度, 宽度)。

    • "channels_last" 或 ChannelDimension.LAST: 图像格式为 (高度, 宽度, 通道数)。

    • "none" 或 ChannelDimension.NONE: 图像格式为 (高度, 宽度)。

预处理图像或图像批次。

Pytorch 隐藏 Pytorch 内容

BlipModel

class transformers.BlipModel

<来源>

( config: BlipConfig )

参数

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

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

该模型还是一个 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 return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_blip.BlipOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，提供填充将被忽略。

    可以使用 AutoProcessor 获取索引。有关详细信息，请参阅 BlipProcessor.__call__()。

    什么是输入 ID？

  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。选择在 [0, 1] 中的掩码值：

    • 1 代表未被“掩码”的标记，

    • 0 代表被“掩码”的标记。

    什么是注意力掩码？

  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 ID？

  • pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。默认情况下会忽略填充。可以使用 BlipImageProcessor 获取像素值。详细信息请参见 BlipImageProcessor.call()。

  • return_loss (bool，可选) — 是否返回对比损失。

  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。

  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。

  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_blip.BlipOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.blip.modeling_blip.BlipOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置 (<class 'transformers.models.blip.configuration_blip.BlipConfig'>) 和输入而异的各种元素。

  • 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 之间的缩放点积分数。这代表文本-图像相似性分数。

  • text_embeds(torch.FloatTensor，形状为 (batch_size, output_dim) — 通过将投影层应用于 BlipTextModel 的池化输出获得的文本嵌入。

  • image_embeds(torch.FloatTensor，形状为 (batch_size, output_dim) — 通过将投影层应用于 BlipVisionModel 的池化输出获得的图像嵌入。

  • text_model_output(BaseModelOutputWithPooling): BlipTextModel 的输出。

  • vision_model_output(BaseModelOutputWithPooling): BlipVisionModel 的输出。

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

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

示例：

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

>>> model = BlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

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

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。

    可以使用 AutoProcessor 获取索引。有关详细信息，请参阅BlipProcessor.__call__()。

    什么是输入 ID？

  • attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]范围内：

    • 1 表示未被掩盖的标记，

    • 0 表示被掩盖的标记。

    什么是注意力掩码？

  • position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

    什么是位置 ID？

  • output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

text_features（形状为(batch_size, output_dim)的torch.FloatTensor

通过将投影层应用于 BlipTextModel 的池化输出获得的文本嵌入。

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

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

示例：

>>> from transformers import AutoProcessor, BlipModel

>>> model = BlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

>>> inputs = processor(text=["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 return_dict: Optional = None ) → export const metadata = 'undefined';image_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

  • pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息，请参阅 BlipImageProcessor.call()。

  • output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

image_features（形状为(batch_size, output_dim)的torch.FloatTensor

通过将投影层应用于 BlipVisionModel 的池化输出获得的图像嵌入。

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

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

示例：

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

>>> model = BlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

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

>>> image_features = model.get_image_features(**inputs)

BlipTextModel

class transformers.BlipTextModel

<来源>

( config add_pooling_layer = True )

该模型可以作为编码器（仅具有自注意力）以及解码器运行，此时在自注意力层之间添加了一层交叉注意力，遵循Ashish Vaswani，Noam Shazeer，Niki Parmar，Jakob Uszkoreit，Llion Jones，Aidan N. Gomez，Lukasz Kaiser 和 Illia Polosukhin 所描述的架构。参数和is_decoder设置为True；然后预期将encoder_hidden_states作为输入传递给前向传递。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_embeds: 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 is_decoder: Optional = False )

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

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。past_key_values（tuple(tuple(torch.FloatTensor))，可选）：包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用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）。

BlipVisionModel

class transformers.BlipVisionModel

<来源>

( config: BlipVisionConfig )

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）— 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息，请参阅 BlipImageProcessor.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.blip.configuration_blip.BlipVisionConfig'>）和输入的不同元素。

  • last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层的隐藏状态序列。

  • 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 之后，用于计算自注意力头中的加权平均值。

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

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

BlipForConditionalGeneration

class transformers.BlipForConditionalGeneration

<来源>

( config: BlipConfig )

参数

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

用于图像字幕的 BLIP 模型。该模型由视觉编码器和文本解码器组成。可以选择向模型传递input_ids，作为文本提示，以使文本解码器继续提示。否则，解码器将从[BOS]（序列开始）标记开始生成文本。将从文本输入开始生成标题。如果未提供文本输入，则解码器将仅从[BOS]标记开始。

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

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

forward

<来源>

( pixel_values: FloatTensor input_ids: Optional = None 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.blip.modeling_blip.BlipForConditionalGenerationModelOutput or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息，请参阅 BlipImageProcessor.call()。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多细节，请参阅返回张量中的 attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多细节，请参阅返回张量中的 hidden_states。

  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput 或 torch.FloatTensor 元组

一个 transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>）和输入的不同元素。

  • loss (torch.FloatTensor, optional, 当提供 labels 时返回，形状为 (1,) 的 torch.FloatTensor) — 文本解码器的语言建模损失。

  • logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.vocab_size)，optional) — 文本解码器模型的语言建模头的预测分数。

  • image_embeds (torch.FloatTensor，形状为 (batch_size, output_dim)，optional) — 将 Vision Transformer 模型应用于输入图像后获得的图像嵌入。

  • last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，optional) — 模型最后一层的隐藏状态序列。

  • hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True) — torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入的输出 + 每个层的输出）的形状为 (batch_size, sequence_length, hidden_size)。

    模型在每个层的输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个）的形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
>>> model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "A picture of"

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

>>> outputs = model(**inputs)

BlipForImageTextRetrieval

class transformers.BlipForImageTextRetrieval

< source >

( config: BlipConfig )

参数

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

带有视觉和文本投影仪以及顶部分类头的 BLIP 模型。该模型用于图像文本检索的上下文。给定一张图像和一段文本，模型返回文本与图像相关的概率。

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

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

forward

<来源>

( input_ids: LongTensor pixel_values: FloatTensor use_itm_head: Optional = True attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_blip.BlipTextVisionModelOutput or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)） — 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息，请参见 BlipImageProcessor.call()。

  • output_attentions (bool，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

  • return_dict (bool，optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_blip.BlipTextVisionModelOutput 或 tuple(torch.FloatTensor)

一个transformers.models.blip.modeling_blip.BlipTextVisionModelOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>）和输入的不同元素。

  • loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回） — 文本解码器的语言建模损失。

  • image_embeds (torch.FloatTensor，形状为(batch_size, output_dim) optional，当模型使用with_projection=True初始化时返回） — 通过将投影层应用于 pooler_output 获得的图像嵌入。

  • last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)） — 模型最后一层的隐藏状态序列。

  • 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> model = BlipForImageTextRetrieval.from_pretrained("Salesforce/blip-itm-base-coco")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-itm-base-coco")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "an image of a cat"

>>> inputs = processor(images=image, text=text, return_tensors="pt")
>>> outputs = model(**inputs)

BlipForQuestionAnswering

class transformers.BlipForQuestionAnswering

<来源>

( config: BlipConfig )

参数

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

用于视觉问答的 BLIP 模型。该模型包括一个视觉编码器、一个文本编码器以及一个文本解码器。视觉编码器将对输入图像进行编码，文本编码器将对输入问题进行编码，并与图像的编码一起进行编码，文本解码器将输出问题的答案。

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

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

forward

<来源>

( input_ids: LongTensor pixel_values: FloatTensor decoder_input_ids: Optional = None decoder_attention_mask: Optional = None 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.blip.modeling_blip.BlipTextVisionModelOutput or tuple(torch.FloatTensor)

参数

  • pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息，请参阅 BlipImageProcessor.call()。

  • output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回的张量下的attentions。

  • output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回的张量下的hidden_states。

  • return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_blip.BlipTextVisionModelOutput或tuple(torch.FloatTensor)

一个transformers.models.blip.modeling_blip.BlipTextVisionModelOutput或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包含根据配置（<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>）和输入的不同元素。

  • loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 来自文本解码器的语言建模损失。

  • image_embeds（形状为(batch_size, output_dim)的torch.FloatTensor 可选，当使用with_projection=True初始化模型时返回）- 通过将投影层应用于 pooler_output 获得的图像嵌入。

  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> model = BlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-vqa-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> # training
>>> text = "How many cats are in the picture?"
>>> label = "2"
>>> inputs = processor(images=image, text=text, return_tensors="pt")
>>> labels = processor(text=label, return_tensors="pt").input_ids

>>> inputs["labels"] = labels
>>> outputs = model(**inputs)
>>> loss = outputs.loss
>>> loss.backward()

>>> # inference
>>> text = "How many cats are in the picture?"
>>> inputs = processor(images=image, text=text, return_tensors="pt")
>>> outputs = model.generate(**inputs)
>>> print(processor.decode(outputs[0], skip_special_tokens=True))
2

TensorFlow 隐藏 TensorFlow 内容

TFBlipModel

class transformers.TFBlipModel

<来源>

( config: BlipConfig *inputs **kwargs )

call

<来源>

( input_ids: tf.Tensor | None = None pixel_values: tf.Tensor | None = None attention_mask: tf.Tensor | None = None position_ids: tf.Tensor | None = None return_loss: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_tf_blip.TFBlipOutput or tuple(tf.Tensor)

参数

  • input_ids（形状为(batch_size, sequence_length)的tf.Tensor） — 输入序列标记在词汇表中的索引。默认情况下，如果提供了填充，将忽略填充。

    可以使用 AutoProcessor 获取索引。有关详细信息，请参阅BlipProcessor.__call__()。

    什么是输入 ID？

  • attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选） — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

    • 1 表示未被掩码的标记，

    • 0 表示被掩码的标记。

    什么是注意力掩码？

  • position_ids（形状为(batch_size, sequence_length)的tf.Tensor，可选） — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

    什么是位置 ID？

  • pixel_values（形状为(batch_size, num_channels, height, width)的tf.Tensor） — 像素值。默认情况下，如果提供了填充，将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息，请参阅 BlipImageProcessor.call()。

  • return_loss（bool，可选） — 是否返回对比损失。

  • output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict（bool，可选） — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.models.blip.modeling_tf_blip.TFBlipOutput或tuple(tf.Tensor)

一个transformers.models.blip.modeling_tf_blip.TFBlipOutput或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（<class 'transformers.models.blip.configuration_blip.BlipConfig'>）和输入的各种元素。

  • 损失（形状为(1,)的tf.Tensor，可选，当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 之间的缩放点积分数。这代表了文本-图像相似性分数。

  • text_embeds(tf.Tensor 的形状为 (batch_size, output_dim) — 通过将投影层应用于 BlipTextModel 的汇聚输出获得的文本嵌入。

  • image_embeds(tf.Tensor 的形状为 (batch_size, output_dim) — 通过将投影层应用于 BlipVisionModel 的汇聚输出获得的图像嵌入。

  • text_model_output(BaseModelOutputWithPooling): BlipTextModel 的输出。

  • vision_model_output(BaseModelOutputWithPooling): BlipVisionModel 的输出。

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

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

示例：

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

>>> model = TFBlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

>>> 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.nn.softmax(logits_per_image, axis=1)  # we can take the softmax to get the label probabilities

get_text_features

< source >

( input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None position_ids: tf.Tensor | None = None return_dict: Optional[bool] = None ) → export const metadata = 'undefined';text_features (tf.Tensor of shape (batch_size, output_dim)

参数

  • input_ids (tf.Tensor 的形状为 (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。默认情况下将忽略填充。

    可以使用 AutoProcessor 获得索引。有关详细信息，请参阅 BlipProcessor.__call__()。

    什么是输入 ID？

  • attention_mask (tf.Tensor 的形状为 (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：

    • 1 代表未被“masked”的标记，

    • 对于被masked的标记。

    什么是注意力掩码？

  • position_ids (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 而不是普通元组。

返回

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

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

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

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

示例：

>>> from transformers import AutoProcessor, TFBlipModel

>>> model = TFBlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

>>> inputs = processor(text=["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: tf.Tensor | None = None return_dict: Optional[bool] = None ) → export const metadata = 'undefined';image_features (tf.Tensor of shape (batch_size, output_dim)

参数

  • pixel_values (tf.Tensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息，请参阅 BlipImageProcessor.call()。

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

image_features (tf.Tensor，形状为(batch_size, output_dim)

通过将 TFBlipVisionModel 的池化输出应用于投影层获得的图像嵌入。

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

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

示例：

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

>>> model = TFBlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")

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

TFBlipTextModel

class transformers.TFBlipTextModel

<来源>

( config add_pooling_layer = True name = None **kwargs )

该模型可以作为编码器（仅具有自注意力）以及解码器运行，此时在自注意力层之间添加了一层交叉注意力，遵循Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser 和 Illia Polosukhin 在《Attention is all you need》中描述的架构。参数is_decoder设置为True；然后期望输入到前向传递的encoder_hidden_states。

调用

<来源>

( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None encoder_embeds: tf.Tensor | None = None encoder_hidden_states: tf.Tensor | None = None encoder_attention_mask: tf.Tensor | None = None past_key_values: Tuple[Tuple[tf.Tensor]] | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None is_decoder: bool = False training: bool = False )

参数

  • input_ids (tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

    可以使用 AutoProcessor 获取索引。有关详细信息，请参阅BlipProcessor.__call__()。

    什么是输入 ID？

  • attention_mask (tf.Tensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

    • 对于未被masked的标记为 1，

    • 对于被masked的标记为 0。

    什么是注意力掩码？

  • position_ids (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 而不是普通元组。

  • encoder_hidden_states (tf.Tensor, optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

  • encoder_attention_mask (tf.Tensor, optional) — 遮罩，用于避免在编码器输入的填充令牌索引上执行注意力。如果模型配置为解码器，则在交叉注意力中使用此遮罩。遮罩值选在 [0, 1] 之间：

    • 1 表示未被遮罩的令牌，

    • 0 表示被遮罩的令牌。

  • past_key_values (tuple(tuple(tf.Tensor)), optional) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用了 past_key_values，用户可以选择仅输入最后的 decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）形状为 (batch_size, 1)，而不是所有 decoder_input_ids 的形状为 (batch_size, sequence_length)。

  • use_cache (bool, optional) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。

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

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

TFBlipVisionModel

class transformers.TFBlipVisionModel

< source >

( config: BlipVisionConfig *args **kwargs )

call

< source >

( pixel_values: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling or tuple(tf.Tensor)

参数

  • pixel_values (tf.Tensor，形状为 (batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充，如果提供的话。可以使用 BlipImageProcessor 获取像素值。有关详细信息，请参阅 BlipImageProcessor.call()。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的 attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的 hidden_states。

  • return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

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.blip.configuration_blip.BlipVisionConfig'>) 和输入不同元素。

  • 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), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size)。

    模型在每个层的输出的隐藏状态加上初始嵌入输出。

  • attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。

    在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

TFBlipForConditionalGeneration

class transformers.TFBlipForConditionalGeneration

<来源>

( config: BlipConfig *args **kwargs )

参数

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

用于图像字幕的 BLIP 模型。该模型由视觉编码器和文本解码器组成。可以选择向模型传递input_ids，这些作为文本提示，以使文本解码器继续提示。否则，解码器将从[BOS]（序列开始）标记开始生成文本。将从文本输入开始生成标题。如果未提供文本输入，则解码器将仅从[BOS]标记开始。

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

该模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

call

<来源>

( pixel_values: tf.Tensor input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None labels: tf.Tensor | None = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutput or tuple(tf.Tensor)

参数

  • pixel_values (tf.Tensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息，请参阅 BlipImageProcessor.call()。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutput 或 tuple(tf.Tensor)

一个transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutput或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False）包含根据配置（<class 'transformers.models.blip.configuration_blip.BlipConfig'>）和输入的不同元素。

  • loss（tf.Tensor，可选，当提供labels时返回，形状为(1,)的tf.Tensor）- 来自文本解码器的语言建模损失。

  • logits（形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor，可选）- 文本解码器模型语言建模头的预测分数。

  • image_embeds（形状为(batch_size, output_dim)的tf.Tensor，可选）- 在将输入图像应用于 Vision Transformer 模型后获得的图像嵌入。

  • last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）- 模型最后一层输出的隐藏状态序列。

  • hidden_states（tuple(tf.Tensor)，可选，当output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（如果模型有嵌入层，则为嵌入输出的一个+每层输出的一个）。

    模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

    注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。`

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

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

示例：

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

>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
>>> model = TFBlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "A picture of"

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

>>> outputs = model(**inputs)

TFBlipForImageTextRetrieval

class transformers.TFBlipForImageTextRetrieval

<来源>

( config: BlipConfig *args **kwargs )

参数

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

带有视觉和文本投影器以及顶部分类头的 BLIP 模型。该模型用于图像文本检索的上下文。给定一张图像和一段文本，模型返回文本与图像相关的概率。

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

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

call

<来源>

( input_ids: tf.Tensor pixel_values: tf.Tensor | None = None use_itm_head: Optional[bool] = True attention_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput or tuple(tf.Tensor)

参数

  • pixel_values（形状为(batch_size, num_channels, height, width)的tf.Tensor）— 像素值。默认情况下将忽略填充。如果提供填充，可以使用 BlipImageProcessor 获取像素值。有关详细信息，请参阅 BlipImageProcessor.call()。

  • output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多细节，请参阅返回张量中的attentions。

  • output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多细节，请参阅返回张量中的hidden_states。

  • return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput或tuple(tf.Tensor)

一个transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput或一个tf.Tensor元组（如果传递return_dict=False或当config.return_dict=False时）包含根据配置（<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>）和输入的不同元素。

  • itm_score（tf.Tensor）— 图像文本相似性分数。

  • loss（形状为(1,)的tf.Tensor，可选，在提供labels时返回）— 文本解码器的语言建模损失。

  • image_embeds（形状为(batch_size, output_dim)的tf.Tensor，可选，在使用with_projection=True初始化模型时返回）— 通过将 pooler_output 应用到投影层获得的图像嵌入。

  • last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型最后一层的隐藏状态序列。

  • hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组。

    模型在每一层输出的隐藏状态加上可选的初始嵌入输出。

  • vision_pooler_output（形状为(batch_size, 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

  • question_embeds（tf.Tensor）— 由文本投影层获得的问题嵌入。

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

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

示例：

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

>>> model = TFBlipForImageTextRetrieval.from_pretrained("Salesforce/blip-itm-base-coco")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-itm-base-coco")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "an image of a cat"

>>> inputs = processor(images=image, text=text, return_tensors="tf")
>>> outputs = model(**inputs)

TFBlipForQuestionAnswering

class transformers.TFBlipForQuestionAnswering

<来源>

( config: BlipConfig *args **kwargs )

参数

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

用于视觉问答的 BLIP 模型。该模型包括一个视觉编码器、一个文本编码器以及一个文本解码器。视觉编码器将对输入图像进行编码，文本编码器将对输入问题以及图像的编码进行编码，文本解码器将输出问题的答案。

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

该模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

call

< source >

( input_ids: tf.Tensor pixel_values: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None attention_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None labels: tf.Tensor | None = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → export const metadata = 'undefined';transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutput or tuple(tf.Tensor)

参数

  • pixel_values (tf.Tensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息，请参阅 BlipImageProcessor.call()。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutput或tuple(tf.Tensor)

一个transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutput或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>)和输入的各种元素。

  • loss (tf.Tensor，形状为(1,)，optional，当提供labels时返回) — 来自文本解码器的语言建模损失。

  • image_embeds (tf.Tensor，形状为(batch_size, output_dim) optional，当模型使用with_projection=True初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。

  • last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

  • hidden_states (tuple(tf.Tensor), optional, 当传递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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> model = TFBlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-vqa-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> # training
>>> text = "How many cats are in the picture?"
>>> label = "2"
>>> inputs = processor(images=image, text=text, return_tensors="tf")
>>> labels = processor(text=label, return_tensors="tf").input_ids

>>> inputs["labels"] = labels
>>> outputs = model(**inputs)
>>> loss = outputs.loss

>>> # inference
>>> text = "How many cats are in the picture?"
>>> inputs = processor(images=image, text=text, return_tensors="tf")
>>> outputs = model.generate(**inputs)
>>> print(processor.decode(outputs[0], skip_special_tokens=True))
2

BLIP-2

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/blip-2

概述

BLIP-2 模型由 Junnan Li、Dongxu Li、Silvio Savarese、Steven Hoi 在BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models中提出。BLIP-2 利用冻结的预训练图像编码器和大型语言模型（LLMs），通过在它们之间训练一个轻量级的 12 层 Transformer 编码器，实现了各种视觉-语言任务的最先进性能。值得注意的是，BLIP-2 在零样本 VQAv2 上比Flamingo（一个 80 亿参数模型）提高了 8.7%，并且可训练参数数量减少了 54 倍。

论文摘要如下：

由于大规模模型的端到端训练，视觉-语言预训练的成本变得越来越高。本文提出了 BLIP-2，一种通用且高效的预训练策略，从现成的冻结预训练图像编码器和冻结大型语言模型中引导视觉-语言预训练。BLIP-2 通过轻量级的 Querying Transformer 消除了模态差异，该模型经过两个阶段的预训练。第一阶段从冻结图像编码器引导视觉-语言表示学习。第二阶段从冻结语言模型引导视觉-语言生成学习。尽管可训练参数数量明显少于现有方法，但 BLIP-2 在各种视觉-语言任务上实现了最先进的性能。例如，我们的模型在零样本 VQAv2 上比 Flamingo80B 提高了 8.7%，并且可训练参数数量减少了 54 倍。我们还展示了模型的新兴能力，即零样本图像到文本生成，可以遵循自然语言指令。

drawing BLIP-2 架构。摘自原始论文。

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

使用提示

  • BLIP-2 可用于在给定图像和可选文本提示的情况下进行条件文本生成。在推理时，建议使用 generate 方法。

  • 可以使用 Blip2Processor 来为模型准备图像，并将预测的标记 ID 解码回文本。

资源

官方 Hugging Face 和社区（由🌎表示）资源列表，帮助您开始使用 BLIP-2。

  • BLIP-2 的演示笔记本用于图像字幕、视觉问答（VQA）和类似对话的会话，可在此处找到。

如果您有兴趣提交资源以包含在此处，请随时提交拉取请求，我们将进行审查！资源应该理想地展示一些新内容，而不是重复现有资源。

Blip2Config

class transformers.Blip2Config

< source >

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

参数

  • vision_config (dict, 可选) — 用于初始化 Blip2VisionConfig 的配置选项字典。

  • qformer_config (dict, 可选) — 用于初始化 Blip2QFormerConfig 的配置选项字典。

  • text_config (dict, 可选) — 用于初始化任何 PretrainedConfig 的配置选项字典。

  • num_query_tokens (int, optional, defaults to 32) — 通过 Transformer 传递的查询令牌数量。

  • kwargs (optional) — 关键字参数的字典。

Blip2Config 是用于存储 Blip2ForConditionalGeneration 配置的配置类。根据指定的参数实例化一个 BLIP-2 模型，定义视觉模型、Q-Former 模型和语言模型配置。使用默认配置实例化将产生类似于 BLIP-2 Salesforce/blip2-opt-2.7b 架构的配置。

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

示例：

>>> from transformers import (
...     Blip2VisionConfig,
...     Blip2QFormerConfig,
...     OPTConfig,
...     Blip2Config,
...     Blip2ForConditionalGeneration,
... )

>>> # Initializing a Blip2Config with Salesforce/blip2-opt-2.7b style configuration
>>> configuration = Blip2Config()

>>> # Initializing a Blip2ForConditionalGeneration (with random weights) from the Salesforce/blip2-opt-2.7b style configuration
>>> model = Blip2ForConditionalGeneration(configuration)

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

>>> # We can also initialize a Blip2Config from a Blip2VisionConfig, Blip2QFormerConfig and any PretrainedConfig

>>> # Initializing BLIP-2 vision, BLIP-2 Q-Former and language model configurations
>>> vision_config = Blip2VisionConfig()
>>> qformer_config = Blip2QFormerConfig()
>>> text_config = OPTConfig()

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

from_vision_qformer_text_configs

< source >

( vision_config: Blip2VisionConfig qformer_config: Blip2QFormerConfig text_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';Blip2Config

返回

Blip2Config

配置对象的实例

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

Blip2VisionConfig

class transformers.Blip2VisionConfig

< 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, optional, defaults to 1408) — 编码器层和池化层的维度。

  • intermediate_size (int, optional, defaults to 6144) — Transformer 编码器中“中间”（即前馈）层的维度。

  • num_hidden_layers (int, optional, defaults to 39) — Transformer 编码器中的隐藏层数量。

  • num_attention_heads (int, optional, defaults to 16) — Transformer 编码器中每个注意力层的注意力头数量。

  • image_size (int, optional, defaults to 224) — 每个图像的大小（分辨率）。

  • patch_size (int, optional, defaults to 14) — 每个补丁的大小（分辨率）。

  • hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new" "gelu"。layer_norm_eps (float, optional, defaults to 1e-5): 层归一化层使用的 epsilon。

  • attention_dropout (float, optional, defaults to 0.0) — 注意力概率的丢失比率。

  • initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

  • qkv_bias (bool, optional, defaults to True) — 是否在自注意力层中为查询和值添加偏置。

这是用于存储 Blip2VisionModel 配置的配置类。根据指定的参数实例化一个 BLIP-2 视觉编码器，定义模型架构。实例化默认配置将产生类似于 BLIP-2 Salesforce/blip2-opt-2.7b 架构的配置。

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

示例：

>>> from transformers import Blip2VisionConfig, Blip2VisionModel

>>> # Initializing a Blip2VisionConfig with Salesforce/blip2-opt-2.7b style configuration
>>> configuration = Blip2VisionConfig()

>>> # Initializing a Blip2VisionModel (with random weights) from the Salesforce/blip2-opt-2.7b style configuration
>>> model = Blip2VisionModel(configuration)

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

Blip2QFormerConfig

class transformers.Blip2QFormerConfig

< source >

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 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, defaults to 30522) — Q-Former 模型的词汇量。定义在调用模型时传递的 inputs_ids 可表示的不同标记数量。

  • hidden_size (int, optional, defaults to 768) — 编码器层和池化层的维度。

  • num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数。

  • num_attention_heads (int, optional, defaults to 12) — 每个注意力层中的注意力头数。

  • intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。

  • hidden_act (str or Callable, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"silu" 和 "gelu_new"。

  • hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

  • attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。

  • max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如，512、1024 或 2048）。

  • initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

  • layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。

  • position_embedding_type (str, optional, defaults to "absolute") — 位置嵌入的类型。选择 "absolute"、"relative_key"、"relative_key_query" 中的一个。对于位置嵌入，请使用 "absolute"。有关 "relative_key" 的更多信息，请参考Self-Attention with Relative Position Representations (Shaw et al.)。有关 "relative_key_query" 的更多信息，请参考Improve Transformer Models with Better Relative Position Embeddings (Huang et al.) 中的 Method 4。

  • cross_attention_frequency (int, optional, defaults to 2) — 向 Transformer 层添加交叉注意力的频率。

  • encoder_hidden_size (int, optional, defaults to 1408) — 交叉注意力中隐藏状态的隐藏大小。

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

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

示例：

>>> from transformers import Blip2QFormerConfig, Blip2QFormerModel

>>> # Initializing a BLIP-2 Salesforce/blip2-opt-2.7b style configuration
>>> configuration = Blip2QFormerConfig()

>>> # Initializing a model (with random weights) from the Salesforce/blip2-opt-2.7b style configuration
>>> model = Blip2QFormerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

Blip2Processor

class transformers.Blip2Processor

< source >

( image_processor tokenizer )

参数

  • image_processor（BlipImageProcessor）— BlipImageProcessor 的一个实例。图像处理器是必需的输入。

  • tokenizer（AutoTokenizer）— [‘PreTrainedTokenizer’]的一个实例。分词器是必需的输入。

构建一个 BLIP-2 处理器，将 BLIP 图像处理器和 OPT/T5 分词器封装到一个处理器中。

BlipProcessor 提供了 BlipImageProcessor 和 AutoTokenizer 的所有功能。有关更多信息，请参阅__call__()和 decode()的文档字符串。

batch_decode

< source >

( *args **kwargs )

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

解码

< source >

( *args **kwargs )

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

Blip2VisionModel

class transformers.Blip2VisionModel

< source >

( config: Blip2VisionConfig )

前进

< 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（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。像素值可以使用 Blip2Processor 获得。有关详细信息，请参阅Blip2Processor.__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.blip_2.configuration_blip_2.Blip2VisionConfig'>）和输入的各种元素。

  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

Blip2QFormerModel

class transformers.Blip2QFormerModel

<来源>

( config: Blip2QFormerConfig )

查询变压器（Q-Former），用于 BLIP-2。

forward

<来源>

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

  • 对于未被“掩盖”的标记为 1，

  • 对于被“掩盖”的标记为 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）。

Blip2Model

class transformers.Blip2Model

<来源>

( config: Blip2Config )

参数

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

用于生成文本和图像特征的 BLIP-2 模型。该模型由视觉编码器、查询变换器（Q-Former）和语言模型组成。

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

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

forward

<来源>

( pixel_values: FloatTensor input_ids: FloatTensor 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.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput or tuple(torch.FloatTensor)

参数

  • pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。可以使用 Blip2Processor 获取像素值。有关详细信息，请参阅Blip2Processor.__call__()。

  • input_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 语言模型词汇表中输入序列标记的索引。输入标记可以选择性地提供作为文本提示，语言模型可以继续。

    可以使用 Blip2Processor 获取索引。有关详细信息，请参阅Blip2Processor.__call__()。

    什么是输入 ID？

  • attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

    • 1 用于“未掩码”标记的标记，

    • 0 用于“掩码”标记的标记。

    什么是注意力掩码？

  • decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 语言模型词汇表中解码器输入序列标记的索引。仅在使用编码器-解码器语言模型（如 T5）时相关。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是解码器输入 ID？

  • decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.BoolTensor，可选）— 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。

    仅在使用编码器-解码器语言模型（如 T5）时相关。

  • output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。

  • output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。

  • return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput 或 tuple(torch.FloatTensor)

transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含各种元素，取决于配置（<class 'transformers.models.blip_2.configuration_blip_2.Blip2VisionConfig'>）和输入。

  • loss（torch.FloatTensor，可选，在提供 labels 时返回，形状为 (1,) 的 torch.FloatTensor）— 语言模型的语言建模损失。

  • logits（形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor）— 语言模型的语言建模头的预测分数。

  • vision_outputs（BaseModelOutputWithPooling）— 视觉编码器的输出。

  • qformer_outputs（BaseModelOutputWithPoolingAndCrossAttentions）— Q-Former（Querying Transformer）的输出。

  • language_model_outputs（CausalLMOutputWithPast 或 Seq2SeqLMOutput）— 语言模型的输出。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import Blip2Processor, Blip2Model
>>> import torch

>>> device = "cuda" if torch.cuda.is_available() else "cpu"

>>> processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b", torch_dtype=torch.float16)
>>> model.to(device)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> prompt = "Question: how many cats are there? Answer:"
>>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device, torch.float16)

>>> outputs = model(**inputs)

get_text_features

< source >

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';text_outputs (CausalLMOutputWithPast, or tuple(torch.FloatTensor) if return_dict=False)

参数

  • input_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor）— 词汇表中输入序列标记的索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？

  • attention_mask（形状为 (batch_size, sequence_length) 的 torch.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：

    • 对于 未被掩盖 的标记为 1，

    • 对于 被掩盖 的标记为 0。什么是注意力掩码？

  • decoder_input_ids（形状为 (batch_size, target_sequence_length) 的 torch.LongTensor，可选）— 词汇表中解码器输入序列标记的索引。

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

    什么是解码器输入 ID？

    T5 使用 pad_token_id 作为 decoder_input_ids 生成的起始标记。如果使用了 past_key_values，则可选择仅输入最后的 decoder_input_ids（参见 past_key_values）。

    要了解有关如何为预训练准备 decoder_input_ids 的更多信息，请查看 T5 Training。

  • decoder_attention_mask（形状为 (batch_size, target_sequence_length) 的 torch.BoolTensor，可选）— 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。因果掩码也将默认使用。

  • output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的 attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

  • return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

text_outputs (CausalLMOutputWithPast，或者如果return_dict=False则为tuple(torch.FloatTensor))

语言模型输出。如果return_dict=True，则输出是一个包含语言模型 logits、过去的键值和隐藏状态（如果output_hidden_states=True）的CausalLMOutputWithPast。

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

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

示例：

>>> import torch
>>> from transformers import AutoTokenizer, Blip2Model

>>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b")

>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> inputs = tokenizer(["a photo of a cat"], 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';vision_outputs (BaseModelOutputWithPooling or tuple of torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 Blip2Processor 获取像素值。有关详细信息，请参阅Blip2Processor.__call__()。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

  • return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

vision_outputs (BaseModelOutputWithPooling或torch.FloatTensor的元组）

视觉模型输出。如果return_dict=True，则输出是一个包含图像特征、池化图像特征和隐藏状态（如果output_hidden_states=True）的BaseModelOutputWithPooling。

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

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

示例：

>>> import torch
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Blip2Model

>>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b")

>>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> 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_outputs = model.get_image_features(**inputs)

get_qformer_features

<来源>

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

参数

  • pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 Blip2Processor 获取像素值。有关详细信息，请参阅Blip2Processor.__call__()。

  • input_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 语言模型词汇中输入序列标记的索引。可以提供输入标记作为文本提示，语言模型可以继续生成。

    可以使用 Blip2Processor 获取索引。有关详细信息，请参阅Blip2Processor.__call__()。

    什么是输入 ID？

  • attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，optional) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]：

    • 对于not masked的标记为 1，

    • 对于masked的标记为 0。

    什么是注意力掩码？

  • decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 解码器输入序列标记在语言模型词汇中的索引。仅在使用编码器-解码器语言模型（如 T5）时相关。

    可以使用 AutoTokenizer 来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。解码器输入 ID 是什么？

  • decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.BoolTensor，可选）— 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

    仅在使用编码器-解码器语言模型（如 T5）时相关。

  • output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。

返回

vision_outputs（BaseModelOutputWithPooling或torch.FloatTensor元组）

视觉模型输出。如果return_dict=True，则输出是包含图像特征、池化图像特征和隐藏状态（如果output_hidden_states=True）的BaseModelOutputWithPooling。

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

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

示例：

>>> import torch
>>> from PIL import Image
>>> import requests
>>> from transformers import Blip2Processor, Blip2Model

>>> processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> model = Blip2Model.from_pretrained("Salesforce/blip2-opt-2.7b")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, return_tensors="pt")
>>> qformer_outputs = model.get_qformer_features(**inputs)

Blip2ForConditionalGeneration

class transformers.Blip2ForConditionalGeneration

<来源>

( config: Blip2Config )

参数

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

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

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

请注意，Flan-T5 检查点不能转换为 float16。它们是使用 bfloat16 进行预训练的。

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

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

forward

<来源>

( pixel_values: FloatTensor input_ids: FloatTensor 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.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput or tuple(torch.FloatTensor)

参数

  • pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。可以使用 Blip2Processor 获取像素值。有关详细信息，请参见Blip2Processor.__call__()。

  • input_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 语言模型词汇表中输入序列标记的索引。输入标记可以选择作为文本提示提供，语言模型可以继续。

    可以使用 Blip2Processor 获取索引。有关详细信息，请参见Blip2Processor.__call__()。

    输入 ID 是什么？

  • attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

    • 对于“未屏蔽”的标记，

    • 对于“屏蔽”的标记为 0。

    什么是注意力掩码？

  • decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 解码器输入序列标记在语言模型词汇表中的索引。仅在使用编码器-解码器语言模型（如 T5）时相关。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。解码器输入 ID 是什么？

  • decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.BoolTensor，可选）- 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

    仅在使用编码器-解码器语言模型（如 T5）时相关。

  • output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

  • output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

  • return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput或tuple(torch.FloatTensor)

一个transformers.models.blip_2.modeling_blip_2.Blip2ForConditionalGenerationModelOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（<class 'transformers.models.blip_2.configuration_blip_2.Blip2VisionConfig'>）和输入的各种元素。

  • loss（torch.FloatTensor，可选，在提供labels时返回，形状为(1,)的torch.FloatTensor）- 语言模型的语言建模损失。

  • logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）- 语言模型头的预测分数。

  • vision_outputs（BaseModelOutputWithPooling）- 视觉编码器的输出。

  • qformer_outputs（BaseModelOutputWithPoolingAndCrossAttentions）- Q-Former（Querying Transformer）的输出。

  • language_model_outputs（CausalLMOutputWithPast或Seq2SeqLMOutput）- 语言模型的输出。

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

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

示例：

准备处理器、模型和图像输入

>>> from PIL import Image
>>> import requests
>>> from transformers import Blip2Processor, Blip2ForConditionalGeneration
>>> import torch

>>> device = "cuda" if torch.cuda.is_available() else "cpu"

>>> processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> model = Blip2ForConditionalGeneration.from_pretrained(
...     "Salesforce/blip2-opt-2.7b", load_in_8bit=True, device_map={"": 0}, torch_dtype=torch.float16
... )  # doctest: +IGNORE_RESULT

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

图像字幕（不提供文本提示）：

>>> inputs = processor(images=image, return_tensors="pt").to(device, torch.float16)

>>> generated_ids = model.generate(**inputs)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
>>> print(generated_text)
two cats laying on a couch

视觉问答（提示=问题）：

>>> prompt = "Question: how many cats are there? Answer:"
>>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device="cuda", dtype=torch.float16)

>>> generated_ids = model.generate(**inputs)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
>>> print(generated_text)
two

请注意，也支持通过bitsandbytes进行 int8 推理。这大大减少了模型使用的内存量，同时保持相同的性能。

>>> model = Blip2ForConditionalGeneration.from_pretrained(
...     "Salesforce/blip2-opt-2.7b", load_in_8bit=True, device_map={"": 0}, torch_dtype=torch.bfloat16
... )  # doctest: +IGNORE_RESULT

>>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device="cuda", dtype=torch.bfloat16)

>>> generated_ids = model.generate(**inputs)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
>>> print(generated_text)
two

generate

<来源>

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

参数

  • pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）—要处理的输入图像。

  • input_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）—用作生成提示的序列。

  • attention_mask（形状为(batch_size, sequence_length)的torch.LongTensor，可选）—避免在填充标记索引上执行注意力的掩码

返回

字幕（列表）

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

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

BridgeTower

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/bridgetower

概述

BridgeTower 模型是由 Xiao Xu、Chenfei Wu、Shachar Rosenman、Vasudev Lal、Wanxiang Che、Nan Duan 在《BridgeTower: Building Bridges Between Encoders in Vision-Language Representative Learning》中提出的。该模型的目标是在每个交叉模态编码器的每一层之间建立桥梁，以实现全面和详细的交互，从而在各种下游任务中取得显著的性能，几乎没有额外的性能和计算成本。

本文已被AAAI’23会议接受。

论文摘要如下：

近年来，具有双塔架构的视觉语言（VL）模型在视觉语言表示学习中占据主导地位。当前的 VL 模型要么使用轻量级的单模编码器并学习同时提取、对齐和融合两种模态，要么将深度预训练的单模编码器的最后一层单模表示馈送到顶部交叉模态编码器中。这两种方法都可能限制视觉语言表示学习并限制模型性能。在本文中，我们提出了 BRIDGETOWER，它引入了多个桥接层，建立了单模编码器的顶层与交叉模态编码器的每一层之间的连接。这使得在交叉模态编码器中能够有效地进行自底向上的跨模态对齐和融合，从而实现不同语义级别的预训练单模编码器的视觉和文本表示之间的交叉模态对齐和融合。仅使用 4M 张图像进行预训练，BRIDGETOWER 在各种下游视觉语言任务上实现了最先进的性能。特别是在 VQAv2 测试集上，BRIDGETOWER 实现了 78.73%的准确率，比之前的最先进模型 METER 高出 1.09%，使用相同的预训练数据几乎没有额外的参数和计算成本。值得注意的是，当进一步扩展模型时，BRIDGETOWER 实现了 81.15%的准确率，超过了在数量级更大的数据集上进行预训练的模型。

drawing BridgeTower 架构。摘自原始论文。

该模型由Anahita Bhiwandiwalla、Tiep Le和Shaoyen Tseng贡献。原始代码可以在这里找到。

使用提示和示例

BridgeTower 包括一个视觉编码器、一个文本编码器和一个带有多个轻量级桥接层的交叉模态编码器。该方法的目标是在每个交叉模态编码器的每一层之间建立桥梁，以实现全面和详细的交互。原则上，可以在提出的架构中应用任何视觉、文本或交叉模态编码器。

BridgeTowerProcessor 将 RobertaTokenizer 和 BridgeTowerImageProcessor 封装成一个单一实例，用于同时对文本进行编码和准备图像。

以下示例展示了如何使用 BridgeTowerProcessor 和 BridgeTowerForContrastiveLearning 来运行对比学习。

>>> from transformers import BridgeTowerProcessor, BridgeTowerForContrastiveLearning
>>> import requests
>>> from PIL import Image

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> texts = ["An image of two cats chilling on a couch", "A football player scoring a goal"]

>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-large-itm-mlm-itc")
>>> model = BridgeTowerForContrastiveLearning.from_pretrained("BridgeTower/bridgetower-large-itm-mlm-itc")

>>> # forward pass
>>> scores = dict()
>>> for text in texts:
...     # prepare inputs
...     encoding = processor(image, text, return_tensors="pt")
...     outputs = model(**encoding)
...     scores[text] = outputs

以下示例显示如何使用 BridgeTowerProcessor 和 BridgeTowerForImageAndTextRetrieval 运行图像文本检索。

>>> from transformers import BridgeTowerProcessor, BridgeTowerForImageAndTextRetrieval
>>> import requests
>>> from PIL import Image

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> texts = ["An image of two cats chilling on a couch", "A football player scoring a goal"]

>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")
>>> model = BridgeTowerForImageAndTextRetrieval.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")

>>> # forward pass
>>> scores = dict()
>>> for text in texts:
...     # prepare inputs
...     encoding = processor(image, text, return_tensors="pt")
...     outputs = model(**encoding)
...     scores[text] = outputs.logits[0, 1].item()

以下示例显示如何使用 BridgeTowerProcessor 和 BridgeTowerForMaskedLM 运行掩码语言建模。

>>> from transformers import BridgeTowerProcessor, BridgeTowerForMaskedLM
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000360943.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
>>> text = "a <mask> looking out of the window"

>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")
>>> model = BridgeTowerForMaskedLM.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")

>>> # prepare inputs
>>> encoding = processor(image, text, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**encoding)

>>> results = processor.decode(outputs.logits.argmax(dim=-1).squeeze(0).tolist())

>>> print(results)
.a cat looking out of the window.

提示：

BridgeTowerConfig

class transformers.BridgeTowerConfig

< source >

( share_cross_modal_transformer_layers = True hidden_act = 'gelu' hidden_size = 768 initializer_factor = 1 layer_norm_eps = 1e-05 share_link_tower_layers = False link_tower_type = 'add' num_attention_heads = 12 num_hidden_layers = 6 tie_word_embeddings = False init_layernorm_from_vision_encoder = False text_config = None vision_config = None **kwargs )

参数

  • share_cross_modal_transformer_layers (bool, optional, defaults to True) — 是否共享跨模态 transformer 层。

  • hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。

  • hidden_size (int, optional, defaults to 768) — 编码器层和池化层的维度。

  • initializer_factor (float, optional, defaults to 1) — 用于初始化所有权重矩阵的因子（应保持为 1，用于内部初始化测试）。

  • layer_norm_eps (float, optional, defaults to 1e-05) — 层归一化层使用的 epsilon。

  • share_link_tower_layers (bool, optional, defaults to False) — 是否共享桥/链接塔层。

  • link_tower_type (str, optional, defaults to "add") — 桥/链接层的类型。

  • num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。

  • num_hidden_layers (int, optional, defaults to 6) — Transformer 编码器中的隐藏层数量。

  • tie_word_embeddings (bool, optional, defaults to False) — 是否绑定输入和输出嵌入。

  • init_layernorm_from_vision_encoder (bool, optional, defaults to False) — 是否从视觉编码器初始化 LayerNorm。

  • text_config (dict, optional) — 用于初始化 BridgeTowerTextConfig 的配置选项字典。

  • vision_config (dict, optional) — 用于初始化 BridgeTowerVisionConfig 的配置选项字典。

这是用于存储 BridgeTowerModel 配置的配置类。根据指定的参数实例化一个 BridgeTower 模型，定义模型架构。使用默认值实例化配置将产生与 bridgetower-base BridgeTower/bridgetower-base架构类似的配置。

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

示例:

>>> from transformers import BridgeTowerModel, BridgeTowerConfig

>>> # Initializing a BridgeTower BridgeTower/bridgetower-base style configuration
>>> configuration = BridgeTowerConfig()

>>> # Initializing a model from the BridgeTower/bridgetower-base style configuration
>>> model = BridgeTowerModel(configuration)

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

from_text_vision_configs

<来源>

( text_config: BridgeTowerTextConfig vision_config: BridgeTowerVisionConfig **kwargs )

从 BridgeTower 文本模型配置中实例化一个 BridgeTowerConfig（或派生类）。返回: BridgeTowerConfig: 配置对象的实例

BridgeTowerTextConfig

class transformers.BridgeTowerTextConfig

<来源>

( vocab_size = 50265 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 initializer_factor = 1 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 514 type_vocab_size = 1 layer_norm_eps = 1e-05 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 position_embedding_type = 'absolute' use_cache = True **kwargs )

参数

  • vocab_size (int, 可选, 默认为 50265) — 模型文本部分的词汇表大小。定义了在调用 BridgeTowerModel 时可以表示的不同标记数量。

  • hidden_size (int, 可选, 默认为 768) — 编码器层和池化器层的维度。

  • num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。

  • num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。

  • intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。

  • hidden_act (str 或 Callable, 可选, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

  • hidden_dropout_prob (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。

  • attention_probs_dropout_prob (float, 可选, 默认为 0.1) — 注意力概率的丢弃比率。

  • max_position_embeddings (int, 可选, 默认为 514) — 此模型可能使用的最大序列长度。通常将其设置为一个较大的值以防万一（例如 512、1024 或 2048）。

  • type_vocab_size (int, 可选, 默认为 2) — token_type_ids 的词汇表大小。

  • initializer_factor (float, 可选, 默认为 1) — 用于初始化所有权重矩阵的因子（应保持为 1，用于内部初始化测试）。

  • layer_norm_eps (float, 可选, 默认为 1e-05) — 层归一化层使用的 epsilon。

  • position_embedding_type (str, 可选, 默认为"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。

  • is_decoder (bool, 可选, 默认为False) — 模型是否用作解码器。如果为False，则模型用作编码器。

  • use_cache (bool, 可选, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。

这是用于存储 BridgeTowerModel 的文本配置的配置类。这里的默认值是从 RoBERTa 复制的。使用默认值实例化配置将产生与 bridgetower-base BridegTower/bridgetower-base架构类似的配置。

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

示例：

>>> from transformers import BridgeTowerTextConfig

>>> # Initializing a BridgeTower BridgeTower/bridgetower-base style configuration for the text model
>>> configuration = BridgeTowerTextConfig()

>>> # Accessing the configuration
>>> configuration

BridgeTowerVisionConfig

class transformers.BridgeTowerVisionConfig

<来源>

( hidden_size = 768 num_hidden_layers = 12 num_channels = 3 patch_size = 16 image_size = 288 initializer_factor = 1 layer_norm_eps = 1e-05 stop_gradient = False share_layernorm = True remove_last_layer = False **kwargs )

参数

  • hidden_size (int，可选，默认为 768) — 编码器层和池化层的维度。

  • num_hidden_layers (int，可选，默认为 12) — 视觉编码器模型中的隐藏层数量。

  • patch_size (int，可选，默认为 16) — 每个补丁的大小（分辨率）。

  • image_size (int，可选，默认为 288) — 每个图像的大小（分辨率）。

  • initializer_factor (float，可选，默认为 1) — 用于初始化所有权重矩阵的因子（应保持为 1，用于内部初始化测试）。

  • layer_norm_eps (float，可选，默认为 1e-05) — 层归一化层使用的 epsilon。

  • stop_gradient (bool，可选，默认为False) — 是否停止训练的梯度。

  • share_layernorm (bool，可选，默认为True) — 是否共享 LayerNorm 层。

  • remove_last_layer (bool，可选，默认为False) — 是否从视觉编码器中移除最后一层。

这是用于存储 BridgeTowerModel 的视觉配置的配置类。使用默认值实例化配置将产生与 bridgetower-base BridgeTower/bridgetower-base架构类似的配置。

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

示例：

>>> from transformers import BridgeTowerVisionConfig

>>> # Initializing a BridgeTower BridgeTower/bridgetower-base style configuration for the vision model
>>> configuration = BridgeTowerVisionConfig()

>>> # Accessing the configuration
>>> configuration

BridgeTowerImageProcessor

class transformers.BridgeTowerImageProcessor

<来源>

( do_resize: bool = True size: Dict = 288 size_divisor: int = 32 resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_center_crop: bool = True do_pad: bool = True **kwargs )

参数

  • do_resize (bool，可选，默认为True) — 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。

  • size (Dict[str, int] 可选，默认为 288) — 将输入的较短边调整为size["shortest_edge"]。较长边将受限于int((1333 / 800) * size["shortest_edge"])，同时保持纵横比。仅在do_resize设置为True时有效。可以被preprocess方法中的size参数覆盖。

  • size_divisor (int，可选，默认为 32) — 确保高度和宽度都可以被划分的大小。仅在do_resize设置为True时有效。可以被preprocess方法中的size_divisor参数覆盖。

  • resample (PILImageResampling, 可选, 默认为 Resampling.BICUBIC) — 如果调整图像大小，则使用的重采样滤波器。仅在 do_resize 设置为 True 时有效。

  • do_rescale (bool, 可选, 默认为 True) — 是否按照指定的比例 rescale_factor 对图像进行重新缩放。可以被 preprocess 方法中的 do_rescale 参数覆盖。

  • rescale_factor (int 或 float, 可选, 默认为 1/255) — 如果重新缩放图像，则使用的缩放因子。仅在 do_rescale 设置为 True 时有效。

  • do_normalize (bool, 可选, 默认为 True) — 是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 参数覆盖。

  • image_mean (float 或 List[float], 可选, 默认为 IMAGENET_STANDARD_MEAN) — 如果归一化图像，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。

  • image_std (float 或 List[float], 可选, 默认为 IMAGENET_STANDARD_STD) — 如果归一化图像，则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。

  • do_center_crop (bool, 可选, 默认为 True) — 是否对图像进行中心裁剪。可以被 preprocess 方法中的 do_center_crop 参数覆盖。

  • do_pad (bool, 可选, 默认为 True) — 是否将图像填充到批次中图像的 (max_height, max_width)。可以被 preprocess 方法中的 do_pad 参数覆盖。

构建一个 BridgeTower 图像处理器。

preprocess

< source >

( images: Union do_resize: Optional = None size: Optional = None size_divisor: Optional = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None do_center_crop: Optional = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

  • images (ImageInput) — 要预处理的图像。期望传入单个图像或图像批次，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。

  • do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。

  • size (Dict[str, int], 可选, 默认为 self.size) — 控制 resize 后图像的大小。图像的最短边被调整为 size["shortest_edge"]，同时保持纵横比。如果调整后图像的最长边 > int(size["shortest_edge"] * (1333 / 800))，则再次调整图像大小，使最长边等于 int(size["shortest_edge"] * (1333 / 800))。

  • size_divisor (int, 可选, 默认为 self.size_divisor) — 将图像调整为此值的倍数。

  • resample (PILImageResampling, 可选, 默认为 self.resample) — 如果调整图像大小，则使用的重采样滤波器。仅在 do_resize 设置为 True 时有效。

  • do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否将图像值重新缩放到 [0 - 1] 之间。

  • rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的缩放因子。

  • do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。

  • image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 如果 do_normalize 设置为 True，则用于归一化图像的图像均值。

  • image_std（float或List[float]，可选，默认为self.image_std）— 如果do_normalize设置为True，用于归一化图像的图像标准差。

  • do_pad（bool，可选，默认为self.do_pad）— 是否将图像填充到批处理中的(max_height, max_width)。如果为True，还会创建并返回像素掩码。

  • do_center_crop（bool，可选，默认为self.do_center_crop）— 是否对图像进行中心裁剪。如果输入尺寸小于任何边缘的crop_size，则图像将填充为 0，然后进行中心裁剪。

  • return_tensors（str或TensorType，可选）— 要返回的张量类型。可以是以下之一：

    • 未设置：返回一个np.ndarray列表。

    • TensorType.TENSORFLOW或'tf'：返回一个tf.Tensor类型的批处理。

    • TensorType.PYTORCH或'pt'：返回一个torch.Tensor类型的批处理。

    • TensorType.NUMPY或'np'：返回一个np.ndarray类型的批处理。

    • TensorType.JAX或'jax'：返回一个jax.numpy.ndarray类型的批处理。

  • data_format（ChannelDimension或str，可选，默认为ChannelDimension.FIRST）— 输出图像的通道维度格式。可以是以下之一：

    • "channels_first"或ChannelDimension.FIRST：图像以(num_channels, height, width)格式。

    • "channels_last"或ChannelDimension.LAST：图像以(height, width, num_channels)格式。

    • 未设置：使用输入图像的通道维度格式。

  • input_data_format（ChannelDimension或str，可选）— 输入图像的通道维度格式。如果未设置，将从输入图像中推断通道维度格式。可以是以下之一：

    • "channels_first"或ChannelDimension.FIRST：图像以(num_channels, height, width)格式。

    • "channels_last"或ChannelDimension.LAST：图像以(height, width, num_channels)格式。

    • "none"或ChannelDimension.NONE：图像以(height, width)格式。

预处理一张图片或一批图片。

BridgeTowerProcessor

class transformers.BridgeTowerProcessor

< source >

( image_processor tokenizer )

参数

  • image_processor（BridgeTowerImageProcessor）— 一个 BridgeTowerImageProcessor 的实例。图像处理器是必需的输入。

  • tokenizer（RobertaTokenizerFast）— 一个[‘RobertaTokenizerFast`]的实例。分词器是必需的输入。

构建一个 BridgeTower 处理器，将一个 Roberta 分词器和一个 BridgeTower 图像处理器包装成一个处理器。

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

__call__

< source >

( images text: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True return_tensors: Union = None **kwargs )

此方法使用 BridgeTowerImageProcessor.call()方法准备模型的图像，并使用 RobertaTokenizerFast.call()准备模型的文本。

有关更多信息，请参考上述两种方法的文档字符串。

BridgeTowerModel

class transformers.BridgeTowerModel

< source >

( config )

参数

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

裸的 BridgeTower 模型，输出 BridgeTowerModelOutput 对象，没有特定的头部在顶部。这个模型是 PyTorch torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>_ 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None image_token_type_idx: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.models.bridgetower.modeling_bridgetower.BridgeTowerModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 ({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  • attention_mask (torch.FloatTensor，形状为 ({0})，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示未被 掩码 的标记，

    • 0 表示被 掩码 的标记。什么是注意力掩码？

  • token_type_ids (torch.LongTensor，形状为 ({0})，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

    • 0 对应于一个 句子 A 标记，

    • 1 对应于一个 句子 B 标记。什么是标记类型 ID？

  • pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。可以使用 BridgeTowerImageProcessor 获取像素值。有关详细信息，请参阅 BridgeTowerImageProcessor.call()。

  • pixel_mask (torch.LongTensor，形状为 (batch_size, height, width)，可选) — 避免在填充像素值上执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示真实的像素（即未被 掩码），

    • 0 表示填充的像素（即被 掩码）。什么是注意力掩码？ <../glossary.html#attention-mask>__

  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示头部未被 掩码，

    • 0 表示头部被 掩码。

  • inputs_embeds (torch.FloatTensor，形状为 ({0}, hidden_size)，可选) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是模型的内部嵌入查找矩阵。

  • image_embeds (torch.FloatTensor，形状为 (batch_size, num_patches, hidden_size)，可选) — 可选地，可以直接传递嵌入表示，而不是传递 pixel_values。如果您想要更多控制如何将 pixel_values 转换为补丁嵌入，这将非常有用。

  • image_token_type_idx (int，可选) —

    • 图像的标记类型 ID。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

  • output_hidden_states (bool, optional) — 如果设置为True，则返回隐藏状态作为一个列表，分别包含文本、图像和跨模态组件的隐藏状态。即(hidden_states_text, hidden_states_image, hidden_states_cross_modal)，其中每个元素都是对应模态的隐藏状态列表。hidden_states_txt/img是对应单模态隐藏状态的张量列表，hidden_states_cross_modal是一个包含每个桥接层的cross_modal_text_hidden_states和cross_modal_image_hidden_states的元组列表。

  • labels (torch.LongTensor，形状为(batch_size,)，可选) — 目前不支持标签。

返回

transformers.models.bridgetower.modeling_bridgetower.BridgeTowerModelOutput或tuple(torch.FloatTensor)

一个transformers.models.bridgetower.modeling_bridgetower.BridgeTowerModelOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（BridgeTowerConfig）和输入的不同元素。

  • text_features (torch.FloatTensor，形状为(batch_size, text_sequence_length, hidden_size)) — 模型最后一层文本输出的隐藏状态序列。

  • image_features (torch.FloatTensor，形状为(batch_size, image_sequence_length, hidden_size)) — 模型最后一层图像输出的隐藏状态序列。

  • pooler_output (torch.FloatTensor，形状为(batch_size, hidden_size x 2)) — 文本和图像序列的第一个标记（分类标记）的最后一层隐藏状态的连接，分别经过用于辅助预训练任务的层进一步处理。

  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import BridgeTowerProcessor, BridgeTowerModel
>>> from PIL import Image
>>> import requests

>>> # prepare image and text
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "hello world"
>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-base")
>>> model = BridgeTowerModel.from_pretrained("BridgeTower/bridgetower-base")

>>> inputs = processor(image, text, return_tensors="pt")
>>> outputs = model(**inputs)
>>> outputs.keys()
odict_keys(['text_features', 'image_features', 'pooler_output'])

BridgeTowerForContrastiveLearning

class transformers.BridgeTowerForContrastiveLearning

< source >

( config )

参数

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

在顶部具有图像文本对比头部的 BridgeTower 模型，计算图像文本对比损失。

这个模型是 PyTorch 的torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>_ 子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = True return_dict: Optional = None return_loss: Optional = None ) → export const metadata = 'undefined';transformers.models.bridgetower.modeling_bridgetower.BridgeTowerContrastiveOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。什么是输入 ID？

  • attention_mask (torch.FloatTensor，形状为({0})，optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

    • 1 表示未被遮罩的标记，

    • 0 表示被遮罩的标记。什么是注意力掩码？

  • token_type_ids (torch.LongTensor，形状为({0})，optional) — 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]之间：

    • 0 对应于句子 A标记，

    • 1 对应于句子 B标记。什么是标记类型 ID？

  • pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 BridgeTowerImageProcessor 获取像素值。查看 BridgeTowerImageProcessor.call()获取详细信息。

  • pixel_mask (torch.LongTensor，形状为(batch_size, height, width)，optional) — 用于避免在填充像素值上执行注意力的掩码。掩码值选择在[0, 1]之间：

    • 1 表示真实像素（即未被遮罩），

    • 0 表示填充像素（即被遮罩）。什么是注意力掩码？<../glossary.html#attention-mask>__

  • head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：

    • 1 表示头部未被遮罩，

    • 0 表示头部被遮罩。

  • inputs_embeds (torch.FloatTensor，形状为({0}, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为与模型内部嵌入查找矩阵相关联的向量，则这很有用。

  • image_embeds (torch.FloatTensor，形状为(batch_size, num_patches, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递pixel_values。如果您想要更多控制如何将pixel_values转换为补丁嵌入，则这很有用。

  • image_token_type_idx (int, optional) —

    • 图像的标记类型 ID。

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。

  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。

  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

  • return_loss (bool, 可选) — 是否返回对比损失。

返回

transformers.models.bridgetower.modeling_bridgetower.BridgeTowerContrastiveOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.bridgetower.modeling_bridgetower.BridgeTowerContrastiveOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False 或 config.return_dict=False）包含根据配置（BridgeTowerConfig）和输入的各种元素。

  • loss (torch.FloatTensor，形状为 (1,)，可选，当 return_loss 为 True 时返回） — 图像-文本对比损失。

  • logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 前每个词汇标记的分数）。

  • text_embeds (torch.FloatTensor)，可选，当使用 with_projection=True 初始化模型时返回） — 通过将投影层应用于 pooler_output 获得的文本嵌入。

  • image_embeds (torch.FloatTensor)，可选，当使用 with_projection=True 初始化模型时返回） — 通过将投影层应用于 pooler_output 获得的图像嵌入。

  • cross_embeds (torch.FloatTensor)，可选，当使用 with_projection=True 初始化模型时返回） — 通过将投影层应用于 pooler_output 获得的文本-图像跨模态嵌入。

  • hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回） — 形状为 (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 元组。

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

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

示例：

>>> from transformers import BridgeTowerProcessor, BridgeTowerForContrastiveLearning
>>> import requests
>>> from PIL import Image
>>> import torch

>>> image_urls = [
...     "https://farm4.staticflickr.com/3395/3428278415_81c3e27f15_z.jpg",
...     "http://images.cocodataset.org/val2017/000000039769.jpg",
... ]
>>> texts = ["two dogs in a car", "two cats sleeping on a couch"]
>>> images = [Image.open(requests.get(url, stream=True).raw) for url in image_urls]

>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-large-itm-mlm-itc")
>>> model = BridgeTowerForContrastiveLearning.from_pretrained("BridgeTower/bridgetower-large-itm-mlm-itc")

>>> inputs = processor(images, texts, padding=True, return_tensors="pt")
>>> loss = model(**inputs, return_loss=True).loss

>>> inputs = processor(images, texts[::-1], padding=True, return_tensors="pt")
>>> loss_swapped = model(**inputs, return_loss=True).loss

>>> print("Loss", round(loss.item(), 4))
Loss 0.0019

>>> print("Loss with swapped images", round(loss_swapped.item(), 4))
Loss with swapped images 2.126

BridgeTowerForMaskedLM

class transformers.BridgeTowerForMaskedLM

< source >

( config )

参数

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

BridgeTower 模型在预训练期间在顶部具有语言建模头。

这个模型是 PyTorch 的 torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>_ 子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？

  • attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示未被遮蔽的标记，

    • 0 表示被遮蔽的标记。什么是注意力掩码？

  • token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段落标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

    • 0 对应于 句子 A 的标记，

    • 1 对应于 句子 B 的标记。什么是标记类型 ID？

  • pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。可以使用 BridgeTowerImageProcessor 获取像素值。有关详细信息，请参阅 BridgeTowerImageProcessor.call()。

  • pixel_mask (torch.LongTensor of shape (batch_size, height, width), optional) — 用于避免在填充像素值上执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示真实的像素（即未被遮蔽），

    • 0 表示填充的像素（即 masked）。什么是注意力掩码？<../glossary.html#attention-mask>__

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示头部未被遮蔽，

    • 0 表示头部被遮蔽。

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是模型的内部嵌入查找矩阵，这将非常有用。

  • image_embeds (torch.FloatTensor of shape (batch_size, num_patches, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 pixel_values。如果您想要更多控制如何将 pixel_values 转换为补丁嵌入，这将非常有用。

  • image_token_type_idx (int, optional) —

    • 图像的标记类型 ID。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。

  • return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

  • labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

transformers.modeling_outputs.MaskedLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MaskedLMOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包括各种元素，取决于配置（BridgeTowerConfig）和输入。

  • loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 掩码语言建模（MLM）损失。

  • logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import BridgeTowerProcessor, BridgeTowerForMaskedLM
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000360943.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
>>> text = "a <mask> looking out of the window"

>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")
>>> model = BridgeTowerForMaskedLM.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")

>>> # prepare inputs
>>> encoding = processor(image, text, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**encoding)

>>> results = processor.decode(outputs.logits.argmax(dim=-1).squeeze(0).tolist())

>>> print(results)
.a cat looking out of the window.

BridgeTowerForImageAndTextRetrieval

class transformers.BridgeTowerForImageAndTextRetrieval

< source >

( config )

参数

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

BridgeTower 模型变压器，顶部带有分类器头（在[CLS]标记的最终隐藏状态之上的线性层），用于图像到文本匹配。

这个模型是一个 PyTorch torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>_ 子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape ({0})) — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID？

  • attention_mask (torch.FloatTensor of shape ({0}), optional) — 用于避免在填充标记索引上执行注意力的掩码。 选择的掩码值在 [0, 1] 之间：

    • 值为 1 的标记是 not masked，

    • 值为 0 的标记是 masked。 什么是注意力掩码？

  • token_type_ids (torch.LongTensor of shape ({0}), optional) — 段标记索引，指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择：

    • 值为 0 对应于 句子 A 标记，

    • 1 对应于 句子 B 标记。 什么是标记类型 ID？

  • pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。 可以使用 BridgeTowerImageProcessor 获取像素值。 有关详细信息，请参见 BridgeTowerImageProcessor.call()。

  • pixel_mask (torch.LongTensor of shape (batch_size, height, width), optional) — 用于避免在填充像素值上执行注意力的掩码。 选择的掩码值在 [0, 1] 之间：

    • 值为 1 的像素是真实的（即 not masked），

    • 填充像素的值为 0（即 masked）。 什么是注意力掩码？ <../glossary.html#attention-mask>__

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。 选择的掩码值在 [0, 1] 之间：

    • 值为 1 表示头部未被 masked，

    • 值为 0 表示头部被 masked。

  • inputs_embeds (torch.FloatTensor of shape ({0}, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。 如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是模型的内部嵌入查找矩阵，这将非常有用。

  • image_embeds (torch.FloatTensor of shape (batch_size, num_patches, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 pixel_values。 如果您想要更多控制如何将 pixel_values 转换为补丁嵌入，这将非常有用。

  • image_token_type_idx (int, optional) —

    • 图像的标记类型 ID。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的 attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的 hidden_states。

  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

  • labels (torch.LongTensor of shape (batch_size, 1), optional) — 用于计算图像文本匹配损失的标签。 0 表示配对不匹配，1 表示匹配。 标签为 0 的配对将被跳过计算。

返回

transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含各种元素，取决于配置（BridgeTowerConfig）和输入。

  • loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回） - 分类（如果 config.num_labels==1 则为回归）损失。

  • logits（形状为(batch_size, config.num_labels)的torch.FloatTensor） - 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。

  • 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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import BridgeTowerProcessor, BridgeTowerForImageAndTextRetrieval
>>> import requests
>>> from PIL import Image

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> texts = ["An image of two cats chilling on a couch", "A football player scoring a goal"]

>>> processor = BridgeTowerProcessor.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")
>>> model = BridgeTowerForImageAndTextRetrieval.from_pretrained("BridgeTower/bridgetower-base-itm-mlm")

>>> # forward pass
>>> scores = dict()
>>> for text in texts:
...     # prepare inputs
...     encoding = processor(image, text, return_tensors="pt")
...     outputs = model(**encoding)
...     scores[text] = outputs.logits[0, 1].item()

BROS

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

概述

BROS 模型是由 Teakgyu Hong、Donghyun Kim、Mingi Ji、Wonseok Hwang、Daehyun Nam、Sungrae Park 在BROS: A Pre-trained Language Model Focusing on Text and Layout for Better Key Information Extraction from Documents中提出的。

BROS 代表BERT 依赖空间性。它是一个仅编码器的 Transformer 模型，接受一系列标记和它们的边界框作为输入，并输出一系列隐藏状态。BROS 编码相对空间信息而不是使用绝对空间信息。

它通过两个目标进行预训练：BERT 中使用的标记掩码语言建模目标（TMLM）和一种新颖的区域掩码语言建模目标（AMLM）。在 TMLM 中，标记被随机掩码，模型使用空间信息和其他未掩码的标记来预测掩码的标记。AMLM 是 TMLM 的二维版本。它随机掩码文本标记，并使用与 TMLM 相同的信息进行预测，但它掩码文本块（区域）。

BrosForTokenClassification在 BrosModel 之上有一个简单的线性层。它预测每个标记的标签。BrosSpadeEEForTokenClassification在 BrosModel 之上有一个initial_token_classifier和subsequent_token_classifier。initial_token_classifier用于预测每个实体的第一个标记，subsequent_token_classifier用于预测实体内的下一个标记。BrosSpadeELForTokenClassification在 BrosModel 之上有一个entity_linker。entity_linker用于预测两个实体之间的关系。

BrosForTokenClassification和BrosSpadeEEForTokenClassification本质上执行相同的任务。然而，BrosForTokenClassification假设输入标记是完全串行化的（这是一个非常具有挑战性的任务，因为它们存在于二维空间），而BrosSpadeEEForTokenClassification允许更灵活地处理串行化错误，因为它从一个标记预测下一个连接标记。

BrosSpadeELForTokenClassification执行实体内链接任务。如果这两个实体共享某种关系，则它预测一个标记（一个实体）到另一个标记（另一个实体）的关系。

BROS 在关键信息提取（KIE）基准测试中取得了可比较或更好的结果，如 FUNSD、SROIE、CORD 和 SciTSR，而不依赖于显式的视觉特征。

论文摘要如下：

从文档图像中提取关键信息（KIE）需要理解二维空间中文本的上下文和空间语义。许多最近的研究尝试通过开发专注于将文档图像的视觉特征与文本及其布局结合的预训练语言模型来解决该任务。另一方面，本文通过回归基本问题来解决问题：文本和布局的有效组合。具体而言，我们提出了一个名为 BROS（BERT 依赖空间性）的预训练语言模型，它编码了二维空间中文本的相对位置，并通过区域掩码策略从未标记的文档中学习。通过这种针对理解二维空间中文本的优化训练方案，BROS 在四个 KIE 基准测试（FUNSD、SROIE、CORD 和 SciTSR）上显示出与先前方法相当或更好的性能，而不依赖于视觉特征。本文还揭示了 KIE 任务中的两个现实挑战-(1)减少由于不正确的文本排序而产生的错误和(2)有效地从更少的下游示例中学习-并展示了 BROS 相对于先前方法的优越性。

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

用法提示和示例

  • forward() 需要 input_ids 和 bbox（边界框）。每个边界框应该以 (x0, y0, x1, y1) 格式（左上角，右下角）表示。边界框的获取取决于外部 OCR 系统。x 坐标应该通过文档图像宽度进行归一化，y 坐标应该通过文档图像高度进行归一化。
def expand_and_normalize_bbox(bboxes, doc_width, doc_height):
    # here, bboxes are numpy array

    # Normalize bbox -> 0 ~ 1
    bboxes[:, [0, 2]] = bboxes[:, [0, 2]] / width
    bboxes[:, [1, 3]] = bboxes[:, [1, 3]] / height
  • [~transformers.BrosForTokenClassification.forward, ~transformers.BrosSpadeEEForTokenClassification.forward, ~transformers.BrosSpadeEEForTokenClassification.forward] 需要不仅 input_ids 和 bbox，还需要 box_first_token_mask 用于损失计算。这是一个用于过滤每个框的非第一个标记的掩码。您可以通过保存从单词创建 input_ids 时的边界框的起始标记索引来获得此掩码。您可以使用以下代码生成 box_first_token_mask，
def make_box_first_token_mask(bboxes, words, tokenizer, max_seq_length=512):

    box_first_token_mask = np.zeros(max_seq_length, dtype=np.bool_)

    # encode(tokenize) each word from words (List[str])
    input_ids_list: List[List[int]] = [tokenizer.encode(e, add_special_tokens=False) for e in words]

    # get the length of each box
    tokens_length_list: List[int] = [len(l) for l in input_ids_list]

    box_end_token_indices = np.array(list(itertools.accumulate(tokens_length_list)))
    box_start_token_indices = box_end_token_indices - np.array(tokens_length_list)

    # filter out the indices that are out of max_seq_length
    box_end_token_indices = box_end_token_indices[box_end_token_indices < max_seq_length - 1]
    if len(box_start_token_indices) > len(box_end_token_indices):
        box_start_token_indices = box_start_token_indices[: len(box_end_token_indices)]

    # set box_start_token_indices to True
    box_first_token_mask[box_start_token_indices] = True

    return box_first_token_mask

资源

  • 演示脚本可以在 这里 找到。

BrosConfig

class transformers.BrosConfig

< source >

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 dim_bbox = 8 bbox_scale = 100.0 n_relations = 1 classifier_dropout_prob = 0.1 **kwargs )

参数

  • vocab_size (int, optional, defaults to 30522) — Bros 模型的词汇表大小。定义了在调用 BrosModel 或 TFBrosModel 时可以由 inputs_ids 表示的不同标记数量。

  • hidden_size (int, optional, defaults to 768) — 编码器层和池化层的维度。

  • num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数量。

  • num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数量。

  • intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。

  • hidden_act (str or Callable, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "silu" 和 "gelu_new"。

  • hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。

  • attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的丢失比率。

  • max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512、1024 或 2048）。

  • type_vocab_size (int, optional, defaults to 2) — 在调用 BrosModel 或 TFBrosModel 时传递的 token_type_ids 的词汇表大小。

  • initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

  • layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。

  • pad_token_id (int, optional, defaults to 0) — 令牌词汇表中填充令牌的索引。

  • dim_bbox (int, optional, defaults to 8) — 边界框坐标的维度。 (x0, y1, x1, y0, x1, y1, x0, y1)

  • bbox_scale (float, optional, defaults to 100.0) — 边界框坐标的缩放因子。

  • n_relations (int, optional, defaults to 1) — SpadeEE（实体提取）、SpadeEL（实体链接）头部的关系数量。

  • classifier_dropout_prob (float, optional, defaults to 0.1) — 分类器头部的丢失比率。

这是用于存储 BrosModel 或TFBrosModel配置的配置类。根据指定的参数实例化一个 Bros 模型，定义模型架构。使用默认值实例化配置将产生类似于 Bros jinho8345/bros-base-uncased架构的配置。

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

示例：

>>> from transformers import BrosConfig, BrosModel

>>> # Initializing a BROS jinho8345/bros-base-uncased style configuration
>>> configuration = BrosConfig()

>>> # Initializing a model from the jinho8345/bros-base-uncased style configuration
>>> model = BrosModel(configuration)

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

BrosProcessor

class transformers.BrosProcessor

<来源>

( tokenizer = None **kwargs )

参数

  • tokenizer (BertTokenizerFast, 可选) — 一个[‘BertTokenizerFast`]的实例。这是一个必需的输入。

构建一个包装了 BERT tokenizer 的 Bros 处理器。

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

__call__

<来源>

( text: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True return_tensors: Union = None **kwargs )

此方法使用 BertTokenizerFast.call()准备文本以供模型使用。

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

BrosModel

class transformers.BrosModel

<来源>

( config add_pooling_layer = True )

参数

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

裸 Bros 模型变换器输出原始隐藏状态，没有特定的头部。这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

<来源>

( input_ids: Optional = None bbox: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: 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 ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。

    可以使用 BrosProcessor 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

    什么是输入 ID？

  • bbox（形状为(batch_size, num_boxes, 4)的‘torch.FloatTensor’） — 输入序列中每个标记的边界框坐标。每个边界框是四个值的列表（x1, y1, x2, y2），其中（x1, y1）是左上角，（x2, y2）是右下角的边界框。

  • attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充令牌索引上执行注意力的掩码。选择的掩码值为[0, 1]：

    • 1 表示未被“掩盖”的令牌，

    • 对于被“掩盖”的令牌为 0。

    什么是注意力掩码？

  • bbox_first_token_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于指示每个边界框的第一个令牌的掩码。选择的掩码值为[0, 1]：

    • 1 表示未被“掩盖”的令牌，

    • 0 表示被“掩盖”的令牌。

  • token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段令牌索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：

    • 0 对应于句子 A令牌，

    • 1 对应于句子 B令牌。

    什么是令牌类型 ID？

  • position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列令牌在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

    什么是位置 ID？

  • head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）- 用于使自注意力模块的选定头部失效的掩码。选择的掩码值为[0, 1]：

    • 1 表示头部未被“掩盖”。

    • 0 表示头部被“掩盖”。

  • inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这是很有用的，而不是使用模型的内部嵌入查找矩阵。

  • output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

  • output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

  • return_dict（bool，可选）- 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包括根据配置（BrosConfig）和输入的不同元素。

  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

  • cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True和config.add_cross_attention=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

    解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

  • 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，还可以使用）可用（见past_key_values输入）以加速顺序解码。

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

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

示例：

>>> import torch
>>> from transformers import BrosProcessor, BrosModel

>>> processor = BrosProcessor.from_pretrained("jinho8345/bros-base-uncased")

>>> model = BrosModel.from_pretrained("jinho8345/bros-base-uncased")

>>> encoding = processor("Hello, my dog is cute", add_special_tokens=False, return_tensors="pt")
>>> bbox = torch.tensor([[[0, 0, 1, 1]]]).repeat(1, encoding["input_ids"].shape[-1], 1)
>>> encoding["bbox"] = bbox

>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_state

BrosForTokenClassification

class transformers.BrosForTokenClassification

<来源>

( config )

参数

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

在顶部带有标记分类头的 Bros 模型（隐藏状态输出的线性层），例如用于命名实体识别（NER）任务。

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

forward

<来源>

( input_ids: Optional = None bbox: Optional = None attention_mask: Optional = None bbox_first_token_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

  • input_ids（形状为(batch_size, sequence_length)的torch.LongTensor） — 词汇表中输入序列标记的索引。

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

    什么是输入 ID？

  • bbox (‘torch.FloatTensor’ of shape ‘(batch_size, num_boxes, 4)’) — 输入序列中每个标记的边界框坐标。每个边界框都是四个值的列表（x1, y1, x2, y2），其中 (x1, y1) 是左上角，(x2, y2) 是右下角的边界框。

  • attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示未被 masked 的标记，

    • 0 表示被 masked 的标记。

    什么是注意力掩码？

  • bbox_first_token_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于指示每个边界框的第一个标记的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示未被 masked 的标记，

    • 0 表示被 masked 的标记。

  • token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

    • 0 对应于 句子 A 标记，

    • 1 对应于 句子 B 标记。

    什么是标记类型 ID？

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记的位置嵌入的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 ID？

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示头部未被 masked，

    • 0 表示头部被 masked。

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。

  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（BrosConfig）和输入的各种元素。

  • loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 分类损失。

  • logits (torch.FloatTensor of shape (batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax 之前）。

  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> import torch
>>> from transformers import BrosProcessor, BrosForTokenClassification

>>> processor = BrosProcessor.from_pretrained("jinho8345/bros-base-uncased")

>>> model = BrosForTokenClassification.from_pretrained("jinho8345/bros-base-uncased")

>>> encoding = processor("Hello, my dog is cute", add_special_tokens=False, return_tensors="pt")
>>> bbox = torch.tensor([[[0, 0, 1, 1]]]).repeat(1, encoding["input_ids"].shape[-1], 1)
>>> encoding["bbox"] = bbox

>>> outputs = model(**encoding)

BrosSpadeEEForTokenClassification

class transformers.BrosSpadeEEForTokenClassification

<来源>

( config )

参数

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

Bros 模型在顶部带有一个标记分类头（在隐藏状态输出的顶部有初始标记层和后续标记层），例如用于命名实体识别（NER）任务。初始标记分类器用于预测每个实体的第一个标记，后续标记分类器用于预测实体内的后续标记。与 BrosForTokenClassification 相比，该模型对序列化错误更加稳健，因为它从一个标记预测下一个标记。

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

forward

<来源>

( input_ids: Optional = None bbox: Optional = None attention_mask: Optional = None bbox_first_token_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None initial_token_labels: Optional = None subsequent_token_labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.bros.modeling_bros.BrosSpadeOutput or tuple(torch.FloatTensor)

参数

  • input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。

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

    什么是输入 ID？

  • bbox（形状为(batch_size, num_boxes, 4)的torch.FloatTensor）- 输入序列中每个标记的边界框坐标。每个边界框是四个值的列表（x1，y1，x2，y2），其中（x1，y1）是左上角，（x2，y2）是边界框的右下角。

  • attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

    • 对于未屏蔽的标记为 1，

    • 对于已屏蔽的标记为 0。

    什么是注意力掩码？

  • bbox_first_token_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，optional) — 用于指示每个边界框的第一个标记的掩码。掩码值选在 [0, 1]：

    • 1 表示未被 masked 的标记，

    • 0 表示被 masked 的标记。

  • token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，optional) — 段标记索引，用于指示输入的第一部分和第二部分。索引选在 [0, 1]：

    • 0 对应于 句子 A 标记，

    • 1 对应于 句子 B 标记。

    什么是标记类型 ID？

  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，optional) — 每个输入序列标记在位置嵌入中的位置索引。选在范围 [0, config.max_position_embeddings - 1]。

    什么是位置 ID？

  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选在 [0, 1]：

    • 1 表示头部未被 masked，

    • 0 表示头部被 masked。

  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

  • output_attentions (bool，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。

  • output_hidden_states (bool，optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。

  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.bros.modeling_bros.BrosSpadeOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.bros.modeling_bros.BrosSpadeOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False 时）包含根据配置（BrosConfig）和输入不同元素。

  • loss (torch.FloatTensor，形状为 (1,)，optional，当提供 labels 时返回） — 分类损失。

  • initial_token_logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.num_labels)) — 实体初始标记的分类分数（SoftMax 之前）。

  • subsequent_token_logits (torch.FloatTensor，形状为 (batch_size, sequence_length, sequence_length+1)) — 实体序列标记的分类分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> import torch
>>> from transformers import BrosProcessor, BrosSpadeEEForTokenClassification

>>> processor = BrosProcessor.from_pretrained("jinho8345/bros-base-uncased")

>>> model = BrosSpadeEEForTokenClassification.from_pretrained("jinho8345/bros-base-uncased")

>>> encoding = processor("Hello, my dog is cute", add_special_tokens=False, return_tensors="pt")
>>> bbox = torch.tensor([[[0, 0, 1, 1]]]).repeat(1, encoding["input_ids"].shape[-1], 1)
>>> encoding["bbox"] = bbox

>>> outputs = model(**encoding)

BrosSpadeELForTokenClassification

class transformers.BrosSpadeELForTokenClassification

<来源>

( config )

参数

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

在隐藏状态输出的顶部有一个标记分类头的 Bros 模型（在隐藏状态输出的顶部有一个实体链接层），例如用于实体链接。实体链接器用于预测实体之间的内部实体链接（一个实体到另一个实体）。

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

forward

<来源>

( input_ids: Optional = None bbox: Optional = None attention_mask: Optional = None bbox_first_token_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

  • input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。

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

    输入 ID 是什么？

  • bbox（形状为(batch_size, num_boxes, 4)的‘torch.FloatTensor’）- 输入序列中每个标记的边界框坐标。每个边界框是一个包含四个值（x1，y1，x2，y2）的列表，其中（x1，y1）是左上角，（x2，y2）是边界框的右下角。

  • attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

    • 对于未被屏蔽的标记为 1，

    • 对于被屏蔽的标记为 0。

    注意掩码是什么？

  • bbox_first_token_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于指示每个边界框的第一个标记的掩码。掩码值选择在[0, 1]中：

    • 对于未被屏蔽的标记为 1，

    • 对于被屏蔽的标记为 0。

  • token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：

    • 0 对应于句子 A标记，

    • 1 对应于句子 B标记。

    令牌类型 ID 是什么？

  • position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 位置嵌入中每个输入序列标记的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

    位置 ID 是什么？

  • head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）- 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：

    • 1 表示头部未被屏蔽。

    • 0 表示头部被屏蔽。

  • inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.TokenClassifierOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（BrosConfig）和输入不同元素。

  • loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 分类损失。

  • logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)） — 分类得分（SoftMax 之前）。

  • hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）的形状为(batch_size, sequence_length, hidden_size)。

    模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。

    在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> import torch
>>> from transformers import BrosProcessor, BrosSpadeELForTokenClassification

>>> processor = BrosProcessor.from_pretrained("jinho8345/bros-base-uncased")

>>> model = BrosSpadeELForTokenClassification.from_pretrained("jinho8345/bros-base-uncased")

>>> encoding = processor("Hello, my dog is cute", add_special_tokens=False, return_tensors="pt")
>>> bbox = torch.tensor([[[0, 0, 1, 1]]]).repeat(1, encoding["input_ids"].shape[-1], 1)
>>> encoding["bbox"] = bbox

>>> outputs = model(**encoding)

Chinese-CLIP

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/chinese_clip

概述

中文 CLIP 模型是由 An Yang、Junshu Pan、Junyang Lin、Rui Men、Yichang Zhang、Jingren Zhou、Chang Zhou 在中文 CLIP：中文对比视觉-语言预训练中提出的。中文 CLIP 是在大规模中文图像-文本对数据集上实现的 CLIP（Radford 等，2021）的一个实现。它能够执行跨模态检索，并且还可以作为视觉任务的视觉骨干，如零样本图像分类、开放域目标检测等。原始的中文 CLIP 代码在此链接上发布。

论文摘要如下：

CLIP（Radford 等，2021）的巨大成功推动了对视觉-语言对比学习的研究和应用。在这项工作中，我们构建了一个大规模的中文图像-文本对数据集，其中大部分数据来自公开可用的数据集，我们在新数据集上对中文 CLIP 模型进行了预训练。我们开发了 5 个不同大小的中文 CLIP 模型，参数范围从 7700 万到 9.58 亿。此外，我们提出了一种两阶段预训练方法，其中模型首先在图像编码器冻结的情况下进行训练，然后在优化所有参数的情况下进行训练，以实现增强的模型性能。我们的全面实验表明，中文 CLIP 在 MUGE、Flickr30K-CN 和 COCO-CN 的零样本学习和微调设置中可以实现最先进的性能，并且在 ELEVATER 基准测试（Li 等，2022）的评估中，它能够在零样本图像分类方面实现竞争性能。我们的代码、预训练模型和演示已发布。

中文 CLIP 模型由OFA-Sys贡献。

用法示例

下面的代码片段显示了如何计算图像和文本特征以及相似性：

>>> from PIL import Image
>>> import requests
>>> from transformers import ChineseCLIPProcessor, ChineseCLIPModel

>>> model = ChineseCLIPModel.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")
>>> processor = ChineseCLIPProcessor.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")

>>> url = "https://clip-cn-beijing.oss-cn-beijing.aliyuncs.com/pokemon.jpeg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> # Squirtle, Bulbasaur, Charmander, Pikachu in English
>>> texts = ["杰尼龟", "妙蛙种子", "小火龙", "皮卡丘"]

>>> # compute image feature
>>> inputs = processor(images=image, return_tensors="pt")
>>> image_features = model.get_image_features(**inputs)
>>> image_features = image_features / image_features.norm(p=2, dim=-1, keepdim=True)  # normalize

>>> # compute text features
>>> inputs = processor(text=texts, padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)
>>> text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)  # normalize

>>> # compute image-text similarity scores
>>> inputs = processor(text=texts, 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)  # probs: [[1.2686e-03, 5.4499e-02, 6.7968e-04, 9.4355e-01]]

目前，在🤗 Hub 上提供以下规模的预训练中文 CLIP 模型：

ChineseCLIPConfig

class transformers.ChineseCLIPConfig

<来源>

( text_config = None vision_config = None projection_dim = 512 logit_scale_init_value = 2.6592 **kwargs )

参数

  • text_config（dict，可选）— 用于初始化 ChineseCLIPTextConfig 的配置选项字典。

  • vision_config（dict，可选）— 用于初始化 ChineseCLIPVisionConfig 的配置选项字典。

  • projection_dim（int，可选，默认为 512）— 文本和视觉投影层的维度。

  • logit_scale_init_value（float，可选，默认为 2.6592）— logit_scale参数的初始值。默认值根据原始 ChineseCLIP 实现使用。

  • kwargs（可选）— 关键字参数的字典。

ChineseCLIPConfig 是用于存储 ChineseCLIPModel 配置的配置类。根据指定的参数实例化 Chinese-CLIP 模型，定义文本模型和视觉模型配置。使用默认值实例化配置将产生类似于 Chinese-CLIP OFA-Sys/chinese-clip-vit-base-patch16架构的配置。

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

示例：

>>> from transformers import ChineseCLIPConfig, ChineseCLIPModel

>>> # Initializing a ChineseCLIPConfig with OFA-Sys/chinese-clip-vit-base-patch16 style configuration
>>> configuration = ChineseCLIPConfig()

>>> # Initializing a ChineseCLIPModel (with random weights) from the OFA-Sys/chinese-clip-vit-base-patch16 style configuration
>>> model = ChineseCLIPModel(configuration)

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

>>> # We can also initialize a ChineseCLIPConfig from a ChineseCLIPTextConfig and a ChineseCLIPVisionConfig

>>> # Initializing a ChineseCLIPTextConfig and ChineseCLIPVisionConfig configuration
>>> config_text = ChineseCLIPTextConfig()
>>> config_vision = ChineseCLIPVisionConfig()

>>> config = ChineseCLIPConfig.from_text_vision_configs(config_text, config_vision)

from_text_vision_configs

< source >

( text_config: ChineseCLIPTextConfig vision_config: ChineseCLIPVisionConfig **kwargs )

从 Chinese-CLIP 文本模型配置和 Chinese-CLIP 视觉模型配置实例化一个 ChineseCLIPConfig（或派生类）。返回：ChineseCLIPConfig：配置对象的实例

ChineseCLIPTextConfig

class transformers.ChineseCLIPTextConfig

< source >

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 initializer_factor = 1.0 layer_norm_eps = 1e-12 pad_token_id = 0 position_embedding_type = 'absolute' use_cache = True **kwargs )

参数

  • vocab_size (int, optional, defaults to 30522) — CHINESE_CLIP 模型的词汇量。定义了在调用 ChineseCLIPModel 时可以表示的不同标记数量。

  • hidden_size (int, optional, defaults to 768) — 编码器层和池化器层的维度。

  • num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数量。

  • num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。

  • intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。

  • hidden_act (str or Callable, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

  • hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

  • attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。

  • max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。

  • type_vocab_size (int, optional, defaults to 2) — 在调用 ChineseCLIPModel 时传递的token_type_ids的词汇量。

  • initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

  • initializer_factor (float, optional, defaults to 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1，用于内部初始化测试）。

  • layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。

  • pad_token_id (int, optional, defaults to 0) — 填充标记 id。

  • position_embedding_type (str, optional, defaults to "absolute") — 位置嵌入的类型。选择"absolute"之一，"relative_key"，"relative_key_query"。对于位置嵌入，请使用"absolute"。有关"relative_key"的更多信息，请参考Self-Attention with Relative Position Representations (Shaw et al.)。有关"relative_key_query"的更多信息，请参考Improve Transformer Models with Better Relative Position Embeddings (Huang et al.)中的Method 4。

  • use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。

这是用于存储 ChineseCLIPModel 配置的配置类。根据指定的参数实例化一个 Chinese CLIP 模型，定义模型架构。使用默认值实例化配置将产生类似于 Chinese CLIP OFA-Sys/chinese-clip-vit-base-patch16架构的配置。

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

示例：

>>> from transformers import ChineseCLIPTextConfig, ChineseCLIPTextModel

>>> # Initializing a ChineseCLIPTextConfig with OFA-Sys/chinese-clip-vit-base-patch16 style configuration
>>> configuration = ChineseCLIPTextConfig()

>>> # Initializing a ChineseCLIPTextModel (with random weights) from the OFA-Sys/chinese-clip-vit-base-patch16 style configuration
>>> model = ChineseCLIPTextModel(configuration)

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

ChineseCLIPVisionConfig

class transformers.ChineseCLIPVisionConfig

<来源>

( hidden_size = 768 intermediate_size = 3072 projection_dim = 512 num_hidden_layers = 12 num_attention_heads = 12 num_channels = 3 image_size = 224 patch_size = 32 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 **kwargs )

参数

  • hidden_size (int, optional, defaults to 768) — 编码器层和池化层的维度。

  • intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

  • projection_dim (int, optional, defaults to 512) — 文本和视觉投影层的维度。

  • num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数量。

  • num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数量。

  • num_channels (int, optional, defaults to 3) — 输入通道数。

  • image_size (int, optional, defaults to 224) — 每个图像的大小（分辨率）。

  • patch_size (int, optional, defaults to 32) — 每个补丁的大小（分辨率）。

  • hidden_act (str or function, optional, defaults to "quick_gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"以及"quick_gelu"。

  • layer_norm_eps (float, optional, defaults to 1e-05) — 层归一化层使用的 epsilon。

  • 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，仅用于初始化测试）。

这是一个配置类，用于存储 ChineseCLIPModel 的配置。它用于根据指定的参数实例化一个 ChineseCLIP 模型，定义模型架构。使用默认值实例化配置将产生类似于 ChineseCLIP OFA-Sys/chinese-clip-vit-base-patch16架构的配置。

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

示例：

>>> from transformers import ChineseCLIPVisionConfig, ChineseCLIPVisionModel

>>> # Initializing a ChineseCLIPVisionConfig with OFA-Sys/chinese-clip-vit-base-patch16 style configuration
>>> configuration = ChineseCLIPVisionConfig()

>>> # Initializing a ChineseCLIPVisionModel (with random weights) from the OFA-Sys/chinese-clip-vit-base-patch16 style configuration
>>> model = ChineseCLIPVisionModel(configuration)

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

ChineseCLIPImageProcessor

class transformers.ChineseCLIPImageProcessor

<来源>

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: Dict = None do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_convert_rgb: bool = True **kwargs )

参数

  • do_resize (bool, optional, 默认为 True) — 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess方法中的do_resize覆盖。

  • size (Dict[str, int] optional, 默认为 {"shortest_edge" -- 224}): 调整大小后的图像尺寸。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入的长宽比。可以被preprocess方法中的size覆盖。

  • resample (PILImageResampling, optional, 默认为 Resampling.BICUBIC) — 调整图像大小时要使用的重采样滤波器。可以被preprocess方法中的resample覆盖。

  • do_center_crop (bool, optional, 默认为 True) — 是否将图像居中裁剪到指定的crop_size。可以被preprocess方法中的do_center_crop覆盖。

  • crop_size (Dict[str, int] optional, 默认为 224) — 应用center_crop后输出图像的大小。可以被preprocess方法中的crop_size覆盖。

  • do_rescale (bool, optional, 默认为 True) — 是否按指定比例因子rescale_factor重新缩放图像。可以被preprocess方法中的do_rescale覆盖。

  • rescale_factor (int 或 float, optional, 默认为 1/255) — 用于重新缩放图像的比例因子。可以被preprocess方法中的rescale_factor覆盖。

  • do_normalize (bool, optional, defaults to True) — 是否对图像进行归一化。可以被preprocess方法中的do_normalize覆盖。

  • image_mean (float 或 List[float], optional, 默认为 IMAGENET_STANDARD_MEAN) — 如果对图像进行归一化，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_mean参数覆盖。

  • image_std (float 或 List[float], optional, 默认为 IMAGENET_STANDARD_STD) — 如果对图像进行归一化，则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_std参数覆盖。可以被preprocess方法中的image_std参数覆盖。

  • do_convert_rgb (bool, optional, 默认为 True) — 是否将图像转换为 RGB。

构建一个 Chinese-CLIP 图像处理器。

preprocess

<来源>

( images: Union do_resize: bool = None size: Dict = None resample: Resampling = None do_center_crop: bool = None crop_size: int = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None do_convert_rgb: bool = None return_tensors: Union = None data_format: Optional = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

  • images (ImageInput) — 要预处理的图像。期望单个或批量的像素值范围为 0 到 255 的图像。如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。

  • do_resize (bool, optional, 默认为 self.do_resize) — 是否调整图像大小。

  • size (Dict[str, int], optional, 默认为 self.size) — 调整大小后的图像尺寸。图像的最短边被调整为 size[“shortest_edge”]，最长边被调整以保持输入的长宽比。

  • resample (int, optional, 默认为 self.resample) — 如果调整图像大小，则要使用的重采样滤波器。这可以是枚举 PILImageResampling 之一。仅在 do_resize 设置为 True 时有效。

  • do_center_crop (bool, optional, 默认为 self.do_center_crop) — 是否对图像进行中心裁剪。

  • crop_size (Dict[str, int], optional, 默认为 self.crop_size) — 中心裁剪的尺寸。仅在 do_center_crop 设置为 True 时有效。

  • do_rescale (bool, optional, 默认为 self.do_rescale) — 是否重新缩放图像。

  • rescale_factor (float, optional, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的重新缩放因子。

  • do_normalize (bool, optional, 默认为 self.do_normalize) — 是否对图像进行归一化。

  • image_mean (float 或 List[float], optional, 默认为 self.image_mean) — 用于归一化的图像均值。仅在 do_normalize 设置为 True 时有效。

  • image_std (float 或 List[float], optional, 默认为 self.image_std) — 用于归一化的图像标准差。仅在 do_normalize 设置为 True 时有效。

  • do_convert_rgb (bool, optional, 默认为 self.do_convert_rgb) — 是否将图像转换为 RGB。

  • return_tensors (str 或 TensorType, optional) — 要返回的张量类型。可以是以下之一：

    • 未设置: 返回一个 np.ndarray 列表。

    • TensorType.TENSORFLOW 或 'tf': 返回类型为 tf.Tensor 的批处理。

    • TensorType.PYTORCH 或 'pt': 返回类型为 torch.Tensor 的批处理。

    • TensorType.NUMPY 或 'np': 返回类型为 np.ndarray 的批处理。

    • TensorType.JAX 或 'jax': 返回类型为 jax.numpy.ndarray 的批处理。

  • data_format (ChannelDimension 或 str, optional, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：

    • "channels_first" 或 ChannelDimension.FIRST: 图像以 (通道数, 高度, 宽度) 格式。

    • "channels_last" 或 ChannelDimension.LAST: 图像以 (高度, 宽度, 通道数) 格式。

    • 未设置: 使用输入图像的通道维度格式。

  • input_data_format (ChannelDimension 或 str, optional) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：

    • "channels_first" 或 ChannelDimension.FIRST: 图像以 (通道数, 高度, 宽度) 格式。

    • "channels_last" 或 ChannelDimension.LAST: 图像以 (高度, 宽度, 通道数) 格式。

    • "none" 或 ChannelDimension.NONE: 图像以 (高度, 宽度) 格式。

预处理一个图像或一批图像。

ChineseCLIPFeatureExtractor

class transformers.ChineseCLIPFeatureExtractor

< source >

( *args **kwargs )

ChineseCLIPProcessor

class transformers.ChineseCLIPProcessor

< source >

( image_processor = None tokenizer = None **kwargs )

参数

  • image_processor (ChineseCLIPImageProcessor, optional) — 图像处理器是必需的输入。

  • tokenizer (BertTokenizerFast, optional) — 分词器是必需的输入。

构建一个包装了中文-CLIP 图像处理器和中文-CLIP 分词器的中文-CLIP 处理器。

ChineseCLIPProcessor 提供了 ChineseCLIPImageProcessor 和 BertTokenizerFast 的所有功能。查看__call__()和 decode()获取更多信息。

批量解码

<来源>

( *args **kwargs )

这个方法将其所有参数转发给 BertTokenizerFast 的 batch_decode()。请参考此方法的文档字符串以获取更多信息。

解码

<来源>

( *args **kwargs )

这个方法将其所有参数转发给 BertTokenizerFast 的 decode()。请参考此方法的文档字符串以获取更多信息。

ChineseCLIPModel

class transformers.ChineseCLIPModel

<来源>

( config: ChineseCLIPConfig )

参数

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

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

前向

<来源>

( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.chinese_clip.modeling_chinese_clip.ChineseCLIPOutput 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]之间：

    • 对于未被masked的标记，值为 1。

    • 对于被masked的标记，值为 0。

    什么是注意力掩码？

  • token_type_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]之间：

    • 0 对应于句子 A标记，

    • 1 对应于句子 B标记。

    什么是标记类型 ID？

  • position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

    什么是位置 ID？

  • pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ChineseCLIPImageProcessor.call()。

  • return_loss (bool, 可选) — 是否返回对比损失。

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.chinese_clip.modeling_chinese_clip.ChineseCLIPOutput 或 tuple(torch.FloatTensor)

一个transformers.models.chinese_clip.modeling_chinese_clip.ChineseCLIPOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置(<class 'transformers.models.chinese_clip.configuration_chinese_clip.ChineseCLIPConfig'>)和输入而异的各种元素。

  • 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之间的缩放点积分数。这代表了文本-图像相似性分数。

  • text_embeds(torch.FloatTensor，形状为(batch_size, output_dim) — 通过将投影层应用于 ChineseCLIPTextModel 的汇聚输出获得的文本嵌入。

  • image_embeds(torch.FloatTensor，形状为(batch_size, output_dim) — 通过将投影层应用于 ChineseCLIPVisionModel 的汇聚输出获得的图像嵌入。

  • text_model_output(BaseModelOutputWithPoolingAndCrossAttentions): ChineseCLIPTextModel 的输出。

  • vision_model_output(BaseModelOutputWithPoolingAndCrossAttentions): ChineseCLIPVisionModel 的输出。

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

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

示例：

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

>>> model = ChineseCLIPModel.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")
>>> processor = AutoProcessor.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")

>>> url = "https://clip-cn-beijing.oss-cn-beijing.aliyuncs.com/pokemon.jpeg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(text=["杰尼龟", "妙蛙种子", "小火龙", "皮卡丘"], 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

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: 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，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

    什么是输入 ID？

  • attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

    • 1 表示标记未被掩盖，

    • 0 表示标记被掩盖。

    什么是注意力掩码？

  • token_type_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：

    • 0 对应于句子 A的标记，

    • 1 对应于句子 B的标记。

    什么是标记类型 ID？

  • position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

    什么是位置 ID？

  • head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：

    • 1 表示头部未被掩盖，

    • 0 表示头部被掩盖。

  • inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

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

通过将投影层应用于 Text-Transformer 的最终[CLS]隐藏状态获得的文本嵌入。

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

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

示例：

>>> from transformers import AutoTokenizer, ChineseCLIPModel

>>> model = ChineseCLIPModel.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")
>>> tokenizer = AutoTokenizer.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")

>>> inputs = tokenizer(["杰尼龟", "妙蛙种子", "小火龙", "皮卡丘"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)
>>> text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)

get_image_features

< source >

( 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 获取像素值。有关详细信息，请参见 ChineseCLIPImageProcessor.call()。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。

  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的 hidden_states。

  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

image_features (torch.FloatTensor，形状为 (batch_size, output_dim))

通过将投影层应用于 Vision-Transformer 的最终 [CLS] 隐藏状态获得的图像嵌入。

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

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

示例：

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

>>> model = ChineseCLIPModel.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")
>>> processor = AutoProcessor.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")

>>> url = "https://clip-cn-beijing.oss-cn-beijing.aliyuncs.com/pokemon.jpeg"
>>> image = Image.open(requests.get(url, stream=True).raw)

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

>>> image_features = model.get_image_features(**inputs)
>>> image_features = image_features / image_features.norm(p=2, dim=-1, keepdim=True)

ChineseCLIPTextModel

class transformers.ChineseCLIPTextModel

<来源>

( config add_pooling_layer = True )

参数

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

CHINESE_CLIP 的文本模型没有任何头部或顶部的投影。这个模型是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

该模型可以作为编码器（仅具有自注意力）以及解码器，此时在自注意力层之间添加了一层交叉注意力，遵循 Attention is all you need 中描述的架构，作者为 Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser 和 Illia Polosukhin。

为了作为解码器行为，模型需要使用配置中设置为 True 的 is_decoder 参数进行初始化。要在 Seq2Seq 模型中使用，模型需要使用设置为 True 的 is_decoder 参数和 add_cross_attention 进行初始化；然后预期将 encoder_hidden_states 作为前向传递的输入。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: 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 ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 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]：

    • 对于被 not masked 的标记为 1，

    • 对于被 masked 的标记为 0。

    什么是注意力掩码？

  • token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

    • 0 对应于一个 句子 A 的标记，

    • 1 对应于一个 句子 B 的标记。

    什么是标记类型 ID？

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 ID？

  • pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ChineseCLIPImageProcessor.call()。

  • return_loss (bool, optional) — 是否返回对比损失。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。

  • return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

  • encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

  • encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。掩码值在 [0, 1] 中选择：

    • 1 表示未被屏蔽的标记，

    • 0 表示被屏蔽的标记。

  • 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) 的张量，而不是形状为 (batch_size, sequence_length) 的所有 decoder_input_ids。

  • use_cache (bool, optional) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或者 config.return_dict=False 时）包含各种元素，取决于配置（ChineseCLIPConfig）和输入。

  • last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

  • cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True和config.add_cross_attention=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。

    解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

  • 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还有交叉注意力块中的键和值），可用于加速顺序解码（查看past_key_values输入）。

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

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

示例：

>>> from transformers import AutoTokenizer, ChineseCLIPTextModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")
>>> model = ChineseCLIPTextModel.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

ChineseCLIPVisionModel

class transformers.ChineseCLIPVisionModel

<来源>

( config: ChineseCLIPVisionConfig )

参数

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

CHINESE_CLIP 中的视觉模型，没有顶部头部或投影。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

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 (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ChineseCLIPImageProcessor.call()。

  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPooling 或torch.FloatTensor元组

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（<class 'transformers.models.chinese_clip.configuration_chinese_clip.ChineseCLIPVisionConfig'>）和输入的各种元素。

  • last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态的序列。

  • pooler_output (torch.FloatTensor of shape (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 后，用于计算加权平均值。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import CLIPProcessor, ChineseCLIPVisionModel

>>> model = ChineseCLIPVisionModel.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")
>>> processor = CLIPProcessor.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")

>>> url = "https://clip-cn-beijing.oss-cn-beijing.aliyuncs.com/pokemon.jpeg"
>>> 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
posted @ 2024-06-22 14:26  绝不原创的飞龙  阅读(27)  评论(0)  编辑  收藏  举报