使用Keras Tuner进行时间序列拆分

Question

是否可以使用Keras调谐器使用时间序列拆分来调整NN，类似于sklearn中的sklearn.model_selection.TimeSeriesSplit。

例如，考虑来自https://towardsdatascience.com/hyperparameter-tuning-with-keras-tuner-283474fbfbe的示例调谐器类

from kerastuner import HyperModel
class SampleModel(HyperModel):
    def __init__(self, input_shape):
        self.input_shape = input_shape
    def build(self, hp):
        model = Sequential()
        model.add(
            layers.Dense(
                units=hp.Int('units', 8, 64, 4, default=8),
                activation=hp.Choice(
                    'dense_activation',
                    values=['relu', 'tanh', 'sigmoid'],
                    default='relu'),
                input_shape=input_shape
            )
        )
    
        model.add(layers.Dense(1))
        
        model.compile(
            optimizer='rmsprop',loss='mse',metrics=['mse']
        )
        
        return model

调谐器：

tuner_rs = RandomSearch(
            hypermodel,
            objective='mse',
            seed=42,
            max_trials=10,
            executions_per_trial=2)


tuner_rs.search(x_train_scaled, y_train, epochs=10, validation_split=0.2, verbose=0)

因此，在上面的代码行中，是否可以执行以下操作而不是validation_split = 0.2

from sklearn.model_selection import TimeSeriesSplit

#defining a time series split object
tscv = TimeSeriesSplit(n_splits = 5)

#using that in Keras Tuner
tuner_rs.search(x_train, y_train, epochs=10, validation_split=tscv, verbose=0)

Answer 1

我是这样解决的：

首先，我设计了一个允许执行阻塞时间序列拆分的类。我发现，使用这种时间序列拆分可能比使用Sklearn TimeSeriesSplit更好，因为我们不会将模型训练在已经看到数据的实例上。如图所示，如果分割数为5，则BTSS会将训练数据分成5个部分，每个分割中只包含相同的验证数据。(由于StackOverflow不允许我上传图片，我将发布一个参考链接：https://hub.packtpub.com/cross-validation-strategies-for-time-series-forecasting-tutorial/)

class BlockingTimeSeriesSplit():
  def __init__(self, n_splits):
      self.n_splits = n_splits

  def get_n_splits(self, X, y, groups):
      return self.n_splits

  def split(self, X, y=None, groups=None):
      n_samples = len(X)
      k_fold_size = n_samples // self.n_splits
      indices = np.arange(n_samples)

      margin = 0
      for i in range(self.n_splits):
          start = i * k_fold_size
          stop = start + k_fold_size
          mid = int(0.8 * (stop - start)) + start
          yield indices[start: mid], indices[mid + margin: stop]

然后，您将继续创建自己的模型：

def build_model(hp):
   pass

最后，您可以将CVtuner创建为回调BlockingTimeSeriesSplit的类。

class CVTuner(kt.engine.tuner.Tuner):
    def run_trial(self, trial, x, y, *args, **kwargs):
        cv = BlockingTimeSeriesSplit(n_splits=5)
        val_accuracy_list = []
        batch_size = trial.hyperparameters.Int('batch_size', 0, 64, step=8)
        epochs = trial.hyperparameters.Int('epochs', 10, 100, step=10)

        for train_indices, test_indices in cv.split(x):
            x_train, x_test = x[train_indices], x[test_indices]
            y_train, y_test = y[train_indices], y[test_indices]
            model = self.hypermodel.build(trial.hyperparameters)
            model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs)
            val_loss, val_accuracy, val_auc = model.evaluate(x_test, y_test)
            val_accuracy_list.append(val_accuracy)
        
            self.oracle.update_trial(trial.trial_id, {'val_accuracy': np.mean(val_accuracy_list)})
            self.save_model(trial.trial_id, model)

  
tuner = CVTuner(oracle=kt.oracles.BayesianOptimization(objective='val_accuracy',max_trials=1), hypermodel=create_model)

stop_early = tf.keras.callbacks.EarlyStopping(monitor='accuracy', patience=10)

tuner.search(X, Y, callbacks=[stop_early])

best_model = tuner.get_best_models()[0]

best_model.summary()

best_model.evaluate(x_out_of_sample, y_out_of_sample)