VisionTextDualEncoder
概述
可以使用 VisionTextDualEncoderModel 初始化一个视觉文本双编码器模型，并使用任何预训练的视觉自动编码模型作为视觉编码器（例如 ViT、BEiT、DeiT）以及任何预训练的文本自动编码模型作为文本编码器（例如 RoBERTa、BERT）。在视觉和文本编码器的顶部添加了两个投影层，将输出嵌入投影到共享的潜在空间。投影层是随机初始化的，因此模型应该在下游任务上进行微调。此模型可用于使用类似 CLIP 的对比图像文本训练来对齐视觉文本嵌入，然后可用于零样本视觉任务，例如图像分类或检索。
在 LiT: Zero-Shot Transfer with Locked-image Text Tuning 中，展示了如何利用预训练的（锁定/冻结）图像和文本模型进行对比学习，这将在新的零样本视觉任务（例如图像分类或检索）上产生显著的改进。
VisionTextDualEncoderConfig
class transformers.VisionTextDualEncoderConfig
< source >( projection_dim = 512 logit_scale_init_value = 2.6592 **kwargs )
VisionTextDualEncoderConfig 是用于存储 VisionTextDualEncoderModel 配置的配置类。它用于根据指定参数实例化 VisionTextDualEncoderModel 模型，定义文本模型和视觉模型配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以了解更多信息。
示例
>>> from transformers import ViTConfig, BertConfig, VisionTextDualEncoderConfig, VisionTextDualEncoderModel
>>> # Initializing a BERT and ViT configuration
>>> config_vision = ViTConfig()
>>> config_text = BertConfig()
>>> config = VisionTextDualEncoderConfig.from_vision_text_configs(config_vision, config_text, projection_dim=512)
>>> # Initializing a BERT and ViT model (with random weights)
>>> model = VisionTextDualEncoderModel(config=config)
>>> # Accessing the model configuration
>>> config_vision = model.config.vision_config
>>> config_text = model.config.text_config
>>> # Saving the model, including its configuration
>>> model.save_pretrained("vit-bert")
>>> # loading model and config from pretrained folder
>>> vision_text_config = VisionTextDualEncoderConfig.from_pretrained("vit-bert")
>>> model = VisionTextDualEncoderModel.from_pretrained("vit-bert", config=vision_text_config)from_vision_text_configs
< source >( vision_config: PretrainedConfig text_config: PretrainedConfig **kwargs ) → VisionTextDualEncoderConfig
从文本模型配置和视觉模型配置实例化 VisionTextDualEncoderConfig（或派生类）。
VisionTextDualEncoderProcessor
class transformers.VisionTextDualEncoderProcessor
( image_processor = None tokenizer = None **kwargs )参数
- image_processor (AutoImageProcessor, 可选) — 图像处理器是必需的输入。
- tokenizer (PreTrainedTokenizer, 可选) — 分词器是必需的输入。
构建一个 VisionTextDualEncoder 处理器，它将图像处理器和分词器封装到一个处理器中。
VisionTextDualEncoderProcessor 提供了 AutoImageProcessor 和 AutoTokenizer 的所有功能。 有关更多信息，请参见 __call__() 和 decode()。
此方法将所有参数转发给 VisionTextDualEncoderTokenizer 的 batch_decode()。 有关更多信息，请参见此方法的文档字符串。
VisionTextDualEncoderModel
class transformers.VisionTextDualEncoderModel
< 源代码 >( config: Optional = None vision_model: Optional = None text_model: Optional = None )
参数
- config (VisionEncoderDecoderConfig) — 模型配置类，包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重，只会加载配置。 查看 from_pretrained() 方法加载模型权重。
此类可用于使用任何预训练的视觉自动编码模型作为视觉编码器，以及任何预训练的文本模型作为文本编码器，来初始化视觉文本双编码器模型。 视觉和文本编码器通过 from_pretrained() 方法加载。 投影层会自动添加到模型中，并且应该在下游任务（如对比图像文本建模）上微调。
在 LiT: Zero-Shot Transfer with Locked-image Text Tuning 中，展示了如何利用预训练的（锁定/冻结的）图像和文本模型进行对比学习，从而在新的零样本视觉任务（如图像分类或检索）中取得显著改进。
在训练/微调这种视觉文本双编码器模型之后，它可以像其他任何模型一样保存/加载（有关更多信息，请参见示例）。
此模型继承自 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 token_type_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.clip.modeling_clip.CLIPOutput or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充，默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length)，可选) — 掩码，以避免对填充标记索引执行注意力。在[0, 1]中选择的掩码值：- 1 用于未掩码的标记，
- 0 用于掩码的标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。如果您提供填充，默认情况下将忽略填充。可以使用图像处理器获取像素值（例如，如果您使用 ViT 作为编码器，则应使用 AutoImageProcessor）。有关详细信息，请参阅 ViTImageProcessor.call()。 - return_loss (
bool，可选) — 是否返回对比损失。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.clip.modeling_clip.CLIPOutput or tuple(torch.FloatTensor)
一个 transformers.models.clip.modeling_clip.CLIPOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置（VisionTextDualEncoderConfig）和输入的不同元素。
- 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) — 通过将投影层应用于 CLIPTextModel 的池化输出获得的文本嵌入。 - image_embeds (
torch.FloatTensor形状为(batch_size, output_dim) — 通过将投影层应用于 CLIPVisionModel 的池化输出获得的图像嵌入。 - text_model_output (
BaseModelOutputWithPooling) — CLIPTextModel 的输出。 - vision_model_output (
BaseModelOutputWithPooling) — CLIPVisionModel 的输出。
VisionTextDualEncoderModel 的前向方法覆盖了 __call__ 特殊方法。
虽然前向传递的配方需要在此函数内定义，但应该随后调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则静默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import (
... VisionTextDualEncoderModel,
... VisionTextDualEncoderProcessor,
... AutoImageProcessor,
... AutoTokenizer,
... )
>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
>>> processor = VisionTextDualEncoderProcessor(image_processor, tokenizer)
>>> model = VisionTextDualEncoderModel.from_vision_text_pretrained(
... "google/vit-base-patch16-224", "google-bert/bert-base-uncased"
... )
>>> # contrastive training
>>> urls = [
... "http://images.cocodataset.org/val2017/000000039769.jpg",
... "https://farm3.staticflickr.com/2674/5850229113_4fe05d5265_z.jpg",
... ]
>>> images = [Image.open(requests.get(url, stream=True).raw) for url in urls]
>>> inputs = processor(
... text=["a photo of a cat", "a photo of a dog"], images=images, return_tensors="pt", padding=True
... )
>>> outputs = model(
... input_ids=inputs.input_ids,
... attention_mask=inputs.attention_mask,
... pixel_values=inputs.pixel_values,
... return_loss=True,
... )
>>> loss, logits_per_image = outputs.loss, outputs.logits_per_image # this is the image-text similarity score
>>> # save and load from pretrained
>>> model.save_pretrained("vit-bert")
>>> model = VisionTextDualEncoderModel.from_pretrained("vit-bert")
>>> # inference
>>> 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 probabilitiesFlaxVisionTextDualEncoderModel
class transformers.FlaxVisionTextDualEncoderModel
< 源代码 >( config: VisionTextDualEncoderConfig input_shape: Optional = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (VisionTextDualEncoderConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype, 可选, 默认值为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32,jax.numpy.float16(在 GPU 上) 和jax.numpy.bfloat16(在 TPU 上)。这可以用来在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定了，所有计算都将使用给定的
dtype进行。注意，这仅指定计算的 dtype，不会影响模型参数的 dtype。
此类可用于使用任何预训练的视觉自动编码模型作为视觉编码器，以及任何预训练的文本模型作为文本编码器，来初始化视觉文本双编码器模型。 视觉和文本编码器通过 from_pretrained() 方法加载。 投影层会自动添加到模型中，并且应该在下游任务（如对比图像文本建模）上微调。
在 LiT: Zero-Shot Transfer with Locked-image Text Tuning 中，展示了如何利用预训练的（锁定/冻结的）图像和文本模型进行对比学习，从而在新的零样本视觉任务（如图像分类或检索）中取得显著改进。
在训练/微调这种视觉文本双编码器模型之后，它可以像其他任何模型一样保存/加载（有关更多信息，请参见示例）。
此模型继承自 PreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
此模型也是一个 flax.linen.Module 子类。将其用作常规的 Flax linen 模块，并参考 Flax 文档以了解与一般使用和行为相关的所有事项。
最后，此模型支持 JAX 的固有功能，例如
__call__
< 源代码 >( input_ids pixel_values attention_mask = None position_ids = None token_type_ids = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.clip.modeling_flax_clip.FlaxCLIPOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarray形状为(batch_size, sequence_length)) — 输入序列词元在词汇表中的索引。如果您提供填充，则默认情况下将忽略填充。索引可以使用 AutoTokenizer 获取。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详细信息。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), *可选*) — 掩码以避免对填充标记索引执行注意力。 掩码值选择在[0, 1]中：- 1 代表未被掩码的标记，
- 0 代表被掩码的标记。
- position_ids (
numpy.ndarray形状为(batch_size, sequence_length), *可选*) — 每个输入序列标记在位置嵌入中的位置索引。 选择范围为[0, config.max_position_embeddings - 1]。 - pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。 默认情况下，如果您提供填充，它将被忽略。 像素值可以使用图像处理器获得（例如，如果您使用 ViT 作为编码器，您应该使用 AutoImageProcessor）。 有关详细信息，请参见 ViTImageProcessor.call()。 - output_attentions (
bool, *可选*) — 是否返回所有注意力层的注意力张量。 有关详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, *可选*) — 是否返回所有层的隐藏状态。 有关详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool, *可选*) — 是否返回一个 ModelOutput 而不是一个简单的元组。
返回
transformers.models.clip.modeling_flax_clip.FlaxCLIPOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.clip.modeling_flax_clip.FlaxCLIPOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含取决于配置（VisionTextDualEncoderConfig）和输入的各种元素。
- logits_per_image:(
jnp.ndarray形状为(image_batch_size, text_batch_size)) —image_embeds和text_embeds之间的缩放点积得分。 这代表了图像-文本相似度得分。 - logits_per_text:(
jnp.ndarray形状为(text_batch_size, image_batch_size)) —text_embeds和image_embeds之间的缩放点积得分。 这代表了文本-图像相似度得分。 - text_embeds(
jnp.ndarray形状为(batch_size, output_dim) — 通过将投影层应用于 FlaxCLIPTextModel 的池化输出获得的文本嵌入。 - image_embeds(
jnp.ndarray形状为(batch_size, output_dim) — 通过将投影层应用于 FlaxCLIPVisionModel 的池化输出获得的图像嵌入。 - text_model_output(
FlaxBaseModelOutputWithPooling): FlaxCLIPTextModel 的输出。 - vision_model_output(
FlaxBaseModelOutputWithPooling): FlaxCLIPVisionModel 的输出。
FlaxVisionTextDualEncoderModel 前向方法覆盖 __call__ 特殊方法。
虽然前向传递的配方需要在此函数内定义，但应该随后调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则静默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> import jax
>>> from transformers import (
... FlaxVisionTextDualEncoderModel,
... VisionTextDualEncoderProcessor,
... AutoImageProcessor,
... AutoTokenizer,
... )
>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> image_processor = AutoImageProcesor.from_pretrained("google/vit-base-patch16-224")
>>> processor = VisionTextDualEncoderProcessor(image_processor, tokenizer)
>>> model = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
... "google/vit-base-patch16-224", "google-bert/bert-base-uncased"
... )
>>> # contrastive training
>>> urls = [
... "http://images.cocodataset.org/val2017/000000039769.jpg",
... "https://farm3.staticflickr.com/2674/5850229113_4fe05d5265_z.jpg",
... ]
>>> images = [Image.open(requests.get(url, stream=True).raw) for url in urls]
>>> inputs = processor(
... text=["a photo of a cat", "a photo of a dog"], images=images, return_tensors="np", padding=True
... )
>>> outputs = model(
... input_ids=inputs.input_ids,
... attention_mask=inputs.attention_mask,
... pixel_values=inputs.pixel_values,
... )
>>> logits_per_image = outputs.logits_per_image # this is the image-text similarity score
>>> # save and load from pretrained
>>> model.save_pretrained("vit-bert")
>>> model = FlaxVisionTextDualEncoderModel.from_pretrained("vit-bert")
>>> # inference
>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image # this is the image-text similarity score
>>> probs = jax.nn.softmax(logits_per_image, axis=1) # we can take the softmax to get the label probabilitiesTFVisionTextDualEncoderModel
class transformers.TFVisionTextDualEncoderModel
< 源代码 >( config: Optional[VisionTextDualEncoderConfig] = None vision_model: Optional[TFPreTrainedModel] = None text_model: Optional[TFPreTrainedModel] = None )
参数
- config (VisionEncoderDecoderConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
此类可用于使用任何预训练的视觉自动编码模型作为视觉编码器，以及任何预训练的文本模型作为文本编码器，来初始化视觉文本双编码器模型。 视觉和文本编码器通过 from_pretrained() 方法加载。 投影层会自动添加到模型中，并且应该在下游任务（如对比图像文本建模）上微调。
在 LiT: Zero-Shot Transfer with Locked-image Text Tuning 中，展示了如何利用预训练的（锁定/冻结的）图像和文本模型进行对比学习，从而在新的零样本视觉任务（如图像分类或检索）中取得显著改进。
在训练/微调这种视觉文本双编码器模型之后，它可以像其他任何模型一样保存/加载（有关更多信息，请参见示例）。
此模型继承自 TFPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪 head 等）。
此模型也是 Keras Model 子类。将其用作常规 Keras Model 并参考 TF 文档以了解与通用用法和行为相关的所有事项。
call
< source >( 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 token_type_ids: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → transformers.models.clip.modeling_tf_clip.TFCLIPOutput 或 tuple(tf.Tensor)
参数
- input_ids (
tf.Tensor形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。如果提供填充，默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor形状为(batch_size, sequence_length)，可选) — 掩码，避免对填充 token 索引执行注意力。在[0, 1]中选择的掩码值：- 1 代表未掩码的 token，
- 0 代表掩码的 token。
- position_ids (
tf.Tensor形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - pixel_values (
tf.Tensor形状为(batch_size, num_channels, height, width)) — 像素值。如果提供填充，默认情况下将忽略填充。可以使用图像处理器获取像素值（例如，如果您使用 ViT 作为编码器，则应使用 AutoImageProcessor）。有关详细信息，请参阅 ViTImageProcessor.call()。 - return_loss (
bool，可选) — 是否返回对比损失。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的attentions。
返回
transformers.models.clip.modeling_tf_clip.TFCLIPOutput 或 tuple(tf.Tensor)
一个 transformers.models.clip.modeling_tf_clip.TFCLIPOutput 或一个 tf.Tensor 的元组 (如果传递了 return_dict=False 或者 config.return_dict=False)，包含根据配置 (VisionTextDualEncoderConfig) 和输入的不同元素。
- loss (
tf.Tensor形状为(1,), 可选, 当return_loss为True时返回) — 图像-文本相似度的对比损失。 - logits_per_image:(
tf.Tensor形状为(image_batch_size, text_batch_size)) —image_embeds和text_embeds之间的缩放点积分数。这代表图像-文本相似度得分。 - logits_per_text:(
tf.Tensor形状为(text_batch_size, image_batch_size)) —text_embeds和image_embeds之间的缩放点积分数。这代表文本-图像相似度得分。 - text_embeds(
tf.Tensor形状为(batch_size, output_dim) — 通过将投影层应用于 TFCLIPTextModel 的池化输出而获得的文本嵌入。 - image_embeds(
tf.Tensor形状为(batch_size, output_dim) — 通过将投影层应用于 TFCLIPVisionModel 的池化输出而获得的图像嵌入。 - text_model_output(
~modeling_tf_utils.TFBaseModelOutputWithPooling): TFCLIPTextModel 的输出。 - vision_model_output(
~modeling_tf_utils.TFBaseModelOutputWithPooling): TFCLIPVisionModel 的输出。
The TFVisionTextDualEncoderModel forward method, overrides the __call__ special method.
虽然前向传递的配方需要在此函数内定义，但应该随后调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则静默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import (
... TFVisionTextDualEncoderModel,
... VisionTextDualEncoderProcessor,
... AutoImageProcessor,
... AutoTokenizer,
... )
>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
>>> processor = VisionTextDualEncoderProcessor(image_processor, tokenizer)
>>> model = TFVisionTextDualEncoderModel.from_vision_text_pretrained(
... "google/vit-base-patch16-224", "google-bert/bert-base-uncased"
... )
>>> # contrastive training
>>> urls = [
... "http://images.cocodataset.org/val2017/000000039769.jpg",
... "https://farm3.staticflickr.com/2674/5850229113_4fe05d5265_z.jpg",
... ]
>>> images = [Image.open(requests.get(url, stream=True).raw) for url in urls]
>>> inputs = processor(
... text=["a photo of a cat", "a photo of a dog"], images=images, return_tensors="np", padding=True
... )
>>> outputs = model(
... input_ids=inputs.input_ids,
... attention_mask=inputs.attention_mask,
... pixel_values=inputs.pixel_values,
... return_loss=True,
... )
>>> loss, logits_per_image = outputs.loss, outputs.logits_per_image # this is the image-text similarity score
>>> # save and load from pretrained
>>> model.save_pretrained("vit-bert")
>>> model = TFVisionTextDualEncoderModel.from_pretrained("vit-bert")
>>> # inference
>>> 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