1
0

DeepTime：时间序列预测中的元学习模型

DeepTime，是一个结合使用元学习的深度时间指数模型。通过使用元学习公式来预测未来，以应对时间序列中的常见问题（协变量偏移和条件分布偏移——非平稳）。该模型是时间序列预测的元学习公式协同作用的一个很好的例子。

DeepTime架构

DeepTime组件

DeepTime中有三种类型的层:

  • 岭回归
  • 多层感知机(MLP)
  • 随机傅里叶特征

让我们看看这些层在做什么:

岭回归

多层感知机(MLP)

这些是在神经网络(nn)中使用的线性回归公式。然后使用了一个ReLU函数激活。这些层非常适合将时间指数映射到该时间指数的时间序列值。公式如下:

随机的傅里叶层

随机傅里叶允许mlp学习高频模式。尽管随机傅里叶层需要为每个任务和数据集找到不同的超参数(只是为了不过度拟合或不足拟合)，但作者通过将各种傅里叶基函数与各种尺度参数相结合来限制这种计算。

DeepTIME架构

在每个任务中，选择一个时间序列，然后将其分为主干窗口(绿色)和预测窗口(蓝色)两部分。然后，然后他们通过两个彼此共享信息并与元参数关联的元模型。 在上图描述的架构上训练模型后，计算损失函数并尝试将其最小化。

其他时间序列预测模型的区别

DeepTIME是一个时间指数模型，就像Prophet，高斯过程等，而最近比较突出的模型如N-HiTS, Autoformer, DeepAR, Informer等都是历史价值模型。

当我们说时间序列的时间指数模型时，确切的意思是预测绝对随时间变化(它考虑了当前的时间指数特征)。另一方面，历史价值模型使用以前的事件来预测未来。这个公式能让你更清楚。：）

它包含了元学习公式，这意味着这个模型可以学会如何学习。由于它是一个时间指数模型，可以在元学习中表现出更好的样本效率。

它采用直接多步估计(DMS)的方法（DMS模型一次直接预测几个数据点）。另外通过多步迭代（IMS），它只预测下一个值，然后使用它来预测下一个数据点，这与ARIMA、DeepAR等相同。

元学习给时间序列预测带来了什么？

  • 更好的任务泛化
  • 符合附近时间步长遵循局部平稳分布的假设。
  • 还包含了相似的时间点将具有相似的特征的假设。

模型如何预测

在每一次训练时，将数据分为两个窗口(通过使用第一个窗口预测第二个窗口)。这里为了简单起见使用PyTorch Lightning简化训练过程。

  1.  importnumpyasnp
  2.  importgin
  3.  importpytorch_lightningaspl
  4.  
  5.  frommodelsimportget_model
  6.  importrandom
  7.  
  8.  importtorch
  9.  importtorch.nn.functionalasF
  10.  fromtorchimportoptim
  11.  
  12.  importmath
  13.  
  14.  fromutilsimportCheckpoint, default_device, to_tensor
  15.  @gin.configurable
  16.  classDeepTimeTrainer(pl.LightningModule):
  17.  
  18.      def__init__(self,
  19.                   lr,
  20.                   lambda_lr,
  21.                   weight_decay,
  22.                   warmup_epochs,
  23.                   random_seed,
  24.                   T_max,
  25.                   eta_min,
  26.                   dim_size,
  27.                   datetime_feats,
  28.                   ):
  29.          gin.parse_config_file('/home/reza/Projects/PL_DeepTime/DeepTime/config/config.gin')
  30.          super(DeepTimeTrainer, self).__init__()
  31.          self.lr=lr
  32.          self.lambda_lr=lambda_lr
  33.          self.weight_decay=weight_decay
  34.          self.warmup_epochs=warmup_epochs
  35.          self.random_seed=random_seed
  36.          self.lr=lr
  37.          self.lambda_lr=lambda_lr
  38.          self.weight_decay=weight_decay
  39.          self.T_max=T_max
  40.          self.warmup_epochs=warmup_epochs
  41.          self.eta_min=eta_min
  42.          self.model=get_model(
  43.              model_type='deeptime',
  44.              dim_size=dim_size,
  45.              datetime_feats=datetime_feats
  46.          )
  47.  
  48.      defon_fit_start(self):
  49.          torch.manual_seed(self.random_seed)
  50.          np.random.seed(self.random_seed)
  51.          random.seed(self.random_seed)
  52.  
  53.      deftraining_step(self, batch, batch_idx):
  54.          x, y, x_time, y_time=map(to_tensor, batch)
  55.          forecast=self.model(x, x_time, y_time)
  56.  
  57.          ifisinstance(forecast, tuple):
  58.              # for models which require reconstruction + forecast loss
  59.              loss=F.mse_loss(forecast[0], x) + \
  60.                     F.mse_loss(forecast[1], y)
  61.          else:
  62.              loss=F.mse_loss(forecast, y)
  63.  
  64.          self.log('train_loss', loss, prog_bar=True, on_epoch=True)
  65.  
  66.          return {'loss': loss, 'train_loss': loss, }
  67.  
  68.      deftraining_epoch_end(self, outputs):
  69.          avg_train_loss=torch.stack([x["train_loss"] forxinoutputs]).mean()
  70.  
  71.          self.log('avg_train_loss', avg_train_loss, on_epoch=True, sync_dist=True)
  72.  
  73.      defvalidation_step(self, batch, batch_idx):
  74.  
  75.          x, y, x_time, y_time=map(to_tensor, batch)
  76.          forecast=self.model(x, x_time, y_time)
  77.  
  78.          ifisinstance(forecast, tuple):
  79.              # for models which require reconstruction + forecast loss
  80.              loss=F.mse_loss(forecast[0], x) + \
  81.                     F.mse_loss(forecast[1], y)
  82.          else:
  83.              loss=F.mse_loss(forecast, y)
  84.  
  85.          self.log('val_loss', loss, prog_bar=True, on_epoch=True)
  86.  
  87.          return {'val_loss': loss}
  88.  
  89.      defvalidation_epoch_end(self, outputs):
  90.          returnoutputs
  91.  
  92.      deftest_step(self, batch, batch_idx):
  93.          x, y, x_time, y_time=map(to_tensor, batch)
  94.          forecast=self.model(x, x_time, y_time)
  95.  
  96.          ifisinstance(forecast, tuple):
  97.              # for models which require reconstruction + forecast loss
  98.              loss=F.mse_loss(forecast[0], x) + \
  99.                     F.mse_loss(forecast[1], y)
  100.          else:
  101.              loss=F.mse_loss(forecast, y)
  102.  
  103.          self.log('test_loss', loss, prog_bar=True, on_epoch=True)
  104.  
  105.          return {'test_loss': loss}
  106.  
  107.      deftest_epoch_end(self, outputs):
  108.          returnoutputs
  109.  
  110.      @gin.configurable
  111.      defconfigure_optimizers(self):
  112.          group1= []  # lambda
  113.          group2= []  # no decay
  114.          group3= []  # decay
  115.          no_decay_list= ('bias', 'norm',)
  116.          forparam_name, paraminself.model.named_parameters():
  117.              if'_lambda'inparam_name:
  118.                  group1.append(param)
  119.              elifany([modinparam_nameformodinno_decay_list]):
  120.                  group2.append(param)
  121.              else:
  122.                  group3.append(param)
  123.          optimizer=optim.Adam([
  124.              {'params': group1, 'weight_decay': 0, 'lr': self.lambda_lr, 'scheduler': 'cosine_annealing'},
  125.              {'params': group2, 'weight_decay': 0, 'scheduler': 'cosine_annealing_with_linear_warmup'},
  126.              {'params': group3, 'scheduler': 'cosine_annealing_with_linear_warmup'}
  127.          ], lr=self.lr, weight_decay=self.weight_decay)
  128.  
  129.          scheduler_fns= []
  130.          forparam_groupinoptimizer.param_groups:
  131.              scheduler=param_group['scheduler']
  132.              ifscheduler=='none':
  133.                  fn=lambdaT_cur: 1
  134.              elifscheduler=='cosine_annealing':
  135.                  lr=eta_max=param_group['lr']
  136.                  fn=lambdaT_cur: (self.eta_min+0.5* (eta_max-self.eta_min) * (
  137.                          1.0+math.cos(
  138.                      (T_cur-self.warmup_epochs) / (self.T_max-self.warmup_epochs) *math.pi))) /lr
  139.              elifscheduler=='cosine_annealing_with_linear_warmup':
  140.                  lr=eta_max=param_group['lr']
  141.                  fn=lambdaT_cur: T_cur/self.warmup_epochsifT_cur<self.warmup_epochselse (self.eta_min+0.5* (
  142.                          eta_max-self.eta_min) * (1.0+math.cos(
  143.                      (T_cur-self.warmup_epochs) / (self.T_max-self.warmup_epochs) *math.pi))) /lr
  144.              else:
  145.                  raiseValueError(f'No such scheduler, {scheduler}')
  146.              scheduler_fns.append(fn)
  147.          scheduler=optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=scheduler_fns)
  148.  
  149.          return {'optimizer': optimizer, 'lr_scheduler': scheduler}
  150.  
  151.      defforward(self, batch, z_0=None):
  152.          z_0=None
  153.          Y=batch['Y'].to(default_device)
  154.          sample_mask=batch['sample_mask'].to(default_device)
  155.          available_mask=batch['available_mask'].to(default_device)
  156.  
  157.          # Forecasting
  158.          forecasting_mask=available_mask.clone()
  159.          ifself.n_time_out>0:
  160.              forecasting_mask[:, 0, -self.n_time_out:] =0
  161.  
  162.          Y, Y_hat, z=self.model(Y=Y, mask=forecasting_mask, idxs=None, z_0=z_0)
  163.  
  164.          ifself.n_time_out>0:
  165.              Y=Y[:, :, -self.n_time_out:]
  166.              Y_hat=Y_hat[:, :, -self.n_time_out:]
  167.              sample_mask=sample_mask[:, :, -self.n_time_out:]
  168.  
  169.          returnY, Y_hat, sample_mask, z

作者在合成数据集和真实世界数据集上进行了广泛的实验，表明DeepTime具有极具竞争力的性能，在基于MSE的多元预测基准的24个实验中，有20个获得了最先进的结果。

有兴趣的可以看看源代码：https://github.com/salesforce/DeepTime

作者：Reza Yazdanfar

标签： 深度学习 时间序列 元学习
登录后发布评论

“DeepTime：时间序列预测中的元学习模型”的评论:

panda rose panda rose 2023-03-08 09:15:13

文章中只提供了训练代码(class DeepTimeTrainer)，请问能否提供预测代码？感谢！

关于作者
...
Deephub
更多文章请关注公众号：Deephub-IMBA
相关阅读

10招立竿见影的PyTorch性能优化技巧，让模型训练速度翻倍

SmolVLM：资源受限环境下的高效多模态模型研究

从零开始用Pytorch实现LLaMA 4的混合专家（MoE）模型

ReSearch：基于强化学习的大语言模型推理搜索框架

2025年GitHub平台上的十大开源MCP服务器汇总分析

Crawl4AI：为大语言模型打造的开源网页数据采集工具

Triton入门教程：安装与编写和运行简单Triton内核