gluonts.torch.model.tft 包#

class gluonts.torch.model.tft.TemporalFusionTransformerEstimator(freq: str, prediction_length: int, context_length: Optional[int] = None, quantiles: Optional[List[float]] = None, distr_output: Optional[gluonts.torch.distributions.output.Output] = None, num_heads: int = 4, hidden_dim: int = 32, variable_dim: int = 32, static_dims: Optional[List[int]] = None, dynamic_dims: Optional[List[int]] = None, past_dynamic_dims: Optional[List[int]] = None, static_cardinalities: Optional[List[int]] = None, dynamic_cardinalities: Optional[List[int]] = None, past_dynamic_cardinalities: Optional[List[int]] = None, time_features: Optional[List[Callable[[pandas.core.indexes.period.PeriodIndex], numpy.ndarray]]] = None, lr: float = 0.001, weight_decay: float = 1e-08, dropout_rate: float = 0.1, patience: int = 10, batch_size: int = 32, num_batches_per_epoch: int = 50, trainer_kwargs: Optional[Dict[str, Any]] = None, train_sampler: Optional[gluonts.transform.sampler.InstanceSampler] = None, validation_sampler: Optional[gluonts.transform.sampler.InstanceSampler] = None)[source]#

基类: gluonts.torch.model.estimator.PyTorchLightningEstimator

Temporal Fusion Transformer (TFT) 模型训练的 Estimator 类，如 [LAL+21] 所述。

TFT 在进行预测时内部执行特征选择。因此，如果实值特征的维度对应于同一变量（例如，将天气特征视为一个特征，将假期指标视为另一个特征），则可以将这些维度分组在一起。

例如，如果数据集包含形状为 [batch_size, 3] 的键 “feat_static_real”，我们可以： - 设置 static_dims = [3] 将所有三个维度视为一个特征 - 设置 static_dims = [1, 1, 1] 将每个维度视为一个单独的特征 - 设置 static_dims = [2, 1] 将前两个维度视为一个特征

有关模型配置如何对应预期输入形状的更多详细信息，请参阅 gluonts.torch.model.tft.TemporalFusionTransformerModel.input_shapes。

参数

  • freq – 用于训练和预测的数据频率。

  • prediction_length (int) – 预测范围的长度。

  • context_length – 提供给编码器的先前时间序列值的数量。(默认值: None, 此时 context_length = prediction_length)。

  • quantiles – 模型将学习预测的分位数列表。默认为 [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

  • distr_output – 要使用的分布输出 (默认值: QuantileOutput)。

  • num_heads – 解码器中自注意力层中的注意力头数量。

  • hidden_dim – LSTM 和 Transformer 隐藏状态的大小。

  • variable_dim – 特征嵌入的大小。

  • static_dims – 实值静态特征的大小。

  • dynamic_dims – 未来已知实值动态特征的大小。

  • past_dynamic_dims – 仅在过去已知实值动态特征的大小。

  • static_cardinalities – 分类静态特征的基数。

  • dynamic_cardinalities – 未来已知分类动态特征的基数。

  • past_dynamic_cardinalities – 仅在过去已知分类动态特征的基数。

  • time_features – 时间特征列表，来自 gluonts.time_feature，用作除了提供的数据之外的动态实值特征（默认值: None, 此时这些特征会根据 freq 自动确定）。

  • lr – 学习率 (默认值: 1e-3)。

  • weight_decay – 权重衰减 (默认值: 1e-8)。

  • dropout_rate – Dropout 正则化参数 (默认值: 0.1)。

  • patience – 学习率调度器的耐心参数。

  • batch_size – 用于训练的批次大小 (默认值: 32)。

  • num_batches_per_epoch (int = 50,) – 每个训练 epoch 中要处理的批次数 (默认值: 50)。

  • trainer_kwargs – 提供给 pl.Trainer 以构建训练器的额外参数。

  • train_sampler – 控制训练期间窗口的采样。

  • validation_sampler – 控制验证期间窗口的采样。

create_lightning_module() → gluonts.torch.model.tft.lightning_module.TemporalFusionTransformerLightningModule[source]#

创建并返回用于训练的网络（即，计算损失）。

返回值

给定输入数据计算损失的网络。

返回类型

pl.LightningModule

create_predictor(transformation: gluonts.transform._base.Transformation, module: gluonts.torch.model.tft.lightning_module.TemporalFusionTransformerLightningModule) → gluonts.torch.model.predictor.PyTorchPredictor[source]#

创建并返回一个预测器对象。

参数

  • transformation – 数据进入模型之前应用的转换。

  • module – 一个训练好的 pl.LightningModule 对象。

返回值

一个封装用于推理的 nn.Module 的预测器。

返回类型

预测器

create_training_data_loader(data: gluonts.dataset.Dataset, module: gluonts.torch.model.tft.lightning_module.TemporalFusionTransformerLightningModule, shuffle_buffer_length: Optional[int] = None, **kwargs) → Iterable[source]#

创建一个用于训练的数据加载器。

参数

  • data – 用于创建数据加载器的数据集。

  • module – 将接收来自数据加载器的批次的 pl.LightningModule 对象。

返回值

数据加载器，即数据批次的迭代器。

返回类型

Iterable

create_transformation() → gluonts.transform._base.Transformation[source]#

创建并返回训练和推理所需的转换。

返回值

将在训练和推理时逐条应用于数据集的转换。

返回类型

转换

create_validation_data_loader(data: gluonts.dataset.Dataset, module: gluonts.torch.model.tft.lightning_module.TemporalFusionTransformerLightningModule, **kwargs) → Iterable[source]#

创建一个用于验证的数据加载器。

参数

  • data – 用于创建数据加载器的数据集。

  • module – 将接收来自数据加载器的批次的 pl.LightningModule 对象。

返回值

数据加载器，即数据批次的迭代器。

返回类型

Iterable

input_names()[source]#
lead_time: int#
prediction_length: int#
class gluonts.torch.model.tft.TemporalFusionTransformerLightningModule(model_kwargs: dict, lr: float = 0.001, patience: int = 10, weight_decay: float = 0.0)[source]#

基类: lightning.pytorch.core.module.LightningModule

一个 pl.LightningModule 类，可用于使用 PyTorch Lightning 训练 TemporalFusionTransformerModel。

这是 TemporalFusionTransformerModel 对象（已封装）的薄层，公开了评估训练和验证损失的方法。

参数

  • model_kwargs – 用于构建待训练的 TemporalFusionTransformerModel 的关键字参数。

  • lr – 学习率。

  • weight_decay – 权重衰减正则化参数。

  • patience – 学习率调度器的耐心参数。

configure_optimizers()[source]#

返回要使用的优化器。

forward(*args, **kwargs)[source]#

与 torch.nn.Module.forward() 相同。

参数

  • *args – 您决定传递给 forward 方法的任何参数。

  • **kwargs – 也可能是关键字参数。

返回值

您的模型输出

training_step(batch, batch_idx: int)[source]#

执行训练步骤。

validation_step(batch, batch_idx: int)[source]#

执行验证步骤。

class gluonts.torch.model.tft.TemporalFusionTransformerModel(context_length: int, prediction_length: int, d_feat_static_real: Optional[List[int]] = None, c_feat_static_cat: Optional[List[int]] = None, d_feat_dynamic_real: Optional[List[int]] = None, c_feat_dynamic_cat: Optional[List[int]] = None, d_past_feat_dynamic_real: Optional[List[int]] = None, c_past_feat_dynamic_cat: Optional[List[int]] = None, num_heads: int = 4, d_hidden: int = 32, d_var: int = 32, dropout_rate: float = 0.1, distr_output: Optional[gluonts.torch.distributions.output.Output] = None)[source]#

基类: torch.nn.modules.module.Module

Temporal Fusion Transformer 神经网络。

部分基于 github.com/kashif/pytorch-transformer-ts 中的实现。

输入 feat_static_real, feat_static_cat 和 feat_dynamic_real 是必需的。输入 feat_dynamic_cat, past_feat_dynamic_real 和 past_feat_dynamic_cat 是可选的。

describe_inputs(batch_size=1) → gluonts.model.inputs.InputSpec[source]#
forward(past_target: torch.Tensor, past_observed_values: torch.Tensor, feat_static_real: Optional[torch.Tensor], feat_static_cat: Optional[torch.Tensor], feat_dynamic_real: Optional[torch.Tensor], feat_dynamic_cat: Optional[torch.Tensor] = None, past_feat_dynamic_real: Optional[torch.Tensor] = None, past_feat_dynamic_cat: Optional[torch.Tensor] = None) → Tuple[Tuple[torch.Tensor, ...], torch.Tensor, torch.Tensor][source]#

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

尽管前向传播的实现需要在该函数内定义，但之后应调用 Module 实例而不是直接调用此函数，因为前者负责运行已注册的钩子，而后者会静默忽略它们。

input_types() → Dict[str, torch.dtype][source]#
loss(past_target: torch.Tensor, past_observed_values: torch.Tensor, future_target: torch.Tensor, future_observed_values: torch.Tensor, feat_static_real: torch.Tensor, feat_static_cat: torch.Tensor, feat_dynamic_real: torch.Tensor, feat_dynamic_cat: Optional[torch.Tensor] = None, past_feat_dynamic_real: Optional[torch.Tensor] = None, past_feat_dynamic_cat: Optional[torch.Tensor] = None) → torch.Tensor[source]#
training: bool#