build_sequences_no_interpolation

build_sequences2.py

def build_sequences(time_series, valid_periods, categories, train_size, test_size):
  """
  Creates all possible test sequences with size <test_size> which have
  a training sequence of <train_size> in front.
  """
  X = []
  y = []
  final_categories = []
  for ts, range, category in zip(time_series, valid_periods, categories):
    valid_ts = cut_valid(ts, range)
    # valid_ts = (valid_ts - np.mean(valid_ts)) / (np.max(valid_ts) - np.min(valid_ts))
    size = len(valid_ts)
    splits = (size - train_size) // test_size
    if splits < 2:
      if size < train_size + test_size:
        # train_ts = valid_ts[0:-test_size]
        # train_ts = interpolate_to_size(train_ts, train_size)
        # X.append(train_ts)

        padding_len = train_size + test_size - size
        padding = np.zeros(padding_len, dtype='float32')
        valid_ts = np.concatenate((padding, valid_ts))
        start = 0
        X.append(valid_ts[0:-test_size])
      else:
        start = size - train_size - test_size
        X.append(valid_ts[start:-test_size])
      y.append(valid_ts[-test_size:])
      final_categories.append(category)
    else:
      # whole interpolated sequence
      # X.append(interpolate_to_size(valid_ts[0:-test_size], train_size))
      # y.append(valid_ts[-test_size:])
      # final_categories.append(category)

      # whole interpolated sequence flipped vertically
      flipped = (-1*valid_ts) + np.max(valid_ts)
      # X.append(interpolate_to_size(flipped[0:-test_size], train_size))
      # y.append(flipped[-test_size:])
      # final_categories.append(category)

      # whole original sequence reversed horizontally
      reverse = valid_ts[::-1]
      # X.append(interpolate_to_size(reverse[0:-test_size], train_size))
      # y.append(reverse[-test_size:])
      # final_categories.append(category)

      # whole original sequence reversed horizontally and flipped vertically
      reverse_flipped = (-1*reverse) + np.max(reverse)
      # X.append(interpolate_to_size(reverse_flipped[0:-test_size], train_size))
      # y.append(reverse_flipped[-test_size:])
      # final_categories.append(category)
      
      for shift in [0, 6, 12]:
        shifted_splits = (size - train_size - shift) // test_size
        if shifted_splits < 2:
          continue
        ts_splitter = TimeSeriesSplit(n_splits=shifted_splits, max_train_size=train_size, test_size=test_size)
        for train_seq_ix, test_seq_ix in ts_splitter.split(valid_ts[:-shift or None]):
          X.append(valid_ts[train_seq_ix[0]:train_seq_ix[-1]+1])
          y.append(valid_ts[test_seq_ix[0]:test_seq_ix[-1]+1])
          final_categories.append(category)
        for train_seq_ix, test_seq_ix in ts_splitter.split(reverse[:-shift or None]):
          X.append(valid_ts[train_seq_ix[0]:train_seq_ix[-1]+1])
          y.append(valid_ts[test_seq_ix[0]:test_seq_ix[-1]+1])
          final_categories.append(category)
        for train_seq_ix, test_seq_ix in ts_splitter.split(flipped[:-shift or None]):
          X.append(valid_ts[train_seq_ix[0]:train_seq_ix[-1]+1])
          y.append(valid_ts[test_seq_ix[0]:test_seq_ix[-1]+1])
          final_categories.append(category)
        for train_seq_ix, test_seq_ix in ts_splitter.split(reverse_flipped[:-shift or None]):
          X.append(valid_ts[train_seq_ix[0]:train_seq_ix[-1]+1])
          y.append(valid_ts[test_seq_ix[0]:test_seq_ix[-1]+1])
          final_categories.append(category)

        # X.append(valid_ts[::-1][train_seq_ix[0]:train_seq_ix[-1]+1])
        # y.append(valid_ts[::-1][test_seq_ix[0]:test_seq_ix[-1]+1])
        # final_categories.append(category)

  return np.array(X), np.array(y), np.array(final_categories)