Transformers 4.37 中文文档（九十五）

原文：huggingface.co/docs/transformers

TrOCR

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

概述

TrOCR 模型是由 Minghao Li、Tengchao Lv、Lei Cui、Yijuan Lu、Dinei Florencio、Cha Zhang、Zhoujun Li、Furu Wei 在TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models中提出的。TrOCR 包括一个图像 Transformer 编码器和一个自回归文本 Transformer 解码器，用于执行光学字符识别（OCR）。

论文的摘要如下：

文本识别是文档数字化的一个长期研究问题。现有的文本识别方法通常基于 CNN 进行图像理解和基于 RNN 进行字符级文本生成。此外，通常需要另一个语言模型作为后处理步骤来提高整体准确性。在本文中，我们提出了一种端到端的文本识别方法，使用预训练的图像 Transformer 和文本 Transformer 模型，即 TrOCR，它利用 Transformer 架构进行图像理解和词片级文本生成。TrOCR 模型简单而有效，可以使用大规模合成数据进行预训练，并使用人工标记的数据集进行微调。实验表明，TrOCR 模型在印刷和手写文本识别任务上优于当前最先进的模型。

drawing

TrOCR 架构。摘自原始论文。

请参考VisionEncoderDecoder类如何使用这个模型。

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

使用提示

• 开始使用 TrOCR 的最快方法是查看教程笔记本，展示了如何在推理时使用模型以及在自定义数据上进行微调。
• TrOCR 在被微调到下游数据集之前经过 2 个阶段的预训练。它在印刷（例如SROIE 数据集）和手写（例如IAM 手写数据集）文本识别任务上取得了最先进的结果。更多信息，请参阅官方模型。
• TrOCR 始终在 VisionEncoderDecoder 框架内使用。

资源

一个官方的 Hugging Face 和社区资源列表（由🌎表示），帮助您开始使用 TrOCR。如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将进行审核！资源应该展示一些新东西，而不是重复现有资源。

文本分类

• 一个关于加速文档 AI与 TrOCR 的博客文章。
• 一个关于如何使用 TrOCR 进行文档 AI的博客文章。
• 一个关于如何使用 Seq2SeqTrainer 在 IAM 手写数据库上微调 TrOCR的笔记本。
• 一个关于inference with TrOCR和 Gradio 演示的笔记本。
• 一个关于在 IAM 手写数据库上微调 TrOCR使用原生 PyTorch 的笔记本。
• 关于在 IAM 测试集上评估 TrOCR的笔记本。

文本生成

• 语言建模任务指南。

⚡️ 推理

• 关于TrOCR 手写字符识别的交互式演示。

推理

TrOCR 的VisionEncoderDecoder模型接受图像作为输入，并利用 generate()来自回归地生成给定输入图像的文本。

[ViTImageProcessor/DeiTImageProcessor]类负责预处理输入图像，[RobertaTokenizer/XLMRobertaTokenizer]解码生成的目标令牌为目标字符串。TrOCRProcessor 将[ViTImageProcessor/DeiTImageProcessor]和[RobertaTokenizer/XLMRobertaTokenizer]封装成单个实例，用于提取输入特征和解码预测的令牌 ID。

• 逐步光学字符识别（OCR）

>>> from transformers import TrOCRProcessor, VisionEncoderDecoderModel
>>> import requests
>>> from PIL import Image

>>> processor = TrOCRProcessor.from_pretrained("microsoft/trocr-base-handwritten")
>>> model = VisionEncoderDecoderModel.from_pretrained("microsoft/trocr-base-handwritten")

>>> # load image from the IAM dataset
>>> url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB")

>>> pixel_values = processor(image, return_tensors="pt").pixel_values
>>> generated_ids = model.generate(pixel_values)

>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

查看模型中心以查找 TrOCR 检查点。

TrOCRConfig

class transformers.TrOCRConfig

<来源>

( vocab_size = 50265 d_model = 1024 decoder_layers = 12 decoder_attention_heads = 16 decoder_ffn_dim = 4096 activation_function = 'gelu' max_position_embeddings = 512 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 decoder_start_token_id = 2 init_std = 0.02 decoder_layerdrop = 0.0 use_cache = True scale_embedding = False use_learned_position_embeddings = True layernorm_embedding = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

• vocab_size (int, optional, defaults to 50265) — TrOCR 模型的词汇量。定义了在调用 TrOCRForCausalLM 时可以表示的不同令牌数量。
• d_model (int, optional, defaults to 1024) — 层和池化层的维度。
• decoder_layers (int, optional, defaults to 12) — 解码器层数。
• decoder_attention_heads (int, optional, defaults to 16) — Transformer 解码器中每个注意力层的注意力头数。
• decoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。
• activation_function (str or function, optional, defaults to "gelu") — 池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。
• max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
• dropout (float, optional, defaults to 0.1) — 嵌入层和池化器中所有全连接层的丢弃概率。
• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的丢弃比例。
• activation_dropout (float, optional, defaults to 0.0) — 全连接层内激活的丢弃比例。
• init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop 论文)。
• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
• scale_embedding (bool, optional, defaults to False) — 是否将词嵌入按 sqrt(d_model)进行缩放。
• use_learned_position_embeddings (bool, optional, defaults to True) — 是否使用学习的位置嵌入。如果不是，则将使用正弦位置嵌入。
• layernorm_embedding（bool，可选，默认为True）—是否在单词+位置嵌入后使用 layernorm。

这是配置类，用于存储 TrOCRForCausalLM 的配置。它用于根据指定的参数实例化 TrOCR 模型，定义模型架构。使用默认值实例化配置将产生类似于 TrOCR microsoft/trocr-base-handwritten架构的配置。

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

示例：

>>> from transformers import TrOCRConfig, TrOCRForCausalLM

>>> # Initializing a TrOCR-base style configuration
>>> configuration = TrOCRConfig()

>>> # Initializing a model (with random weights) from the TrOCR-base style configuration
>>> model = TrOCRForCausalLM(configuration)

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

TrOCRProcessor

class transformers.TrOCRProcessor

<来源>

( image_processor = None tokenizer = None **kwargs )

参数

• image_processor（[ViTImageProcessor/DeiTImageProcessor]，可选）—[ViTImageProcessor/DeiTImageProcessor]的实例。图像处理器是必需的输入。
• tokenizer（[RobertaTokenizer/XLMRobertaTokenizer]，可选）—[RobertaTokenizer/XLMRobertaTokenizer]的实例。标记器是必需的输入。

构建一个 TrOCR 处理器，将视觉图像处理器和 TrOCR 标记器封装到单个处理器中。

TrOCRProcessor 提供了所有[ViTImageProcessor/DeiTImageProcessor]和[RobertaTokenizer/XLMRobertaTokenizer]的功能。查看call()和 decode()以获取更多信息。

__call__

<来源>

( *args **kwargs )

在正常模式下使用时，此方法将所有参数转发到 AutoImageProcessor 的__call__()并返回其输出。如果在上下文as_target_processor()中使用此方法，则将所有参数转发到 TrOCRTokenizer 的~TrOCRTokenizer.__call__。请参考上述两种方法的文档获取更多信息。

from_pretrained

<来源>

( pretrained_model_name_or_path: Union cache_dir: Union = None force_download: bool = False local_files_only: bool = False token: Union = None revision: str = 'main' **kwargs )

参数

• pretrained_model_name_or_path（str或os.PathLike）—这可以是：
  • 一个字符串，预训练特征提取器的模型 ID，托管在 huggingface.co 上的模型存储库中。有效的模型 ID 可以位于根级别，如bert-base-uncased，或命名空间在用户或组织名称下，如dbmdz/bert-base-german-cased。
  • 一个目录的路径，其中包含使用 save_pretrained()方法保存的特征提取器文件，例如./my_model_directory/。
  • 一个保存的特征提取器 JSON 文件的路径或 URL，例如./my_model_directory/preprocessor_config.json。**kwargs —传递给 from_pretrained()和~tokenization_utils_base.PreTrainedTokenizer.from_pretrained的额外关键字参数。

实例化与预训练模型相关联的处理器。

这个类方法只是调用特征提取器 from_pretrained()、图像处理器 ImageProcessingMixin 和分词器~tokenization_utils_base.PreTrainedTokenizer.from_pretrained方法。有关更多信息，请参阅上述方法的文档字符串。

save_pretrained

<来源>

( save_directory push_to_hub: bool = False **kwargs )

参数

• save_directory (str或os.PathLike) — 特征提取器 JSON 文件和分词器文件将保存在的目录（如果目录不存在将被创建）。
• push_to_hub (bool, 可选, 默认为False) — 是否在保存后将模型推送到 Hugging Face 模型中心。您可以使用repo_id指定要推送到的存储库（将默认为您命名空间中的save_directory名称）。
• kwargs (Dict[str, Any], 可选) — 传递给 push_to_hub()方法的额外关键字参数。

将此处理器的属性（特征提取器、分词器等）保存在指定目录中，以便可以使用 from_pretrained()方法重新加载。

这个类方法只是调用 save_pretrained()和 save_pretrained()。有关更多信息，请参阅上述方法的文档字符串。

batch_decode

<来源>

( *args **kwargs )

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

decode

<来源>

( *args **kwargs )

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

TrOCRForCausalLM

class transformers.TrOCRForCausalLM

<来源>

( config )

参数

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

带有语言建模头的 TrOCR 解码器。可用作 EncoderDecoderModel 和VisionEncoderDecoder的解码器部分。此模型继承自 PreTrainedModel。检查超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 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 表示标记是被掩码。

  什么是注意力掩码？

• encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
• encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。掩码值选在[0, 1]之间：
• head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使注意力模块的选定头部失效的掩码。掩码值选在[0, 1]之间：
  • 1 表示头部是未被掩码，
  • 0 表示头部是被掩码。
• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使交叉注意力模块的选定头部失效的掩码。掩码值选在[0, 1]之间：
  • 1 表示头部是未被掩码，
  • 0 表示头部是被掩码。
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。当模型用作序列到序列模型中的解码器时，这两个额外的张量是必需的。 包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。 如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100（参见input_ids文档字符串）。将索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。
• use_cache（bool，可选）— 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
  • 对于未被masked的标记为 1，
  • 对于被masked的标记为 0。
• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个 torch.FloatTensor 元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（TrOCRConfig）和输入的不同元素。

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个标记预测）。
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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 之后的注意力权重，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=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的torch.FloatTensor元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。仅在config.is_decoder = True时相关。 包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。

示例：

>>> from transformers import (
...     TrOCRConfig,
...     TrOCRProcessor,
...     TrOCRForCausalLM,
...     ViTConfig,
...     ViTModel,
...     VisionEncoderDecoderModel,
... )
>>> import requests
>>> from PIL import Image

>>> # TrOCR is a decoder model and should be used within a VisionEncoderDecoderModel
>>> # init vision2text model with random weights
>>> encoder = ViTModel(ViTConfig())
>>> decoder = TrOCRForCausalLM(TrOCRConfig())
>>> model = VisionEncoderDecoderModel(encoder=encoder, decoder=decoder)

>>> # If you want to start from the pretrained model, load the checkpoint with `VisionEncoderDecoderModel`
>>> processor = TrOCRProcessor.from_pretrained("microsoft/trocr-base-handwritten")
>>> model = VisionEncoderDecoderModel.from_pretrained("microsoft/trocr-base-handwritten")

>>> # load image from the IAM dataset
>>> url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
>>> pixel_values = processor(image, return_tensors="pt").pixel_values
>>> text = "industry, ' Mr. Brown commented icily. ' Let us have a"

>>> # training
>>> model.config.decoder_start_token_id = processor.tokenizer.cls_token_id
>>> model.config.pad_token_id = processor.tokenizer.pad_token_id
>>> model.config.vocab_size = model.config.decoder.vocab_size

>>> labels = processor.tokenizer(text, return_tensors="pt").input_ids
>>> outputs = model(pixel_values, labels=labels)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
5.30

>>> # inference
>>> generated_ids = model.generate(pixel_values)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> generated_text
'industry, " Mr. Brown commented icily. " Let us have a'

TVLT

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

概述

TVLT 模型是由 Zineng Tang、Jaemin Cho、Yixin Nie、Mohit Bansal 提出的，首三位作者贡献相同。无文本视觉语言变换器（TVLT）是一个使用原始视觉和音频输入进行视觉和语言表示学习的模型，而不使用文本特定模块，如标记化或自动语音识别（ASR）。它可以执行各种音频视觉和视觉语言任务，如检索、问答等。

论文摘要如下：

在这项工作中，我们提出了无文本视觉语言变换器（TVLT），其中同质变换器块接受原始视觉和音频输入进行视觉和语言表示学习，具有最小的模态特定设计，并且不使用文本特定模块，如标记化或自动语音识别（ASR）。 TVLT 通过重建连续视频帧和音频频谱图的掩码块（掩码自编码）和对比建模来训练，并对齐视频和音频。 TVLT 在各种多模态任务上取得了与基于文本的对应物相当的性能，如视觉问答、图像检索、视频检索和多模态情感分析，推理速度快 28 倍，参数仅为原来的 1/3。我们的研究结果表明，在不假定文本事先存在的情况下，可以从低级视觉和音频信号中学习紧凑高效的视觉-语言表示的可能性。

drawing

TVLT 架构。取自原始论文)。

原始代码可以在这里找到。该模型由Zineng Tang贡献。

使用提示

• TVLT 是一个接受pixel_values和audio_values作为输入的模型。可以使用 TvltProcessor 为模型准备数据。该处理器将图像处理器（用于图像/视频模态）和音频特征提取器（用于音频模态）封装在一起。
• TVLT 是使用各种大小的图像/视频和音频进行训练的：作者将输入图像/视频调整大小并裁剪到 224，并限制音频频谱图的长度为 2048。为了使视频和音频的批处理成为可能，作者使用pixel_mask指示哪些像素是真实/填充的，以及audio_mask指示哪些音频值是真实/填充的。
• TVLT 的设计与标准视觉变换器（ViT）和掩码自编码器（MAE）非常相似，如 ViTMAE。不同之处在于该模型包括音频模态的嵌入层。
• 此模型的 PyTorch 版本仅在 torch 1.10 及更高版本中可用。

TvltConfig

class transformers.TvltConfig

<来源>

( image_size = 224 spectrogram_length = 2048 frequency_length = 128 image_patch_size = [16, 16] audio_patch_size = [16, 16] num_image_channels = 3 num_audio_channels = 1 num_frames = 8 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-06 qkv_bias = True use_mean_pooling = False decoder_num_attention_heads = 16 decoder_hidden_size = 512 decoder_num_hidden_layers = 8 decoder_intermediate_size = 2048 pixel_mask_ratio = 0.75 audio_mask_ratio = 0.15 audio_mask_type = 'frame-level' task_matching = True task_mae = True loss_type = 'classification' **kwargs )

参数

• image_size (int, optional, 默认为 224) — 每个图像的大小（分辨率）。
• spectrogram_length (int, optional, 默认为 2048) — 每个音频频谱图的时间长度。
• frequency_length (int, optional, 默认为 128) — 音频频谱图的频率长度。
• image_patch_size (List[int], optional, 默认为 [16, 16]) — 每个图像块的大小（分辨率）。
• audio_patch_size (List[int], optional, 默认为 [16, 16]) — 每个音频块的大小（分辨率）。
• num_image_channels (int, optional, 默认为 3) — 输入图像通道数。
• num_audio_channels (int, optional, 默认为 1) — 输入音频通道数。
• num_frames (int，可选，默认为 8) — 输入视频的最大帧数。
• hidden_size (int，可选，默认为 768) — 编码器层和池化器层的维度。
• num_hidden_layers (int，可选，默认为 12) — Transformer 编码器中的隐藏层数。
• num_attention_heads (int，可选，默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
• intermediate_size (int，可选，默认为 3072) — Transformer 编码器中“中间”（即前馈）层的维度。
• hidden_act (str 或 function，可选，默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu" 和 "gelu_new"。
• hidden_dropout_prob (float，可选，默认为 0.0) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。
• attention_probs_dropout_prob (float，可选，默认为 0.0) — 注意力概率的丢弃比率。
• initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float，可选，默认为 1e-06) — 层归一化层使用的 epsilon。
• qkv_bias (bool，可选，默认为 True) — 是否向查询、键和值添加偏置。
• use_mean_pooling (bool，可选，默认为 False) — 是否对最终隐藏状态进行平均池化，而不是使用 [CLS] 标记的最终隐藏状态。
• decoder_num_attention_heads (int，可选，默认为 16) — 解码器中每个注意力层的注意力头数。
• decoder_hidden_size (int，可选，默认为 512) — 解码器的维度。
• decoder_num_hidden_layers (int，可选，默认为 8) — 解码器中的隐藏层数。
• decoder_intermediate_size (int，可选，默认为 2048) — 解码器中“中间”（即前馈）层的维度。
• pixel_mask_ratio (float，可选，默认为 0.75) — 图像补丁掩码比例。
• audio_mask_ratio (float，可选，默认为 0.15) — 音频补丁掩码比例。
• audio_mask_type (str，可选，默认为 "frame-level") — 音频补丁掩码类型，可选择"frame-level"和“patch-level”。
• task_matching (bool，可选，默认为 True) — 是否在预训练中使用视觉音频匹配任务。
• task_mae (bool，可选，默认为 True) — 是否在预训练中使用掩码自编码器（MAE）。
• loss_type (str，可选，默认为 "classification") — 包括回归和分类在内的损失类型。

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

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

示例：

>>> from transformers import TvltConfig, TvltModel

>>> # # Initializing a TVLT ZinengTang/tvlt-base style configuration
>>> configuration = TvltConfig()

>>> # # Initializing a model (with random weights) from the ZinengTang/tvlt-base style configuration
>>> model = TvltModel(configuration)

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

TvltProcessor

class transformers.TvltProcessor

<来源>

( image_processor feature_extractor )

参数

• image_processor (TvltImageProcessor) — TvltImageProcessor 的一个实例。图像处理器是一个必需的输入。
• feature_extractor（TvltFeatureExtractor）— TvltFeatureExtractor 的一个实例。特征提取器是一个必需的输入。

构建一个 TVLT 处理器，将 TVLT 图像处理器和 TVLT 特征提取器包装成一个单一处理器。

TvltProcessor 提供了 TvltImageProcessor 和 TvltFeatureExtractor 的所有功能。查看call()的文档字符串以获取更多信息。

__call__

<来源>

( images = None audio = None images_mixed = None sampling_rate = None mask_audio = False mask_pixel = False *args **kwargs )

将images参数转发到 TvltImageProcessor 的 preprocess()，将audio参数转发到 TvltFeatureExtractor 的call()。更多信息请参考上述两个方法的文档字符串。

TvltImageProcessor

class transformers.TvltImageProcessor

<来源>

( do_resize: bool = True size: Dict = None patch_size: List = [16, 16] num_frames: int = 8 resample: Resampling = <Resampling.BILINEAR: 2> 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 = [0.5, 0.5, 0.5] image_std: Union = [0.5, 0.5, 0.5] init_mask_generator = False **kwargs )

参数

• do_resize（bool，可选，默认为True）— 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。
• size（Dict[str, int] 可选，默认为{"shortest_edge" -- 224}）：调整大小后的输出图像大小。图像的最短边将被调整为size["shortest_edge"]，同时保持原始图像的纵横比。可以通过preprocess方法中的size进行覆盖。
• patch_size（List[int] 可选，默认为[16,16]）— 图像补丁嵌入的补丁大小。
• num_frames（int 可选，默认为 8）— 视频帧的最大数量。
• resample（PILImageResampling，可选，默认为PILImageResampling.BILINEAR）— 调整图像大小时要使用的重采样滤波器。可以被preprocess方法中的resample参数覆盖。
• do_center_crop（bool，可选，默认为True）— 是否将图像居中裁剪到指定的crop_size。可以被preprocess方法中的do_center_crop参数覆盖。
• crop_size（Dict[str, int]，可选，默认为{"height" -- 224, "width": 224}）：应用中心裁剪后的图像大小。可以被preprocess方法中的crop_size参数覆盖。
• do_rescale（bool，可选，默认为True）— 是否按指定比例rescale_factor对图像进行重新缩放。可以被preprocess方法中的do_rescale参数覆盖。
• rescale_factor（int或float，可选，默认为 1/255）— 定义在重新缩放图像时要使用的比例因子。可以被preprocess方法中的rescale_factor参数覆盖。
• 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参数覆盖。

构建一个 TVLT 图像处理器。

此处理器可通过将图像转换为 1 帧视频来为模型准备视频或图像。

preprocess

<来源>

( videos: Union do_resize: bool = None size: Dict = None patch_size: List = None num_frames: int = None resample: Resampling = None do_center_crop: bool = None crop_size: Dict = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None is_mixed: bool = False return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs ) → export const metadata = 'undefined';BatchFeature

参数

• videos (ImageInput) — 要预处理的图像或视频。期望单个或批处理的帧，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的帧，请设置do_rescale=False。
• do_resize (bool, 可选, 默认为self.do_resize) — 是否调整图像大小。
• size (Dict[str, int], 可选, 默认为self.size) — 应用调整大小后的图像大小。
• patch_size (List[int] 可选, 默认为 self.patch_size) — 图像补丁嵌入的补丁大小。
• num_frames (int 可选, 默认为 self.num_frames) — 视频帧的最大数量。
• resample (PILImageResampling, 可选, 默认为self.resample) — 如果调整图像大小，则要使用的重采样滤波器。这可以是枚举PILImageResampling之一，仅在do_resize设置为True时有效。
• do_center_crop (bool, 可选, 默认为self.do_centre_crop) — 是否对图像进行中心裁剪。
• crop_size (Dict[str, int], 可选, 默认为self.crop_size) — 应用中心裁剪后的图像大小。
• 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) — 图像均值。
• image_std (float 或 List[float], 可选, 默认为self.image_std) — 图像标准差。
• is_mixed (bool, 可选) — 如果输入视频有负样本。
• 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) — 输出图像的通道维度格式。可以是以下之一：
  • ChannelDimension.FIRST: 图像格式为(num_channels, height, width)。
  • 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)。

返回

BatchFeature

具有以下字段的 BatchFeature：

• pixel_values — 要馈送给模型的像素值，形状为(batch_size, num_channels, height, width)。
• pixel_mask — 用于输入模型的像素掩码，形状为（batch_size，num_pixel_patches）。
• pixel_values_mixed — 具有正负值的像素值，用于输入模型，形状为（batch_size，num_channels，height，width）。
• pixel_mask_mixed — 具有正负值的像素掩码，用于输入模型，形状为（batch_size，num_pixel_patches）。

预处理视频或图像或视频或图像批处理。

TvltFeatureExtractor

class transformers.TvltFeatureExtractor

< source >

( spectrogram_length = 2048 num_channels = 1 patch_size = [16, 16] feature_size = 128 sampling_rate = 44100 hop_length_to_sampling_rate = 86 n_fft = 2048 padding_value = 0.0 **kwargs )

参数

• spectrogram_length (Dict[str, int] optional, defaults to 2048) — 每个音频频谱图的时间长度。
• num_channels (int optional, defaults to 1) — 音频通道数。
• patch_size (List[int] optional, defaults to [16, 16]) — 音频补丁嵌入的补丁大小。
• feature_size (int, optional, defaults to 128) — 音频频谱图的频率长度。
• sampling_rate (int, optional, defaults to 44100) — 音频文件应数字化的采样率，以赫兹（Hz）表示。
• hop_length_to_sampling_rate (int, optional, defaults to 86) — Hop length 是用于获取 Mel 频率系数的 STFT 中重叠窗口的长度。例如，对于采样率 44100，跳跃长度为 512，即 44100 / 512 = 86
• n_fft (int, optional, defaults to 2048) — 傅立叶变换的大小。
• padding_value (float, optional, defaults to 0.0) — 用于填充音频的填充值。应对应于静音。

构建一个 TVLT 音频特征提取器。此特征提取器可用于为模型准备音频。

此特征提取器继承自 FeatureExtractionMixin，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

__call__

< source >

( raw_speech: Union return_tensors: Union = None return_attention_mask: Optional = True sampling_rate: Optional = None resample: bool = False mask_audio: bool = False **kwargs ) → export const metadata = 'undefined';BatchFeature

参数

• raw_speech (np.ndarray, List[float], List[np.ndarray], List[List[float]]) — 要填充的序列或序列批次。每个序列可以是一个 numpy 数组，一个浮点值列表，一个 numpy 数组列表或一个浮点值列表的列表。必须是单声道音频，不是立体声，即每个时间步长一个浮点数。
• return_tensors (str or TensorType, optional) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
  • 'pt': 返回 PyTorch torch.Tensor对象。
  • 'np': 返回 Numpy np.ndarray对象。
• return_attention_mask (bool, optional, default to True) — 是否返回注意力掩码。如果保持默认值，将根据特定 feature_extractor 的默认值返回注意力掩码。什么是注意力掩码？ 对于 TvltTransformer 模型，应始终传递attention_mask以进行批量推断，以避免细微错误。
• sampling_rate (int, optional) — 对raw_speech输入进行采样的采样率。强烈建议在前向调用时传递sampling_rate，以防止静默错误并允许自动语音识别流水线。当前模型支持采样率为 16000 和 44100。
• resample (bool, optional, defaults to False) — 如果采样率不匹配，则重新采样输入音频以匹配。
• mask_audio (bool, optional, defaults to False) — 是否对 MAE 任务的输入音频进行掩码。

返回

BatchFeature

具有以下字段的 BatchFeature：

• audio_values — 要馈送给模型的音频值，形状为(batch_size, num_channels, height, width)。
• audio_mask — 要馈送给模型的音频掩码，形状为(batch_size, num_audio_patches)。

为模型准备一个或多个音频的主要方法。

TvltModel

class transformers.TvltModel

<来源>

( config )

参数

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

裸 TVLT 模型变压器输出原始隐藏状态，没有特定的顶部头。这个模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( pixel_values: FloatTensor audio_values: FloatTensor pixel_mask: Optional = None audio_mask: Optional = None mask_pixel: bool = False mask_audio: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.tvlt.modeling_tvlt.TvltModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_frames, num_channels, height, width)) — 像素值。可以使用 TvltProcessor 获取像素值。有关详细信息，请参阅 TvltProcessor.call()。
• audio_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 音频值。可以使用 TvltProcessor 获取音频值。有关详细信息，请参阅 TvltProcessor.call()。
• pixel_mask (torch.FloatTensor of shape (batch_size, num_pixel_patches)) — 像素掩码。可以使用 TvltProcessor 获取像素掩码。有关详细信息，请参阅 TvltProcessor.call()。
• audio_mask (torch.FloatTensor of shape (batch_size, num_audio_patches)) — 音频掩码。可以使用 TvltProcessor 获取音频掩码。有关详细信息，请参阅 TvltProcessor.call()。
• pixel_values_mixed (torch.FloatTensor of shape (batch_size, num_frames, num_channels, height, width)) — 在 Tvlt 视听匹配中混合正负样本的像素值。可以使用 TvltProcessor 获取混合像素值。有关详细信息，请参阅 TvltProcessor.call()。
• pixel_mask_mixed (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — pixel_values_mixed 的像素掩码。可以使用 TvltProcessor 获取混合像素掩码。有关详细信息，请参阅 TvltProcessor.call()。
• mask_pixel (bool, optional) — 是否对 MAE 任务遮蔽像素。仅在 TvltForPreTraining 中设置为 True。
• mask_audio (bool, optional) — 是否对 MAE 任务遮蔽音频。仅在 TvltForPreTraining 中设置为 True。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.models.tvlt.modeling_tvlt.TvltModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.tvlt.modeling_tvlt.TvltModelOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False）包含各种元素，取决于配置（TvltConfig）和输入。

• last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
• last_pixel_hidden_state (torch.FloatTensor，形状为 (batch_size, pixel_sequence_length, hidden_size)) — 模型最后一层的像素隐藏状态序列。
• last_audio_hidden_state (torch.FloatTensor，形状为 (batch_size, audio_sequence_length, hidden_size)) — 模型最后一层的音频隐藏状态序列。
• pixel_label_masks (torch.FloatTensor，形状为 (batch_size, pixel_patch_length)) — 指示哪些像素 patch 被 mask（1）哪些没有被 mask（0）的张量。
• audio_label_masks (torch.FloatTensor，形状为 (batch_size, audio_patch_length)) — 指示哪些音频 patch 被 mask（1）哪些没有被 mask（0）的张量。
• pixel_ids_restore (torch.LongTensor，形状为 (batch_size, pixel_patch_length)) — 包含像素 masking 的 ids 排列的张量。
• audio_ids_restore (torch.LongTensor，形状为 (batch_size, audio_patch_length)) — 包含音频 masking 的 ids 排列的张量。
• 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import TvltProcessor, TvltModel
>>> import numpy as np
>>> import torch

>>> num_frames = 8
>>> images = list(np.random.randn(num_frames, 3, 224, 224))
>>> audio = list(np.random.randn(10000))

>>> processor = TvltProcessor.from_pretrained("ZinengTang/tvlt-base")
>>> model = TvltModel.from_pretrained("ZinengTang/tvlt-base")

>>> input_dict = processor(images, audio, sampling_rate=44100, return_tensors="pt")

>>> outputs = model(**input_dict)
>>> loss = outputs.loss

TvltForPreTraining

class transformers.TvltForPreTraining

< source >

( config )

参数

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

带有顶部解码器用于自监督预训练的 TVLT 模型变压器。此模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( pixel_values: FloatTensor audio_values: FloatTensor pixel_mask: Optional = None audio_mask: Optional = None labels: Optional = None pixel_values_mixed: Optional = None pixel_mask_mixed: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.tvlt.modeling_tvlt.TvltForPreTrainingOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_frames, num_channels, height, width)) — 像素值。可以使用 TvltProcessor 获取像素值。详细信息请参见 TvltProcessor.call()。
• audio_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 音频值。可以使用 TvltProcessor 获取音频值。详细信息请参见 TvltProcessor.call()。
• pixel_mask (torch.FloatTensor of shape (batch_size, num_pixel_patches)) — 像素掩码。可以使用 TvltProcessor 获取像素掩码。详细信息请参见 TvltProcessor.call()。
• audio_mask (torch.FloatTensor of shape (batch_size, num_audio_patches)) — 音频掩码。音频掩码可以使用 TvltProcessor 获取。详细信息请参见 TvltProcessor.call()。
• pixel_values_mixed (torch.FloatTensor of shape (batch_size, num_frames, num_channels, height, width)) — 在 Tvlt 视听匹配中混合正负样本的像素值。混合的像素值可以使用 TvltProcessor 获取。详细信息请参见 TvltProcessor.call()。
• pixel_mask_mixed (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 混合像素值的像素掩码。可以使用 TvltProcessor 获取像素掩码混合。详细信息请参见 TvltProcessor.call()。
• mask_pixel (bool, 可选) — 是否为 MAE 任务屏蔽像素。仅在 TvltForPreTraining 中设置为 True。
• mask_audio (bool, 可选) — 是否为 MAE 任务屏蔽音频。仅在 TvltForPreTraining 中设置为 True。
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
• pixel_values_mixed (torch.FloatTensor of shape (batch_size, num_frames, num_channels, height, width)) — 在 Tvlt 视听匹配中混合正负样本的像素值。音频值可以使用 TvltProcessor 获取。详细信息请参见 TvltProcessor.call()。
• pixel_mask_mixed（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值混合的像素掩码。可以使用 TvltProcessor 获取像素值混合。有关详细信息，请参阅 TvltProcessor.call()。
• labels（形状为(batch_size, num_labels)的torch.LongTensor，可选）— 用于计算视听匹配损失的标签。索引应在[0, 1]范围内。num_labels 必须为 1。

返回

transformers.models.tvlt.modeling_tvlt.TvltForPreTrainingOutput或tuple(torch.FloatTensor)

一个transformers.models.tvlt.modeling_tvlt.TvltForPreTrainingOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（TvltConfig）和输入的各种元素。

• loss（形状为(1,)的torch.FloatTensor）— 像素重建损失。
• matching_logits（形状为(batch_size, 1)的torch.FloatTensor）— 匹配目标对数。
• pixel_logits（形状为(batch_size, pixel_patch_length, image_patch_size ** 3 * pixel_num_channels)的torch.FloatTensor）：像素重建对数。
• audio_logits（形状为(batch_size, audio_patch_length, image_patch_size[0] * image_patch_size[1])的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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import TvltProcessor, TvltForPreTraining
>>> import numpy as np
>>> import torch

>>> num_frames = 8
>>> images = list(np.random.randn(num_frames, 3, 224, 224))
>>> images_mixed = list(np.random.randn(num_frames, 3, 224, 224))
>>> audio = list(np.random.randn(10000))
>>> processor = TvltProcessor.from_pretrained("ZinengTang/tvlt-base")
>>> model = TvltForPreTraining.from_pretrained("ZinengTang/tvlt-base")
>>> input_dict = processor(
...     images, audio, images_mixed, sampling_rate=44100, mask_pixel=True, mask_audio=True, return_tensors="pt"
... )

>>> outputs = model(**input_dict)
>>> loss = outputs.loss

TvltForAudioVisualClassification

class transformers.TvltForAudioVisualClassification

<来源>

( config )

参数

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

Tvlt 模型变压器，顶部带有分类器头（在[CLS]标记的最终隐藏状态之上的 MLP）用于音频视觉分类任务，例如 CMU-MOSEI 情感分析和音频到视频检索。

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

forward

<来源>

( pixel_values: FloatTensor audio_values: FloatTensor pixel_mask: Optional = None audio_mask: 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)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_frames, num_channels, height, width)) — 像素值。可以使用 TvltProcessor 获取像素值。有关详细信息，请参阅 TvltProcessor.call()。
• audio_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 音频值。可以使用 TvltProcessor 获取音频值。有关详细信息，请参阅 TvltProcessor.call()。
• pixel_mask (torch.FloatTensor of shape (batch_size, num_pixel_patches)) — 像素掩码。可以使用 TvltProcessor 获取像素掩码。有关详细信息，请参阅 TvltProcessor.call()。
• audio_mask (torch.FloatTensor of shape (batch_size, num_audio_patches)) — 音频掩码。可以使用 TvltProcessor 获取音频掩码。有关详细信息，请参阅 TvltProcessor.call()。
• pixel_values_mixed (torch.FloatTensor of shape (batch_size, num_frames, num_channels, height, width)) — 在 Tvlt 视听匹配中混合正负样本的像素值。可以使用 TvltProcessor 获取混合像素值。有关详细信息，请参阅 TvltProcessor.call()。
• pixel_mask_mixed (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — pixel_values_mixed 的像素掩码。可以使用 TvltProcessor 获取混合像素掩码。有关详细信息，请参阅 TvltProcessor.call()。
• mask_pixel (bool, optional) — 是否为 MAE 任务屏蔽像素。仅在 TvltForPreTraining 中设置为 True。
• mask_audio (bool, optional) — 是否为 MAE 任务屏蔽音频。仅在 TvltForPreTraining 中设置为 True。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• labels (torch.LongTensor of shape (batch_size, num_labels), optional) — 用于计算音视频损失的标签。索引应在[0, ..., num_classes-1]范围内，其中 num_classes 是音视频任务中类别的数量。

返回

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

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置(TvltConfig)和输入的各种元素。

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（如果 config.num_labels==1 则为回归）损失。
• logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果 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 后的注意力权重，用于计算自注意力头中的加权平均值。

为音频视觉分类而设计的 TvltForAudioVisualClassification 前向方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import TvltProcessor, TvltForAudioVisualClassification
>>> import numpy as np
>>> import torch

>>> num_frames = 8
>>> images = list(np.random.randn(num_frames, 3, 224, 224))
>>> audio = list(np.random.randn(10000))
>>> processor = TvltProcessor.from_pretrained("ZinengTang/tvlt-base")
>>> model = TvltForAudioVisualClassification.from_pretrained("ZinengTang/tvlt-base")
>>> input_dict = processor(images, audio, sampling_rate=44100, return_tensors="pt")

>>> outputs = model(**input_dict)
>>> loss = outputs.loss

TVP

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

概述

文本视觉提示（TVP）框架是由 Yimeng Zhang，Xin Chen，Jinghan Jia，Sijia Liu，Ke Ding 在论文Text-Visual Prompting for Efficient 2D Temporal Video Grounding中提出的。

论文的摘要如下：

在本文中，我们研究了时间视频定位（TVG）问题，旨在预测长视频中由文本句子描述的时刻的起始/结束时间点。由于精细的 3D 视觉特征，TVG 技术近年来取得了显著进展。然而，3D 卷积神经网络（CNNs）的高复杂性使得提取密集的 3D 视觉特征耗时，需要大量内存和计算资源。为了实现高效的 TVG，我们提出了一种新颖的文本-视觉提示（TVP）框架，将优化的扰动模式（我们称之为“提示”）集成到 TVG 模型的视觉输入和文本特征中。与 3D CNN 形成鲜明对比，我们展示了 TVP 允许我们在 2D TVG 模型中有效地共同训练视觉编码器和语言编码器，并且仅使用低复杂度的稀疏 2D 视觉特征改善了跨模态特征融合的性能。此外，我们提出了一种用于高效学习 TVG 的时间距离 IoU（TDIoU）损失。对两个基准数据集 Charades-STA 和 ActivityNet Captions 数据集的实验经验表明，所提出的 TVP 显著提升了 2D TVG 的性能（例如，在 Charades-STA 上提高了 9.79%，在 ActivityNet Captions 上提高了 30.77%），并且相比使用 3D 视觉特征的 TVG 实现了 5 倍的推理加速。

这项研究解决了时间视频定位（TVG）问题，即在长视频中准确定位特定事件的开始和结束时间，如文本句子所描述。文本-视觉提示（TVP）被提出以增强 TVG。TVP 涉及将专门设计的模式（称为“提示”）集成到 TVG 模型的视觉（基于图像）和文本（基于单词）输入组件中。这些提示提供额外的时空上下文，提高了模型准确确定视频中事件时间的能力。该方法使用 2D 视觉输入代替 3D 输入。虽然 3D 输入提供更多的时空细节，但处理起来也更耗时。使用 2D 输入与提示方法旨在更有效地提供类似水平的上下文和准确性。

drawing

TVP 架构。摘自原始论文

该模型由Jiqing Feng贡献。原始代码可以在这里找到。

使用提示和示例

提示是经过优化的扰动模式，将添加到输入视频帧或文本特征中。通用集指的是对于任何输入使用完全相同的提示集，这意味着这些提示被一致地添加到所有视频帧和文本特征中，而不考虑输入的内容。

TVP 包括一个视觉编码器和跨模态编码器。一个通用的视觉提示集和文本提示集分别集成到采样的视频帧和文本特征中。特别地，一组不同的视觉提示被应用于一个未修剪视频的均匀采样帧中。

该模型的目标是将可训练的提示集成到视觉输入和文本特征中，以解决时间视频定位（TVG）问题。原则上，可以在提出的架构中应用任何视觉、跨模态编码器。

TvpProcessor 将 BertTokenizer 和 TvpImageProcessor 包装成一个单一实例，分别对文本进行编码和准备图像。

以下示例展示了如何使用 TvpProcessor 和 TvpForVideoGrounding 运行时间视频定位。

import av
import cv2
import numpy as np
import torch
from huggingface_hub import hf_hub_download
from transformers import AutoProcessor, TvpForVideoGrounding

def pyav_decode(container, sampling_rate, num_frames, clip_idx, num_clips, target_fps):
    '''
    Convert the video from its original fps to the target_fps and decode the video with PyAV decoder.
    Args:
        container (container): pyav container.
        sampling_rate (int): frame sampling rate (interval between two sampled frames).
        num_frames (int): number of frames to sample.
        clip_idx (int): if clip_idx is -1, perform random temporal sampling.
            If clip_idx is larger than -1, uniformly split the video to num_clips
            clips, and select the clip_idx-th video clip.
        num_clips (int): overall number of clips to uniformly sample from the given video.
        target_fps (int): the input video may have different fps, convert it to
            the target video fps before frame sampling.
    Returns:
        frames (tensor): decoded frames from the video. Return None if the no
            video stream was found.
        fps (float): the number of frames per second of the video.
    '''
    video = container.streams.video[0]
    fps = float(video.average_rate)
    clip_size = sampling_rate * num_frames / target_fps * fps
    delta = max(num_frames - clip_size, 0)
    start_idx = delta * clip_idx / num_clips
    end_idx = start_idx + clip_size - 1
    timebase = video.duration / num_frames
    video_start_pts = int(start_idx * timebase)
    video_end_pts = int(end_idx * timebase)
    seek_offset = max(video_start_pts - 1024, 0)
    container.seek(seek_offset, any_frame=False, backward=True, stream=video)
    frames = {}
    for frame in container.decode(video=0):
        if frame.pts < video_start_pts:
            continue
        frames[frame.pts] = frame
        if frame.pts > video_end_pts:
            break
    frames = [frames[pts] for pts in sorted(frames)]
    return frames, fps

def decode(container, sampling_rate, num_frames, clip_idx, num_clips, target_fps):
    '''
    Decode the video and perform temporal sampling.
    Args:
        container (container): pyav container.
        sampling_rate (int): frame sampling rate (interval between two sampled frames).
        num_frames (int): number of frames to sample.
        clip_idx (int): if clip_idx is -1, perform random temporal sampling.
            If clip_idx is larger than -1, uniformly split the video to num_clips
            clips, and select the clip_idx-th video clip.
        num_clips (int): overall number of clips to uniformly sample from the given video.
        target_fps (int): the input video may have different fps, convert it to
            the target video fps before frame sampling.
    Returns:
        frames (tensor): decoded frames from the video.
    '''
    assert clip_idx >= -2, "Not a valied clip_idx {}".format(clip_idx)
    frames, fps = pyav_decode(container, sampling_rate, num_frames, clip_idx, num_clips, target_fps)
    clip_size = sampling_rate * num_frames / target_fps * fps
    index = np.linspace(0, clip_size - 1, num_frames)
    index = np.clip(index, 0, len(frames) - 1).astype(np.int64)
    frames = np.array([frames[idx].to_rgb().to_ndarray() for idx in index])
    frames = frames.transpose(0, 3, 1, 2)
    return frames

file = hf_hub_download(repo_id="Intel/tvp_demo", filename="AK2KG.mp4", repo_type="dataset")
model = TvpForVideoGrounding.from_pretrained("Intel/tvp-base")

decoder_kwargs = dict(
    container=av.open(file, metadata_errors="ignore"),
    sampling_rate=1,
    num_frames=model.config.num_frames,
    clip_idx=0,
    num_clips=1,
    target_fps=3,
)
raw_sampled_frms = decode(**decoder_kwargs)

text = "a person is sitting on a bed."
processor = AutoProcessor.from_pretrained("Intel/tvp-base")
model_inputs = processor(
    text=[text], videos=list(raw_sampled_frms), return_tensors="pt", max_text_length=100#, size=size
)

model_inputs["pixel_values"] = model_inputs["pixel_values"].to(model.dtype)
output = model(**model_inputs)

def get_video_duration(filename):
    cap = cv2.VideoCapture(filename)
    if cap.isOpened():
        rate = cap.get(5)
        frame_num = cap.get(7)
        duration = frame_num/rate
        return duration
    return -1

duration = get_video_duration(file)
start, end = processor.post_process_video_grounding(output.logits, duration)

print(f"The time slot of the video corresponding to the text \"{text}\" is from {start}s to {end}s")

提示：

• TVP 的这个实现使用 BertTokenizer 生成文本嵌入和 Resnet-50 模型计算视觉嵌入。
• 已发布预训练 tvp-base 的检查点。
• 请参考 Table 2 了解 TVP 在时间视频定位任务上的性能。

TvpConfig

class transformers.TvpConfig

< source >

( backbone_config = None distance_loss_weight = 1.0 duration_loss_weight = 0.1 visual_prompter_type = 'framepad' visual_prompter_apply = 'replace' visual_prompt_size = 96 max_img_size = 448 num_frames = 48 vocab_size = 30522 hidden_size = 768 intermediate_size = 3072 num_hidden_layers = 12 num_attention_heads = 12 max_position_embeddings = 512 max_grid_col_position_embeddings = 100 max_grid_row_position_embeddings = 100 hidden_dropout_prob = 0.1 hidden_act = 'gelu' layer_norm_eps = 1e-12 initializer_range = 0.02 attention_probs_dropout_prob = 0.1 **kwargs )

参数

• backbone_config (PretrainedConfig or dict, optional) — 骨干模型的配置。
• distance_loss_weight (float, optional, defaults to 1.0) — 距离损失的权重。
• duration_loss_weight (float, optional, defaults to 0.1) — 持续时间损失的权重。
• visual_prompter_type (str, optional, defaults to "framepad") — 视觉提示类型。填充的类型。Framepad 表示在每个帧上填充。应为"framepad"或“framedownpad”之一。
• visual_prompter_apply (str, optional, defaults to "replace") — 应用视觉提示的方式。Replace 表示使用提示的值来更改视觉输入中的原始值。应为"replace"、“add”或“remove”之一。
• visual_prompt_size (int, optional, defaults to 96) — 视觉提示的大小。
• max_img_size (int, optional, defaults to 448) — 帧的最大尺寸。
• num_frames (int, optional, defaults to 48) — 从视频中提取的帧数。
• vocab_size (int, optional, defaults to 30522) — Tvp 文本模型的词汇量。定义了在调用 TvpModel 时可以由 inputs_ids 表示的不同标记的数量。
• 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) — Transformer 编码器中每个注意力层的注意力头数。
• max_position_embeddings (int, optional, defaults to 512) — 模型可能使用的最大序列长度。通常将其设置为一个较大的值以防万一（例如 512、1024 或 2048）。
• max_grid_col_position_embeddings (int, optional, defaults to 100) — 从视频帧中提取的水平补丁的最大数量。
• max_grid_row_position_embeddings (int, optional, defaults to 100) — 从视频帧中提取的垂直补丁的最大数量。
• hidden_dropout_prob (float, optional, defaults to 0.1) — 隐藏层的丢失概率。
• hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu" 和 "gelu_new" "quick_gelu"。
• layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。
• initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• attention_probs_dropout_prob (float，可选，默认为 0.1) — 注意力层的丢失概率。

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

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

from_backbone_config

<来源>

( backbone_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';TvpConfig

参数

• backbone_config (PretrainedConfig) — 骨干配置。

返回

TvpConfig

配置对象的一个实例

从预训练的骨干模型配置实例化一个 TvpConfig（或派生类）。

to_dict

<来源>

( ) → export const metadata = 'undefined';Dict[str, any]

返回

Dict[str, any]

包含构成此配置实例的所有属性的字典，

将此实例序列化为 Python 字典。覆盖默认 to_dict()。

TvpImageProcessor

class transformers.TvpImageProcessor

<来源>

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_center_crop: bool = True crop_size: Dict = None do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_pad: bool = True pad_size: Dict = None constant_values: Union = 0 pad_mode: PaddingMode = <PaddingMode.CONSTANT: 'constant'> do_normalize: bool = True do_flip_channel_order: bool = True image_mean: Union = None image_std: Union = None **kwargs )

参数

• do_resize (bool，可选，默认为True) — 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。
• size (Dict[str, int] 可选，默认为{"longest_edge" -- 448})：调整大小后的输出图像大小。图像的最长边将被调整为size["longest_edge"]，同时保持原始图像的纵横比。可以被preprocess方法中的size覆盖。
• resample (PILImageResampling，可选，默认为Resampling.BILINEAR) — 如果调整图像大小，则要使用的重采样滤波器。可以被preprocess方法中的resample参数覆盖。
• do_center_crop (bool，可选，默认为True) — 是否将图像居中裁剪到指定的crop_size。可以被preprocess方法中的do_center_crop参数覆盖。
• crop_size (Dict[str, int]，可选，默认为{"height" -- 448, "width": 448})：应用中心裁剪后的图像大小。可以被preprocess方法中的crop_size参数覆盖。
• do_rescale (bool，可选，默认为True) — 是否按指定比例rescale_factor重新缩放图像。可以被preprocess方法中的do_rescale参数覆盖。
• rescale_factor (int或float，可选，默认为1/255) — 定义如果重新缩放图像要使用的比例因子。可以被preprocess方法中的rescale_factor参数覆盖。
• do_pad (bool，可选，默认为True) — 是否填充图像。可以被preprocess方法中的do_pad参数覆盖。
• pad_size（Dict[str, int]，可选，默认为{"height" -- 448, "width": 448}）：应用填充后图像的大小。可以被preprocess方法中的pad_size参数覆盖。
• constant_values（Union[float, Iterable[float]]，可选，默认为 0）— 在填充图像时使用的填充值。
• pad_mode（PaddingMode，可选，默认为PaddingMode.CONSTANT）— 在填充中使用什么样的模式。
• do_normalize（bool，可选，默认为True）— 是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。
• do_flip_channel_order（bool，可选，默认为True）— 是否将颜色通道从 RGB 翻转为 BGR。可以被preprocess方法中的do_flip_channel_order参数覆盖。
• image_mean（float或List[float]，可选，默认为IMAGENET_STANDARD_MEAN）— 如果对图像进行归一化，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_mean参数覆盖。
• image_std（float或List[float]，可选，默认为IMAGENET_STANDARD_STD）— 如果对图像进行归一化，则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_std参数覆盖。

构造一个 Tvp 图像处理器。

preprocess

<来源>

( videos: Union do_resize: bool = None size: Dict = None resample: Resampling = None do_center_crop: bool = None crop_size: Dict = None do_rescale: bool = None rescale_factor: float = None do_pad: bool = None pad_size: Dict = None constant_values: Union = None pad_mode: PaddingMode = None do_normalize: bool = None do_flip_channel_order: bool = None image_mean: Union = None image_std: Union = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• videos（ImageInput或List[ImageInput]或List[List[ImageInput]]）— 要预处理的帧。
• do_resize（bool，可选，默认为self.do_resize）— 是否调整图像大小。
• size（Dict[str, int]，可选，默认为self.size）— 调整大小后图像的大小。
• resample（PILImageResampling，可选，默认为self.resample）— 如果调整图像大小，则使用的重采样滤波器。这可以是枚举PILImageResampling之一，仅在do_resize设置为True时有效。
• do_center_crop（bool，可选，默认为self.do_centre_crop）— 是否对图像进行中心裁剪。
• crop_size（Dict[str, int]，可选，默认为self.crop_size）— 应用中心裁剪后图像的大小。
• do_rescale（bool，可选，默认为self.do_rescale）— 是否将图像值重新缩放在[0 - 1]之间。
• rescale_factor（float，可选，默认为self.rescale_factor）— 如果do_rescale设置为True，则重新缩放图像的重新缩放因子。
• do_pad（bool，可选，默认为True）— 是否填充图像。可以被preprocess方法中的do_pad参数覆盖。
• pad_size（Dict[str, int]，可选，默认为{"height" -- 448, "width": 448}）：应用填充后图像的大小。可以被preprocess方法中的pad_size参数覆盖。
• constant_values（Union[float, Iterable[float]]，可选，默认为 0）— 在填充图像时使用的填充值。
• pad_mode（PaddingMode，可选，默认为“PaddingMode.CONSTANT”）— 在填充中使用什么样的模式。
• do_normalize（bool，可选，默认为self.do_normalize）— 是否对图像进行归一化。
• do_flip_channel_order（bool，可选，默认为self.do_flip_channel_order）— 是否翻转图像的通道顺序。
• image_mean（float或List[float]，可选，默认为self.image_mean）— 图像均值。
• image_std（float或List[float]，可选，默认为self.image_std）— 图像标准差。
• 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) — 输出图像的通道维度格式。可以是以下之一：
  • ChannelDimension.FIRST：图像以 (num_channels, height, width) 格式。
  • 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) 格式。

预处理图像或图像批次。

TvpProcessor

class transformers.TvpProcessor

< source >

( image_processor = None tokenizer = None **kwargs )

参数

• image_processor (TvpImageProcessor, 可选) — 图像处理器是必需的输入。
• tokenizer (BertTokenizerFast, 可选) — tokenizer 是必需的输入。

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

TvpProcessor 提供了 TvpImageProcessor 和 BertTokenizerFast 的所有功能。查看 call() 和 decode() 以获取更多信息。

__call__

< source >

( text = None videos = None return_tensors = None **kwargs ) → export const metadata = 'undefined';BatchEncoding

参数

• text (str, List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果将序列提供为字符串列表（预分词），必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
• videos (List[PIL.Image.Image], List[np.ndarray], List[torch.Tensor], List[List[PIL.Image.Image]], List[List[np.ndarrray]], — List[List[torch.Tensor]]): 要准备的视频或视频批次。每个视频应该是一个帧列表，可以是 PIL 图像或 NumPy 数组。对于 NumPy 数组/PyTorch 张量，每个帧应该是形状为 (H, W, C) 的，其中 H 和 W 是帧的高度和宽度，C 是通道数。
• return_tensors (str 或 TensorType, 可选) — 如果设置，将返回特定框架的张量。可接受的值为：
  • 'tf'：返回 TensorFlow tf.constant 对象。
  • 'pt'：返回 PyTorch torch.Tensor 对象。
  • 'np'：返回 NumPy np.ndarray 对象。
  • 'jax'：返回 JAX jnp.ndarray 对象。

返回

BatchEncoding

具有以下字段的 BatchEncoding：

• input_ids — 要提供给模型的令牌 id 列表。当 text 不是 None 时返回。
• attention_mask — 指定哪些令牌应该被模型关注的索引列表（当 return_attention_mask=True 或 attention_mask 在 self.model_input_names 中，且 text 不是 None 时）。
• pixel_values — 要馈送给模型的像素值。当videos不为None时返回。

准备模型一个或多个序列和图像的主要方法。如果text不为None，则此方法将text和kwargs参数转发给 BertTokenizerFast 的call()以对文本进行编码。要准备图像，如果videos不为None，则此方法将videos和kwargs参数转发给 TvpImageProcessor 的call()。有关更多信息，请参阅上述两种方法的文档。

TvpModel

class transformers.TvpModel

< source >

( config )

参数

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

裸 Tvp 模型输出 BaseModelOutputWithPooling 对象，没有特定的头部。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

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

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？
• pixel_values (torch.FloatTensor，形状为(batch_size, num_frames, num_channels, height, width)) — 像素值。可以使用 TvpImageProcessor 获取像素值。有关详细信息，请参阅 TvpImageProcessor.call()。
• attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 1 表示未被掩盖的标记，
  • 0 表示被掩盖的标记。什么是注意力掩码？
• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选在[0, 1]之间：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPooling 或torch.FloatTensor元组

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（<class 'transformers.models.tvp.configuration_tvp.TvpConfig'>）和输入的各种元素。

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

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

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

示例：

>>> import torch
>>> from transformers import AutoConfig, AutoTokenizer, TvpModel

>>> model = TvpModel.from_pretrained("Jiqing/tiny-random-tvp")

>>> tokenizer = AutoTokenizer.from_pretrained("Jiqing/tiny-random-tvp")

>>> pixel_values = torch.rand(1, 1, 3, 448, 448)
>>> text_inputs = tokenizer("This is an example input", return_tensors="pt")
>>> output = model(text_inputs.input_ids, pixel_values, text_inputs.attention_mask)

TvpForVideoGrounding

class transformers.TvpForVideoGrounding

<来源>

( config )

参数

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

具有视频定位头的 Tvp 模型，计算 IoU、距离和持续时间损失。

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

forward

<来源>

( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None labels: Tuple = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.tvp.modeling_tvp.TvpVideoGroundingOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor） — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？
• pixel_values（形状为(batch_size, num_frames, num_channels, height, width)的torch.FloatTensor） — 像素值。可以使用 TvpImageProcessor 获取像素值。有关详细信息，请参阅 TvpImageProcessor.call()。
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选） — 用于避免在填充标记索引上执行注意力的掩码。在[0, 1]中选择的掩码值：
  • 对于未被屏蔽的标记，返回 1，
  • 对于被屏蔽的标记返回 0。什么是注意力掩码？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选） — 用于使自注意力模块中的选定头部失效的掩码。在[0, 1]中选择的掩码值：
  • 1 表示头部未被屏蔽，
  • 0 表示头部被屏蔽。
• output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选） — 是否返回 ModelOutput 而不是普通元组。
• labels（形状为(batch_size, 3)的torch.FloatTensor，可选） — 标签包含视频的持续时间、开始时间和结束时间，与文本对应。

返回值

transformers.models.tvp.modeling_tvp.TvpVideoGroundingOutput或tuple(torch.FloatTensor)

一个transformers.models.tvp.modeling_tvp.TvpVideoGroundingOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（<class 'transformers.models.tvp.configuration_tvp.TvpConfig'>）和输入的不同元素。

• loss（形状为(1,)的torch.FloatTensor，可选，当return_loss为True时返回） — 视频定位的时间距离 IoU 损失。
• logits（形状为(batch_size, 2)的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元组（每层一个）。

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

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

示例：

>>> import torch
>>> from transformers import AutoConfig, AutoTokenizer, TvpForVideoGrounding

>>> model = TvpForVideoGrounding.from_pretrained("Jiqing/tiny-random-tvp")

>>> tokenizer = AutoTokenizer.from_pretrained("Jiqing/tiny-random-tvp")

>>> pixel_values = torch.rand(1, 1, 3, 448, 448)
>>> text_inputs = tokenizer("This is an example input", return_tensors="pt")
>>> output = model(text_inputs.input_ids, pixel_values, text_inputs.attention_mask)

ViLT

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

概述

ViLT 模型是由 Wonjae Kim、Bokyung Son、Ildoo Kim 在ViLT: Vision-and-Language Transformer Without Convolution or Region Supervision中提出的。ViLT 将文本嵌入集成到 Vision Transformer（ViT）中，使其在视觉和语言预训练（VLP）中具有最小设计。

论文摘要如下：

视觉和语言预训练（VLP）在各种联合视觉和语言下游任务上提高了性能。当前的 VLP 方法主要依赖于图像特征提取过程，其中大部分涉及区域监督（例如目标检测）和卷积架构（例如 ResNet）。尽管文献中忽略了这一点，但我们发现这在效率/速度方面存在问题，仅仅提取输入特征就需要比多模态交互步骤更多的计算量；以及表达能力方面，因为它受到视觉嵌入器及其预定义视觉词汇表表达能力的上限。在本文中，我们提出了一个最小的 VLP 模型，Vision-and-Language Transformer（ViLT），在处理视觉输入方面与处理文本输入的无卷积方式相同，从而使其成为一个整体。我们展示 ViLT 比以前的 VLP 模型快数十倍，但在下游任务性能上具有竞争力或更好。

ViLT 架构。取自原始论文。

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

使用提示

• 开始使用 ViLT 的最快方法是查看示例笔记本（展示了对自定义数据的推理和微调）。
• ViLT 是一个同时接受pixel_values和input_ids作为输入的模型。可以使用 ViltProcessor 为模型准备数据。该处理器将图像处理器（用于图像模态）和标记器（用于语言模态）封装在一起。
• ViLT 使用各种尺寸的图像进行训练：作者将输入图像的较短边调整为 384，并将较长边限制在 640 以下，同时保持纵横比。为了使图像的批处理成为可能，作者使用一个pixel_mask指示哪些像素值是真实的，哪些是填充的。ViltProcessor 会自动为您创建这个。
• ViLT 的设计与标准 Vision Transformer（ViT）非常相似。唯一的区别是该模型包括用于语言模态的额外嵌入层。
• 此模型的 PyTorch 版本仅在 torch 1.10 及更高版本中可用。

ViltConfig

class transformers.ViltConfig

<来源>

( vocab_size = 30522 type_vocab_size = 2 modality_type_vocab_size = 2 max_position_embeddings = 40 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-12 image_size = 384 patch_size = 32 num_channels = 3 qkv_bias = True max_image_length = -1 tie_word_embeddings = False num_images = -1 **kwargs )

参数

• vocab_size（int，可选，默认为 30522）—模型文本部分的词汇量。定义了在调用 ViltModel 时可以表示的不同标记数量。
• type_vocab_size（int，可选，默认为 2）—在调用 ViltModel 时传递的token_type_ids的词汇量。在编码文本时使用。
• modality_type_vocab_size (int, optional, defaults to 2) — 在调用 ViltModel 时传递的模态词汇表大小。在连接文本和图像模态的嵌入后使用。
• max_position_embeddings (int, optional, defaults to 40) — 该模型可能使用的最大序列长度。
• 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 function, optional, defaults to "gelu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
• hidden_dropout_prob (float, optional, defaults to 0.0) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。
• attention_probs_dropout_prob (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
• layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。
• image_size (int, optional, defaults to 384) — 每张图片的大小（分辨率）。
• patch_size (int, optional, defaults to 32) — 每个补丁的大小（分辨率）。
• num_channels (int, optional, defaults to 3) — 输入通道数。
• qkv_bias (bool, optional, defaults to True) — 是否为查询、键和值添加偏置。
• max_image_length (int, optional, defaults to -1) — 用于 Transformer 编码器的输入最大补丁数。如果设置为正整数，编码器将最多采样max_image_length个补丁。如果设置为-1，则不会考虑。
• num_images (int, optional, defaults to -1) — 用于自然语言视觉推理的图像数量。如果设置为正整数，将被 ViltForImagesAndTextClassification 用于定义分类器头。

这是用于存储ViLTModel配置的配置类。根据指定的参数实例化 ViLT 模型，定义模型架构。使用默认值实例化配置将产生类似于 ViLTdandelin/vilt-b32-mlm架构的配置。

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

示例：

>>> from transformers import ViLTModel, ViLTConfig

>>> # Initializing a ViLT dandelin/vilt-b32-mlm style configuration
>>> configuration = ViLTConfig()

>>> # Initializing a model from the dandelin/vilt-b32-mlm style configuration
>>> model = ViLTModel(configuration)

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

ViltFeatureExtractor

class transformers.ViltFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

预处理一张图片或一批图片。

ViltImageProcessor

class transformers.ViltImageProcessor

<来源>

( do_resize: bool = True size: Dict = None 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_pad: bool = True **kwargs )

参数

• do_resize (bool, optional, defaults to True) — 是否将图像的（高度，宽度）尺寸调整为指定的 size。可以被 preprocess 方法中的 do_resize 参数覆盖。
• size (Dict[str, int] optional, defaults to {"shortest_edge" -- 384}): 调整输入的较短边到 size["shortest_edge"]。较长边将被限制在 int((1333 / 800) * size["shortest_edge"]) 以下，同时保持纵横比。仅在 do_resize 设置为 True 时有效。可以被 preprocess 方法中的 size 参数覆盖。
• size_divisor (int, optional, defaults to 32) — 用于确保高度和宽度都可以被整除的大小。仅在 do_resize 设置为 True 时有效。可以被 preprocess 方法中的 size_divisor 参数覆盖。
• resample (PILImageResampling, optional, defaults to Resampling.BICUBIC) — 如果调整图像大小，则使用的重采样滤波器。仅在 do_resize 设置为 True 时有效。可以被 preprocess 方法中的 resample 参数覆盖。
• do_rescale (bool, optional, defaults to True) — 是否按指定比例 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 参数覆盖。
• rescale_factor (int or float, optional, defaults to 1/255) — 如果重新缩放图像，则使用的缩放因子。仅在 do_rescale 设置为 True 时有效。可以被 preprocess 方法中的 rescale_factor 参数覆盖。
• do_normalize (bool, optional, defaults to True) — 是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 参数覆盖。
• image_mean (float or List[float], optional, defaults to IMAGENET_STANDARD_MEAN) — 如果对图像进行归一化，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。
• image_std (float or List[float], optional, defaults to IMAGENET_STANDARD_STD) — 如果对图像进行归一化，则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。
• do_pad (bool, optional, defaults to True) — 是否将图像填充到批次中图像的（最大高度，最大宽度）。可以被 preprocess 方法中的 do_pad 参数覆盖。

构建一个 ViLT 图像处理器。

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 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, optional, defaults to self.do_resize) — 是否调整图像大小。
• size (Dict[str, int], optional, defaults to self.size) — 控制 resize 后图像的大小。图像的最短边被调整为 size["shortest_edge"]，同时保持纵横比。如果调整后图像的最长边 > int(size["shortest_edge"] * (1333 / 800))，则再次调整图像，使最长边等于 int(size["shortest_edge"] * (1333 / 800))。
• size_divisor (int, optional, defaults to self.size_divisor) — 图像被调整为该值的倍数。
• resample (PILImageResampling, optional, defaults to 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，还会创建并返回像素掩码。
• 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）— 输出图像的通道维度格式。可以是以下之一：
  • ChannelDimension.FIRST：图像以（通道数，高度，宽度）格式。
  • ChannelDimension.LAST：图像以（高度，宽度，通道数）格式。
• input_data_format（ChannelDimension或str，可选）— 输入图像的通道维度格式。如果未设置，则从输入图像中推断出通道维度格式。可以是以下之一：
  • "channels_first"或ChannelDimension.FIRST：图像以（通道数，高度，宽度）格式。
  • "channels_last"或ChannelDimension.LAST：图像以（高度，宽度，通道数）格式。
  • "none"或ChannelDimension.NONE：图像以（高度，宽度）格式。

预处理图像或图像批处理。

ViltProcessor

class transformers.ViltProcessor

<来源>

( image_processor = None tokenizer = None **kwargs )

参数

• image_processor（ViltImageProcessor，可选）— 一个 ViltImageProcessor 的实例。图像处理器是必需的输入。
• tokenizer（BertTokenizerFast，可选）— 一个[‘BertTokenizerFast`]的实例。分词器是必需的输入。

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

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

__call__

<来源>

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

此方法使用 ViltImageProcessor.call()方法准备模型的图像，并使用 BertTokenizerFast.call()准备模型的文本。

有关更多信息，请参阅上述两种方法的文档字符串。

ViltModel

class transformers.ViltModel

<来源>

( config add_pooling_layer = True )

参数

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

裸 ViLT 模型变压器输出原始隐藏状态，没有特定的头部。此模型是 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 ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape ({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
• attention_mask (torch.FloatTensor of shape ({0}), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
  • 1 表示未被“遮蔽”的标记，
  • 0 表示被“遮蔽”的标记。什么是注意力掩码？
• 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)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViltImageProcessor.call()。
• pixel_mask (torch.LongTensor of shape (batch_size, height, width), optional) — 用于避免在填充像素值上执行注意力的掩码。掩码值在 [0, 1] 中选择：
  • 1 表示真实的像素（即未被遮蔽），
  • 0 表示填充的像素（即“遮蔽”）。什么是注意力掩码？<../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 ({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 转换为补丁嵌入，这将非常有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回的张量下的 attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

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

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置(ViltConfig)和输入的各种元素。

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

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

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

示例：

>>> from transformers import ViltProcessor, ViltModel
>>> 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 = ViltProcessor.from_pretrained("dandelin/vilt-b32-mlm")
>>> model = ViltModel.from_pretrained("dandelin/vilt-b32-mlm")

>>> inputs = processor(image, text, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

ViltForMaskedLM

class transformers.ViltForMaskedLM

< source >

( config )

参数

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

在预训练期间，ViLT 模型在顶部带有一个语言建模头。

这个模型是 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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？
• attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：
  • 1 表示标记是 未掩码，
  • 0 表示 被掩码 的标记。什么是注意力掩码？
• token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 段标记索引，指示输入的第一部分和第二部分。索引选在 [0, 1]：
  • 0 对应一个 句子 A 标记，
  • 1 对应一个 句子 B 标记。什么是标记类型 ID？
• pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViltImageProcessor.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，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• image_embeds (torch.FloatTensor，形状为 (batch_size, num_patches, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 pixel_values。如果您想要更多控制权来将 pixel_values 转换为补丁嵌入，这将非常有用。
• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。
• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
• labels（torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在 [-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 时）包含根据配置（ViltConfig）和输入的不同元素。

• loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 掩码语言建模（MLM）损失。
• logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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 之后的注意力权重。

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

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

示例：

>>> from transformers import ViltProcessor, ViltForMaskedLM
>>> import requests
>>> from PIL import Image
>>> import re
>>> import torch

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "a bunch of [MASK] laying on a [MASK]."

>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-mlm")
>>> model = ViltForMaskedLM.from_pretrained("dandelin/vilt-b32-mlm")

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

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

>>> tl = len(re.findall("\[MASK\]", text))
>>> inferred_token = [text]

>>> # gradually fill in the MASK tokens, one by one
>>> with torch.no_grad():
...     for i in range(tl):
...         encoded = processor.tokenizer(inferred_token)
...         input_ids = torch.tensor(encoded.input_ids)
...         encoded = encoded["input_ids"][0][1:-1]
...         outputs = model(input_ids=input_ids, pixel_values=encoding.pixel_values)
...         mlm_logits = outputs.logits[0]  # shape (seq_len, vocab_size)
...         # only take into account text features (minus CLS and SEP token)
...         mlm_logits = mlm_logits[1 : input_ids.shape[1] - 1, :]
...         mlm_values, mlm_ids = mlm_logits.softmax(dim=-1).max(dim=-1)
...         # only take into account text
...         mlm_values[torch.tensor(encoded) != 103] = 0
...         select = mlm_values.argmax().item()
...         encoded[select] = mlm_ids[select].item()
...         inferred_token = [processor.decode(encoded)]

>>> selected_token = ""
>>> encoded = processor.tokenizer(inferred_token)
>>> output = processor.decode(encoded.input_ids[0], skip_special_tokens=True)
>>> print(output)
a bunch of cats laying on a couch.

ViltForQuestionAnswering

class transformers.ViltForQuestionAnswering

<来源>

( config )

参数

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

Vilt 模型变压器，顶部带有分类器头（在 [CLS] 标记的最终隐藏状态之上的线性层），用于视觉问答，例如用于 VQAv2。

这个模型是 PyTorch 的 torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>_ 子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( 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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为 ({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取详细信息。什么是输入 ID？
• attention_mask (torch.FloatTensor，形状为 ({0})，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：
  • 对于未被掩码的标记为 1，
  • 对于被掩码的标记为 0。什么是注意力掩码？
• token_type_ids（形状为({0})的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引选定在[0, 1]之间：
  • 0 对应于句子 A的标记，
  • 1 对应于句子 B的标记。什么是标记类型 ID？
• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViltImageProcessor.call()。
• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）— 用于避免对填充像素值执行注意力的掩码。掩码值选定在[0, 1]之间：
  • 像素为 1 表示是真实像素（即未被掩码），
  • 对于填充像素（即masked）的像素为 0。什么是注意力掩码？<../glossary.html#attention-mask>__
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]之间：
  • 1 表示头部未被掩码，
  • 0 表示头部被掩码。
• inputs_embeds（形状为({0}, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵。
• image_embeds（形状为(batch_size, num_patches, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递pixel_values。如果您想要更多控制如何将pixel_values转换为补丁嵌入，这将非常有用。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。查看返回的张量中的attentions以获取更多细节。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。查看返回的张量中的hidden_states以获取更多细节。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。
• labels（形状为(batch_size, num_labels)的torch.FloatTensor，可选）— 用于计算视觉问答损失的标签。此张量必须是给定示例批次中适用的所有答案的独热编码，或者指示哪些答案适用的软编码，其中 1.0 是最高分。

返回

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

一个 transformers.modeling_outputs.SequenceClassifierOutput 或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者当config.return_dict=False时），包括根据配置（ViltConfig）和输入的不同元素。

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

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

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

示例：

>>> from transformers import ViltProcessor, ViltForQuestionAnswering
>>> import requests
>>> from PIL import Image

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "How many cats are there?"

>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-finetuned-vqa")
>>> model = ViltForQuestionAnswering.from_pretrained("dandelin/vilt-b32-finetuned-vqa")

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

>>> # forward pass
>>> outputs = model(**encoding)
>>> logits = outputs.logits
>>> idx = logits.argmax(-1).item()
>>> print("Predicted answer:", model.config.id2label[idx])
Predicted answer: 2

ViltForImagesAndTextClassification

transformers.ViltForImagesAndTextClassification 类

< source >

( config )

参数

• input_ids (torch.LongTensor，形状为 ({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？
• 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_images, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 ViltImageProcessor.call()。
• pixel_mask (torch.LongTensor，形状为 (batch_size, num_images, 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 of shape ({0}, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• image_embeds (torch.FloatTensor of shape (batch_size, num_images, num_patches, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递pixel_values。如果您想要更多控制如何将pixel_values转换为补丁嵌入，这将非常有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

Vilt 模型变压器，顶部带有自然语言视觉推理的分类器头部，例如 NLVR2。

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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput 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 表示未被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)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViltImageProcessor.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转换为补丁嵌入，这将非常有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• labels (torch.LongTensor of shape (batch_size,), optional) — 二元分类标签。

返回

transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput 或 tuple(torch.FloatTensor)

一个transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（ViltConfig）和输入的不同元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。
• logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）分数（SoftMax 之前）。
• hidden_states (List[tuple(torch.FloatTensor)], optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 一个元组列表，每个元组包含每个图像-文本对的torch.FloatTensor输出（每个元组包含嵌入的输出和每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层的输出处的隐藏状态加上初始嵌入输出。
• attentions (List[tuple(torch.FloatTensor)], optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 一个元组列表，每个元组包含形状为(batch_size, num_heads, sequence_length, sequence_length)的注意力权重的torch.FloatTensor（每个图像-文本对一个元组）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import ViltProcessor, ViltForImagesAndTextClassification
>>> import requests
>>> from PIL import Image

>>> image1 = Image.open(requests.get("https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg", stream=True).raw)
>>> image2 = Image.open(requests.get("https://lil.nlp.cornell.edu/nlvr/exs/ex0_1.jpg", stream=True).raw)
>>> text = "The left image contains twice the number of dogs as the right image."

>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-finetuned-nlvr2")
>>> model = ViltForImagesAndTextClassification.from_pretrained("dandelin/vilt-b32-finetuned-nlvr2")

>>> # prepare inputs
>>> encoding = processor([image1, image2], text, return_tensors="pt")

>>> # forward pass
>>> outputs = model(input_ids=encoding.input_ids, pixel_values=encoding.pixel_values.unsqueeze(0))
>>> logits = outputs.logits
>>> idx = logits.argmax(-1).item()
>>> print("Predicted answer:", model.config.id2label[idx])
Predicted answer: True

ViltForImageAndTextRetrieval

class transformers.ViltForImageAndTextRetrieval

<来源>

( config )

参数

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

Vilt 模型变压器，顶部带有分类器头（在[CLS]标记的最终隐藏状态之上的线性层），用于图像到文本或文本到图像检索，例如 MSCOCO 和 F30K。

这个模型是一个 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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: 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 表示 未掩码 的标记，
  • 0 表示被 掩码 的标记。什么是注意力掩码？
• 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)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViltImageProcessor.call()。
• pixel_mask (torch.LongTensor of shape (batch_size, height, width), optional) — 用于避免在填充像素值上执行注意力的掩码。掩码值在 [0, 1] 中选择：
  • 1 表示真实的像素（即 未掩码），
  • 0 表示填充的像素（即 掩码）。什么是注意力掩码？ <../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 ({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 转换为补丁嵌入，则这是有用的。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
• labels (torch.LongTensor of shape (batch_size,), optional) — 目前不支持标签。

返回

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

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（ViltConfig）和输入。

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

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

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

示例：

>>> from transformers import ViltProcessor, ViltForImageAndTextRetrieval
>>> 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 = ViltProcessor.from_pretrained("dandelin/vilt-b32-finetuned-coco")
>>> model = ViltForImageAndTextRetrieval.from_pretrained("dandelin/vilt-b32-finetuned-coco")

>>> # 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, :].item()

ViltForTokenClassification

class transformers.ViltForTokenClassification

<来源>

( config )

参数

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

ViLT 模型在顶部有一个标记分类头（文本标记的最终隐藏状态上的线性层），例如用于命名实体识别（NER）任务。

这个模型是 PyTorch 的torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>_ 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

<来源>

( 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 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（形状为({0})的torch.LongTensor）- 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？
• attention_mask（形状为({0})的torch.FloatTensor，可选）—用于避免在填充标记索引上执行注意力的遮罩。选择的遮罩值在[0, 1]中：
  • 1 表示未被遮罩的标记，
  • 0 表示被遮罩的标记。什么是注意力遮罩？
• token_type_ids（形状为({0})的torch.LongTensor，可选）—段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。什么是标记类型 ID？
• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）—像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViltImageProcessor.call()。
• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）—用于避免在填充像素值上执行注意力的遮罩。选择的遮罩值在[0, 1]中：
  • 1 表示真实的像素（即未被遮罩），
  • 0 表示填充的像素（即被遮罩）。什么是注意力遮罩？<../glossary.html#attention-mask>__
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）—用于使自注意力模块的选定头部失效的遮罩。选择的遮罩值在[0, 1]中：
  • 1 表示头部未被遮罩，
  • 0 表示头部被遮罩。
• inputs_embeds（形状为({0}, hidden_size)的torch.FloatTensor，可选）—可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• image_embeds（形状为(batch_size, num_patches, hidden_size)的torch.FloatTensor，可选）—可选地，可以直接传递嵌入表示，而不是传递pixel_values。如果您想要更多控制如何将pixel_values转换为补丁嵌入，这将非常有用。
• output_attentions（bool，可选）—是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）—是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）—是否返回 ModelOutput 而不是普通元组。
• labels（形状为(batch_size, text_sequence_length)的torch.LongTensor，可选）—用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]中。

返回

一个 transformers.modeling_outputs.TokenClassifierOutput 或者tuple(torch.FloatTensor)，

一个 transformers.modeling_outputs.TokenClassifierOutput 或者一个torch.FloatTensor元组（如果传递了return_dict=False或者config.return_dict=False时）包括各种元素，取决于配置（ViltConfig）和输入。

• loss（形状为(1,)的torch.FloatTensor，可选，在提供labels时返回）—分类损失。
• logits（形状为(batch_size, sequence_length, config.num_labels)的torch.FloatTensor）—分类分数（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size)。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。 在自注意力头中用于计算加权平均值的注意力 softmax 后的注意力权重。

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

虽然前向传递的步骤需要在这个函数中定义，但应该在此之后调用 Module 实例，而不是在此处调用，因为前者会处理运行前后的处理步骤，而后者会默默地忽略它们。 pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）—像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 ViltImageProcessor.call()。

• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）—用于避免在填充像素值上执行注意力的遮罩。选择的遮罩值在[0, 1]中：
  • 1 表示真实的像素（即未被遮罩），
  • 0 表示填充的像素（即被遮罩）。什么是注意力遮罩？<../glossary.html#attention-mask>__
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）—用于使自注意力模块的选定头部失效的遮罩。选择的遮罩值在[0, 1]中：
  • 1 表示头部未被遮罩，
  • 0 表示头部被遮罩。
• inputs_embeds（形状为({0}, hidden_size)的torch.FloatTensor，可选）—可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• image_embeds（形状为(batch_size, num_patches, hidden_size)的torch.FloatTensor，可选）—可选地，可以直接传递嵌入表示，而不是传递pixel_values。如果您想要更多控制如何将pixel_values转换为补丁嵌入，这将非常有用。
• output_attentions（bool，可选）—是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）—是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）—是否返回 ModelOutput 而不是普通元组。
• labels（形状为(batch_size, text_sequence_length)的torch.LongTensor，可选）—用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]中。

返回

一个 transformers.modeling_outputs.TokenClassifierOutput 或者tuple(torch.FloatTensor)，

一个 transformers.modeling_outputs.TokenClassifierOutput 或者一个torch.FloatTensor元组（如果传递了return_dict=False或者config.return_dict=False时）包括各种元素，取决于配置（ViltConfig）和输入。

• loss（形状为(1,)的torch.FloatTensor，可选，在提供labels时返回）—分类损失。
• logits（形状为(batch_size, sequence_length, config.num_labels)的torch.FloatTensor）—分类分数（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size)。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。 在自注意力头中用于计算加权平均值的注意力 softmax 后的注意力权重。

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

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