Transformers 4.37 中文文档（九十七）

原文：huggingface.co/docs/transformers

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)

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