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

Transformers 4.37 中文文档（四十七）

原文：huggingface.co/docs/transformers

VipLlava

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

概述

VipLlava 模型是由 Mu Cai、Haotian Liu、Siva Karthik Mustikovela、Gregory P. Meyer、Yuning Chai、Dennis Park、Yong Jae Lee 在《Making Large Multimodal Models Understand Arbitrary Visual Prompts》中提出的。

VipLlava 通过在训练过程中标记图像并使用自然提示（如“红色边界框”或“指向箭头”）与模型进行交互，增强了 Llava 的训练协议。

该论文的摘要如下：

尽管现有的大型视觉-语言多模态模型侧重于整体图像理解，但在实现特定区域理解方面存在明显差距。目前使用文本坐标或空间编码的方法通常无法提供用户友好的视觉提示界面。为了解决这一挑战，我们引入了一种能够解码任意视觉提示的新型多模态模型。这使用户可以直观地标记图像，并使用自然提示与模型进行交互，如“红色边界框”或“指向箭头”。我们的简单设计直接将视觉标记叠加在 RGB 图像上，消除了复杂区域编码的需求，同时在 Visual7W、PointQA 和 Visual Commonsense Reasoning 基准等区域理解任务上实现了最先进的性能。此外，我们提出了 ViP-Bench，一个全面的基准，用于评估模型在理解多维视觉提示方面的能力，促进该领域的未来研究。代码、数据和模型均可公开获取。

提示：

• 该架构与 llava 架构类似，只是多模态投影器采用一组连接的视觉隐藏状态，并在该模块上增加了一个 layernorm 层。

• 我们建议用户在计算批量生成时使用padding_side="left"，因为这会导致更准确的结果。只需确保在生成之前调用processor.tokenizer.padding_side = "left"。

• 请注意，该模型尚未明确训练以处理同一提示中的多个图像，尽管从技术上讲这是可能的，但您可能会遇到不准确的结果。

• 为了获得更好的结果，我们建议用户使用正确的提示格式提示模型：

A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human's questions.###Human: <image>\n<prompt>###Assistant:

对于多轮对话:

A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human's questions.###Human: <image>\n<prompt1>###Assistant: <answer1>###Human: <prompt2>###Assistant:

原始代码可在此处找到。

该模型由Younes Belkada贡献

VipLlavaConfig

class transformers.VipLlavaConfig

<来源>

( vision_config = None text_config = None ignore_index = -100 image_token_index = 32000 projector_hidden_act = 'gelu' projector_layernorm_eps = 1e-05 vision_feature_layers = [-2, -5, -8, -11, 6] vocab_size = 32000 **kwargs )

参数

• vision_config（VipLlavaVisionConfig，可选）— 自定义视觉配置或字典

• text_config（Union[AutoConfig, dict]，可选）— 文本主干的配置对象。可以是LlamaConfig或MistralConfig中的任何一个。

• ignore_index（int，可选，默认为-100）— 损失函数的忽略索引。

• image_token_index（int，可选，默认为 32000）— 用于编码图像提示的图像标记索引。

• projector_hidden_act（str，可选，默认为"gelu"）— 多模态投影器使用的激活函数。

• projector_layernorm_eps（float，可选，默认为 1e-05）— 投影器 layernorm 的层归一化 epsilon

• vision_feature_layers（List[int]，可选，默认为[-2, -5, -8, -11, 6]）— 选择视觉特征的层列表。

• vocab_size（int，可选，默认为 32000）— VipLlava 模型的词汇量。定义了在调用~VipLlavaForConditionalGeneration 时可以表示的不同标记数量。

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

例如ybelkada/vip-llava-7b-hf

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

示例：

>>> from transformers import VipLlavaForConditionalGeneration, VipLlavaConfig, CLIPVisionConfig, LlamaConfig

>>> # Initializing a CLIP-vision config
>>> vision_config = CLIPVisionConfig()

>>> # Initializing a Llama config
>>> text_config = LlamaConfig()

>>> # Initializing a VipLlava vipllava-7b style configuration
>>> configuration = VipLlavaConfig(vision_config, text_config)

>>> # Initializing a model from the vipllava-7b style configuration
>>> model = VipLlavaForConditionalGeneration(configuration)

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

VipLlavaForConditionalGeneration

class transformers.VipLlavaForConditionalGeneration

<来源>

( config: VipLlavaConfig )

参数

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

VIPLLAVA 模型由视觉主干和语言模型组成。此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

前进

<来源>

( input_ids: LongTensor = None pixel_values: FloatTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None vision_feature_layers: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.vipllava.modeling_vipllava.VipLlavaCausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• pixel_values（形状为(batch_size, num_channels, image_size, image_size)的torch.FloatTensor）- 对应输入图像的张量。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 CLIPImageProcessor.call()（[LlavaProcessor]使用 CLIPImageProcessor 处理图像）。

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

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

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

  什么是注意力蒙版？

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

  如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（参见past_key_values）。

  如果要更改填充行为，您应该阅读modeling_opt._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

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

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

  如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（即未将其过去的键值状态提供给此模型的那些）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多控制如何将input_ids索引转换为相关向量，则这很有用，而不是使用模型的内部嵌入查找矩阵。

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

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

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

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

  参数 — 标签（形状为(batch_size, sequence_length)的torch.LongTensor，可选）：用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100（参见input_ids文档字符串）。将索引设置为-100的标记将被忽略（masked），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

transformers.models.vipllava.modeling_vipllava.VipLlavaCausalLMOutputWithPast或tuple(torch.FloatTensor)

一个transformers.models.vipllava.modeling_vipllava.VipLlavaCausalLMOutputWithPast或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False）包含根据配置（VipLlavaConfig）和输入的不同元素。

• 损失 (torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 语言建模损失（用于下一个标记的预测）。

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）

  包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（查看past_key_values输入）。

• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。

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

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

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

• image_hidden_states (tuple(torch.FloatTensor)，可选) — 形状为(batch_size, num_images, sequence_length, hidden_size)的torch.FloatTensor元组（用于图像嵌入的输出）。

  由视觉编码器生成的模型的图像隐藏状态，以及可选的感知器

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

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

示例：

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

>>> model = VipLlavaForConditionalGeneration.from_pretrained("llava-hf/vip-llava-7b-hf", device_map="auto", torch_dtype=torch.float16)
>>> processor = AutoProcessor.from_pretrained("llava-hf/vip-llava-7b-hf")

>>> prompt = "A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human's questions.###Human: <image>\n{}###Assistant:"
>>> question = "Can you please describe this image?"
>>> prompt = prompt.format(question)
>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/compel-neg.png"
>>> image = Image.open(requests.get(url, stream=True).raw)

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

>>> # Generate
>>> generate_ids = model.generate(**inputs, max_new_tokens=20)
>>> processor.decode(generate_ids[0][len(inputs["input_ids"][0]):], skip_special_tokens=True)
The image features a brown and white cat sitting on a green surface, with a red ball in its

视觉编码器解码器模型

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/vision-encoder-decoder

概述

VisionEncoderDecoderModel 可用于使用任何预训练的基于 Transformer 的视觉模型作为编码器（例如 ViT、BEiT、DeiT、Swin）和任何预训练语言模型作为解码器（例如 RoBERTa、GPT2、BERT、DistilBERT）初始化图像到文本模型。

使用预训练检查点初始化图像到文本序列模型的有效性已在 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中得到展示。

在训练/微调了这样一个 VisionEncoderDecoderModel 之后，它可以像其他模型一样保存/加载（有关更多信息，请参见下面的示例）。

一个示例应用是图像字幕，其中编码器用于对图像进行编码，之后自回归语言模型生成字幕。另一个示例是光学字符识别。请参考 TrOCR，这是 VisionEncoderDecoderModel 的一个实例。

从模型配置随机初始化 VisionEncoderDecoderModel。

VisionEncoderDecoderModel 可以从编码器和解码器配置随机初始化。在以下示例中，我们展示了如何使用编码器的默认 ViTModel 配置和解码器的默认BertForCausalLM配置来实现这一点。

>>> from transformers import BertConfig, ViTConfig, VisionEncoderDecoderConfig, VisionEncoderDecoderModel

>>> config_encoder = ViTConfig()
>>> config_decoder = BertConfig()

>>> config = VisionEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
>>> model = VisionEncoderDecoderModel(config=config)

从预训练的编码器和预训练的解码器初始化 VisionEncoderDecoderModel。

VisionEncoderDecoderModel 可以从预训练的编码器检查点和预训练的解码器检查点初始化。请注意，任何预训练的基于 Transformer 的视觉模型，例如 Swin，都可以作为编码器，而预训练的自编码模型，例如 BERT，预训练的因果语言模型，例如 GPT2，以及序列到序列模型的预训练解码器部分，例如 BART 的解码器，都可以作为解码器。根据您选择的解码器架构，交叉注意力层可能会被随机初始化。从预训练的编码器和解码器检查点初始化 VisionEncoderDecoderModel 需要对模型进行下游任务的微调，正如在Warm-starting-encoder-decoder blog post中所示。为此，VisionEncoderDecoderModel类提供了一个 VisionEncoderDecoderModel.from_encoder_decoder_pretrained()方法。

>>> from transformers import VisionEncoderDecoderModel

>>> model = VisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "microsoft/swin-base-patch4-window7-224-in22k", "bert-base-uncased"
... )

加载现有的 VisionEncoderDecoderModel 检查点并执行推理。

要加载VisionEncoderDecoderModel类的微调检查点，VisionEncoderDecoderModel 提供了from_pretrained(...)方法，就像 Transformers 中的任何其他模型架构一样。

要执行推断，可以使用 generate 方法，该方法允许自回归生成文本。此方法支持各种解码形式，如贪婪、束搜索和多项式采样。

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

>>> from transformers import GPT2TokenizerFast, ViTImageProcessor, VisionEncoderDecoderModel

>>> # load a fine-tuned image captioning model and corresponding tokenizer and image processor
>>> model = VisionEncoderDecoderModel.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
>>> tokenizer = GPT2TokenizerFast.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
>>> image_processor = ViTImageProcessor.from_pretrained("nlpconnect/vit-gpt2-image-captioning")

>>> # let's perform inference on an image
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> pixel_values = image_processor(image, return_tensors="pt").pixel_values

>>> # autoregressively generate caption (uses greedy decoding by default)
>>> generated_ids = model.generate(pixel_values)
>>> generated_text = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print(generated_text)
a cat laying on a blanket next to a cat laying on a bed

将 PyTorch checkpoint 加载到 TFVisionEncoderDecoderModel 中。

TFVisionEncoderDecoderModel.from_pretrained() 目前不支持从 PyTorch checkpoint 初始化模型。将 from_pt=True 传递给此方法将引发异常。如果特定视觉编码器-解码器模型仅有 PyTorch checkpoints，可以使用以下解决方法：

>>> from transformers import VisionEncoderDecoderModel, TFVisionEncoderDecoderModel

>>> _model = VisionEncoderDecoderModel.from_pretrained("nlpconnect/vit-gpt2-image-captioning")

>>> _model.encoder.save_pretrained("./encoder")
>>> _model.decoder.save_pretrained("./decoder")

>>> model = TFVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "./encoder", "./decoder", encoder_from_pt=True, decoder_from_pt=True
... )
>>> # This is only for copying some specific attributes of this particular model.
>>> model.config = _model.config

训练

创建模型后，可以类似于 BART、T5 或任何其他编码器-解码器模型在（图像，文本）对数据集上进行微调。正如您所看到的，为了计算损失，模型只需要 2 个输入：pixel_values（即图像）和 labels（即编码目标序列的 input_ids）。

>>> from transformers import ViTImageProcessor, BertTokenizer, VisionEncoderDecoderModel
>>> from datasets import load_dataset

>>> image_processor = ViTImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")
>>> tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
>>> model = VisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google/vit-base-patch16-224-in21k", "bert-base-uncased"
... )

>>> model.config.decoder_start_token_id = tokenizer.cls_token_id
>>> model.config.pad_token_id = tokenizer.pad_token_id

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> pixel_values = image_processor(image, return_tensors="pt").pixel_values

>>> labels = tokenizer(
...     "an image of two cats chilling on a couch",
...     return_tensors="pt",
... ).input_ids

>>> # the forward function automatically creates the correct decoder_input_ids
>>> loss = model(pixel_values=pixel_values, labels=labels).loss

此模型由 nielsr 贡献。此模型的 TensorFlow 和 Flax 版本由 ydshieh 贡献。

VisionEncoderDecoderConfig

class transformers.VisionEncoderDecoderConfig

<来源>

( **kwargs )

参数

• kwargs（可选）— 关键字参数字典。特别包括：

  • encoder（PretrainedConfig，可选）— 定义编码器配置的配置对象实例。

  • decoder（PretrainedConfig，可选）— 定义解码器配置的配置对象实例。

VisionEncoderDecoderConfig 是用于存储 VisionEncoderDecoderModel 配置的配置类。根据指定的参数实例化 Vision-Encoder-Text-Decoder 模型，定义编码器和解码器配置。

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

示例：

>>> from transformers import BertConfig, ViTConfig, VisionEncoderDecoderConfig, VisionEncoderDecoderModel

>>> # Initializing a ViT & BERT style configuration
>>> config_encoder = ViTConfig()
>>> config_decoder = BertConfig()

>>> config = VisionEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)

>>> # Initializing a ViTBert model (with random weights) from a ViT & bert-base-uncased style configurations
>>> model = VisionEncoderDecoderModel(config=config)

>>> # Accessing the model configuration
>>> config_encoder = model.config.encoder
>>> config_decoder = model.config.decoder
>>> # set decoder config to causal lm
>>> config_decoder.is_decoder = True
>>> config_decoder.add_cross_attention = True

>>> # Saving the model, including its configuration
>>> model.save_pretrained("my-model")

>>> # loading model and config from pretrained folder
>>> encoder_decoder_config = VisionEncoderDecoderConfig.from_pretrained("my-model")
>>> model = VisionEncoderDecoderModel.from_pretrained("my-model", config=encoder_decoder_config)

from_encoder_decoder_configs

<来源>

( encoder_config: PretrainedConfig decoder_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';VisionEncoderDecoderConfig

返回

VisionEncoderDecoderConfig

配置对象实例

从预训练编码器模型配置和解码器模型配置实例化一个 VisionEncoderDecoderConfig（或派生类）。

PytorchHide Pytorch content

VisionEncoderDecoderModel

class transformers.VisionEncoderDecoderModel

<来源>

( config: Optional = None encoder: Optional = None decoder: Optional = None )

参数

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

这个类可以用来初始化一个图像到文本序列模型，其中预训练的视觉自编码模型作为编码器，预训练的文本自回归模型作为解码器。编码器通过 from_pretrained() 函数加载，解码器通过 from_pretrained() 函数加载。交叉注意力层会自动添加到解码器，并应在下游生成任务（如图像字幕）上进行微调。

在 Leveraging Pre-trained Checkpoints for Sequence Generation Tasks 中，Sascha Rothe、Shashi Narayan、Aliaksei Severyn、Michael Matena、Yanqi Zhou、Wei Li、Peter J. Liu 展示了使用预训练检查点初始化序列到序列模型进行序列生成任务的有效性。

此外，在 TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models 中，展示了如何利用大型预训练视觉模型进行光学字符识别（OCR）可以显著提高性能。

训练/微调了这样一个视觉-编码器-文本-解码器模型后，它可以像其他模型一样保存/加载（有关更多信息，请参阅示例）。

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

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

VisionEncoderDecoderModel 是一个通用的模型类，当使用 :meth~transformers.AutoModel.from_pretrained 类方法为编码器创建一个基础视觉模型类，并为解码器创建另一个基础视觉模型类时，将实例化为一个变压器架构。

forward

< source >

( pixel_values: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以通过图像处理器获得（例如，如果您使用 ViT 作为编码器，应该使用 AutoImageProcessor）。有关详细信息，请参阅 ViTImageProcessor.call()。

• decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。

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

  什么是输入 ID？

  如果使用了 past_key_values，可选择仅输入最后的 decoder_input_ids（参见 past_key_values）。

  对于训练，decoder_input_ids 会被模型自动创建，通过将 labels 向右移动，用 pad_token_id 替换 -100，并在前面加上 decoder_start_token_id。

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

• encoder_outputs (tuple(torch.FloatTensor), optional) — 此元组必须包含 (last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) 是编码器最后一层的隐藏状态张量。用于解码器的交叉注意力。

• past_key_values (tuple(tuple(torch.FloatTensor))，长度为 config.n_layers，每个元组包含 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量） — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

  如果使用了 past_key_values，用户可以选择仅输入形状为 (batch_size, 1) 的最后的 decoder_input_ids（即没有将过去的键值状态提供给该模型的那些）而不是形状为 (batch_size, sequence_length) 的所有 decoder_input_ids。

• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 decoder_input_ids。如果您想要更多控制如何将 decoder_input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算解码器的掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 范围内（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅计算具有标签在 [0, ..., config.vocab_size] 范围内的标记。

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

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

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

• return_dict (bool, optional) — 如果设置为 True，模型将返回一个 ~utils.Seq2SeqLMOutput 而不是一个普通元组。

• kwargs (optional) — 剩余的关键字参数字典。关键字参数有两种类型：

  • 没有前缀，将作为 **encoder_kwargs 输入到编码器前向函数中。

  • 使用 decoder_ 前缀，将作为 **decoder_kwargs 输入到解码器前向函数中。

返回

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

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（VisionEncoderDecoderConfig）和输入而异的各种元素。

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

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (tuple(tuple(torch.FloatTensor))，optional，当传递use_cache=True或config.use_cache=True时返回) — 一个长度为config.n_layers的元组，每个元组有 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输入）。

• decoder_hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 一个元组，包含形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor（如果模型有嵌入层，则为嵌入层输出的一个+每层输出的一个）。

  解码器在每一层输出的隐藏状态加上初始嵌入输出。

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

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

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

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

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

• encoder_hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 一个元组，包含形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor（如果模型有嵌入层，则为嵌入层输出的一个+每层输出的一个）。

  编码器在每一层输出的隐藏状态加上初始嵌入输出。

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

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

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

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

示例：

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

>>> processor = AutoProcessor.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")

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

>>> pixel_values = processor(image, return_tensors="pt").pixel_values
>>> text = "hello world"
>>> labels = processor.tokenizer(text, return_tensors="pt").input_ids
>>> outputs = model(pixel_values=pixel_values, labels=labels)
>>> loss = outputs.loss

>>> # inference (generation)
>>> generated_ids = model.generate(pixel_values)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

from_encoder_decoder_pretrained

<来源>

( encoder_pretrained_model_name_or_path: str = None decoder_pretrained_model_name_or_path: str = None *model_args **kwargs )

参数

• encoder_pretrained_model_name_or_path（str，可选）- 启动图像编码器所需的信息。可以是：

  • 一个字符串，预训练模型的模型 ID，托管在 huggingface.co 上的模型存储库内。一个示例是google/vit-base-patch16-224-in21k。

  • 一个包含使用 save_pretrained()保存的模型权重的目录的路径，例如，./my_model_directory/。

  • 一个指向 tensorflow 索引检查点文件的路径或 url（例如，./tf_model/model.ckpt.index）。在这种情况下，from_tf应设置为True，并且应将配置对象提供为config参数。使用此加载路径比使用提供的转换脚本将 TensorFlow 检查点转换为 PyTorch 模型并加载 PyTorch 模型要慢。

• decoder_pretrained_model_name_or_path（str，可选，默认为None）- 启动文本解码器所需的信息。可以是：

  • 一个字符串，预训练模型的模型 ID，托管在 huggingface.co 上的模型存储库内。有效的模型 ID 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下命名空间，如dbmdz/bert-base-german-cased。

  • 一个包含使用 save_pretrained()保存的模型权重的目录的路径，例如，./my_model_directory/。

  • 一个指向 tensorflow 索引检查点文件的路径或 url（例如，./tf_model/model.ckpt.index）。在这种情况下，from_tf应设置为True，并且应将配置对象提供为config参数。使用此加载路径比使用提供的转换脚本将 TensorFlow 检查点转换为 PyTorch 模型并加载 PyTorch 模型要慢。

• model_args（剩余的位置参数，可选）- 所有剩余的位置参数将传递给底层模型的__init__方法。

• kwargs（剩余的关键字参数字典，可选）- 可用于更新配置对象（在加载后）并启动模型（例如，output_attentions=True）。

  • 要更新编码器配置，请为每个配置参数使用前缀encoder_。

  • 要更新解码器配置，请为每个配置参数使用前缀decoder_。

  • 要更新父模型配置，请不要为每个配置参数使用前缀。

  根据是否提供config而表现不同。

从预训练模型检查点中的一个或两个基类库中实例化一个编码器和一个解码器。

默认情况下，使用model.eval()将模型设置为评估模式（Dropout 模块被停用）。要训练模型，您需要首先使用model.train()将其设置回训练模式。

示例：

>>> from transformers import VisionEncoderDecoderModel

>>> # initialize a vit-bert from a pretrained ViT and a pretrained BERT model. Note that the cross-attention layers will be randomly initialized
>>> model = VisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google/vit-base-patch16-224-in21k", "bert-base-uncased"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./vit-bert")
>>> # load fine-tuned model
>>> model = VisionEncoderDecoderModel.from_pretrained("./vit-bert")

TensorFlowHide TensorFlow 内容

TFVisionEncoderDecoderModel

class transformers.TFVisionEncoderDecoderModel

<来源>

( config: Optional[PretrainedConfig] = None encoder: Optional[TFPreTrainedModel] = None decoder: Optional[TFPreTrainedModel] = None )

参数

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

这个类可用于使用任何预训练的视觉自编码模型作为编码器和任何预训练的文本自回归模型作为解码器来初始化一个图像到文本序列模型。编码器通过 from_pretrained()函数加载，解码器通过 from_pretrained()函数加载。交叉注意力层会自动添加到解码器，并应在下游生成任务（如图像字幕）上进行微调。

在Sascha Rothe, Shashi Narayan, Aliaksei Severyn. Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu 的《利用预训练检查点进行序列生成任务》中展示了使用预训练检查点初始化序列生成任务的序列到序列模型的有效性。

此外，在TrOCR: 基于 Transformer 的预训练模型的光学字符识别中展示了如何利用大型预训练的视觉模型进行光学字符识别（OCR）可以显著提高性能。

在训练/微调了这样一个 Vision-Encoder-Text-Decoder 模型之后，它可以像任何其他模型一样保存/加载（查看示例以获取更多信息）。

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

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

TFVisionEncoderDecoderModel 是一个通用模型类，当使用 from_pretrained()类方法为编码器创建一个库中的基础视觉模型类，并为解码器创建另一个基础模型类时，将实例化为一个变压器架构。

call

<来源>

( pixel_values: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: Optional[Union[Tuple, TFBaseModelOutput]] = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None labels: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False **kwargs ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqLMOutput or tuple(tf.Tensor)

参数

• pixel_values（np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_channels, height, width)）— 像素值。像素值可以使用视觉模型的图像处理器获得。例如，使用 AutoImageProcessor。有关详细信息，请参阅 ViTImageProcessor.call()。

• decoder_input_ids (np.ndarray or tf.Tensor of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。

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

  什么是输入 ID？

  如果使用了 past_key_values，可以选择仅输入最后的 decoder_input_ids（参见 past_key_values）。

  为解码器提供序列到序列训练。可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

• decoder_attention_mask (np.ndarray or tf.Tensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略 decoder_input_ids 中的填充标记。因果掩码也将默认使用。

• encoder_outputs (tuple(tuple(tf.Tensor), optional) — 这个元组必须包含 (last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size)) 是编码器最后一层的隐藏状态张量。用于解码器的交叉注意力。

• past_key_values (tuple(tuple(tf.Tensor)) of length config.n_layers with each tuple having 4 tensors of shape (batch_size, num_heads, sequence_length - 1, embed_size_per_head)) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

  如果使用了 past_key_values，用户可以选择仅输入最后的 decoder_input_ids（这些没有将它们的过去键值状态提供给此模型）的形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。

• decoder_inputs_embeds (np.ndarray or tf.Tensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地，您可以直接传递嵌入表示，而不是传递 decoder_input_ids。如果您想要更多控制权来将 decoder_input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• labels (np.ndarray or tf.Tensor of shape (batch_size, sequence_length), optional) — 用于计算解码器的掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size]（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅计算具有标签在 [0, ..., config.vocab_size] 中的标记。

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

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

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

• return_dict (bool, optional) — 如果设置为 True，模型将返回一个 ~utils.Seq2SeqLMOutput 而不是一个普通元组。

• training (bool, optional, 默认为False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• kwargs (optional) — 剩余的关键字参数字典。关键字参数有两种类型：

  • 没有前缀，将作为编码器前向函数的**encoder_kwargs输入。

  • 带有decoder_前缀，将作为解码器前向函数的**decoder_kwargs输入。

返回

transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（VisionEncoderDecoderConfig）和输入的各种元素。

• loss (tf.Tensor of shape (n,), optional, 其中 n 是未屏蔽标签的数量，在提供labels时返回) — 语言建模损失。

• logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (List[tf.Tensor], optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。

  包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。

• decoder_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组。

  解码器在每一层输出的隐藏状态加上初始嵌入输出。

• decoder_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。

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

• cross_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。

  解码器的交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出，一个用于每一层的输出）。

  编码器在每一层输出的隐藏状态加上初始嵌入输出。

• encoder_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。

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

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

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

示例：

>>> from transformers import AutoImageProcessor, AutoTokenizer, TFVisionEncoderDecoderModel
>>> from PIL import Image
>>> import requests

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")
>>> decoder_tokenizer = AutoTokenizer.from_pretrained("gpt2")

>>> # initialize a bert2gpt2 from a pretrained BERT and GPT2 models. Note that the cross-attention layers will be randomly initialized
>>> model = TFVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google/vit-base-patch16-224-in21k", "gpt2"
... )

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

>>> # forward
>>> pixel_values = image_processor(images=img, return_tensors="tf").pixel_values  # Batch size 1
>>> decoder_input_ids = decoder_tokenizer("Linda Davis", return_tensors="tf").input_ids  # Batch size 1
>>> outputs = model(pixel_values=pixel_values, decoder_input_ids=decoder_input_ids)

>>> # training
>>> outputs = model(pixel_values=pixel_values, decoder_input_ids=decoder_input_ids, labels=decoder_input_ids)
>>> loss, logits = outputs.loss, outputs.logits

>>> # save and load from pretrained
>>> model.save_pretrained("vit-gpt2")
>>> model = TFVisionEncoderDecoderModel.from_pretrained("vit-gpt2")

>>> # generation
>>> generated = model.generate(pixel_values, decoder_start_token_id=model.config.decoder.bos_token_id)

from_encoder_decoder_pretrained

<来源>

( encoder_pretrained_model_name_or_path: str = None decoder_pretrained_model_name_or_path: str = None *model_args **kwargs )

参数

• encoder_pretrained_model_name_or_path（str，可选） — 初始化编码器所需的信息。可以是：

  • 预训练模型的模型 id，托管在 huggingface.co 上的模型存储库中。例如，google/vit-base-patch16-224-in21k。

  • 指向使用 save_pretrained()保存的模型权重的目录的路径，例如，./my_model_directory/。

  • 指向pytorch 索引检查点文件的路径或 url（例如，./pt_model/）。在这种情况下，encoder_from_pt应设置为True。

• decoder_pretrained_model_name_or_path（str，可选，默认为None） — 初始化解码器所需的信息。可以是：

  • 预训练模型的模型 id，托管在 huggingface.co 上的模型存储库中。有效的模型 id 可以位于根级别，如bert-base-uncased，或在用户或组织名称下命名空间化，如dbmdz/bert-base-german-cased。

  • 指向包含使用 save_pretrained()保存的模型权重的目录的路径，例如，./my_model_directory/。

  • 指向pytorch 检查点文件的路径或 url（例如，./pt_model/）。在这种情况下，decoder_from_pt应设置为True。

• model_args（剩余的位置参数，可选） — 所有剩余的位置参数将传递给底层模型的__init__方法。

• kwargs（剩余的关键字参数字典，可选） — 可用于更新配置对象（加载后）并初始化模型（例如，output_attentions=True）。

  • 更新编码器配置时，对每个配置参数使用前缀encoder_。

  • 更新解码器配置时，对每个配置参数使用前缀decoder_。

  • 要更新父模型配置，请不要对每个配置参数使用前缀。

  根据是否提供config或自动加载而表现不同。

从预训练模型检查点实例化一个编码器和一个解码器，可以是库中一个或两个基类的预训练模型检查点。

示例：

>>> from transformers import TFVisionEncoderDecoderModel

>>> # initialize a vit-bert from a pretrained ViT and a pretrained BERT model. Note that the cross-attention layers will be randomly initialized
>>> model = TFVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google/vit-base-patch16-224-in21k", "bert-base-uncased"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./vit-bert")
>>> # load fine-tuned model
>>> model = TFVisionEncoderDecoderModel.from_pretrained("./vit-bert")

JAXHide JAX content

FlaxVisionEncoderDecoderModel

class transformers.FlaxVisionEncoderDecoderModel

<来源>

( config: VisionEncoderDecoderConfig input_shape: Optional = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

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

• dtype（jax.numpy.dtype，可选，默认为jax.numpy.float32） — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。

  这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了dtype，则所有计算将使用给定的dtype执行。

  请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。

  如果您希望更改模型参数的 dtype，请参阅 to_fp16()和 to_bf16()。

这个类可以用来初始化一个图像到文本序列模型，其中编码器是任何预训练的视觉自编码模型，解码器是任何预训练的文本自回归模型。编码器通过 from_pretrained()函数加载，解码器通过 from_pretrained()函数加载。交叉注意力层会自动添加到解码器上，并应该在下游生成任务（如图像字幕）上进行微调。

在Sascha Rothe, Shashi Narayan, Aliaksei Severyn. Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu的研究中展示了使用预训练检查点初始化序列生成任务的序列到序列模型的有效性。

此外，在TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models中展示了如何利用大型预训练视觉模型进行光学字符识别（OCR）可以显著提高性能。

训练/微调了这样一个视觉-编码器-文本-解码器模型后，它可以像其他模型一样保存/加载（有关更多信息，请参阅示例）。

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

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

FlaxVisionEncoderDecoderModel 是一个通用的模型类，当使用:meth~transformers.FlaxAutoModel.from_pretrained类方法为编码器创建模块（flax.nn.Module）时，会实例化为一个 transformer 架构，库中的一个基本视觉模型类作为编码器模块，另一个作为解码器模块，并使用:meth~transformers.FlaxAutoModelForCausalLM.from_pretrained类方法为解码器创建模块。

__call__

< source >

( pixel_values: Array decoder_input_ids: Optional = None decoder_attention_mask: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• pixel_values（jnp.ndarray，形状为(batch_size, num_channels, height, width)）— 像素值。像素值可以使用视觉模型的图像处理器获得。例如，使用 AutoImageProcessor。有关详细信息，请参阅 ViTImageProcessor.call()。

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

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

  什么是解码器输入 ID？

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

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

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

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

• return_dict (bool, 可选) — 如果设置为True，模型将返回一个~utils.FlaxSeq2SeqLMOutput而不是一个普通元组。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（VisionEncoderDecoderConfig）和输入而异的各种元素。

• logits (jnp.ndarray，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (tuple(tuple(jnp.ndarray)), 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组有 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输入）。

• decoder_hidden_states (tuple(jnp.ndarray), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出，一个用于每一层的输出）。

  解码器在每一层输出的隐藏状态以及初始嵌入输出。

• decoder_attentions (tuple(jnp.ndarray), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

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

• cross_attentions (tuple(jnp.ndarray), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

  解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(jnp.ndarray), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每层的输出）。

  编码器在每层输出的隐藏状态加上初始嵌入输出。

• encoder_attentions (tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

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

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

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

示例：

>>> from transformers import FlaxVisionEncoderDecoderModel, AutoImageProcessor, AutoTokenizer
>>> from PIL import Image
>>> import requests

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

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")

>>> # load output tokenizer
>>> tokenizer_output = AutoTokenizer.from_pretrained("gpt2")

>>> # initialize a vit-gpt2 from pretrained ViT and GPT2 models. Note that the cross-attention layers will be randomly initialized
>>> model = FlaxVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google/vit-base-patch16-224-in21k", "gpt2"
... )

>>> pixel_values = image_processor(images=image, return_tensors="np").pixel_values

>>> # use GPT2's eos_token as the pad as well as eos token
>>> model.config.eos_token_id = model.config.decoder.eos_token_id
>>> model.config.pad_token_id = model.config.eos_token_id

>>> # generation
>>> sequences = model.generate(pixel_values, num_beams=4, max_length=12).sequences

>>> captions = tokenizer_output.batch_decode(sequences, skip_special_tokens=True)

from_encoder_decoder_pretrained

<来源>

( encoder_pretrained_model_name_or_path: Union = None decoder_pretrained_model_name_or_path: Union = None *model_args **kwargs )

参数

• encoder_pretrained_model_name_or_path (Union[str, os.PathLike], 可选) — 初始化编码器所需的信息。可以是：

  • 一个字符串，托管在 huggingface.co 上的模型存储库中的预训练模型的模型 ID。一个示例是google/vit-base-patch16-224-in21k。

  • 一个包含使用 save_pretrained()保存的模型权重的目录路径，例如，./my_model_directory/。

• decoder_pretrained_model_name_or_path (Union[str, os.PathLike], 可选, 默认为None) — 初始化解码器所需的信息。可以是：

  • 一个字符串，预训练模型的模型 ID，托管在 huggingface.co 上的模型存储库中。有效的模型 ID 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下命名空间化，如dbmdz/bert-base-german-cased。

  • 一个包含使用 save_pretrained()保存的模型权重的目录路径，例如，./my_model_directory/。

• model_args（剩余的位置参数，可选） — 所有剩余的位置参数将传递给底层模型的__init__方法。

• kwargs（剩余的关键字参数字典，可选） — 可用于更新配置对象（在加载后）并初始化模型（例如，output_attentions=True）。

  • 要更新编码器配置，请为每个配置参数使用前缀encoder_。

  • 要更新解码器配置，请为每个配置参数使用前缀decoder_。

  • 更新父模型配置时，不要为每个配置参数使用前缀。

  根据是否提供config或自动加载而表现不同。

从预训练模型检查点实例化一个编码器和一个解码器，可以是库中一个或两个基类。

示例：

>>> from transformers import FlaxVisionEncoderDecoderModel

>>> # initialize a vit-gpt2 from a pretrained ViT and a pretrained GPT2 model. Note that the cross-attention layers will be randomly initialized
>>> model = FlaxVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google/vit-base-patch16-224-in21k", "gpt2"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./vit-gpt2")
>>> # load fine-tuned model
>>> model = FlaxVisionEncoderDecoderModel.from_pretrained("./vit-gpt2")

VisionTextDualEncoder

原文链接: huggingface.co/docs/transformers/v4.37.2/en/model_doc/vision-text-dual-encoder

概述

VisionTextDualEncoderModel 可以用于使用任何预训练的视觉自编码模型作为视觉编码器（如 ViT, BEiT, DeiT）和任何预训练的文本自编码模型作为文本编码器（如 RoBERTa, BERT）初始化视觉文本双编码器模型。在视觉和文本编码器的顶部添加了两个投影层，将输出嵌入投影到共享的潜在空间。投影层是随机初始化的，因此模型应该在下游任务上进行微调。该模型可用于使用类似 CLIP 的对比图像文本训练来对齐视觉文本嵌入，然后可用于零样本视觉任务，如图像分类或检索。

在 LiT: Zero-Shot Transfer with Locked-image Text Tuning 中展示了如何利用预训练的（锁定/冻结）图像和文本模型进行对比学习，从而在新的零样本视觉任务（如图像分类或检索）上取得显著改进。

VisionTextDualEncoderConfig

class transformers.VisionTextDualEncoderConfig

< source >

( projection_dim = 512 logit_scale_init_value = 2.6592 **kwargs )

参数

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

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

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

VisionTextDualEncoderConfig 是用于存储 VisionTextDualEncoderModel 配置的配置类。它用于根据指定的参数实例化 VisionTextDualEncoderModel 模型，定义文本模型和视觉模型配置。

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

示例:

>>> from transformers import ViTConfig, BertConfig, VisionTextDualEncoderConfig, VisionTextDualEncoderModel

>>> # Initializing a BERT and ViT configuration
>>> config_vision = ViTConfig()
>>> config_text = BertConfig()

>>> config = VisionTextDualEncoderConfig.from_vision_text_configs(config_vision, config_text, projection_dim=512)

>>> # Initializing a BERT and ViT model (with random weights)
>>> model = VisionTextDualEncoderModel(config=config)

>>> # Accessing the model configuration
>>> config_vision = model.config.vision_config
>>> config_text = model.config.text_config

>>> # Saving the model, including its configuration
>>> model.save_pretrained("vit-bert")

>>> # loading model and config from pretrained folder
>>> vision_text_config = VisionTextDualEncoderConfig.from_pretrained("vit-bert")
>>> model = VisionTextDualEncoderModel.from_pretrained("vit-bert", config=vision_text_config)

from_vision_text_configs

< source >

( vision_config: PretrainedConfig text_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';VisionTextDualEncoderConfig

返回

VisionTextDualEncoderConfig

配置对象的一个实例

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

VisionTextDualEncoderProcessor

class transformers.VisionTextDualEncoderProcessor

< source >

( image_processor = None tokenizer = None **kwargs )

参数

• image_processor (AutoImageProcessor, optional) — 图像处理器是必需的输入。

• tokenizer（PreTrainedTokenizer，可选）— 标记器是必需的输入。

构建一个 VisionTextDualEncoder 处理器，将图像处理器和标记器包装成一个单一处理器。

VisionTextDualEncoderProcessor 提供了 AutoImageProcessor 和 AutoTokenizer 的所有功能。有关更多信息，请参阅__call__()和 decode()。

batch_decode

<来源>

( *args **kwargs )

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

decode

<来源>

( *args **kwargs )

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

PytorchHide Pytorch 内容

VisionTextDualEncoderModel

class transformers.VisionTextDualEncoderModel

<来源>

( config: Optional = None vision_model: Optional = None text_model: Optional = None )

参数

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

此类可用于使用任何预训练的视觉自编码模型作为视觉编码器和任何预训练的文本模型作为文本编码器初始化视觉文本双编码器模型。视觉和文本编码器通过 from_pretrained()方法加载。投影层会自动添加到模型中，并应在下游任务（如对比图像文本建模）上进行微调。

在LiT: Zero-Shot Transfer with Locked-image Text Tuning中展示了如何利用预训练（锁定/冻结）图像和文本模型进行对比学习，对新的零样本视觉任务（如图像分类或检索）产生了显著的改进。

训练/微调了这样一个 Vision-Text-Dual-Encoder 模型之后，它可以像任何其他模型一样保存/加载（有关更多信息，请参阅示例）。

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

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

forward

< source >

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

参数

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

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

  什么是输入 ID？

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

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

  • 对于被masked的标记为 0。

  什么是注意力掩码？

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

  什么是位置 ID？

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。可以使用图像处理器获取像素值（例如，如果您使用 ViT 作为编码器，应该使用 AutoImageProcessor）。有关详细信息，请参见 ViTImageProcessor.call()。

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

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

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

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

返回

transformers.models.clip.modeling_clip.CLIPOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.clip.modeling_clip.CLIPOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含各种元素，这取决于配置（VisionTextDualEncoderConfig）和输入。

• loss (torch.FloatTensor of shape (1,), 可选, 当 return_loss 为 True 时返回) — 图像-文本相似性的对比损失。

• logits_per_image:(torch.FloatTensor of shape (image_batch_size, text_batch_size)) — image_embeds 和 text_embeds 之间的缩放点积分数。这代表了图像-文本相似性分数。

• logits_per_text:(torch.FloatTensor of shape (text_batch_size, image_batch_size)) — text_embeds 和 image_embeds 之间的缩放点积分数。这代表了文本-图像相似性分数。

• text_embeds(torch.FloatTensor of shape (batch_size, output_dim) — 通过将投影层应用于 CLIPTextModel 的汇总输出获得的文本嵌入。

• image_embeds(torch.FloatTensor of shape (batch_size, output_dim) — 通过将投影层应用于 CLIPVisionModel 的汇总输出获得的图像嵌入。

• text_model_output(BaseModelOutputWithPooling): CLIPTextModel 的输出。

• vision_model_output(BaseModelOutputWithPooling): CLIPVisionModel 的输出。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import (
...     VisionTextDualEncoderModel,
...     VisionTextDualEncoderProcessor,
...     AutoImageProcessor,
...     AutoTokenizer,
... )

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
>>> processor = VisionTextDualEncoderProcessor(image_processor, tokenizer)
>>> model = VisionTextDualEncoderModel.from_vision_text_pretrained(
...     "google/vit-base-patch16-224", "bert-base-uncased"
... )

>>> # contrastive training
>>> urls = [
...     "http://images.cocodataset.org/val2017/000000039769.jpg",
...     "https://farm3.staticflickr.com/2674/5850229113_4fe05d5265_z.jpg",
... ]
>>> images = [Image.open(requests.get(url, stream=True).raw) for url in urls]
>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], images=images, return_tensors="pt", padding=True
... )
>>> outputs = model(
...     input_ids=inputs.input_ids,
...     attention_mask=inputs.attention_mask,
...     pixel_values=inputs.pixel_values,
...     return_loss=True,
... )
>>> loss, logits_per_image = outputs.loss, outputs.logits_per_image  # this is the image-text similarity score

>>> # save and load from pretrained
>>> model.save_pretrained("vit-bert")
>>> model = VisionTextDualEncoderModel.from_pretrained("vit-bert")

>>> # inference
>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = logits_per_image.softmax(dim=1)  # we can take the softmax to get the label probabilities

TensorFlowHide TensorFlow content

FlaxVisionTextDualEncoderModel

class transformers.FlaxVisionTextDualEncoderModel

< source >

( config: VisionTextDualEncoderConfig input_shape: Optional = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

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

• dtype (jax.numpy.dtype, 可选，默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。

  这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了dtype，则所有计算将使用给定的dtype执行。

  请注意，这仅指定计算的数据类型，不影响模型参数的数据类型。

  如果要更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

此类可用于使用任何预训练视觉自编码模型作为视觉编码器和任何预训练文本模型作为文本编码器初始化视觉文本双编码器模型。视觉和文本编码器通过 from_pretrained()方法加载。投影层会自动添加到模型中，并应在下游任务（如对比图像文本建模）上进行微调。

在LiT: Zero-Shot Transfer with Locked-image Text Tuning中，展示了如何利用预训练（锁定/冻结）图像和文本模型进行对比学习，从而在新的零样本视觉任务（如图像分类或检索）上取得显著改进。

训练/微调了这样一个视觉文本双编码器模型后，它可以像其他模型一样保存/加载（有关更多信息，请参阅示例）。

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

此模型还是一个flax.linen.Module子类。将其用作常规的 Flax 亚麻模块，并参考 Flax 文档以获取与一般用法和行为相关的所有内容。

最后，此模型支持内在的 JAX 特性，例如：

• 即时（JIT）编译

• 自动微分

• 向量化

• 并行化

__call__

<来源>

( input_ids pixel_values attention_mask = None position_ids = None token_type_ids = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.clip.modeling_flax_clip.FlaxCLIPOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

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

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

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

  什么是注意力掩码？

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

  什么是位置 ID？

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。默认情况下将忽略填充。可以使用图像处理器获取像素值（例如，如果您使用 ViT 作为编码器，则应使用 AutoImageProcessor）。有关详细信息，请参阅 ViTImageProcessor.call()。

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

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

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

返回

transformers.models.clip.modeling_flax_clip.FlaxCLIPOutput或tuple(torch.FloatTensor)

一个transformers.models.clip.modeling_flax_clip.FlaxCLIPOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（VisionTextDualEncoderConfig）和输入的各种元素。

• logits_per_image:(jnp.ndarray of shape (image_batch_size, text_batch_size)) — image_embeds和text_embeds之间的缩放点积分数。这代表图像-文本相似性分数。

• logits_per_text:(jnp.ndarray of shape (text_batch_size, image_batch_size)) — text_embeds和image_embeds之间的缩放点积分数。这代表文本-图像相似性分数。

• text_embeds(jnp.ndarray of shape (batch_size, output_dim) — 通过将 FlaxCLIPTextModel 的池化输出应用于投影层获得的文本嵌入。

• image_embeds(jnp.ndarray of shape (batch_size, output_dim) — 通过将 FlaxCLIPVisionModel 的池化输出应用于投影层获得的图像嵌入。

• text_model_output(FlaxBaseModelOutputWithPooling): FlaxCLIPTextModel 的输出。

• vision_model_output(FlaxBaseModelOutputWithPooling): FlaxCLIPVisionModel 的输出。

FlaxVisionTextDualEncoderModel 的前向方法重写了__call__特殊方法。

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

示例：

>>> from PIL import Image
>>> import requests
>>> import jax
>>> from transformers import (
...     FlaxVisionTextDualEncoderModel,
...     VisionTextDualEncoderProcessor,
...     AutoImageProcessor,
...     AutoTokenizer,
... )

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> image_processor = AutoImageProcesor.from_pretrained("google/vit-base-patch16-224")
>>> processor = VisionTextDualEncoderProcessor(image_processor, tokenizer)
>>> model = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
...     "google/vit-base-patch16-224", "bert-base-uncased"
... )

>>> # contrastive training
>>> urls = [
...     "http://images.cocodataset.org/val2017/000000039769.jpg",
...     "https://farm3.staticflickr.com/2674/5850229113_4fe05d5265_z.jpg",
... ]
>>> images = [Image.open(requests.get(url, stream=True).raw) for url in urls]
>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], images=images, return_tensors="np", padding=True
... )
>>> outputs = model(
...     input_ids=inputs.input_ids,
...     attention_mask=inputs.attention_mask,
...     pixel_values=inputs.pixel_values,
... )
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score

>>> # save and load from pretrained
>>> model.save_pretrained("vit-bert")
>>> model = FlaxVisionTextDualEncoderModel.from_pretrained("vit-bert")

>>> # inference
>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = jax.nn.softmax(logits_per_image, axis=1)  # we can take the softmax to get the label probabilities

JAXHide JAX content

TFVisionTextDualEncoderModel

class transformers.TFVisionTextDualEncoderModel

< source >

( config: Optional[VisionTextDualEncoderConfig] = None vision_model: Optional[TFPreTrainedModel] = None text_model: Optional[TFPreTrainedModel] = None )

参数

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

此类可用于使用任何预训练的视觉自编码模型作为视觉编码器和任何预训练的文本模型作为文本编码器初始化视觉文本双编码器模型。视觉和文本编码器通过 from_pretrained()方法加载。投影层会自动添加到模型中，并应在下游任务（如对比图像-文本建模）上进行微调。

在LiT: Zero-Shot Transfer with Locked-image Text Tuning中展示了如何利用预训练（锁定/冻结）的图像和文本模型进行对比学习，从而在新的零样本视觉任务（如图像分类或检索）上取得显著改进。

经过训练/微调的 Vision-Text-Dual-Encoder 模型可以像其他模型一样保存/加载（有关更多信息，请参见示例）。

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

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

call

<来源>

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

参数

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

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

  什么是输入 ID？

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

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

  • 对于被masked的标记为 0。

  什么是注意力掩码？

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

  什么是位置 ID？

• pixel_values (tf.Tensor of shape (batch_size, num_channels, height, width)) — 像素值。默认情况下，如果提供了填充，将被忽略。可以使用图像处理器获取像素值（例如，如果您使用 ViT 作为编码器，应该使用 AutoImageProcessor）。有关详细信息，请参阅 ViTImageProcessor.call()。

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

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

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

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

返回

transformers.models.clip.modeling_tf_clip.TFCLIPOutput或tuple(tf.Tensor)

一个transformers.models.clip.modeling_tf_clip.TFCLIPOutput或一组tf.Tensor（如果传递了return_dict=False或当config.return_dict=False时）包括根据配置（VisionTextDualEncoderConfig）和输入的各种元素。

• loss (tf.Tensor of shape (1,), 可选, 当return_loss为True时返回) — 图像-文本相似性的对比损失。

• logits_per_image:(tf.Tensor of shape (image_batch_size, text_batch_size)) — image_embeds和text_embeds之间的缩放点积分数。这代表图像-文本相似性分数。

• logits_per_text:(tf.Tensor of shape (text_batch_size, image_batch_size)) — text_embeds和image_embeds之间的缩放点积分数。这代表文本-图像相似性分数。

• text_embeds(tf.Tensor of shape (batch_size, output_dim) — 通过将投影层应用于 TFCLIPTextModel 的汇总输出获得的文本嵌入。

• image_embeds(tf.Tensor of shape (batch_size, output_dim) — 通过将投影层应用于 TFCLIPVisionModel 的汇总输出获得的图像嵌入。

• text_model_output(~modeling_tf_utils.TFBaseModelOutputWithPooling): TFCLIPTextModel 的输出。

• vision_model_output(~modeling_tf_utils.TFBaseModelOutputWithPooling): TFCLIPVisionModel 的输出。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import (
...     TFVisionTextDualEncoderModel,
...     VisionTextDualEncoderProcessor,
...     AutoImageProcessor,
...     AutoTokenizer,
... )

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
>>> processor = VisionTextDualEncoderProcessor(image_processor, tokenizer)
>>> model = TFVisionTextDualEncoderModel.from_vision_text_pretrained(
...     "google/vit-base-patch16-224", "bert-base-uncased"
... )

>>> # contrastive training
>>> urls = [
...     "http://images.cocodataset.org/val2017/000000039769.jpg",
...     "https://farm3.staticflickr.com/2674/5850229113_4fe05d5265_z.jpg",
... ]
>>> images = [Image.open(requests.get(url, stream=True).raw) for url in urls]
>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], images=images, return_tensors="np", padding=True
... )
>>> outputs = model(
...     input_ids=inputs.input_ids,
...     attention_mask=inputs.attention_mask,
...     pixel_values=inputs.pixel_values,
...     return_loss=True,
... )
>>> loss, logits_per_image = outputs.loss, outputs.logits_per_image  # this is the image-text similarity score

>>> # save and load from pretrained
>>> model.save_pretrained("vit-bert")
>>> model = TFVisionTextDualEncoderModel.from_pretrained("vit-bert")

>>> # inference
>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = tf.nn.softmax(logits_per_image, axis=1)  # we can take the softmax to get the label probabilities

VisualBERT

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

概述

VisualBERT 模型是由 Liunian Harold Li、Mark Yatskar、Da Yin、Cho-Jui Hsieh、Kai-Wei Chang 在VisualBERT: A Simple and Performant Baseline for Vision and Language中提出的。VisualBERT 是一个在各种（图像，文本）对上训练的神经网络。

论文摘要如下：

我们提出了 VisualBERT，一个简单灵活的框架，用于建模广泛的视觉和语言任务。VisualBERT 由一堆 Transformer 层组成，通过自注意力隐式对齐输入文本的元素和相关输入图像中的区域。我们进一步提出了两个基于视觉的语言模型目标，用于在图像标题数据上预训练 VisualBERT。对包括 VQA、VCR、NLVR2 和 Flickr30K 在内的四个视觉和语言任务的实验表明，VisualBERT 在简化的同时优于或与最先进的模型相媲美。进一步的分析表明，VisualBERT 可以将语言元素与图像区域联系起来，而无需任何明确的监督，并且甚至对句法关系敏感，例如跟踪动词和与其参数对应的图像区域之间的关联。

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

使用提示

1. 提供的大多数检查点适用于 VisualBertForPreTraining 配置。提供的其他检查点是用于下游任务微调的检查点 - VQA（'visualbert-vqa'）、VCR（'visualbert-vcr'）、NLVR2（'visualbert-nlvr2'）。因此，如果您不是在进行这些下游任务，建议使用预训练检查点。

2. 对于 VCR 任务，作者使用了一个经过微调的检测器来生成视觉嵌入，对于所有的检查点。我们不会将检测器及其权重作为软件包的一部分提供，但它将在研究项目中提供，并且状态可以直接加载到提供的检测器中。

VisualBERT 是一个多模态视觉和语言模型。它可用于视觉问答、多项选择、视觉推理和区域到短语对应任务。VisualBERT 使用类似 BERT 的变压器来为图像-文本对准备嵌入。然后将文本和视觉特征投影到具有相同维度的潜在空间中。

要将图像馈送到模型中，必须通过预训练的对象检测器传递每个图像，并提取区域和边界框。作者使用通过将这些区域通过预训练的 CNN（如 ResNet）传递后生成的特征作为视觉嵌入。他们还添加了绝对位置嵌入，并将生成的向量序列馈送到标准的 BERT 模型中。文本输入在嵌入层的前面与视觉嵌入连接，并且预期由[CLS]和[SEP]标记限定，就像 BERT 一样。段 ID 也必须适当设置为文本和视觉部分。

使用 BertTokenizer 对文本进行编码。必须使用自定义检测器/图像处理器来获取视觉嵌入。以下示例笔记本展示了如何使用类似 Detectron 的模型与 VisualBERT 一起使用：

• VisualBERT VQA 演示笔记本：此笔记本包含 VisualBERT VQA 的示例。

• 为 VisualBERT 生成嵌入（Colab 笔记本）：此笔记本包含如何生成视觉嵌入的示例。

以下示例显示如何使用 VisualBertModel 获取最后一个隐藏状态：

>>> import torch
>>> from transformers import BertTokenizer, VisualBertModel

>>> model = VisualBertModel.from_pretrained("uclanlp/visualbert-vqa-coco-pre")
>>> tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")

>>> inputs = tokenizer("What is the man eating?", return_tensors="pt")
>>> # this is a custom function that returns the visual embeddings given the image path
>>> visual_embeds = get_visual_embeddings(image_path)

>>> visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
>>> visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)
>>> inputs.update(
...     {
...         "visual_embeds": visual_embeds,
...         "visual_token_type_ids": visual_token_type_ids,
...         "visual_attention_mask": visual_attention_mask,
...     }
... )
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state

VisualBertConfig

class transformers.VisualBertConfig

< source >

( vocab_size = 30522 hidden_size = 768 visual_embedding_dim = 512 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 bypass_transformer = False special_visual_initialize = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

• vocab_size (int, optional, defaults to 30522) — VisualBERT 模型的词汇表大小。定义了在调用 VisualBertModel 时可以由 inputs_ids 表示的不同标记数量。模型的词汇表大小。定义了可以由传递给 VisualBertModel 的 forward 方法的 inputs_ids 表示的不同标记数量。

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

• visual_embedding_dim (int, optional, defaults to 512) — 要传递给模型的视觉嵌入的维度。

• 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.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

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

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

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

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

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

• bypass_transformer (bool, optional, defaults to False) — 模型是否应绕过 Transformer 处理视觉嵌入。如果设置为 True，模型直接将来自 VisualBertEmbeddings 的视觉嵌入与来自 transformers 的文本输出连接起来，然后传递给自注意力层。

• special_visual_initialize (bool, optional, defaults to True) — 视觉标记类型和位置类型嵌入权重是否应该与文本标记类型和正向类型嵌入相同初始化。当设置为 True 时，文本标记类型和位置类型嵌入的权重将复制到相应的视觉嵌入层。

这是用于存储 VisualBertModel 配置的配置类。根据指定的参数实例化 VisualBERT 模型，定义模型架构。使用默认值实例化配置将产生类似于 VisualBERT uclanlp/visualbert-vqa-coco-pre 架构的配置。

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

示例：

>>> from transformers import VisualBertConfig, VisualBertModel

>>> # Initializing a VisualBERT visualbert-vqa-coco-pre style configuration
>>> configuration = VisualBertConfig.from_pretrained("uclanlp/visualbert-vqa-coco-pre")

>>> # Initializing a model (with random weights) from the visualbert-vqa-coco-pre style configuration
>>> model = VisualBertModel(configuration)

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

VisualBertModel

class transformers.VisualBertModel

<来源>

( config add_pooling_layer = True )

参数

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

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

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

该模型可以作为一个编码器（仅具有自注意力），遵循Ashish Vaswani，Noam Shazeer，Niki Parmar，Jakob Uszkoreit，Llion Jones，Aidan N. Gomez，Lukasz Kaiser 和 Illia Polosukhin 描述的架构。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None visual_embeds: Optional = None visual_attention_mask: Optional = None visual_token_type_ids: Optional = None image_text_alignment: 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（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

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

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

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

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未被“掩盖”，

  • 0 表示头部被“掩盖”。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• visual_embeds（形状为(batch_size, visual_seq_length, visual_embedding_dim)的torch.FloatTensor，可选）— 视觉输入的嵌入表示，通常使用对象检测器派生。

• visual_attention_mask（形状为(batch_size, visual_seq_length)的torch.FloatTensor，可选）— 用于避免在视觉嵌入上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 1 表示未被masked的令牌，

  • 0 表示被masked的令牌。

  注意力掩码是什么？

• VisualBERT 的作者将visual_token_type_ids设置为所有令牌的1。

  令牌类型 ID 是什么？

• image_text_alignment（形状为(batch_size, visual_seq_length, alignment_number)的torch.LongTensor，可选）— 用于决定视觉嵌入的位置 ID 的图像-文本对齐。

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

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

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

返回

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

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

• visual_token_type_ids（形状为(batch_size, visual_seq_length)的torch.LongTensor，可选）— 段令牌索引，用于指示视觉嵌入的不同部分。

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

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

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

示例：

# Assumption: *get_visual_embeddings(image)* gets the visual embeddings of the image.
from transformers import AutoTokenizer, VisualBertModel
import torch

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = VisualBertModel.from_pretrained("uclanlp/visualbert-vqa-coco-pre")

inputs = tokenizer("The capital of France is Paris.", return_tensors="pt")
visual_embeds = get_visual_embeddings(image).unsqueeze(0)
visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)

inputs.update(
    {
        "visual_embeds": visual_embeds,
        "visual_token_type_ids": visual_token_type_ids,
        "visual_attention_mask": visual_attention_mask,
    }
)

outputs = model(**inputs)

last_hidden_states = outputs.last_hidden_state

VisualBertForPreTraining

class transformers.VisualBertForPreTraining

<来源>

( config )

参数

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

VisualBert 模型在预训练期间在顶部有两个头部：一个掩码语言建模头部和一个句子-图像预测（分类）头部。

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None visual_embeds: Optional = None visual_attention_mask: Optional = None visual_token_type_ids: Optional = None image_text_alignment: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None sentence_image_labels: Optional = None ) → export const metadata = 'undefined';transformers.models.visual_bert.modeling_visual_bert.VisualBertForPreTrainingOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 1 表示未屏蔽的标记，

  • 0 表示已屏蔽的标记。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于一个句子 A标记，

  • 1 对应于一个句子 B标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部是未屏蔽，

  • 0 表示头部是已屏蔽。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递一个嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• visual_embeds（形状为(batch_size, visual_seq_length, visual_embedding_dim)的torch.FloatTensor，可选）— 视觉输入的嵌入表示，通常使用对象检测器派生。

• visual_attention_mask（形状为(batch_size, visual_seq_length)的torch.FloatTensor，可选）— 用于避免在视觉嵌入上执行注意力的掩码。选择的掩码值在[0, 1]中：

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

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• visual_token_type_ids（形状为(batch_size, visual_seq_length)的torch.LongTensor，可选）— 段标记索引，用于指示视觉嵌入的不同部分。

  什么是标记类型 ID？ VisualBERT 的作者将visual_token_type_ids设置为1以表示所有标记。

• image_text_alignment（形状为(batch_size, visual_seq_length, alignment_number)的torch.LongTensor，可选）— 用于决定视觉嵌入的位置 ID 的图像-文本对齐。

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

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

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

• labels（形状为(batch_size, total_sequence_length)的torch.LongTensor，可选）— 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]中（请参见input_ids文档字符串）。将索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

• sentence_image_labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算句子-图像预测（分类）损失的标签。输入应为一个序列对（请参见input_ids文档字符串）索引应在[0, 1]中。

  • 0 表示对于给定图像，序列 B 是序列 A 的匹配对，

  • 1 表示对于给定图像，序列 B 是相对于 A 的随机序列。

返回

transformers.models.visual_bert.modeling_visual_bert.VisualBertForPreTrainingOutput或tuple(torch.FloatTensor)

一个transformers.models.visual_bert.modeling_visual_bert.VisualBertForPreTrainingOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），包含根据配置（VisualBertConfig）和输入的不同元素。

• loss（可选，当提供labels时返回，形状为(1,)的torch.FloatTensor）— 作为掩码语言建模损失和句子-图像预测（分类）损失之和的总损失。

• prediction_logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• seq_relationship_logits（形状为(batch_size, 2)的torch.FloatTensor）— 句子-图像预测（分类）头的预测分数（SoftMax 之前的 True/False 连续分数）。

• 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 后的注意力权重。

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

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

示例：

# Assumption: *get_visual_embeddings(image)* gets the visual embeddings of the image in the batch.
from transformers import AutoTokenizer, VisualBertForPreTraining

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = VisualBertForPreTraining.from_pretrained("uclanlp/visualbert-vqa-coco-pre")

inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")
visual_embeds = get_visual_embeddings(image).unsqueeze(0)
visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)

inputs.update(
    {
        "visual_embeds": visual_embeds,
        "visual_token_type_ids": visual_token_type_ids,
        "visual_attention_mask": visual_attention_mask,
    }
)
max_length = inputs["input_ids"].shape[-1] + visual_embeds.shape[-2]
labels = tokenizer(
    "The capital of France is Paris.", return_tensors="pt", padding="max_length", max_length=max_length
)["input_ids"]
sentence_image_labels = torch.tensor(1).unsqueeze(0)  # Batch_size

outputs = model(**inputs, labels=labels, sentence_image_labels=sentence_image_labels)
loss = outputs.loss
prediction_logits = outputs.prediction_logits
seq_relationship_logits = outputs.seq_relationship_logits

VisualBertForQuestionAnswering

class transformers.VisualBertForQuestionAnswering

<来源>

( config )

参数

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

VisualBert 模型在顶部具有分类/回归头（在汇总输出的顶部有一个 dropout 和一个线性层）用于 VQA。

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None visual_embeds: Optional = None visual_attention_mask: Optional = None visual_token_type_ids: Optional = None image_text_alignment: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

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

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

  • 0 代表被掩码的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• visual_embeds (torch.FloatTensor，形状为(batch_size, visual_seq_length, visual_embedding_dim)，可选) — 视觉输入的嵌入表示，通常使用对象检测器派生。

• visual_attention_mask (torch.FloatTensor，形状为(batch_size, visual_seq_length)，可选) — 避免对视觉嵌入执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 1 表示未被masked的令牌，

  • 0 表示被masked的令牌。

  什么是注意力掩码？

• visual_token_type_ids (torch.LongTensor，形状为(batch_size, visual_seq_length)，可选) — 段令牌索引，用于指示视觉嵌入的不同部分。

  什么是令牌类型 ID？ VisualBERT 的作者将visual_token_type_ids设置为所有令牌的1。

• image_text_alignment (torch.LongTensor，形状为(batch_size, visual_seq_length, alignment_number)，可选) — 用于决定视觉嵌入的位置 ID 的图像-文本对齐。

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

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

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

• labels (torch.LongTensor，形状为(batch_size, total_sequence_length)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。标签和返回的 logits 之间计算 KLDivLoss。

返回值

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

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

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

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

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

示例：

# Assumption: *get_visual_embeddings(image)* gets the visual embeddings of the image in the batch.
from transformers import AutoTokenizer, VisualBertForQuestionAnswering
import torch

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = VisualBertForQuestionAnswering.from_pretrained("uclanlp/visualbert-vqa")

text = "Who is eating the apple?"
inputs = tokenizer(text, return_tensors="pt")
visual_embeds = get_visual_embeddings(image).unsqueeze(0)
visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)

inputs.update(
    {
        "visual_embeds": visual_embeds,
        "visual_token_type_ids": visual_token_type_ids,
        "visual_attention_mask": visual_attention_mask,
    }
)

labels = torch.tensor([[0.0, 1.0]]).unsqueeze(0)  # Batch size 1, Num labels 2

outputs = model(**inputs, labels=labels)
loss = outputs.loss
scores = outputs.logits

VisualBertForMultipleChoice

class transformers.VisualBertForMultipleChoice

<来源>

( config )

参数

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

VisualBert 模型在顶部具有多选分类头（池化输出顶部的线性层和 softmax），例如用于 VCR 任务。

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None visual_embeds: Optional = None visual_attention_mask: Optional = None visual_token_type_ids: Optional = None image_text_alignment: 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.MultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, num_choices, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

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

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

  • 0 表示被掩码的标记。

  什么是注意力蒙版？

• token_type_ids（torch.LongTensor，形状为(batch_size, num_choices, sequence_length)，可选）— 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A标记，

  • 1 对应一个句子 B的标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]范围内：

  • 1 表示头部未被屏蔽，

  • 0 表示头部被屏蔽。

• inputs_embeds（形状为(batch_size, num_choices, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• visual_embeds（形状为(batch_size, visual_seq_length, visual_embedding_dim)的torch.FloatTensor，可选）— 视觉输入的嵌入表示，通常使用对象检测器派生。

• visual_attention_mask（形状为(batch_size, visual_seq_length)的torch.FloatTensor，可选）— 用于避免在视觉嵌入上执行注意力的掩码。掩码值选择在[0, 1]范围内：

  • 1 用于那些未被屏蔽的标记，

  • 0 用于被屏蔽的标记。

  什么是注意力屏蔽？

• visual_token_type_ids（形状为(batch_size, visual_seq_length)的torch.LongTensor，可选）— 段标记索引，用于指示视觉嵌入的不同部分。

  什么是标记类型 ID？ VisualBERT 的作者将visual_token_type_ids设置为1，适用于所有标记。

• image_text_alignment（形状为(batch_size, visual_seq_length, alignment_number)的torch.LongTensor，可选）— 图像文本对齐用于决定视觉嵌入的位置 ID。

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

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

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

• 标签（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算多选分类损失的标签。索引应在[0, ..., num_choices-1]范围内，其中num_choices是输入张量第二维的大小。（参见上面的input_ids）

返回

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

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

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

• logits（形状为(batch_size, num_choices)的torch.FloatTensor）— num_choices是输入张量的第二维。（参见上面的input_ids）。

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

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

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

示例：

# Assumption: *get_visual_embeddings(image)* gets the visual embeddings of the image in the batch.
from transformers import AutoTokenizer, VisualBertForMultipleChoice
import torch

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = VisualBertForMultipleChoice.from_pretrained("uclanlp/visualbert-vcr")

prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
choice0 = "It is eaten with a fork and a knife."
choice1 = "It is eaten while held in the hand."

visual_embeds = get_visual_embeddings(image)
# (batch_size, num_choices, visual_seq_length, visual_embedding_dim)
visual_embeds = visual_embeds.expand(1, 2, *visual_embeds.shape)
visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)

labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

encoding = tokenizer([[prompt, prompt], [choice0, choice1]], return_tensors="pt", padding=True)
# batch size is 1
inputs_dict = {k: v.unsqueeze(0) for k, v in encoding.items()}
inputs_dict.update(
    {
        "visual_embeds": visual_embeds,
        "visual_attention_mask": visual_attention_mask,
        "visual_token_type_ids": visual_token_type_ids,
        "labels": labels,
    }
)
outputs = model(**inputs_dict)

loss = outputs.loss
logits = outputs.logits

VisualBertForVisualReasoning

class transformers.VisualBertForVisualReasoning

<来源>

( config )

参数

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

VisualBert 模型在顶部具有一个序列分类头（在池化输出的顶部有一个 dropout 和一个线性层），用于视觉推理，例如用于 NLVR 任务。

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None visual_embeds: Optional = None visual_attention_mask: Optional = None visual_token_type_ids: Optional = None image_text_alignment: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为(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？

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

  什么是位置 ID？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值：

  • 1 表示头部未被遮罩，

  • 0 表示头部被遮罩。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• visual_embeds（形状为(batch_size, visual_seq_length, visual_embedding_dim)的torch.FloatTensor，可选）— 视觉输入的嵌入表示，通常使用对象检测器派生。

• visual_attention_mask（形状为(batch_size, visual_seq_length)的torch.FloatTensor，可选）— 用于避免对视觉嵌入执行注意力的掩码。在[0, 1]中选择的掩码值：

  • 1 表示未被遮罩的标记，

  • 0 表示被遮罩的标记。

  什么是注意力掩码？

• visual_token_type_ids（形状为(batch_size, visual_seq_length)的torch.LongTensor，可选）— 段标记索引，用于指示视觉嵌入的不同部分。

  什么是标记类型 ID？ VisualBERT 的作者将visual_token_type_ids设置为1以表示所有标记。

• image_text_alignment（形状为(batch_size, visual_seq_length, alignment_number)的torch.LongTensor，可选）— 用于决定视觉嵌入的位置 ID 的图像-文本对齐。

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

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

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

• labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。根据这些标签计算分类损失（交叉熵）。

返回

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

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

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

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

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

示例：

# Assumption: *get_visual_embeddings(image)* gets the visual embeddings of the image in the batch.
from transformers import AutoTokenizer, VisualBertForVisualReasoning
import torch

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = VisualBertForVisualReasoning.from_pretrained("uclanlp/visualbert-nlvr2")

text = "Who is eating the apple?"
inputs = tokenizer(text, return_tensors="pt")
visual_embeds = get_visual_embeddings(image).unsqueeze(0)
visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)

inputs.update(
    {
        "visual_embeds": visual_embeds,
        "visual_token_type_ids": visual_token_type_ids,
        "visual_attention_mask": visual_attention_mask,
    }
)

labels = torch.tensor(1).unsqueeze(0)  # Batch size 1, Num choices 2

outputs = model(**inputs, labels=labels)
loss = outputs.loss
scores = outputs.logits

VisualBertForRegionToPhraseAlignment

class transformers.VisualBertForRegionToPhraseAlignment

<来源>

( config )

参数

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

VisualBert 模型具有一个用于区域到短语对齐的遮蔽语言建模头部和一个位于顶部的注意力层，例如用于 Flickr30 实体任务。

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None visual_embeds: Optional = None visual_attention_mask: Optional = None visual_token_type_ids: Optional = None image_text_alignment: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None region_to_phrase_position: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput 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.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

  • 1 表示未被masked的标记，

  • 对于被masked的标记为 0。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 指示输入的第一部分和第二部分的段标记索引。索引选在[0, 1]之间：

  • 0 对应于句子 A标记，

  • 1 对应于一个 sentence B 标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在 [0, 1] 之间：

  • 1 表示头部是 not masked 的，

  • 0 表示头部是 masked。

• inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，可以直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• visual_embeds (torch.FloatTensor，形状为 (batch_size, visual_seq_length, visual_embedding_dim)，可选) — 视觉输入的嵌入表示，通常使用对象检测器生成。

• visual_attention_mask (torch.FloatTensor，形状为 (batch_size, visual_seq_length)，可选) — 用于避免在视觉嵌入上执行注意力的掩码。掩码值选择在 [0, 1] 之间：

  • 1 表示未被 masked 的标记，

  • 0 表示头部是 masked 的标记。

  什么是注意力掩码？

• visual_token_type_ids (torch.LongTensor，形状为 (batch_size, visual_seq_length)，可选) — 段标记索引，用于指示视觉嵌入的不同部分。

  什么是标记类型 ID？ VisualBERT 的作者将 visual_token_type_ids 设置为 1 以表示所有标记。

• image_text_alignment (torch.LongTensor，形状为 (batch_size, visual_seq_length, alignment_number)，可选) — 图像-文本对齐用于决定视觉嵌入的位置 ID。

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

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

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

• region_to_phrase_position (torch.LongTensor，形状为 (batch_size, total_sequence_length)，可选) — 描述图像嵌入位置与文本标记位置对应的位置。

• labels (torch.LongTensor，形状为 (batch_size, total_sequence_length, visual_sequence_length)，可选) — 用于计算掩码语言建模损失的标签。KLDivLoss 是根据这些标签和注意力层的输出计算的。

返回

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

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

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

VisualBertForRegionToPhraseAlignment 的前向方法重写了__call__特殊方法。

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

示例：

# Assumption: *get_visual_embeddings(image)* gets the visual embeddings of the image in the batch.
from transformers import AutoTokenizer, VisualBertForRegionToPhraseAlignment
import torch

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = VisualBertForRegionToPhraseAlignment.from_pretrained("uclanlp/visualbert-vqa-coco-pre")

text = "Who is eating the apple?"
inputs = tokenizer(text, return_tensors="pt")
visual_embeds = get_visual_embeddings(image).unsqueeze(0)
visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)
region_to_phrase_position = torch.ones((1, inputs["input_ids"].shape[-1] + visual_embeds.shape[-2]))

inputs.update(
    {
        "region_to_phrase_position": region_to_phrase_position,
        "visual_embeds": visual_embeds,
        "visual_token_type_ids": visual_token_type_ids,
        "visual_attention_mask": visual_attention_mask,
    }
)

labels = torch.ones(
    (1, inputs["input_ids"].shape[-1] + visual_embeds.shape[-2], visual_embeds.shape[-2])
)  # Batch size 1

outputs = model(**inputs, labels=labels)
loss = outputs.loss
scores = outputs.logits

X-CLIP

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

概述

X-CLIP 模型是由 Bolin Ni、Houwen Peng、Minghao Chen、Songyang Zhang、Gaofeng Meng、Jianlong Fu、Shiming Xiang、Haibin Ling 在扩展语言-图像预训练模型以用于通用视频识别中提出的。X-CLIP 是对视频的 CLIP 的最小扩展。该模型包括文本编码器、跨帧视觉编码器、多帧集成 Transformer 和视频特定提示生成器。

论文摘要如下：

对比语言-图像预训练在从网络规模数据中学习视觉-文本联合表示方面取得了巨大成功，展示了在各种图像任务中出色的“零样本”泛化能力。然而，如何有效地将这种新的语言-图像预训练方法扩展到视频领域仍然是一个悬而未决的问题。在这项工作中，我们提出了一种简单而有效的方法，将预训练的语言-图像模型直接适应于视频识别，而不是从头开始预训练一个新模型。更具体地说，为了捕捉沿时间维度的帧之间的长距离依赖关系，我们提出了一个跨帧注意机制，明确地在帧之间交换信息。这种模块轻量级且可以无缝地插入预训练的语言-图像模型中。此外，我们提出了一个视频特定的提示方案，利用视频内容信息生成具有区分性的文本提示。大量实验证明我们的方法是有效的，并且可以推广到不同的视频识别场景。特别是，在完全监督的设置下，我们的方法在 Kinectics-400 上实现了 87.1%的 top-1 准确率，与 Swin-L 和 ViViT-H 相比，FLOPs 减少了 12 倍。在零样本实验中，我们的方法在两种流行协议下的 top-1 准确率方面超过了当前最先进的方法+7.6%和+14.9%。在少样本场景下，我们的方法在标记数据极为有限时，比以前最佳方法提高了+32.1%和+23.1%。

提示：

• X-CLIP 的使用与 CLIP 相同。

X-CLIP 架构。摘自原始论文。

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

资源

以下是官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 X-CLIP。

• X-CLIP 的演示笔记本可以在这里找到。

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

XCLIP 处理器

class transformers.XCLIPProcessor

<来源>

( image_processor = None tokenizer = None **kwargs )

参数

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

• tokenizer（CLIPTokenizerFast，可选）— Tokenizer 是必需的输入。

构建一个 X-CLIP 处理器，将 VideoMAE 图像处理器和 CLIP tokenizer 包装成一个单一处理器。

XCLIPProcessor 提供了 VideoMAEImageProcessor 和 CLIPTokenizerFast 的所有功能。查看 __call__() 和 decode() 获取更多信息。

batch_decode

< source >

( *args **kwargs )

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

decode

< source >

( *args **kwargs )

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

XCLIPConfig

class transformers.XCLIPConfig

< source >

( text_config = None vision_config = None projection_dim = 512 prompt_layers = 2 prompt_alpha = 0.1 prompt_hidden_act = 'quick_gelu' prompt_num_attention_heads = 8 prompt_attention_dropout = 0.0 prompt_projection_dropout = 0.0 logit_scale_init_value = 2.6592 **kwargs )

参数

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

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

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

• prompt_layers (int, optional, 默认为 2) — 视频特定提示生成器中的层数。

• prompt_alpha (float, optional, 默认为 0.1) — 视频特定提示生成器中使用的 Alpha 值。

• prompt_hidden_act (str 或 function, optional, 默认为 "quick_gelu") — 视频特定提示生成器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "selu" 和 "gelu_new" 以及 "quick_gelu"。

• prompt_num_attention_heads (int, optional, 默认为 8) — 视频特定提示生成器中交叉注意力的注意力头数。

• prompt_attention_dropout (float, optional, 默认为 0.0) — 视频特定提示生成器中注意力层的丢弃概率。

• prompt_projection_dropout (float, optional, 默认为 0.0) — 视频特定提示生成器中投影层的丢弃概率。

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

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

XCLIPConfig 是用来存储 XCLIPModel 配置的配置类。它用于根据指定的参数实例化 X-CLIP 模型，定义文本模型和视觉模型的配置。使用默认值实例化配置将产生类似于 X-CLIP microsoft/xclip-base-patch32 架构的配置。

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

from_text_vision_configs

<来源>

( text_config: XCLIPTextConfig vision_config: XCLIPVisionConfig **kwargs ) → export const metadata = 'undefined';XCLIPConfig

返回

XCLIPConfig

配置对象的一个实例

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

XCLIPTextConfig

class transformers.XCLIPTextConfig

<来源>

( vocab_size = 49408 hidden_size = 512 intermediate_size = 2048 num_hidden_layers = 12 num_attention_heads = 8 max_position_embeddings = 77 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

• vocab_size (int, optional, defaults to 49408) — X-CLIP 文本模型的词汇表大小。定义了在调用 XCLIPModel 时可以表示的不同标记数量。

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

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

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

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

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

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

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

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

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

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

这是一个配置类，用于存储 XCLIPModel 的配置。根据指定的参数实例化一个 X-CLIP 模型，定义模型架构。使用默认值实例化配置将产生类似于 X-CLIP microsoft/xclip-base-patch32架构的配置。

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

示例：

>>> from transformers import XCLIPTextModel, XCLIPTextConfig

>>> # Initializing a XCLIPTextModel with microsoft/xclip-base-patch32 style configuration
>>> configuration = XCLIPTextConfig()

>>> # Initializing a XCLIPTextConfig from the microsoft/xclip-base-patch32 style configuration
>>> model = XCLIPTextModel(configuration)

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

XCLIPVisionConfig

class transformers.XCLIPVisionConfig

<来源>

( hidden_size = 768 intermediate_size = 3072 num_hidden_layers = 12 num_attention_heads = 12 mit_hidden_size = 512 mit_intermediate_size = 2048 mit_num_hidden_layers = 1 mit_num_attention_heads = 8 num_channels = 3 image_size = 224 patch_size = 32 num_frames = 8 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 drop_path_rate = 0.0 **kwargs )

参数

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

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

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

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

• mit_hidden_size (int, optional, 默认为 512) — Multiframe Integration Transformer (MIT) 编码器层的维度。

• mit_intermediate_size (int, optional, 默认为 2048) — Multiframe Integration Transformer (MIT) 中“中间”（即前馈）层的维度。

• mit_num_hidden_layers (int, optional, 默认为 1) — Multiframe Integration Transformer (MIT) 中的隐藏层数量。

• mit_num_attention_heads (int, optional, 默认为 8) — Multiframe Integration Transformer (MIT) 中每个注意力层的注意力头数。

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

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

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

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

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

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

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

• drop_path_rate (float, optional, 默认为 0.0) — 随机深度率。

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

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

示例：

>>> from transformers import XCLIPVisionModel, XCLIPVisionConfig

>>> # Initializing a XCLIPVisionModel with microsoft/xclip-base-patch32 style configuration
>>> configuration = XCLIPVisionConfig()

>>> # Initializing a XCLIPVisionModel model from the microsoft/xclip-base-patch32 style configuration
>>> model = XCLIPVisionModel(configuration)

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

XCLIPModel

class transformers.XCLIPModel

< source >

( config: XCLIPConfig )

参数

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

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

forward

< source >

( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None position_ids: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.x_clip.modeling_x_clip.XCLIPOutput 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]之间：

  • 位置 ID 是什么？

  • 对于被“掩盖”的标记，位置 ID 为 0。

  注意掩码是什么？

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

  位置 ID 是什么？

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

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

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

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

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

返回

transformers.models.x_clip.modeling_x_clip.XCLIPOutput或tuple(torch.FloatTensor)

transformers.models.x_clip.modeling_x_clip.XCLIPOutput或一组torch.FloatTensor（如果传递了return_dict=False或当config.return_dict=False时）包括根据配置（<class 'transformers.models.x_clip.configuration_x_clip.XCLIPConfig'>）和输入的各种元素。对于被“掩盖”的标记，位置 ID 为 1。

• loss（形状为(1,)的torch.FloatTensor，可选，当return_loss为True时返回）- 视频文本相似性的对比损失。

• logits_per_video（形状为(video_batch_size, text_batch_size)的torch.FloatTensor）- video_embeds和text_embeds之间的缩放点积分数。这代表视频文本相似性分数。

• logits_per_text（形状为(text_batch_size, video_batch_size)的torch.FloatTensor）- text_embeds和video_embeds之间的缩放点积分数。这代表文本视频相似性分数。

• “text_embeds”（形状为(batch_size, output_dim)的torch.FloatTensor）- 通过将 XCLIPTextModel 的池化输出应用到投影层获得的文本嵌入。

• “video_embeds”（形状为(batch_size, output_dim)的torch.FloatTensor）- 通过将 XCLIPVisionModel 的池化输出应用到投影层获得的视频嵌入。

• text_model_output（BaseModelOutputWithPooling）- XCLIPTextModel 的输出。

• vision_model_output (BaseModelOutputWithPooling) — XCLIPVisionModel 的输出。

• mit_output (BaseModelOutputWithPooling) — XCLIPMultiframeIntegrationTransformer (MIT 的简称)的输出。

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

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

示例：

>>> import av
>>> import torch
>>> import numpy as np

>>> from transformers import AutoProcessor, AutoModel
>>> from huggingface_hub import hf_hub_download

>>> np.random.seed(0)

>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`List[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])

>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
...     '''
...     Sample a given number of frame indices from the video.
...     Args:
...         clip_len (`int`): Total number of frames to sample.
...         frame_sample_rate (`int`): Sample every n-th frame.
...         seg_len (`int`): Maximum allowed index of sample's last frame.
...     Returns:
...         indices (`List[int]`): List of sampled frame indices
...     '''
...     converted_len = int(clip_len * frame_sample_rate)
...     end_idx = np.random.randint(converted_len, seg_len)
...     start_idx = end_idx - converted_len
...     indices = np.linspace(start_idx, end_idx, num=clip_len)
...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
...     return indices

>>> # video clip consists of 300 frames (10 seconds at 30 FPS)
>>> file_path = hf_hub_download(
...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)

>>> # sample 8 frames
>>> indices = sample_frame_indices(clip_len=8, frame_sample_rate=1, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container, indices)

>>> processor = AutoProcessor.from_pretrained("microsoft/xclip-base-patch32")
>>> model = AutoModel.from_pretrained("microsoft/xclip-base-patch32")

>>> inputs = processor(
...     text=["playing sports", "eating spaghetti", "go shopping"],
...     videos=list(video),
...     return_tensors="pt",
...     padding=True,
... )

>>> # forward pass
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> logits_per_video = outputs.logits_per_video  # this is the video-text similarity score
>>> probs = logits_per_video.softmax(dim=1)  # we can take the softmax to get the label probabilities
>>> print(probs)
tensor([[1.9496e-04, 9.9960e-01, 2.0825e-04]])

get_text_features

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';text_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

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

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

  什么是输入 ID？

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

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

  • 对于被masked的标记为 0。

  什么是注意力掩码？

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

  什么是位置 ID？

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

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

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

返回

text_features (torch.FloatTensor of shape (batch_size, output_dim)

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

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

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

示例：

>>> from transformers import AutoTokenizer, AutoModel

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/xclip-base-patch32")
>>> model = AutoModel.from_pretrained("microsoft/xclip-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)

get_video_features

<来源>

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';video_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

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

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

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

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

返回

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

通过将投影层应用于 XCLIPVisionModel 和XCLIPMultiframeIntegrationTransformer的汇聚输出获得的视频嵌入。

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

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

示例：

>>> import av
>>> import torch
>>> import numpy as np

>>> from transformers import AutoProcessor, AutoModel
>>> from huggingface_hub import hf_hub_download

>>> np.random.seed(0)

>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`List[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])

>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
...     '''
...     Sample a given number of frame indices from the video.
...     Args:
...         clip_len (`int`): Total number of frames to sample.
...         frame_sample_rate (`int`): Sample every n-th frame.
...         seg_len (`int`): Maximum allowed index of sample's last frame.
...     Returns:
...         indices (`List[int]`): List of sampled frame indices
...     '''
...     converted_len = int(clip_len * frame_sample_rate)
...     end_idx = np.random.randint(converted_len, seg_len)
...     start_idx = end_idx - converted_len
...     indices = np.linspace(start_idx, end_idx, num=clip_len)
...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
...     return indices

>>> # video clip consists of 300 frames (10 seconds at 30 FPS)
>>> file_path = hf_hub_download(
...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)

>>> # sample 8 frames
>>> indices = sample_frame_indices(clip_len=8, frame_sample_rate=1, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container, indices)

>>> processor = AutoProcessor.from_pretrained("microsoft/xclip-base-patch32")
>>> model = AutoModel.from_pretrained("microsoft/xclip-base-patch32")

>>> inputs = processor(videos=list(video), return_tensors="pt")

>>> video_features = model.get_video_features(**inputs)

XCLIPTextModel

class transformers.XCLIPTextModel

<来源>

( config: XCLIPTextConfig )

forward

<来源>

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

参数

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

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

  输入 ID 是什么？

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

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

  • 0 用于“被掩盖”的标记。

  注意力掩码是什么？

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

  位置 ID 是什么？

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

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

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

返回

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

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False，或者config.return_dict=False）包含根据配置（<class 'transformers.models.x_clip.configuration_x_clip.XCLIPTextConfig'>）和输入的不同元素。

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

• pooler_output (torch.FloatTensor，形状为(batch_size, hidden_size)） — 经过用于辅助预训练任务的层进一步处理后的序列的第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。

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

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

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, XCLIPTextModel

>>> model = XCLIPTextModel.from_pretrained("microsoft/xclip-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/xclip-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

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

XCLIPVisionModel

class transformers.XCLIPVisionModel

<来源>

( config: XCLIPVisionConfig )

forward

<来源>

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

参数

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

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

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

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

返回

transformers.modeling_outputs.BaseModelOutputWithPooling 或torch.FloatTensor元组

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

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

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

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

示例：

>>> import av
>>> import torch
>>> import numpy as np

>>> from transformers import AutoProcessor, XCLIPVisionModel
>>> from huggingface_hub import hf_hub_download

>>> np.random.seed(0)

>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`List[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])

>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
...     '''
...     Sample a given number of frame indices from the video.
...     Args:
...         clip_len (`int`): Total number of frames to sample.
...         frame_sample_rate (`int`): Sample every n-th frame.
...         seg_len (`int`): Maximum allowed index of sample's last frame.
...     Returns:
...         indices (`List[int]`): List of sampled frame indices
...     '''
...     converted_len = int(clip_len * frame_sample_rate)
...     end_idx = np.random.randint(converted_len, seg_len)
...     start_idx = end_idx - converted_len
...     indices = np.linspace(start_idx, end_idx, num=clip_len)
...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
...     return indices

>>> # video clip consists of 300 frames (10 seconds at 30 FPS)
>>> file_path = hf_hub_download(
...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)

>>> # sample 16 frames
>>> indices = sample_frame_indices(clip_len=8, frame_sample_rate=1, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container, indices)

>>> processor = AutoProcessor.from_pretrained("microsoft/xclip-base-patch32")
>>> model = XCLIPVisionModel.from_pretrained("microsoft/xclip-base-patch32")

>>> pixel_values = processor(videos=list(video), return_tensors="pt").pixel_values

>>> batch_size, num_frames, num_channels, height, width = pixel_values.shape
>>> pixel_values = pixel_values.reshape(-1, num_channels, height, width)

>>> outputs = model(pixel_values)
>>> last_hidden_state = outputs.last_hidden_state

强化学习模型

Decision Transformer

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

概述

Decision Transformer 模型提出于Decision Transformer: Reinforcement Learning via Sequence Modeling

作者为 Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Michael Laskin, Pieter Abbeel, Aravind Srinivas, Igor Mordatch。

该论文的摘要如下：

我们引入了一个将强化学习（RL）抽象为序列建模问题的框架。这使我们能够利用 Transformer 架构的简单性和可扩展性，以及与语言建模相关的进展，如 GPT-x 和 BERT。特别是，我们提出了 Decision Transformer，这是一个将 RL 问题转化为条件序列建模的架构。与先前拟合值函数或计算策略梯度的 RL 方法不同，Decision Transformer 通过利用因果屏蔽的 Transformer 简单地输出最佳动作。通过将自回归模型条件于期望的回报（奖励）、过去状态和动作，我们的 Decision Transformer 模型可以生成实现期望回报的未来动作。尽管简单，Decision Transformer 在 Atari、OpenAI Gym 和 Key-to-Door 任务上与最先进的无模型离线 RL 基线模型的性能相匹配或超越。

该模型版本适用于状态为向量的任务。

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

DecisionTransformerConfig

class transformers.DecisionTransformerConfig

< source >

( state_dim = 17 act_dim = 4 hidden_size = 128 max_ep_len = 4096 action_tanh = True vocab_size = 1 n_positions = 1024 n_layer = 3 n_head = 1 n_inner = None activation_function = 'relu' resid_pdrop = 0.1 embd_pdrop = 0.1 attn_pdrop = 0.1 layer_norm_epsilon = 1e-05 initializer_range = 0.02 scale_attn_weights = True use_cache = True bos_token_id = 50256 eos_token_id = 50256 scale_attn_by_inverse_layer_idx = False reorder_and_upcast_attn = False **kwargs )

参数

• state_dim (int, optional, 默认为 17) — RL 环境的状态大小

• act_dim (int, optional, 默认为 4) — 输出动作空间的大小

• hidden_size (int, optional, 默认为 128) — 隐藏层的大小

• max_ep_len (int, optional, 默认为 4096) — 环境中一个 episode 的最大长度

• action_tanh (bool, optional, 默认为 True) — 是否在动作预测上使用 tanh 激活

• vocab_size (int, optional, 默认为 50257) — GPT-2 模型的词汇大小。定义了在调用 DecisionTransformerModel 时可以表示的不同标记数量。

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

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

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

• n_inner (int, optional) — 内部前馈层的维度。如果未设置，将默认为n_embd的 4 倍。

• activation_function (str, optional, 默认为"gelu") — 激活函数，可在列表["relu", "silu", "gelu", "tanh", "gelu_new"]中选择。

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

• embd_pdrop (int, optional, 默认为 0.1) — 嵌入的丢失比例。

• attn_pdrop (float, optional, 默认为 0.1) — 注意力的丢失比例。

• layer_norm_epsilon (float, optional, 默认为 1e-5) — 在层归一化层中使用的 epsilon 值。

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

• scale_attn_weights (bool, 可选, 默认为 True) — 通过除以 sqrt(hidden_size)来缩放注意力权重。

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

• scale_attn_by_inverse_layer_idx (bool, 可选, 默认为 False) — 是否通过1 / layer_idx + 1额外缩放注意力权重。

• reorder_and_upcast_attn (bool, 可选, 默认为 False) — 是否在计算注意力（点积）之前缩放键（K），并在使用混合精度训练时将注意力点积/softmax 向上转换为 float()。

这是用于存储 DecisionTransformerModel 配置的配置类。它用于根据指定的参数实例化一个决策变换器模型，定义模型架构。使用默认值实例化配置将产生类似于标准 DecisionTransformer 架构的配置。许多配置选项用于实例化作为架构一部分使用的 GPT2 模型。

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

示例：

>>> from transformers import DecisionTransformerConfig, DecisionTransformerModel

>>> # Initializing a DecisionTransformer configuration
>>> configuration = DecisionTransformerConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = DecisionTransformerModel(configuration)

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

DecisionTransformerGPT2Model

class transformers.DecisionTransformerGPT2Model

<来源>

( config )

forward

<来源>

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

DecisionTransformerModel

class transformers.DecisionTransformerModel

<来源>

( config )

参数

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

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

该模型基于 GPT2 架构，在离线 RL 设置中执行动作的自回归预测。更多细节请参考论文：arxiv.org/abs/2106.01345

forward

<来源>

( states: Optional = None actions: Optional = None rewards: Optional = None returns_to_go: Optional = None timesteps: Optional = None attention_mask: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.decision_transformer.modeling_decision_transformer.DecisionTransformerOutput or tuple(torch.FloatTensor)

参数

• states (torch.FloatTensor，形状为(batch_size, episode_length, state_dim)) — 轨迹中每个步骤的状态

• actions (torch.FloatTensor，形状为(batch_size, episode_length, act_dim)) — “专家”策略对当前状态采取的动作，这些动作用于自回归预测

• rewards (torch.FloatTensor，形状为(batch_size, episode_length, 1)) — 每个状态、动作的奖励

• returns_to_go（形状为(batch_size, episode_length, 1)的torch.FloatTensor）- 轨迹中每个状态的回报

• timesteps（形状为(batch_size, episode_length)的torch.LongTensor）- 轨迹中每一步的时间步长

• attention_mask（形状为(batch_size, episode_length)的torch.FloatTensor）- 掩码，用于在执行自回归预测时屏蔽动作

返回

transformers.models.decision_transformer.modeling_decision_transformer.DecisionTransformerOutput或tuple(torch.FloatTensor)

一个transformers.models.decision_transformer.modeling_decision_transformer.DecisionTransformerOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含各种元素，取决于配置（DecisionTransformerConfig）和输入。

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

• state_preds（形状为(batch_size, sequence_length, state_dim)的torch.FloatTensor）- 环境状态预测

• action_preds（形状为(batch_size, sequence_length, action_dim)的torch.FloatTensor）- 模型动作预测

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

DecisionTransformerModel的forward方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import DecisionTransformerModel
>>> import torch

>>> model = DecisionTransformerModel.from_pretrained("edbeeching/decision-transformer-gym-hopper-medium")
>>> # evaluation
>>> model = model.to(device)
>>> model.eval()

>>> env = gym.make("Hopper-v3")
>>> state_dim = env.observation_space.shape[0]
>>> act_dim = env.action_space.shape[0]

>>> state = env.reset()
>>> states = torch.from_numpy(state).reshape(1, 1, state_dim).to(device=device, dtype=torch.float32)
>>> actions = torch.zeros((1, 1, act_dim), device=device, dtype=torch.float32)
>>> rewards = torch.zeros(1, 1, device=device, dtype=torch.float32)
>>> target_return = torch.tensor(TARGET_RETURN, dtype=torch.float32).reshape(1, 1)
>>> timesteps = torch.tensor(0, device=device, dtype=torch.long).reshape(1, 1)
>>> attention_mask = torch.zeros(1, 1, device=device, dtype=torch.float32)

>>> # forward pass
>>> with torch.no_grad():
...     state_preds, action_preds, return_preds = model(
...         states=states,
...         actions=actions,
...         rewards=rewards,
...         returns_to_go=target_return,
...         timesteps=timesteps,
...         attention_mask=attention_mask,
...         return_dict=False,
...     )

轨迹 Transformer

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

此模型仅处于维护模式，因此我们不会接受任何更改其代码的新 PR。

如果您在运行此模型时遇到任何问题，请重新安装支持此模型的最后一个版本：v4.30.0。您可以通过运行以下命令来执行：pip install -U transformers==4.30.0。

概述

轨迹 Transformer 模型是由 Michael Janner、Qiyang Li、Sergey Levine 在离线强化学习作为一个大的序列建模问题中提出的。

该论文的摘要如下：

强化学习（RL）通常涉及估计稳态策略或单步模型，利用马尔可夫性质在时间上分解问题。然而，我们也可以将 RL 视为一个通用的序列建模问题，目标是产生一系列导致高奖励序列的动作。从这个角度看，我们很容易考虑高容量序列预测模型在其他领域（如自然语言处理）中的良好工作是否也可以为 RL 问题提供有效的解决方案。为此，我们探讨了如何使用序列建模工具来解决 RL 问题，使用 Transformer 架构来建模轨迹分布，并将波束搜索重新用作规划算法。将 RL 作为序列建模问题来框定简化了一系列设计决策，使我们能够摒弃许多离线 RL 算法中常见的组件。我们展示了这种方法在长期动态预测、模仿学习、目标条件 RL 和离线 RL 等方面的灵活性。此外，我们展示了这种方法可以与现有的无模型算法结合，产生稀疏奖励、长期视野任务中的最先进规划器。

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

使用提示

这个 Transformer 用于深度强化学习。要使用它，您需要从所有先前时间步的动作、状态和奖励创建序列。这个模型将把所有这些元素一起视为一个大序列（一个轨迹）。

TrajectoryTransformerConfig

class transformers.TrajectoryTransformerConfig

<来源>

( vocab_size = 100 action_weight = 5 reward_weight = 1 value_weight = 1 block_size = 249 action_dim = 6 observation_dim = 17 transition_dim = 25 n_layer = 4 n_head = 4 n_embd = 128 embd_pdrop = 0.1 attn_pdrop = 0.1 resid_pdrop = 0.1 learning_rate = 0.0006 max_position_embeddings = 512 initializer_range = 0.02 layer_norm_eps = 1e-12 kaiming_initializer_range = 1 use_cache = True pad_token_id = 1 bos_token_id = 50256 eos_token_id = 50256 **kwargs )

参数

• vocab_size（int，可选，默认为 100）—TrajectoryTransformer 模型的词汇量。定义了在调用 TrajectoryTransformerModel 时可以表示的trajectories的不同标记数量。

• action_weight（int，可选，默认为 5）—损失函数中动作的权重

• reward_weight（int，可选，默认为 1）—损失函数中奖励的权重

• value_weight（int，可选，默认为 1）—损失函数中值的权重

• block_size（int，可选，默认为 249）—轨迹 Transformer 中块的大小。

• action_dim（int，可选，默认为 6）—动作空间的维度。

• observation_dim（int，可选，默认为 17）—观察空间的维度。

• transition_dim（int，可选，默认为 25）—转换空间的维度。

• n_layer（int，可选，默认为 4）—Transformer 编码器中的隐藏层数。

• n_head（int，可选，默认为 4）—Transformer 编码器中每个注意力层的注意力头数。

• n_embd (int, optional, defaults to 128) — 嵌入和隐藏状态的维度。

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

• embd_pdrop (int, optional, defaults to 0.1) — 嵌入的 dropout 比率。

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

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

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

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

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

• kaiming_initializer_range (`float, optional, defaults to 1) — 缩放 kaiming 初始化器整流器的负斜率的系数，用于 EinLinear 层。

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

这是用于存储 TrajectoryTransformerModel 配置的配置类。根据指定的参数实例化 TrajectoryTransformer 模型，定义模型架构。使用默认值实例化配置将产生类似于 TrajectoryTransformer CarlCochet/trajectory-transformer-halfcheetah-medium-v2架构的配置。

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

>>> from transformers import TrajectoryTransformerConfig, TrajectoryTransformerModel

>>> # Initializing a TrajectoryTransformer CarlCochet/trajectory-transformer-halfcheetah-medium-v2 style configuration
>>> configuration = TrajectoryTransformerConfig()

>>> # Initializing a model (with random weights) from the CarlCochet/trajectory-transformer-halfcheetah-medium-v2 style configuration
>>> model = TrajectoryTransformerModel(configuration)

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

TrajectoryTransformerModel

class transformers.TrajectoryTransformerModel

< source >

( config )

参数

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

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

完整的 GPT 语言模型，上下文大小为 block_size

forward

< source >

( trajectories: Optional = None past_key_values: Optional = None targets: Optional = None attention_mask: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.deprecated.trajectory_transformer.modeling_trajectory_transformer.TrajectoryTransformerOutput or tuple(torch.FloatTensor)

参数

• trajectories (torch.LongTensor of shape (batch_size, sequence_length)) — 轨迹的批次，其中轨迹是状态、动作和奖励的序列。

• past_key_values (Tuple[Tuple[torch.Tensor]] 长度为config.n_layers, optional) — 包含由模型计算的预先计算的隐藏状态（注意力块中的键和值）（参见下面的past_key_values输出）。可用于加速顺序解码。将过去给定给该模型的input_ids不应作为input_ids传递，因为它们已经计算过。

• targets (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算损失的目标值。

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

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

  • 对于被masked的标记为 0。

  什么是注意力掩码？

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

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

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

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

返回

transformers.models.deprecated.trajectory_transformer.modeling_trajectory_transformer.TrajectoryTransformerOutput 或 tuple(torch.FloatTensor)

一个transformers.models.deprecated.trajectory_transformer.modeling_trajectory_transformer.TrajectoryTransformerOutput或一个torch.FloatTensor的元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（TrajectoryTransformerConfig）和输入的不同元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失。

• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (Tuple[Tuple[torch.Tensor]], optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的元组，包含形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量元组。包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 长度为 2 的元组，包含形状为(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 之后的 GPT2Attentions 权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import TrajectoryTransformerModel
>>> import torch

>>> model = TrajectoryTransformerModel.from_pretrained(
...     "CarlCochet/trajectory-transformer-halfcheetah-medium-v2"
... )
>>> model.to(device)
>>> model.eval()

>>> observations_dim, action_dim, batch_size = 17, 6, 256
>>> seq_length = observations_dim + action_dim + 1

>>> trajectories = torch.LongTensor([np.random.permutation(self.seq_length) for _ in range(batch_size)]).to(
...     device
... )
>>> targets = torch.LongTensor([np.random.permutation(self.seq_length) for _ in range(batch_size)]).to(device)

>>> outputs = model(
...     trajectories,
...     targets=targets,
...     use_cache=True,
...     output_attentions=True,
...     output_hidden_states=True,
...     return_dict=True,
... )

时间序列模型

Autoformer

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

概述

Autoformer 模型是由 Haixu Wu，Jiehui Xu，Jianmin Wang，Mingsheng Long 在Autoformer: Decomposition Transformers with Auto-Correlation for Long-Term Series Forecasting中提出的。

该模型将 Transformer 作为深度分解架构，可以在预测过程中逐步分解趋势和季节性组件。

论文摘要如下：

延长预测时间是真实应用的关键需求，例如极端天气预警和长期能源消耗规划。本文研究了时间序列的长期预测问题。之前基于 Transformer 的模型采用各种自注意机制来发现长距离依赖关系。然而，长期未来的复杂时间模式阻碍了模型找到可靠的依赖关系。此外，为了长序列的效率，Transformer 必须采用稀疏版本的点对点自注意力，导致信息利用瓶颈。超越 Transformer，我们设计 Autoformer 作为一种具有自相关机制的新型分解架构。我们打破了系列分解的预处理惯例，并将其改造为深度模型的基本内部块。这种设计赋予 Autoformer 对复杂时间序列的渐进分解能力。此外，受随机过程理论启发，我们设计了基于系列周期性的自相关机制，它在子系列级别进行依赖关系发现和表示聚合。自相关在效率和准确性方面优于自注意力。在长期预测中，Autoformer 取得了最先进的准确性，在六个基准测试中相对提高了 38％，涵盖了五个实际应用：能源，交通，经济，天气和疾病。

该模型由elisim和kashif贡献。原始代码可以在此处找到。

资源

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

• 在 HuggingFace 博客中查看 Autoformer 博文：是的，Transformers 对时间序列预测有效（+ Autoformer）

AutoformerConfig

class transformers.AutoformerConfig

<来源>

( prediction_length: Optional = None context_length: Optional = None distribution_output: str = 'student_t' loss: str = 'nll' input_size: int = 1 lags_sequence: List = [1, 2, 3, 4, 5, 6, 7] scaling: bool = True num_time_features: int = 0 num_dynamic_real_features: int = 0 num_static_categorical_features: int = 0 num_static_real_features: int = 0 cardinality: Optional = None embedding_dimension: Optional = None d_model: int = 64 encoder_attention_heads: int = 2 decoder_attention_heads: int = 2 encoder_layers: int = 2 decoder_layers: int = 2 encoder_ffn_dim: int = 32 decoder_ffn_dim: int = 32 activation_function: str = 'gelu' dropout: float = 0.1 encoder_layerdrop: float = 0.1 decoder_layerdrop: float = 0.1 attention_dropout: float = 0.1 activation_dropout: float = 0.1 num_parallel_samples: int = 100 init_std: float = 0.02 use_cache: bool = True is_encoder_decoder = True label_length: int = 10 moving_average: int = 25 autocorrelation_factor: int = 3 **kwargs )

参数

• prediction_length（int）— 解码器的预测长度。换句话说，模型的预测时间范围。

• context_length（int，可选，默认为prediction_length）— 编码器的上下文长度。如果未设置，上下文长度将与prediction_length相同。

• distribution_output（string，可选，默认为"student_t"）— 模型的分布发射头。可以是"student_t"，“normal”或“negative_binomial”。

• loss（string，可选，默认为"nll"）— 与distribution_output头部对应的模型的损失函数。对于参数分布，它是负对数似然（nll）- 目前是唯一支持的。

• input_size（int，可选，默认为 1）— 目标变量的大小，默认情况下对于单变量目标为 1。在多变量目标的情况下会大于 1。

• lags_sequence (list[int], optional, defaults to [1, 2, 3, 4, 5, 6, 7]) — 输入时间序列的滞后作为协变量，通常由频率决定。默认为[1, 2, 3, 4, 5, 6, 7]。

• scaling (bool, optional defaults to True) — 是否对输入目标进行缩放。

• num_time_features (int, optional, defaults to 0) — 输入时间序列中的时间特征数量。

• num_dynamic_real_features (int, optional, defaults to 0) — 动态实值特征的数量。

• num_static_categorical_features (int, optional, defaults to 0) — 静态分类特征的数量。

• num_static_real_features (int, optional, defaults to 0) — 静态实值特征的数量。

• cardinality (list[int], optional) — 每个静态分类特征的基数（不同值的数量）。应该是一个整数列表，长度与num_static_categorical_features相同。如果num_static_categorical_features大于 0，则不能为None。

• embedding_dimension (list[int], optional) — 每个静态分类特征的嵌入维度。应该是一个整数列表，长度与num_static_categorical_features相同。如果num_static_categorical_features大于 0，则不能为None。

• d_model (int, optional, defaults to 64) — Transformer 层的维度。

• encoder_layers (int, optional, defaults to 2) — 编码器层的数量。

• decoder_layers (int, optional, defaults to 2) — 解码器层的数量。

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

• decoder_attention_heads (int, optional, defaults to 2) — Transformer 解码器中每个注意力层的注意力头数。

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

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

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

• dropout (float, optional, defaults to 0.1) — 编码器和解码器中所有全连接层的丢弃概率。

• encoder_layerdrop (float, optional, defaults to 0.1) — 每个编码器层的注意力和全连接层的丢弃概率。

• decoder_layerdrop (float, optional, defaults to 0.1) — 每个解码器层的注意力和全连接层的丢弃概率。

• attention_dropout (float, optional, defaults to 0.1) — 注意力概率的丢弃概率。

• activation_dropout (float, optional, defaults to 0.1) — 在前馈网络的两层之间使用的丢弃概率。

• num_parallel_samples (int, optional, defaults to 100) — 每个推断时间步生成的并行样本数量。

• init_std (float, optional, defaults to 0.02) — 截断正态权重初始化分布的标准差。

• use_cache (bool, optional, defaults to True) — 是否使用过去的键/值注意力（如果适用于模型）以加速解码。

• label_length (int, optional, defaults to 10) — Autoformer 解码器的起始标记长度，用于直接多步预测（即非自回归生成）。

• moving_average (int, defaults to 25) — 移动平均的窗口大小。在实践中，它是分解层的 AvgPool1d 中的核大小。

• autocorrelation_factor (int, defaults to 3) — “注意力”（即自相关机制）因子，用于找到前 k 个自相关延迟。建议在论文中将其设置为 1 到 5 之间的数字。

这是用于存储 AutoformerModel 配置的配置类。它用于根据指定的参数实例化 Autoformer 模型，定义模型架构。使用默认值实例化配置将产生类似于 Autoformer huggingface/autoformer-tourism-monthly架构的配置。

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

>>> from transformers import AutoformerConfig, AutoformerModel

>>> # Initializing a default Autoformer configuration
>>> configuration = AutoformerConfig()

>>> # Randomly initializing a model (with random weights) from the configuration
>>> model = AutoformerModel(configuration)

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

AutoformerModel

class transformers.AutoformerModel

<来源>

( config: AutoformerConfig )

参数

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

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

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

forward

<来源>

( past_values: Tensor past_time_features: Tensor past_observed_mask: Tensor static_categorical_features: Optional = None static_real_features: Optional = None future_values: Optional = None future_time_features: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None use_cache: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.autoformer.modeling_autoformer.AutoformerModelOutput or tuple(torch.FloatTensor)

参数

• past_values (torch.FloatTensor of shape (batch_size, sequence_length)) — 时间序列的过去值，用作上下文以预测未来。这些值可能包含滞后，即过去的附加值，这些值被添加以充当“额外上下文”。past_values 是 Transformer 编码器接收的输入（还可以包括可选的其他特征，如static_categorical_features、static_real_features、past_time_features）。

  这里的序列长度等于context_length + max(config.lags_sequence)。

  缺失值需要用零替换。

• past_time_features (torch.FloatTensor of shape (batch_size, sequence_length, num_features), 可选) — 可选的时间特征，模型内部将添加到past_values中。这些可能是诸如“年份中的月份”、“月份中的日期”等编码为向量（例如作为傅立叶特征）的内容。这些也可以是所谓的“年龄”特征，基本上帮助模型知道时间序列处于“生命中的哪个阶段”。年龄特征对于远处的过去时间步具有较小的值，并且随着我们接近当前时间步而单调增加。

  这些特征充当输入的“位置编码”。因此，与 BERT 这样的模型不同，BERT 的位置编码是从头开始内部作为模型的参数学习的，时间序列 Transformer 需要提供额外的时间特征。

  Autoformer 仅为static_categorical_features学习额外的嵌入。

• past_observed_mask (torch.BoolTensor of shape (batch_size, sequence_length), optional) — 布尔掩码，指示哪些 past_values 被观察到，哪些是缺失的。掩码值选在 [0, 1] 之间：

  • 1 表示值为 observed,

  • 0 表示值为 missing（即被零替换的 NaN）。

• static_categorical_features (torch.LongTensor of shape (batch_size, number of static categorical features), optional) — 模型将学习的可选静态分类特征的嵌入，将其添加到时间序列的值中。

  静态分类特征是所有时间步长具有相同值的特征（随时间保持不变）。

  静态分类特征的典型示例是时间序列 ID。

• static_real_features (torch.FloatTensor of shape (batch_size, number of static real features), optional) — 可选的静态实数特征，模型将将其添加到时间序列的值中。

  静态实数特征是所有时间步长具有相同值的特征（随时间保持不变）。

  静态实数特征的典型示例是促销信息。

• future_values (torch.FloatTensor of shape (batch_size, prediction_length)) — 时间序列的未来值，作为模型的标签。future_values 是 Transformer 需要学习输出的内容，给定 past_values。

  有关详细信息，请参阅演示笔记本和代码片段。

  缺失值需要用零替换。

• future_time_features (torch.FloatTensor of shape (batch_size, prediction_length, num_features), optional) — 可选的时间特征，模型将内部添加到 future_values 中。这些可能是像“年份的月份”，“月份的日期”等编码为向量（例如傅立叶特征）的内容。这也可能是所谓的“年龄”特征，基本上帮助模型知道时间序列处于“生命中的哪个阶段”。年龄特征对于远处的过去时间步具有较小的值，并且随着我们接近当前时间步而单调增加。

  这些特征作为输入的“位置编码”。与像 BERT 这样的模型不同，BERT 的位置编码是从头开始内部作为模型的参数学习的，时间序列 Transformer 需要提供额外的特征。

  Autoformer 仅为 static_categorical_features 学习额外的嵌入。

• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在某些标记索引上执行注意力的掩码。掩码值选在 [0, 1] 之间：

  • 1 表示标记未被掩码，

  • 0 表示标记被掩码。

  什么是注意力掩码？

• decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 用于避免在某些标记索引上执行注意力的掩码。默认情况下，将使用因果掩码，以确保模型只能查看以前的输入以预测未来。

• head_mask (torch.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 用于在编码器中使注意力模块的特定头部失效的掩码。掩码值选在 [0, 1] 之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• decoder_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于在解码器中使注意力模块的特定头部失效的掩码。掩码值选在 [0, 1] 之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使交叉注意力模块的特定头部失效的掩码。掩码值选在 [0, 1] 之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包括last_hidden_state、hidden_states (optional) 和 attentions (optional)。last_hidden_state的形状为(batch_size, sequence_length, hidden_size) (optional)，是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回 — 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

  如果使用past_key_values，用户可以选择仅输入最后一个decoder_input_ids（这些没有给出其过去键值状态的模型）的形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。

• inputs_embeds (torch.FloatTensor的形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

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

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

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

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

返回

transformers.models.autoformer.modeling_autoformer.AutoformerModelOutput或tuple(torch.FloatTensor)

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

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

  如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• trend (torch.FloatTensor的形状为(batch_size, sequence_length, hidden_size)) — 每个时间序列的趋势张量。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回 — 长度为config.n_layers的元组，每个元组有 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输入）。

• decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出加上每层的输出）。

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

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

• encoder_last_hidden_state（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）- 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出加上每层的输出）。

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

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

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

• loc（torch.FloatTensor，形状为(batch_size,)或(batch_size, input_size)，可选）- 每个时间序列上下文窗口的偏移值，用于使模型输入具有相同的量级，然后用于将其偏移回原始量级。

• scale（torch.FloatTensor，形状为(batch_size,)或(batch_size, input_size)，可选）- 每个时间序列上下文窗口的缩放值，用于使模型输入具有相同的量级，然后用于将其重新缩放回原始量级。

• static_features:（torch.FloatTensor，形状为(batch_size, feature size)，可选）- 批处理中每个时间序列的静态特征，在推断时复制到协变量中。

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

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

示例：

>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import AutoformerModel

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/tourism-monthly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> model = AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly")

>>> # during training, one provides both past and future values
>>> # as well as possible additional features
>>> outputs = model(
...     past_values=batch["past_values"],
...     past_time_features=batch["past_time_features"],
...     past_observed_mask=batch["past_observed_mask"],
...     static_categorical_features=batch["static_categorical_features"],
...     future_values=batch["future_values"],
...     future_time_features=batch["future_time_features"],
... )

>>> last_hidden_state = outputs.last_hidden_state

AutoformerForPrediction

class transformers.AutoformerForPrediction

<来源>

( config: AutoformerConfig )

参数

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

Autoformer 模型在时间序列预测的顶部具有一个分布头。该模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( past_values: Tensor past_time_features: Tensor past_observed_mask: Tensor static_categorical_features: Optional = None static_real_features: Optional = None future_values: Optional = None future_time_features: Optional = None future_observed_mask: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None use_cache: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqTSPredictionOutput or tuple(torch.FloatTensor)

参数

• past_values（torch.FloatTensor，形状为(batch_size, sequence_length)）— 时间序列的过去值，作为上下文以预测未来。这些值可能包含滞后，即过去的其他值，以作为“额外上下文”添加。past_values是 Transformer 编码器的输入（还可以包括可选的其他特征，如static_categorical_features、static_real_features、past_time_features）。

  这里的序列长度等于context_length + max(config.lags_sequence)。

  缺失值需要用零替换。

• past_time_features（torch.FloatTensor，形状为(batch_size, sequence_length, num_features)，可选）— 可选的时间特征，模型内部将其添加到past_values中。这些可能是诸如“年份中的月份”，“月份中的日期”等编码为向量（例如傅立叶特征）的内容。这些也可以是所谓的“年龄”特征，基本上帮助模型了解时间序列处于“生命中的哪个阶段”。年龄特征对于过去的时间步具有较小的值，并且随着我们接近当前时间步而单调增加。

  这些特征作为输入的“位置编码”。因此，与像 BERT 这样的模型相反，BERT 的位置编码是从头开始内部作为模型的参数学习的，时间序列 Transformer 需要提供额外的时间特征。

  Autoformer 仅为static_categorical_features学习额外的嵌入。

• past_observed_mask（torch.BoolTensor，形状为(batch_size, sequence_length)，可选）— 布尔掩码，指示哪些past_values是观察到的，哪些是缺失的。掩码值选在[0, 1]之间：

  • 1 表示“观察到”的值，

  • 0 表示“缺失”的值（即用零替换的 NaN）。

• static_categorical_features（torch.LongTensor，形状为(batch_size, number of static categorical features)，可选）— 模型将学习嵌入的可选静态分类特征，将其添加到时间序列的值中。

  静态分类特征是所有时间步长具有相同值的特征（随时间保持静态）。

  静态分类特征的典型示例是时间序列 ID。

• static_real_features（torch.FloatTensor，形状为(batch_size, number of static real features)，可选）— 模型将添加到时间序列值中的可选静态实特征。

  静态实特征是所有时间步长具有相同值的特征（随时间保持静态）。

  静态实特征的典型示例是促销信息。

• future_values (torch.FloatTensor，形状为(batch_size, prediction_length)) — 时间序列的未来值，作为模型的标签。Transformer 需要学习输出future_values，给定past_values。

  有关详细信息，请参阅演示笔记本和代码片段。

  缺失值需要用零替换。

• future_time_features (torch.FloatTensor，形状为(batch_size, prediction_length, num_features)，optional) — 可选的时间特征，模型内部将其添加到future_values中。这些可能是诸如“年份的月份”，“月份的日期”等编码为向量（例如作为傅立叶特征）的内容。这些也可以是所谓的“年龄”特征，基本上帮助模型知道时间序列处于“生命中的哪个阶段”。年龄特征对于远处的过去时间步具有较小的值，并且随着我们接近当前时间步而单调增加。

  这些特征作为输入的“位置编码”。与 BERT 等模型不同，BERT 等模型的位置编码是从头开始内部作为模型的参数学习的，时间序列 Transformer 需要提供额外的特征。

  Autoformer 仅为static_categorical_features学习额外的嵌入。

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

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

  • 0 表示被掩盖的标记。

  什么是注意力掩码？

• decoder_attention_mask (torch.LongTensor，形状为(batch_size, target_sequence_length)，optional) — 用于避免在某些标记索引上执行注意力的掩码。默认情况下，将使用因果掩码，以确保模型只能查看以前的输入以预测未来。

• head_mask (torch.Tensor，形状为(encoder_layers, encoder_attention_heads)，optional) — 用于使编码器中的注意力模块中的选定头部失效的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• decoder_head_mask (torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，optional) — 用于使解码器中的注意力模块中的选定头部失效的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• cross_attn_head_mask (torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，optional) — 用于使交叉注意力模块中的选定头部失效的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• encoder_outputs (tuple(tuple(torch.FloatTensor)，optional) — 元组包括last_hidden_state，hidden_states（optional）和attentions（optional）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)的隐藏状态序列是编码器最后一层的输出。用于解码器的交叉注意力。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

  如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这很有用。

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

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

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

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

返回

transformers.modeling_outputs.Seq2SeqTSPredictionOutput 或torch.FloatTensor元组

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

• loss (torch.FloatTensor，形状为(1,)，可选，当提供future_values时返回) — 分布损失。

• params (torch.FloatTensor，形状为(batch_size, num_samples, num_params)) — 所选分布的参数。

• 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输入）。

• decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入层的输出+每层的输出）。

  解码器在每一层输出的隐藏状态加上初始嵌入输出。

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

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

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

  编码器在每个层的输出以及初始嵌入输出的隐藏状态。

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

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

• loc (torch.FloatTensor，形状为(batch_size,)或(batch_size, input_size)，optional) — 每个时间序列上下文窗口的偏移值，用于使模型输入具有相同的量级，然后用于将其偏移回原始量级。

• scale (torch.FloatTensor，形状为(batch_size,)或(batch_size, input_size)，optional) — 每个时间序列上下文窗口的缩放值，用于使模型输入具有相同的量级，然后用于将其重新缩放回原始量级。

• static_features (torch.FloatTensor，形状为(batch_size, feature size)，optional) — 每个时间序列批次中的静态特征，在推断时复制到协变量中。

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

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

示例：

>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import AutoformerForPrediction

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/tourism-monthly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> model = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly")

>>> # during training, one provides both past and future values
>>> # as well as possible additional features
>>> outputs = model(
...     past_values=batch["past_values"],
...     past_time_features=batch["past_time_features"],
...     past_observed_mask=batch["past_observed_mask"],
...     static_categorical_features=batch["static_categorical_features"],
...     static_real_features=batch["static_real_features"],
...     future_values=batch["future_values"],
...     future_time_features=batch["future_time_features"],
... )

>>> loss = outputs.loss
>>> loss.backward()

>>> # during inference, one only provides past values
>>> # as well as possible additional features
>>> # the model autoregressively generates future values
>>> outputs = model.generate(
...     past_values=batch["past_values"],
...     past_time_features=batch["past_time_features"],
...     past_observed_mask=batch["past_observed_mask"],
...     static_categorical_features=batch["static_categorical_features"],
...     static_real_features=batch["static_real_features"],
...     future_time_features=batch["future_time_features"],
... )

>>> mean_prediction = outputs.sequences.mean(dim=1)

Informer

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

概述

Informer 模型由周浩毅、张尚航、彭杰琦、张帅、李建新、熊辉和张万才在Informer: Beyond Efficient Transformer for Long Sequence Time-Series Forecasting中提出。

该方法引入了一种概率注意机制，用于选择“活跃”查询而不是“懒惰”查询，并提供了一种稀疏 Transformer，从而减轻了传统注意力的二次计算和内存需求。

该论文的摘要如下：

许多现实应用需要预测长序列时间序列，例如电力消耗规划。长序列时间序列预测（LSTF）要求模型具有高预测能力，即能够有效捕捉输出和输入之间精确的长程依赖关系耦合。最近的研究表明 Transformer 有增加预测能力的潜力。然而，Transformer 存在几个严重问题，阻碍了其直接应用于 LSTF，包括二次时间复杂度、高内存使用和编码器-解码器架构的固有限制。为了解决这些问题，我们设计了一种高效的基于 Transformer 的 LSTF 模型，名为 Informer，具有三个独特特征：(i) ProbSparse 自注意机制，实现了 O(L logL)的时间复杂度和内存使用，并在序列的依赖对齐上具有可比性的性能。(ii) 自注意力提取突出主导注意力，通过减半级联层输入，有效处理极长输入序列。(iii) 生成式解码器，概念上简单，可以一次性预测长时间序列序列，而不是逐步预测，大大提高了长序列预测的推理速度。对四个大规模数据集的广泛实验表明，Informer 明显优于现有方法，并为 LSTF 问题提供了新的解决方案。

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

资源

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

• 在 HuggingFace 博客中查看 Informer 博文：Multivariate Probabilistic Time Series Forecasting with Informer

InformerConfig

class transformers.InformerConfig

< source >

( prediction_length: Optional = None context_length: Optional = None distribution_output: str = 'student_t' loss: str = 'nll' input_size: int = 1 lags_sequence: List = None scaling: Union = 'mean' num_dynamic_real_features: int = 0 num_static_real_features: int = 0 num_static_categorical_features: int = 0 num_time_features: int = 0 cardinality: Optional = None embedding_dimension: Optional = None d_model: int = 64 encoder_ffn_dim: int = 32 decoder_ffn_dim: int = 32 encoder_attention_heads: int = 2 decoder_attention_heads: int = 2 encoder_layers: int = 2 decoder_layers: int = 2 is_encoder_decoder: bool = True activation_function: str = 'gelu' dropout: float = 0.05 encoder_layerdrop: float = 0.1 decoder_layerdrop: float = 0.1 attention_dropout: float = 0.1 activation_dropout: float = 0.1 num_parallel_samples: int = 100 init_std: float = 0.02 use_cache = True attention_type: str = 'prob' sampling_factor: int = 5 distil: bool = True **kwargs )

参数

• prediction_length (int) — 解码器的预测长度。换句话说，模型的预测范围。这个值通常由数据集决定，我们建议适当设置。

• context_length (int, optional, defaults to prediction_length) — 编码器的上下文长度。如果为None，上下文长度将与prediction_length相同。

• distribution_output (string, optional, defaults to "student_t") — 模型的分布发射头。可以是"student_t"、“normal”或“negative_binomial”之一。

• loss (string, optional, defaults to "nll") — 该模型对应distribution_output头部的损失函数。对于参数分布，它是负对数似然(nll) - 目前是唯一支持的。

• input_size (int, optional, defaults to 1) — 目标变量的大小，默认为 1 表示单变量目标。对于多变量目标，应该大于 1。

• scaling (string or bool, optional defaults to "mean") — 是否通过"mean"缩放器、“std”缩放器或无缩放器（如果为None）来缩放输入目标。如果为True，则缩放器设置为"mean"。

• lags_sequence (list[int], optional, defaults to [1, 2, 3, 4, 5, 6, 7]) — 输入时间序列的滞后作为协变量，通常由数据频率决定。默认为[1, 2, 3, 4, 5, 6, 7]，但建议根据数据集适当更改。

• num_time_features (int, optional, defaults to 0) — 输入时间序列中的时间特征数量。

• num_dynamic_real_features (int, optional, defaults to 0) — 动态实值特征的数量。

• num_static_categorical_features (int, optional, defaults to 0) — 静态分类特征的数量。

• num_static_real_features (int, optional, defaults to 0) — 静态实值特征的数量。

• cardinality (list[int], optional) — 静态分类特征的基数（不同值的数量）。应该是一个整数列表，长度与num_static_categorical_features相同。如果num_static_categorical_features大于 0，则不能为None。

• embedding_dimension (list[int], optional) — 每个静态分类特征的嵌入维度。应该是一个整数列表，长度与num_static_categorical_features相同。如果num_static_categorical_features大于 0，则不能为None。

• d_model (int, optional, defaults to 64) — transformer 层的维度。

• encoder_layers (int, optional, defaults to 2) — 编码器层数。

• decoder_layers (int, optional, defaults to 2) — 解码器层数。

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

• decoder_attention_heads (int, optional, defaults to 2) — Transformer 解码器中每个注意力层的注意力头数。

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

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

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

• dropout (float, optional, defaults to 0.1) — 编码器和解码器中所有全连接层的 dropout 概率。

• encoder_layerdrop (float, optional, defaults to 0.1) — 每个编码器层的注意力和全连接层的 dropout 概率。

• decoder_layerdrop (float, optional, defaults to 0.1) — 每个解码器层的注意力和全连接层的 dropout 概率。

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

• activation_dropout (float, optional, defaults to 0.1) — 前馈网络两层之间使用的 dropout 概率。

• num_parallel_samples (int, optional, defaults to 100) — 每个推断时间步生成的并行样本数量。

• init_std (float, optional, defaults to 0.02) — 截断正态权重初始化分布的标准差。

• use_cache (bool, optional, defaults to True) — 是否使用过去的键/值注意力（如果适用于模型）以加速解码。

• attention_type (str, optional, defaults to “prob”) — 编码器中使用的注意力机制。可以设置为“prob”（Informer 的 ProbAttention）或“full”（传统 transformer 的自注意力机制）。

• sampling_factor（int，可选，默认为 5）- ProbSparse 采样因子（仅在attention_type=“prob”时生效）。它用于控制减少的查询矩阵（Q_reduce）的输入长度。

• distil（bool，可选，默认为True）- 是否在编码器中使用蒸馏。

这是一个配置类，用于存储 InformerModel 的配置。根据指定的参数实例化一个 Informer 模型，定义模型架构。使用默认值实例化配置将产生类似于 Informer huggingface/informer-tourism-monthly 架构的配置。

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

例：

>>> from transformers import InformerConfig, InformerModel

>>> # Initializing an Informer configuration with 12 time steps for prediction
>>> configuration = InformerConfig(prediction_length=12)

>>> # Randomly initializing a model (with random weights) from the configuration
>>> model = InformerModel(configuration)

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

InformerModel

class transformers.InformerModel

<来源>

( config: InformerConfig )

参数

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

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

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

前进

<来源>

( past_values: Tensor past_time_features: Tensor past_observed_mask: Tensor static_categorical_features: Optional = None static_real_features: Optional = None future_values: Optional = None future_time_features: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None use_cache: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqTSModelOutput or tuple(torch.FloatTensor)

参数

• past_values（形状为(batch_size, sequence_length)或(batch_size, sequence_length, input_size)的torch.FloatTensor）- 时间序列的过去值，用作上下文以预测未来。此张量的序列大小必须大于模型的context_length，因为模型将使用较大的大小来构建滞后特征，即从过去添加的额外值，以充当“额外上下文”。

  这里的sequence_length等于config.context_length + max(config.lags_sequence)，如果没有配置lags_sequence，则等于config.context_length + 7（因为默认情况下，config.lags_sequence中最大的回溯索引为 7）。属性_past_length返回过去的实际长度。

  past_values是 Transformer 编码器作为输入的内容（可选的附加特征，如static_categorical_features、static_real_features、past_time_features和滞后）。

  可选地，缺失值需要用零替换，并通过past_observed_mask指示。

  对于多变量时间序列，需要input_size > 1 维，并对应于每个时间步长中时间序列中的变量数量。

• past_time_features（形状为(batch_size, sequence_length, num_features)的torch.FloatTensor）- 必需的时间特征，模型将内部将这些特征添加到past_values中。这些可能是“年份的月份”，“月份的日期”等，编码为向量（例如作为傅立叶特征）。这也可以是所谓的“年龄”特征，基本上帮助模型知道时间序列处于“生命中的哪个阶段”。年龄特征对于远处的过去时间步具有较小的值，并且随着我们接近当前时间步而单调增加。假日特征也是时间特征的一个很好的例子。

  这些特征充当输入的“位置编码”。因此，与像 BERT 这样的模型相反，BERT 的位置编码是从头开始内部作为模型的参数学习的，时间序列 Transformer 需要提供额外的时间特征。时间序列 Transformer 仅为static_categorical_features学习额外的嵌入。

  可以将额外的动态实数协变量连接到此张量中，但这些特征必须在预测时已知。

  这里的num_features等于config.num_time_features+config.num_dynamic_real_features。

• past_observed_mask（形状为(batch_size, sequence_length)或(batch_size, sequence_length, input_size)的torch.BoolTensor，可选）- 用于指示哪些past_values被观察到，哪些缺失。掩码值选在[0, 1]之间：

  • 对于被观察到的数值，

  • 对于missing的值为 0（即被替换为零的 NaN）。

• static_categorical_features（形状为(batch_size, number of static categorical features)的torch.LongTensor，可选）- 模型将学习一个嵌入，将这些静态分类特征添加到时间序列的值中。

  静态分类特征是所有时间步的值相同的特征（随时间保持不变）。

  静态分类特征的典型示例是时间序列 ID。

• static_real_features（形状为(batch_size, number of static real features)的torch.FloatTensor，可选）- 模型将将这些静态实数特征添加到时间序列的值中。

  静态实数特征是所有时间步的值相同的特征（随时间保持不变）。

  静态实数特征的典型示例是促销信息。

• future_values（形状为(batch_size, prediction_length)或(batch_size, prediction_length, input_size)的torch.FloatTensor，可选）- 时间序列的未来值，作为模型的标签。future_values是 Transformer 在训练期间需要学习输出的内容，给定past_values。

  这里的序列长度等于prediction_length。

  有关详细信息，请参阅演示笔记本和代码片段。

  在训练期间，任何缺失值都需要用零替换，并通过future_observed_mask指示。

  对于多变量时间序列，需要input_size > 1 维度，对应于时间序列每个时间步中的变量数量。

• future_time_features（形状为(batch_size, prediction_length, num_features)的torch.FloatTensor）- 预测窗口的必需时间特征，模型将内部将这些特征添加到future_values中。这些可能是“年份的月份”，“月份的日期”等，编码为向量（例如作为傅立叶特征）。这也可以是所谓的“年龄”特征，基本上帮助模型知道时间序列处于“生命中的哪个阶段”。年龄特征对于远处的过去时间步具有较小的值，并且随着我们接近当前时间步而单调增加。假日特征也是时间特征的一个很好的例子。

  这些特征作为输入的“位置编码”。因此，与 BERT 这样的模型不同，BERT 的位置编码是从头开始内部作为模型的参数学习的，时间序列 Transformer 需要提供额外的时间特征。时间序列 Transformer 仅为static_categorical_features学习额外的嵌入。

  可以将额外的动态实际协变量连接到此张量中，但必须在预测时已知这些特征。

  这里的num_features等于config.num_time_features+config.num_dynamic_real_features。

• future_observed_mask（形状为(batch_size, sequence_length)或(batch_size, sequence_length, input_size)的torch.BoolTensor，可选）— 布尔掩码，指示哪些future_values被观察到，哪些缺失。掩码值选定在[0, 1]之间：

  • 1 表示已观察到的值，

  • 0 表示缺失的值（即被零替换的 NaN）。

  此掩码用于过滤出最终损失计算中的缺失值。

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

  • 1 表示标记未被掩码，

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 用于避免在某些标记索引上执行注意力的掩码。默认情况下，将使用因果掩码，以确保模型只能查看以前的输入以预测未来。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）— 用于使编码器中的注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• decoder_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 表示头部被掩码。

• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包含last_hidden_state、hidden_states（可选）和attentions（可选）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)（可选）是编码器最后一层的输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。

  如果使用了past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后decoder_input_ids（即那些没有将它们的过去键值状态提供给此模型的输入）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

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

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

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

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

返回

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

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

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

  如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。

  解码器在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

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

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

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

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

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

• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出+每层的输出）。

  每层编码器的隐藏状态以及可选的初始嵌入输出。

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

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

• loc (torch.FloatTensor of shape (batch_size,) or (batch_size, input_size), optional) — 用于给模型输入相同数量级的每个时间序列上下文窗口的偏移值，然后用于将其偏移回原始数量级。

• scale (torch.FloatTensor of shape (batch_size,) or (batch_size, input_size), optional) — 用于给模型输入相同数量级的每个时间序列上下文窗口的缩放值，然后用于将其重新缩放回原始数量级。

• static_features (torch.FloatTensor of shape (batch_size, feature size), optional) — 每个时间序列在批处理中的静态特征，在推断时被复制到协变量中。

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

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

示例：

>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import InformerModel

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/tourism-monthly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> model = InformerModel.from_pretrained("huggingface/informer-tourism-monthly")

>>> # during training, one provides both past and future values
>>> # as well as possible additional features
>>> outputs = model(
...     past_values=batch["past_values"],
...     past_time_features=batch["past_time_features"],
...     past_observed_mask=batch["past_observed_mask"],
...     static_categorical_features=batch["static_categorical_features"],
...     static_real_features=batch["static_real_features"],
...     future_values=batch["future_values"],
...     future_time_features=batch["future_time_features"],
... )

>>> last_hidden_state = outputs.last_hidden_state

InformerForPrediction

class transformers.InformerForPrediction

< source >

( config: InformerConfig )

参数

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

Informer 模型在时间序列预测的顶部具有分布头。该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

< source >

( past_values: Tensor past_time_features: Tensor past_observed_mask: Tensor static_categorical_features: Optional = None static_real_features: Optional = None future_values: Optional = None future_time_features: Optional = None future_observed_mask: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None use_cache: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqTSModelOutput or tuple(torch.FloatTensor)

参数

• past_values（形状为(batch_size, sequence_length)或(batch_size, sequence_length, input_size)的torch.FloatTensor）- 时间序列的过去值，用作上下文以预测未来。此张量的序列大小必须大于模型的context_length，因为模型将使用较大的大小来构建滞后特征，即从过去添加的额外值，以充当“额外上下文”。

  这里的sequence_length等于config.context_length + max(config.lags_sequence)，如果没有配置lags_sequence，则等于config.context_length + 7（默认情况下，config.lags_sequence中最大的回顾索引为 7）。属性_past_length返回过去的实际长度。

  past_values是 Transformer 编码器作为输入接收的内容（还可以包括额外特征，如static_categorical_features、static_real_features、past_time_features和滞后）。

  可选地，缺失值需要用零替换，并通过past_observed_mask指示。

  对于多变量时间序列，input_size > 1 维度是必需的，对应于时间序列中每个时间步的变量数量。

• past_time_features（形状为(batch_size, sequence_length, num_features)的torch.FloatTensor）- 必需的时间特征，模型将内部添加到past_values中。这些可能是诸如“年份的月份”，“月份的日期”等编码为向量的内容（例如作为傅立叶特征）。这也可能是所谓的“年龄”特征，基本上帮助模型知道时间序列处于“生命中的哪个阶段”。年龄特征对于远处的过去时间步具有较小的值，并且随着我们接近当前时间步而单调增加。假期特征也是时间特征的一个很好的例子。

  这些特征充当输入的“位置编码”。因此，与像 BERT 这样的模型相反，BERT 模型中的位置编码是从头开始内部学习的模型参数，时间序列 Transformer 需要提供额外的时间特征。时间序列 Transformer 仅为static_categorical_features学习额外的嵌入。

  可以将额外的动态实协变量连接到此张量中，但必须在预测时知道这些特征。

  这里的num_features等于config.num_time_features+config.num_dynamic_real_features。

• past_observed_mask（形状为(batch_size, sequence_length)或(batch_size, sequence_length, input_size)的torch.BoolTensor，可选）- 布尔掩码，指示哪些past_values是观察到的，哪些是缺失的。掩码值选在[0, 1]之间：

  • 对于observed的值为 1，

  • 对于missing的值为 0（即用零替换的 NaN）。

• static_categorical_features（形状为(batch_size, number of static categorical features)的torch.LongTensor，可选）- 模型将学习嵌入的可选静态分类特征，然后将其添加到时间序列值中。

  静态分类特征是所有时间步的值相同的特征（随时间保持不变）。

  静态分类特征的典型示例是时间序列 ID。

• static_real_features（形状为(batch_size, number of static real features)的torch.FloatTensor，可选）- 模型将添加到时间序列值中的可选静态实特征。

  静态实特征是所有时间步的值相同的特征（随时间保持不变）。

  静态实特征的典型示例是促销信息。

• future_values（形状为(batch_size, prediction_length)或(batch_size, prediction_length, input_size)的torch.FloatTensor，可选）- 时间序列的未来值，用作模型的标签。future_values是 Transformer 在训练期间需要学习输出的内容，给定past_values。

  这里的序列长度等于prediction_length。

  查看演示笔记本和代码片段以获取详细信息。

  在训练期间，任何缺失值都需要被替换为零，并通过future_observed_mask指示。

  对于多变量时间序列，input_size > 1 维度是必需的，对应于每个时间步长中时间序列中的变量数。

• future_time_features（形状为(batch_size, prediction_length, num_features)的torch.FloatTensor）- 预测窗口所需的时间特征，模型内部将这些特征添加到future_values中。这些特征可以是诸如“年份的月份”，“月份的日期”等。编码为向量（例如傅立叶特征）。这些也可以是所谓的“年龄”特征，基本上帮助模型知道时间序列处于“生命中的哪个阶段”。年龄特征对于过去的时间步具有较小的值，并且随着我们接近当前时间步，值会单调增加。假期特征也是时间特征的一个很好的例子。

  这些特征作为输入的“位置编码”。因此，与 BERT 这样的模型相反，BERT 的位置编码是从头开始内部作为模型的参数学习的，时间序列 Transformer 需要提供额外的时间特征。时间序列 Transformer 仅为static_categorical_features学习额外的嵌入。

  可以将额外的动态实际协变量连接到这个张量中，但必须在预测时知道这些特征。

  这里的num_features等于config.num_time_features+config.num_dynamic_real_features。

• future_observed_mask（形状为(batch_size, sequence_length)或(batch_size, sequence_length, input_size)的torch.BoolTensor，可选）- 布尔掩码，指示哪些future_values是观察到的，哪些是缺失的。掩码值选在[0, 1]之间：

  • 1 表示observed的值，

  • 0 表示missing的值（即被零替换的 NaN）。

  此掩码用于过滤出最终损失计算中的缺失值。

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

  • 1 表示未被masked的标记，

  • 0 表示被masked的标记。

  什么是注意力掩码？

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 用于避免对某些标记索引执行注意力的掩码。默认情况下，将使用因果掩码，以确保模型只能查看以前的输入以预测未来。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）- 用于将编码器中注意力模块的选定头部置零的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部未被masked,

  • 0 表示头部被masked。

• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）- 用于将解码器中注意力模块的选定头部置零的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部未被masked,

  • 0 表示头部被masked。

• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）- 用于将交叉注意力模块的选定头部置零的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部未被masked,

  • 0 表示头部被masked。

• encoder_outputs（元组（元组（torch.FloatTensor）, 可选）- 元组由last_hidden_state、hidden_states（可选）和attentions（可选）组成，last_hidden_state的形状为(batch_size, sequence_length, hidden_size)（可选）是编码器最后一层的隐藏状态的序列。用于解码器的交叉注意力。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 由长度为config.n_layers的tuple(torch.FloatTensor)组成的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。

  如果使用past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（这些没有将它们的过去键值状态提供给此模型）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

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

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

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

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

返回

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

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

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

  如果使用past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 由长度为config.n_layers的tuple(torch.FloatTensor)组成的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。

• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 由torch.FloatTensor组成的元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。

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

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

• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。

  编码器在每一层输出的隐藏状态，以及可选的初始嵌入输出。

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

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

• loc（形状为(batch_size,)或(batch_size, input_size)的torch.FloatTensor，可选）- 每个时间序列上下文窗口的偏移值，用于给模型输入相同数量级的值，然后用于将其偏移回原始数量级。

• scale（形状为(batch_size,)或(batch_size, input_size)的torch.FloatTensor，可选）- 每个时间序列上下文窗口的缩放值，用于给模型输入相同数量级的值，然后用于将其重新缩放回原始数量级。

• static_features（形状为(batch_size, feature size)的torch.FloatTensor，可选）- 批处理中每个时间序列的静态特征，在推断时复制到协变量中。

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

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

示例：

>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import InformerForPrediction

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/tourism-monthly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> model = InformerForPrediction.from_pretrained(
...     "huggingface/informer-tourism-monthly"
... )

>>> # during training, one provides both past and future values
>>> # as well as possible additional features
>>> outputs = model(
...     past_values=batch["past_values"],
...     past_time_features=batch["past_time_features"],
...     past_observed_mask=batch["past_observed_mask"],
...     static_categorical_features=batch["static_categorical_features"],
...     static_real_features=batch["static_real_features"],
...     future_values=batch["future_values"],
...     future_time_features=batch["future_time_features"],
... )

>>> loss = outputs.loss
>>> loss.backward()

>>> # during inference, one only provides past values
>>> # as well as possible additional features
>>> # the model autoregressively generates future values
>>> outputs = model.generate(
...     past_values=batch["past_values"],
...     past_time_features=batch["past_time_features"],
...     past_observed_mask=batch["past_observed_mask"],
...     static_categorical_features=batch["static_categorical_features"],
...     static_real_features=batch["static_real_features"],
...     future_time_features=batch["future_time_features"],
... )

>>> mean_prediction = outputs.sequences.mean(dim=1)

PatchTSMixer

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

概述

PatchTSMixer 模型是由 Vijay Ekambaram、Arindam Jati、Nam Nguyen、Phanwadee Sinthong 和 Jayant Kalagnanam 在TSMixer: Lightweight MLP-Mixer Model for Multivariate Time Series Forecasting中提出的。

PatchTSMixer 是基于 MLP-Mixer 架构的轻量级时间序列建模方法。在这个 HuggingFace 实现中，我们提供了 PatchTSMixer 的功能，以轻松促进跨补丁、通道和隐藏特征的轻量级混合，以实现有效的多变量时间序列建模。它还支持各种注意机制，从简单的门控注意力到更复杂的自注意力块，可以根据需要进行定制。该模型可以进行预训练，随后用于各种下游任务，如预测、分类和回归。

论文摘要如下：

TSMixer 是一种轻量级的神经架构，专门由多层感知器（MLP）模块组成，设计用于修补时间序列上的多变量预测和表示学习。我们的模型受到 MLP-Mixer 模型在计算机视觉中的成功启发。我们展示了将视觉 MLP-Mixer 调整为时间序列时涉及的挑战，并引入了经验验证的组件来提高准确性。这包括一种新颖的设计范式，将在线协调头附加到 MLP-Mixer 骨干上，以明确地建模时间序列的属性，如层次结构和通道相关性。我们还提出了一种混合通道建模方法，以有效处理嘈杂的通道交互和跨多样数据集的泛化，这是现有补丁通道混合方法中的一个常见挑战。此外，在骨干中引入了一个简单的门控注意机制，以优先处理重要特征。通过整合这些轻量级组件，我们显著增强了简单 MLP 结构的学习能力，优于具有最小计算使用的复杂 Transformer 模型。此外，TSMixer 的模块化设计使其与监督和掩蔽自监督学习方法兼容，使其成为时间序列基础模型的有前途的构建模块。TSMixer 在预测方面的表现明显优于最先进的 MLP 和 Transformer 模型，差距为 8-60%。它还在内存和运行时间上优于最新的强大基准 Patch-Transformer 模型（提高了 1-2%），同时显著减少了内存和运行时间（2-3 倍）。

该模型由ajati, vijaye12, gsinthong, namctin, wmgifford, kashif贡献。

示例用法

from transformers import PatchTSMixerConfig, PatchTSMixerForPrediction
from transformers import Trainer, TrainingArguments,

config = PatchTSMixerConfig(context_length = 512, prediction_length = 96)
model = PatchTSMixerForPrediction(config)
trainer = Trainer(model=model, args=training_args, 
            train_dataset=train_dataset,
            eval_dataset=valid_dataset)
trainer.train()
results = trainer.evaluate(test_dataset)

使用提示

该模型还可用于时间序列分类和时间序列回归。请查看相应的 PatchTSMixerForTimeSeriesClassification 和 PatchTSMixerForRegression 类。

PatchTSMixerConfig

class transformers.PatchTSMixerConfig

<来源>

( context_length: int = 32 patch_len: int = 8 num_input_channels: int = 1 patch_stride: int = 8 num_parallel_samples: int = 100 d_model: int = 8 expansion_factor: int = 2 num_layers: int = 3 dropout: float = 0.2 mode: str = 'common_channel' gated_attn: bool = True norm_mlp: str = 'LayerNorm' self_attn: bool = False self_attn_heads: int = 1 use_positional_encoding: bool = False positional_encoding_type: str = 'sincos' scaling: Union = 'std' loss: str = 'mse' init_std: float = 0.02 post_init: bool = False norm_eps: float = 1e-05 mask_type: str = 'random' random_mask_ratio: float = 0.5 num_forecast_mask_patches: Union = [2] mask_value: int = 0 masked_loss: bool = True channel_consistent_masking: bool = True unmasked_channel_indices: Optional = None head_dropout: float = 0.2 distribution_output: str = 'student_t' prediction_length: int = 16 prediction_channel_indices: list = None num_targets: int = 3 output_range: list = None head_aggregation: str = 'max_pool' **kwargs )

参数

• context_length (int, 可选, 默认为 32) — 输入序列的上下文/历史长度。

• patch_len (int, 可选, 默认为 8) — 输入序列的补丁长度。

• num_input_channels (int, 可选, 默认为 1) — 输入变量的数量。对于单变量，将其设置为 1。

• patch_stride (int, optional, 默认为 8) — 确定两个连续补丁之间的重叠。如果我们想要非重叠的补丁，则将其设置为 patch_length（或更大）。

• num_parallel_samples (int, optional, 默认为 100) — 用于概率预测并行生成的样本数量。

• d_model (int, optional, 默认为 8) — 模型的隐藏维度。建议将其设置为 patch_length 的倍数（即 patch_len 的 2-5 倍）。较大的值表示更复杂的模型。

• expansion_factor (int, optional, 默认为 2) — 在 MLP 内部使用的扩展因子。推荐范围为 2-5。较大的值表示更复杂的模型。

• num_layers (int, optional, 默认为 3) — 要使用的层数。推荐范围为 3-15。较大的值表示更复杂的模型。

• dropout (float, optional, 默认为 0.2) — PatchTSMixer主干的丢失概率。推荐范围为 0.2-0.7

• mode (str, optional, 默认为"common_channel") — Mixer 模式。确定如何处理通道。允许的值："common_channel"、“mix_channel”。在"common_channel"模式中，我们遵循独立于通道的建模，没有显式的通道混合。通道混合通过跨通道共享权重以隐式方式发生。（首选第一种方法）在“mix_channel”模式中，我们遇到显式的通道混合以及补丁和特征混合。（当通道相关性对模型非常重要时，首选方法）

• gated_attn (bool, optional, 默认为True) — 启用门控注意力。

• norm_mlp (str, optional, 默认为"LayerNorm") — 归一化层（BatchNorm 或 LayerNorm）。

• self_attn (bool, optional, 默认为False) — 在补丁之间启用小型自注意力。当 Vanilla PatchTSMixer 的门控注意力的输出不理想时，可以启用此功能。启用此功能会导致显式的成对注意力和跨补丁建模。

• self_attn_heads (int, optional, 默认为 1) — 自注意力头的数量。仅当self_attn设置为True时才有效。

• use_positional_encoding (bool, optional, 默认为False) — 启用小型自注意力层的位置嵌入使用。仅当self_attn设置为True时才有效。

• positional_encoding_type (str, optional, 默认为"sincos") — 位置编码。支持选项"random"和"sincos"。仅当use_positional_encoding设置为True时才有效。

• scaling (string或bool, optional, 默认为"std") — 是否通过“mean”缩放器、"std"缩放器或如果为None则不缩放输入目标。如果为True，则缩放器设置为“mean”。

• loss (string, optional, 默认为"mse") — 与distribution_output头对应的模型的损失函数。对于参数分布，它是负对数似然（“nll”），对于点估计，它是均方误差"mse"。

• init_std (float, optional, 默认为 0.02) — 截断正态权重初始化分布的标准差。

• post_init (bool, optional, 默认为False) — 是否使用transformers库中的自定义权重初始化，或者使用PyTorch中的默认初始化。将其设置为False执行PyTorch权重初始化。

• norm_eps (float, optional, 默认为 1e-05) — 用于归一化的分母的数值稳定性的值。

• mask_type (str, optional, 默认为"random") — 用于掩码预训练模式的掩码类型。允许的值为"random"、“forecast”。在随机掩码中，点被随机掩盖。在预测掩码中，点被朝向末尾掩盖。

• random_mask_ratio (float, optional, 默认为 0.5) — 当mask_type为random时使用的掩码比例。较高的值表示更多的掩码。

• num_forecast_mask_patches (int or list, optional, defaults to [2]) — 每个批次样本末尾要屏蔽的补丁数量。如果是整数，则批次中的所有样本将具有相同数量的屏蔽补丁。如果是列表，则批次中的样本将随机屏蔽列表中定义的数字。此参数仅用于预测预训练。

• mask_value (float, optional, defaults to 0.0) — 要使用的屏蔽值。

• masked_loss (bool, optional, defaults to True) — 是否仅在屏蔽部分计算预训练损失，还是在整个输出上计算。

• channel_consistent_masking (bool, optional, defaults to True) — 当为 True 时，屏蔽将在时间序列的所有通道上相同。否则，屏蔽位置将在通道之间变化。

• unmasked_channel_indices (list, optional) — 预训练期间未屏蔽的通道。

• head_dropout (float, optional, defaults to 0.2) — PatchTSMixer 头部的 dropout 概率。

• distribution_output (string, optional, defaults to "student_t") — 当损失为“nll”时，模型的分布发射头。可以是"student_t"、“normal”或“negative_binomial”。

• prediction_length (int, optional, defaults to 16) — 用于预测任务的预测时间步数。也称为预测视野。

• prediction_channel_indices (list, optional) — 要预测的通道索引列表。如果为 None，则预测所有通道。目标数据预期具有所有通道，我们在损失计算之前明确过滤预测和目标中的通道。

• num_targets (int, optional, defaults to 3) — 回归任务的目标数量（回归变量的维度）。

• output_range (list, optional) — 用于限制回归任务的输出范围。默认为 None。

• head_aggregation (str, optional, defaults to "max_pool") — 用于分类或回归任务的聚合模式。允许的值为 None、"use_last"、"max_pool"、"avg_pool"。

这是一个配置类，用于存储 PatchTSMixerModel 的配置。根据指定的参数实例化一个 PatchTSMixer 模型，定义模型架构。使用默认值实例化配置将产生与 PatchTSMixer ibm/patchtsmixer-etth1-pretrain 架构类似的配置。

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

示例：

>>> from transformers import PatchTSMixerConfig, PatchTSMixerModel

>>> # Initializing a default PatchTSMixer configuration
>>> configuration = PatchTSMixerConfig()

>>> # Randomly initializing a model (with random weights) from the configuration
>>> model = PatchTSMixerModel(configuration)

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

PatchTSMixerModel

class transformers.PatchTSMixerModel

< source >

( config: PatchTSMixerConfig mask_input: bool = False )

参数

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

• mask_input (bool, optional, defaults to False) — 如果为 True，则启用屏蔽。否则为 False。

用于时间序列预测的 PatchTSMixer 模型。

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

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

forward

<来源>

( past_values: Tensor observed_mask: Optional = None output_hidden_states: Optional = False return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerModelOutput or tuple(torch.FloatTensor)

参数

• past_values (torch.FloatTensor，形状为(batch_size, seq_length, num_input_channels)) — 时间序列的上下文值。对于预训练任务，这表示要预测掩码部分的输入时间序列。对于预测任务，这表示历史/过去的时间序列值。同样，对于分类或回归任务，它表示时间序列的适当上下文值。

  对于单变量时间序列，num_input_channels维度应为 1。对于多变量时间序列，它大于 1。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。

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

• observed_mask (torch.FloatTensor，形状为(batch_size, sequence_length, num_input_channels)，可选) — 布尔蒙版，指示哪些past_values是观察到的，哪些是缺失的。蒙版值选择在[0, 1]之间：

  • 1 表示observed的值，

  • 0 表示missing的值（即被零替换的 NaN）。

返回

transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerModelOutput或tuple(torch.FloatTensor)

一个transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerModelOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（PatchTSMixerConfig）和输入的各种元素。

• last_hidden_state (torch.FloatTensor，形状为(batch_size, num_channels, num_patches, d_model)) — 模型最后一层的隐藏状态。

• hidden_states (tuple(torch.FloatTensor)，可选) — 模型在每一层输出的隐藏状态。

• patch_input (torch.FloatTensor，形状为(batch_size, num_channels, num_patches, patch_length)) — 输入到模型的补丁化数据。

• mask: (torch.FloatTensor，形状为(batch_size, num_channels, num_patches)，可选) — 布尔张量，指示掩码补丁中的 True 和其他地方的 False。

• loc: (torch.FloatTensor，形状为(batch_size, 1, num_channels)，可选) — 给出每个通道上下文窗口的均值。如果启用了 revin，则用于模型外的 revin 反归一化。

• scale: (torch.FloatTensor，形状为(batch_size, 1, num_channels)，可选) — 给出每个通道上下文窗口的标准差。如果启用了 revin，则用于模型外的 revin 反归一化。

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

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

PatchTSMixerForPrediction

class transformers.PatchTSMixerForPrediction

<来源>

( config: PatchTSMixerConfig )

参数

• config (PatchTSMixerConfig, required) — 配置。

用于预测应用的 PatchTSMixer。

forward

< source >

( past_values: Tensor observed_mask: Optional = None future_values: Optional = None output_hidden_states: Optional = False return_loss: bool = True return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerForPredictionOutput or tuple(torch.FloatTensor)

参数

• past_values (torch.FloatTensor of shape (batch_size, seq_length, num_input_channels)) — 时间序列的上下文值。对于预训练任务，这表示用于预测被屏蔽部分的输入时间序列。对于预测任务，这表示历史/过去的时间序列值。同样，对于分类或回归任务，它表示时间序列的适当上下文值。

  对于单变量时间序列，num_input_channels 维度应为 1。对于多变量时间序列，它大于 1。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。

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

• observed_mask (torch.FloatTensor of shape (batch_size, sequence_length, num_input_channels), optional) — 布尔掩码，指示哪些 past_values 是观察到的，哪些是缺失的。掩码值选在 [0, 1]：

  • 对于 observed 的值为 1，

  • 对于 missing 的值为 0（即被零替换的 NaN）。

• future_values (torch.FloatTensor of shape (batch_size, target_len, num_input_channels) 用于预测， — (batch_size, num_targets) 用于回归，或 (batch_size,) 用于分类， optional): 时间序列的目标值，作为模型的标签。future_values 是训练期间 Transformer 需要的，以学习在给定 past_values 时输出。请注意，这对于预训练任务并非必需。

  对于预测任务，形状为 (batch_size, target_len, num_input_channels)。即使我们想通过在 prediction_channel_indices 参数中设置索引来仅预测特定通道，也要传递带有所有通道的目标数据，因为在损失计算之前，预测和目标的通道过滤将手动应用。

• return_loss (bool, optional) — 是否在 forward 调用中返回损失。

返回

transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerForPredictionOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerForPredictionOutput 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（PatchTSMixerConfig）和输入的不同元素。

• prediction_outputs (torch.FloatTensor of shape (batch_size, prediction_length, num_input_channels)) — 预测头部的预测输出。

• last_hidden_state (torch.FloatTensor of shape (batch_size, num_input_channels, num_patches, d_model)) — 通过头部之前的主干嵌入。

• hidden_states (tuple(torch.FloatTensor), optional) — 模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。

• loss (optional, 当提供 y 时返回，形状为 () 的 torch.FloatTensor) — 总损失。

• loc (torch.FloatTensor, optional of shape (batch_size, 1, num_input_channels)) — 输入均值

• scale (torch.FloatTensor, optional of shape (batch_size, 1, num_input_channels)) — 输入标准差

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

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

PatchTSMixerForTimeSeriesClassification

class transformers.PatchTSMixerForTimeSeriesClassification

<来源>

( config: PatchTSMixerConfig )

参数

• config (PatchTSMixerConfig, 必需) — 配置。

用于分类应用的PatchTSMixer。

forward

<来源>

( past_values: Tensor future_values: Tensor = None output_hidden_states: Optional = False return_loss: bool = True return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerForTimeSeriesClassificationOutput or tuple(torch.FloatTensor)

参数

• past_values (torch.FloatTensor of shape (batch_size, seq_length, num_input_channels)) — 时间序列的上下文值。对于预训练任务，这表示要预测掩码部分的输入时间序列。对于预测任务，这表示历史/过去的时间序列值。类似地，对于分类或回归任务，它表示时间序列的适当上下文值。

  对于单变量时间序列，num_input_channels维度应为 1。对于多变量时间序列，它大于 1。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。

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

• future_values (torch.FloatTensor of shape (batch_size, target_len, num_input_channels) 用于预测，— (batch_size, num_targets) 用于回归，或 (batch_size,) 用于分类，可选): 时间序列的目标值，作为模型的标签。future_values是 Transformer 在训练期间需要的，以便学习如何输出，给定past_values。请注意，这对于预训练任务并不是必需的。

  对于预测任务，形状为(batch_size, target_len, num_input_channels)。即使我们只想通过在prediction_channel_indices参数中设置索引来预测特定通道，也要传递带有所有通道的目标数据，因为在计算损失之前，预测和目标的通道过滤将手动应用。

  对于分类任务，形状为(batch_size,)。

  对于回归任务，形状为(batch_size, num_targets)。

• return_loss (bool, 可选) — 是否在forward调用中返回损失。

返回

transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerForTimeSeriesClassificationOutput 或 tuple(torch.FloatTensor)

一个transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerForTimeSeriesClassificationOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（PatchTSMixerConfig）和输入的各种元素。

• prediction_outputs (torch.FloatTensor of shape (batch_size, num_labels)) — 分类头部的预测输出。

• last_hidden_state (torch.FloatTensor of shape (batch_size, num_input_channels, num_patches, d_model)) — 通过头部之前的主干嵌入。

• hidden_states (tuple(torch.FloatTensor), 可选) — 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。

• loss (可选, 当提供y时返回, torch.FloatTensor of shape ()) — 总损失。

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

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

PatchTSMixerForPretraining

class transformers.PatchTSMixerForPretraining

<来源>

( config: PatchTSMixerConfig )

参数

• config（PatchTSMixerConfig，必需）— 配置。

PatchTSMixer用于掩码预训练。

forward

<来源>

( past_values: Tensor observed_mask: Optional = None output_hidden_states: Optional = False return_loss: bool = True return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerForPreTrainingOutput or tuple(torch.FloatTensor)

参数

• past_values（形状为(batch_size, seq_length, num_input_channels)的torch.FloatTensor）— 时间序列的上下文值。对于预训练任务，这表示要预测掩码部分的输入时间序列。对于预测任务，这表示历史/过去的时间序列值。同样，对于分类或回归任务，它表示时间序列的适当上下文值。

  对于单变量时间序列，num_input_channels维度应为 1。对于多变量时间序列，它大于 1。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。

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

• observed_mask（形状为(batch_size, sequence_length, num_input_channels)的torch.FloatTensor，可选）— 布尔掩码，指示哪些past_values是观察到的，哪些是缺失的。掩码值选在[0, 1]之间：

  • 1 表示observed的值，

  • 0 表示missing的值（即被零替换的 NaN）。

• return_loss（bool，可选）— 是否在forward调用中返回损失。

返回

transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerForPreTrainingOutput或tuple(torch.FloatTensor)

一个transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerForPreTrainingOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含各种元素，取决于配置（PatchTSMixerConfig）和输入。

• prediction_outputs（形状为(batch_size, num_input_channels, num_patches, patch_length)的torch.FloatTensor）— 来自预训练头部的预测输出。

• hidden_states（tuple(torch.FloatTensor)，可选）— 模型在每一层输出的隐藏状态。

• last_hidden_state（形状为(batch_size, num_input_channels, num_patches, d_model)的torch.FloatTensor）— 通过头部之前的主干嵌入。

• loss（可选，在提供y时返回，形状为()的torch.FloatTensor）— 总损失

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

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

PatchTSMixerForRegression

class transformers.PatchTSMixerForRegression

<来源>

( config: PatchTSMixerConfig )

参数

• config（PatchTSMixerConfig，必需）— 配置。

PatchTSMixer用于回归应用。

forward

<来源>

( past_values: Tensor future_values: Tensor = None output_hidden_states: Optional = False return_loss: bool = True return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerForRegressionOutput or tuple(torch.FloatTensor)

参数

• past_values（形状为(batch_size, seq_length, num_input_channels)的torch.FloatTensor）：时间序列的上下文值。对于预训练任务，这表示要预测掩码部分的输入时间序列。对于预测任务，这表示历史/过去的时间序列值。同样，对于分类或回归任务，它表示时间序列的适当上下文值。

  对于单变量时间序列，num_input_channels维度应为 1。对于多变量时间序列，它大于 1。

• output_hidden_states（bool，可选）：是否返回所有层的隐藏状态。

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

• future_values（形状为(batch_size, target_len, num_input_channels)的torch.FloatTensor用于预测，形状为(batch_size, num_targets)用于回归，或形状为(batch_size,)用于分类，可选）：时间序列的目标值，作为模型的标签。future_values是 Transformer 在训练期间需要的，以便学习在给定past_values时输出。请注意，这对于预训练任务是不需要的。

  对于一个预测任务，形状应为(batch_size, target_len, num_input_channels)。即使我们只想通过在prediction_channel_indices参数中设置索引来预测特定通道，也要传递带有所有通道的目标数据，因为在损失计算之前，预测和目标的通道过滤将手动应用。

  对于分类任务，形状为(batch_size,)。

  对于回归任务，形状为(batch_size, num_targets)。

• return_loss（bool，可选）：是否在forward调用中返回损失。

返回值

transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerForRegressionOutput或tuple(torch.FloatTensor)

一个transformers.models.patchtsmixer.modeling_patchtsmixer.PatchTSMixerForRegressionOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（PatchTSMixerConfig）和输入的不同元素。

• prediction_outputs（形状为(batch_size, num_targets)的torch.FloatTensor）：回归头部的预测输出。

• last_hidden_state（形状为(batch_size, num_input_channels, num_patches, d_model)的torch.FloatTensor）：通过头部之前的主干嵌入。

• hidden_states（tuple(torch.FloatTensor)，可选）：模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

• loss（可选，在提供y时返回，形状为()的torch.FloatTensor）：总损失。

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

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