0
0

时间序列的蒙特卡罗交叉验证

交叉验证应用于时间序列需要注意是要防止泄漏和获得可靠的性能估计本文将介绍蒙特卡洛交叉验证。这是一种流行的TimeSeriesSplits方法的替代方法。

时间序列交叉验证

TimeSeriesSplit通常是时间序列数据进行交叉验证的首选方法。下图1说明了该方法的操作方式。可用的时间序列被分成几个大小相等的折叠。然后每一次折首先被用来测试一个模型，然后重新训练它。除了第一折只用于训练。

使用TimeSeriesSplit进行交叉验证的主要好处如下:

  • 它保持了观察的顺序。这个问题在有序数据集(如时间序列)中非常重要。
  • 它生成了很多拆分 。几次拆分后可以获得更稳健的评估。如果数据集不大，这一点尤其重要。

TimeSeriesSplit的主要缺点是跨折叠的训练样本量是不一致的。这是什么意思?

假设将该方法应用于图1所示的5次分折。在第一次迭代中，所有可用观测值的20%用于训练。但是，这个数字在上次迭代中是80%。因此，初始迭代可能不能代表完整的时间序列。这个问题会影响性能估计。

那么如何解决这个问题?

蒙特卡罗交叉验证

蒙特卡罗交叉验证(MonteCarloCV)是一种可以用于时间序列的方法。这个想法是在不同的随机起点来获取一个时间周期的数据，下面是这种方法的可视化描述:

像TimeSeriesSplit一样，MonteCarloCV也保留了观测的时间顺序。它还会保留多次重复估计过程。

MonteCarloCV与TimeSeriesSplit的区别主要有两个方面:

  • 对于训练和验证样本量，使用TimeSeriesSplit时训练集的大小会增加。在MonteCarloCV中，训练集的大小在每次迭代过程中都是固定的，这样可以防止训练规模不能代表整个数据;
  • 随机的分折，在MonteCarloCV中，验证原点是随机选择的。这个原点标志着训练集的结束和验证的开始。在TimeSeriesSplit的情况下，这个点是确定的。它是根据迭代次数预先定义的。

MonteCarloCV最初由Picard和Cook使用。详细信息可以查看参考文献[1]。

经过详细研究MonteCarloCV。这包括与TimeSeriesSplit等其他方法的比较。MonteCarloCV可以获得更好的估计，所以我一直在使用它。你可以在参考文献[2]中查看完整的研究。

不幸的是，scikit-learn不提供MonteCarloCV的实现。所以，我们决定自己手动实现它:

  1.  from typing import List, Generator
  2.  
  3.  import numpy as np
  4.  
  5.  from sklearn.model_selection._split import _BaseKFold
  6.  from sklearn.utils.validation import indexable, _num_samples
  7.  
  8.  
  9.  class MonteCarloCV(_BaseKFold):
  10.  
  11.      def __init__(self,
  12.                   n_splits: int,
  13.                   train_size: float,
  14.                   test_size: float,
  15.                   gap: int = 0):
  16.          """
  17.          Monte Carlo Cross-Validation
  18.  
  19.          Holdout applied in multiple testing periods
  20.          Testing origin (time-step where testing begins) is randomly chosen according to a monte carlo simulation
  21.  
  22.          :param n_splits: (int) Number of monte carlo repetitions in the procedure
  23.          :param train_size: (float) Train size, in terms of ratio of the total length of the series
  24.          :param test_size: (float) Test size, in terms of ratio of the total length of the series
  25.          :param gap: (int) Number of samples to exclude from the end of each train set before the test set.
  26.          """
  27.  
  28.          self.n_splits = n_splits
  29.          self.n_samples = -1
  30.          self.gap = gap
  31.          self.train_size = train_size
  32.          self.test_size = test_size
  33.          self.train_n_samples = 0
  34.          self.test_n_samples = 0
  35.  
  36.          self.mc_origins = []
  37.  
  38.      def split(self, X, y=None, groups=None) -> Generator:
  39.          """Generate indices to split data into training and test set.
  40.          Parameters
  41.          ----------
  42.          X : array-like of shape (n_samples, n_features)
  43.              Training data, where `n_samples` is the number of samples
  44.              and `n_features` is the number of features.
  45.          y : array-like of shape (n_samples,)
  46.              Always ignored, exists for compatibility.
  47.          groups : array-like of shape (n_samples,)
  48.              Always ignored, exists for compatibility.
  49.          Yields
  50.          ------
  51.          train : ndarray
  52.              The training set indices for that split.
  53.          test : ndarray
  54.              The testing set indices for that split.
  55.          """
  56.  
  57.          X, y, groups = indexable(X, y, groups)
  58.          self.n_samples = _num_samples(X)
  59.  
  60.          self.train_n_samples = int(self.n_samples * self.train_size) - 1
  61.          self.test_n_samples = int(self.n_samples * self.test_size) - 1
  62.  
  63.          # Make sure we have enough samples for the given split parameters
  64.          if self.n_splits > self.n_samples:
  65.              raise ValueError(
  66.                  f'Cannot have number of folds={self.n_splits} greater'
  67.                  f' than the number of samples={self.n_samples}.'
  68.              )
  69.          if self.train_n_samples - self.gap <= 0:
  70.              raise ValueError(
  71.                  f'The gap={self.gap} is too big for number of training samples'
  72.                  f'={self.train_n_samples} with testing samples={self.test_n_samples} and gap={self.gap}.'
  73.              )
  74.  
  75.          indices = np.arange(self.n_samples)
  76.  
  77.          selection_range = np.arange(self.train_n_samples + 1, self.n_samples - self.test_n_samples - 1)
  78.  
  79.          self.mc_origins = \
  80.              np.random.choice(a=selection_range,
  81.                               size=self.n_splits,
  82.                               replace=True)
  83.  
  84.          for origin in self.mc_origins:
  85.              if self.gap > 0:
  86.                  train_end = origin - self.gap + 1
  87.              else:
  88.                  train_end = origin - self.gap
  89.              train_start = origin - self.train_n_samples - 1
  90.  
  91.              test_end = origin + self.test_n_samples
  92.  
  93.              yield (
  94.                  indices[train_start:train_end],
  95.                  indices[origin:test_end],
  96.              )
  97.  
  98.      def get_origins(self) -> List[int]:
  99.          return self.mc_origins

MonteCarloCV接受四个参数:

n_splitting:分折或迭代的次数。这个值趋向于10;

training_size:每次迭代时训练集的大小与时间序列大小的比值;

test_size:类似于training_size，但用于验证集;

gap:分离训练集和验证集的观察数。与TimeSeriesSplits一样，此参数的值默认为0(无间隙)。

每次迭代的训练和验证大小取决于输入数据。我发现一个0.6/0.1的分区工作得很好。也就是说，在每次迭代中，60%的数据被用于训练。10%的观察结果用于验证。

实际使用的例子

下面是配置的一个例子:

  1.  from sklearn.datasets import make_regression
  2.  from src.mccv import MonteCarloCV
  3.  
  4.  X, y = make_regression(n_samples=120)
  5.  
  6.  mccv = MonteCarloCV(n_splits=5, 
  7.                      train_size=0.6, 
  8.                      test_size=0.1, 
  9.                      gap=0)
  10.  
  11.  for train_index, test_index in mccv.split(X):
  12.      print("TRAIN:", train_index, "TEST:", test_index)
  13.      X_train, X_test = X[train_index], X[test_index]
  14.      y_train, y_test = y[train_index], y[test_index]

该实现也与scikit-learn兼容。以下是如何结合GridSearchCV:

  1.  from sklearn.ensemble import RandomForestRegressor
  2.  from sklearn.model_selection import GridSearchCV
  3.  
  4.  model = RandomForestRegressor()
  5.  param_search = {'n_estimators': [10, 100]}
  6.  
  7.  gsearch = GridSearchCV(estimator=model, cv=mccv, param_grid=param_search)
  8.  gsearch.fit(X, y)

我希望你发现MonteCarloCV有用!

引用

[1] Picard, Richard R., and R. Dennis Cook. “Cross-validation of regression models.” Journal of the American Statistical Association 79.387 (1984): 575–583.

[2] Vitor Cerqueira, Luis Torgo, and Igor Mozetič. “Evaluating time series forecasting models: An empirical study on performance estimation methods.” Machine Learning 109.11 (2020): 1997–2028.

作者：Vitor Cerqueira

标签： 机器学习 交叉验证 数据分析
登录后发布评论

“时间序列的蒙特卡罗交叉验证”的评论:

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

GenPRM：思维链+代码验证，通过生成式推理的过程奖励让大模型推理准确率显著提升

PyTabKit：比sklearn更强大的表格数据机器学习框架

SecMulti-RAG：兼顾数据安全与智能检索的多源RAG框架，为企业构建不泄密的智能搜索引擎

KG4MM：融合知识图谱与多模态数据预测药物相互作用

CLIMB自举框架：基于语义聚类的迭代数据混合优化及其在LLM预训练中的应用

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

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