# Core Tidyverse
library(tidyverse)
library(glue)
library(forcats)
# Time Series
library(timetk)
library(tidyquant)
library(tibbletime)
# Visualization
library(cowplot)
# Preprocessing
library(recipes)
# Sampling / Accuracy
library(rsample)
library(yardstick) 
# Modeling
library(keras)
library(tfruns)

Prepare Data

sun_spots <- datasets::sunspot.month %>% 
  timetk::tk_tbl() %>% 
  mutate(index = as_date(index)) %>% 
  tibbletime::as_tbl_time(index = index)

Exploratory Data Analysis

We’ll make two ggplots and combine them using cowplot::plot_grid(). Note that for the zoomed in plot, we make use of tibbletime::time_filter(), which is an easy way to perform time-based filtering.

p1 <- sun_spots %>% 
  ggplot(aes(index, value)) + 
  geom_point(alpha = 0.5) + 
  labs(
        title = "From 1749 to 2013 (Full Data Set)"
    )
p2 <- sun_spots %>% 
  filter(index < "1800-01-01") %>% 
  #filter_time("start" ~ "1800") %>%
  ggplot(aes(index, value)) + 
  geom_line(color = palette_light()[[1]], alpha = 0.5) +
    geom_point(color = palette_light()[[1]]) +
    geom_smooth(method = "loess", span = 0.2, se = FALSE) + 
  labs(
        title = "1749 to 1759 (Zoomed In To Show Changes over the Year)",
        caption = "datasets::sunspot.month"
    )
p_title <- cowplot::ggdraw() + 
  draw_label("Sunspots", size = 18, fontface = "bold")
cowplot::plot_grid(p_title, 
                   p1, p2, 
                   ncol = 1, 
                   rel_heights = c(0.1, 1, 1))

Backtesting: time series cross validation

Can be done with rsample package which includes facilities for backtesting time series. The rolling_origin() function is used to created samples deigned for time series cross validation.

Developing a backtesting strategy

The sampling strategy: we use 50 years (initial = 12 x 50 samples) for training set and 10 years (assess = 12 x 10 samples) for testing (validation) set. The skip span of about 20 years (skip = 12 x 20 - 1) to approximately evenly distribute the samples into 6 sets that span the entire 265 years of sunspot history. And finally we select cumulative = FALSE to allow the origin to shift which ensures that models on more resetl data are not given an unfair advantage (more observations) over those operation on less recent data.

periods_train <- 12 * 100
periods_test <- 12 * 50
skip_span = 12 * 22 - 1
rolling_origin_resamples <- rsample::rolling_origin(
  data = sun_spots,
  initial = periods_train,
  assess = periods_test,
  cumulative = FALSE,
  skip = skip_span
)
rolling_origin_resamples %>% head()

[38;5;246m# A tibble: 6 x 2[39m
  splits       id    
[38;5;250m*[39m [3m[38;5;246m<list>[39m[23m       [3m[38;5;246m<chr>[39m[23m 
[38;5;250m1[39m [38;5;246m<S3: rsplit>[39m Slice1
[38;5;250m2[39m [38;5;246m<S3: rsplit>[39m Slice2
[38;5;250m3[39m [38;5;246m<S3: rsplit>[39m Slice3
[38;5;250m4[39m [38;5;246m<S3: rsplit>[39m Slice4
[38;5;250m5[39m [38;5;246m<S3: rsplit>[39m Slice5
[38;5;250m6[39m [38;5;246m<S3: rsplit>[39m Slice6

Visualizing the backtesting strategy

The resamples can be visualized with two custom functions:

plot_split() plots one of the resampling splits using ggplot2. The expand_y_axis argument is added to expand the date range to the full sun_spots dataset date range.

#plotting function for a single split
plot_split <- function(split, expand_y_axis = TRUE, alpha = 1, size = 1, base_size = 14) {
  
  #manipulate data
  train_tbl <- rsample::training(split) %>% 
    tibble::add_column(key = "training")
  
   test_tbl <- rsample::testing(split) %>% 
    tibble::add_column(key = "testing")
   
   data_manipulated <- bind_rows(train_tbl, test_tbl) %>% 
     tibbletime::as_tbl_time(index = index) %>% 
     mutate(key = forcats::fct_relevel(key, "training", "testing"))
   
   #collect attributes
   train_time_summary <- train_tbl %>% 
     timetk::tk_index() %>% 
     timetk::tk_get_timeseries_summary()
   
   test_time_summary <- test_tbl %>% 
     timetk::tk_index() %>% 
     timetk::tk_get_timeseries_summary()
   
   #visualize
   g <- data_manipulated %>% 
     ggplot(aes(x = index, y = value, color = key)) + 
     geom_line(size = size, alpha = alpha) + 
     tidyquant::theme_tq(base_size = base_size) + 
     tidyquant::scale_color_tq() + 
     labs(
       title = glue::glue("Split: {split$id}"),
       subtitle = glue::glue("{train_time_summary$start} to {test_time_summary$end}"),
       y = "", x = ""
     ) + 
     theme(legend.position = "none") 
   
   if(expand_y_axis) {
     sun_spots_time_summary <- sun_spots %>% 
       timetk::tk_index() %>% 
       timetk::tk_get_timeseries_summary()
     
     g <- g +
       scale_x_date(limits = c(sun_spots_time_summary$start,
                               sun_spots_time_summary$end))
   }
   
   return(g)
}

The plot_split() takes one split and return a visual of the sampling strategy.

rolling_origin_resamples$splits[[1]] %>% 
  plot_split(expand_y_axis = TRUE) + 
  theme(legend.position = "bottom")

plot_sampling_plan() scales the plot_split() to all the samples via purrr and cowplot.

#plotting function that scales to all splits
plot_sampling_plan <- function(sampling_tbl, expand_y_axis = TRUE, 
                               ncol = 3, alpha = 1, size = 1, base_size = 14,
                               title = "Sampling Plan") {
  
  #map plot_slit() to sampling tbl
  sampling_tbl_with_plots <- sampling_tbl %>% 
    mutate(gg_plots = map(splits, plot_split, 
                           expand_y_axis = expand_y_axis, 
                           alpha = alpha, base_size = base_size))
  
  #make plots with cowplot
  plot_list <- sampling_tbl_with_plots$gg_plots
  
  p_temp <- plot_list[[1]] + 
    theme(legend.position = "bottom")
  
  legend <- cowplot::get_legend(p_temp)
  
  p_body <- cowplot::plot_grid(plotlist = plot_list, ncol = ncol)
  p_title <- cowplot::ggdraw() + 
    draw_label(title, size = 14, colour = palette_light()[[1]], fontface = "bold")
  
  
  g <- cowplot::plot_grid(p_title, p_body, ncol = 1, rel_heights = c(0.05, 1, 0.05))
  
  return(g)
  }

Now we can visualize the entire backtesting strategy with plot_sampling_plan().

rolling_origin_resamples %>% 
  plot_sampling_plan(expand_y_axis = TRUE, ncol = 3, alpha = 1, size = 1,  base_size = 10, 
                     title = "Backtesting Strategy: Rolling Origin Sampling Plan")

We can zoom in by setting expand_y_axis = FALSE:

rolling_origin_resamples %>% 
  plot_sampling_plan(expand_y_axis = FALSE, ncol = 3, alpha = 1, size = 1,  base_size = 10, 
                     title = "Backtesting Strategy: Zoomed In")

The LSTM Model

To begin, we’ll develop and LSTM model on a single sample from backtesting strategy (the recent one) and then apply the model to all samples to investigate modeling performance.

example_split <- rolling_origin_resamples$splits[[6]]
example_split_id <- rolling_origin_resamples$id[[6]]

Let’s reuse the plot_split() to visualize the split.

plot_split(example_split, expand_y_axis = FALSE, size = 0.5) + 
  theme(legend.position = "bottom") + 
  ggtitle(glue::glue("Split: {example_split_id}"))

Data Setup

To aid hyperparameter tuning, we need to create a validation set as well. So we’ll dedicate 2/3 of training set to training, and remaining 1/3 to validation.

df_trn <- rsample::analysis(example_split)[1:800, , drop = FALSE]
df_val <- rsample::analysis(example_split)[801:1200, , drop = FALSE]
df_tst <- rsample::assessment(example_split)

First, let’s combine the training and testing sets into a single dataset with a column key that specifies where they came from (train or test).

df <- bind_rows(
  df_trn %>% add_column(key = "training"), 
  df_val %>% add_column(key = "validation"), 
  df_tst %>% add_column(key = "testing")
) %>% 
  tibbletime::as_tbl_time(index = index)

Preprocessing with recipes

The LSTM works better if the input data has been centered and scaled. This (and many other useful transformations) can be done with recipes package.

rec_obj <- recipes::recipe(value ~ ., df) %>% 
  recipes::step_sqrt(value) %>% #to reduce variane and remove outliers
  recipes::step_center(value) %>% 
  recipes::step_scale(value) %>% 
  recipes::prep()
#bake the recipe
df_processed_tlb <- recipes::bake(rec_obj, df)

Now, let’s capture the original center and scale so we can invert the steps after modeling. The square root step can then simply be undone by squaring the back transformed data.

center_history <- rec_obj$steps[[2]]$means["value"]
scale_history <- rec_obj$steps[[3]]$sds["value"]
c("center" = center_history, "scale" = scale_history)

center.value  scale.value 
    6.758380     3.285035

Reshaping the data

Keras LSTM expects the input as well as the target data to be in a specific shape. The input has to be a 3D array of size num_samples, num_timestamps, num_features.

num_samples - the number of observations in the set. This will get fed to the model in portions of batch_size
num_timesteps - the lenght of the hidden state
num_features - number of predictions we’re using. For univariate time series, this is 1.

Suppose we wanted to forecaset 12 months ahead. The way we can do this, with Keras, is by wiring the LSTM hidden states to sets of consecutive outputs of the same lenght. Thus, if we want to produce predictions for 12 months, our LSTM should have a hidden state length of 12.

These 12 time steps will then get wired to 12 linear predictor unites using keras::time_districuted() wrapper. That wrapper’s task is to apply the same calculation (i.e., the same weight matrix) ti every state input it receives.

The target array’s format should be 3-dimensional:

Dim 1 - batch dimension
Dim 2 - corresponds to the number of timestamps (the forecasted ones)
Dim 3 - the size of the wrapped layer. In our case, the wrapped layer is a layer_dense() of a single unit, as we want exactly one prediction per point in time.

So let’s reshape the data. The main action here is creating the sliding windows of 12 steps of input, followed by 12 steps of output each.

n_timesteps <- 12
n_predictions <- n_timesteps
batch_size <- 10
#function used
build_matrix <- function(tseries, overall_timesteps) {
  
  t(sapply(1:(length(tseries) - overall_timesteps + 1), 
    function(x) tseries[x:(x + overall_timesteps - 1)]))
}
reshape_X_3d <- function(X) {
  dim(X) <- c(dim(X)[1], dim(X)[2], 1)
  X
}
#extract values from data frame
train_vals <- df_processed_tlb %>% 
  filter(key == "training") %>% 
  select(value) %>% 
  dplyr::pull() #converts to a vector
valid_vals <- df_processed_tlb %>% 
  filter(key == "validation") %>% 
  select(value) %>% 
  dplyr::pull()
test_vals <- df_processed_tlb %>% 
  filter(key == "testing") %>% 
  select(value) %>% 
  dplyr::pull()
#build the windowed matrices
train_matrix <- build_matrix(train_vals, n_timesteps + n_predictions)
valid_matrix <- build_matrix(valid_vals, n_timesteps + n_predictions)
test_matrix <- build_matrix(test_vals, n_timesteps + n_predictions)
#separate matrices into training and testing parts
#discard last batch, if there fewer than batch_size samples
X_train <- train_matrix[, 1:n_timesteps]
y_train <- train_matrix[, (n_timesteps + 1):(n_timesteps * 2)]
X_train <- X_train[1:(nrow(X_train) %/% batch_size * batch_size), ]
y_train <- X_train[1:(nrow(y_train) %/% batch_size * batch_size), ]
X_valid <- valid_matrix[, 1:n_timesteps]
y_valid <- valid_matrix[, (n_timesteps + 1):(n_timesteps * 2)]
X_valid <- X_valid[1:(nrow(X_valid) %/% batch_size * batch_size), ]
y_valid <- X_valid[1:(nrow(y_valid) %/% batch_size * batch_size), ]
X_test <- test_matrix[, 1:n_timesteps]
y_test <- test_matrix[, (n_timesteps + 1):(n_timesteps * 2)]
X_test <- X_test[1:(nrow(X_test) %/% batch_size * batch_size), ]
y_test <- X_test[1:(nrow(y_test) %/% batch_size * batch_size), ]
#add on the required third axis
X_train <- reshape_X_3d(X_train)
X_valid <- reshape_X_3d(X_valid)
X_test <- reshape_X_3d(X_test)
y_train <- reshape_X_3d(y_train)
y_valid <- reshape_X_3d(y_valid)
y_test <- reshape_X_3d(y_test)

Building LSTM model

Instead of coding the hyperparameters, we’ll use tfruns to set up an environment where we could easily perform a grid search.

FLAGS <- tfruns::flags(
  flag_boolean("stateful", FALSE),
  flag_boolean("stack_layers", FALSE), # should be use several layers of LSTM
  flag_integer("batch_size", 10), # number of samples fed to model in one go
  flag_integer("n_timesteps", 12), #size of the hidden state, equals size of predictions
  flag_integer("n_epochs", 100), #how many epochs to train for
  flag_numeric("dropout", 0.2), 
  flag_numeric("recurrent_dropout", 0.2), 
  flag_string("loss", "logcosh"), #this particular method worked better on the task
  flag_string("optimizer_type", "sgd"), 
  flag_integer("n_units", 128), 
  flag_numeric("lr", 0.003), 
  flag_numeric("momentum", 0.9),
  flag_integer("patience", 10) #parameter to the early stopping callback
  
)
n_predictions <- FLAGS$n_timesteps
n_features <- 1
optimizer <- switch(FLAGS$optimizer_type, 
                    sgd = optimizer_sgd(lr = FLAGS$lr,
                                        momentum = FLAGS$momentum))

Using TensorFlow backend.

callbacks <- list(
  callback_early_stopping(patience = FLAGS$patience))

model <- keras_model_sequential()

model %>% 
  layer_lstm(
    units <- FLAGS$n_units,
    batch_input_shape = c(FLAGS$batch_size, FLAGS$n_timesteps, n_features),
    dropout = FLAGS$dropout,
    recurrent_dropout = FLAGS$recurrent_dropout, 
    return_sequences = TRUE
  ) %>% time_distributed(layer_dense(units = 1))


model %>% 
  compile(
    loss = FLAGS$loss,
    optimizer = optimizer, 
    metrics = list("mean_squared_error")
  )

history <- model %>% fit(
  x = X_train, 
  y = y_train, 
  validation_data = list(X_valid, y_valid), 
  batch_size = FLAGS$batch_size,
  epochs     = FLAGS$n_epochs,
  callbacks = callbacks
)

plot(history, metrics = "loss")

Now let’s see how well the model was able to capute the characterics of the training set.

We compute the evarage RSME over all sequences of predictions.

rmse_train

[1] 22.93601

How do there predictions really look? Let’s took some random start points at regular intervals:

compare_train %>% 
  ggplot(aes(x = index, y = value)) + 
  geom_line() + 
  geom_line(aes(y = pred_train1), color = "cyan") + 
  geom_line(aes(y = pred_train50), color = "red") + 
  geom_line(aes(y = pred_train100), color = "green") + 
  geom_line(aes(y = pred_train150), color = "violet") + 
  geom_line(aes(y = pred_train200), color = "cyan") + 
  geom_line(aes(y = pred_train250), color = "red") + 
  geom_line(aes(y = pred_train300), color = "green") + 
  geom_line(aes(y = pred_train350), color = "violet") + 
  geom_line(aes(y = pred_train400), color = "cyan") + 
  geom_line(aes(y = pred_train450), color = "red") + 
  geom_line(aes(y = pred_train500), color = "green") + 
  geom_line(aes(y = pred_train550), color = "violet") + 
  geom_line(aes(y = pred_train600), color = "cyan") + 
  geom_line(aes(y = pred_train650), color = "red") + 
  geom_line(aes(y = pred_train700), color = "green") + 
  geom_line(aes(y = pred_train750), color = "violet") +
  ggtitle("Predictions on the training set")

Let’s do the same with test set:

rmse_test

[1] 31.36336

compare_test %>% 
  ggplot(aes(x = index, y = value)) + 
  geom_line() + 
  geom_line(aes(y = pred_test1), color = "cyan") + 
  geom_line(aes(y = pred_test50), color = "red") + 
  geom_line(aes(y = pred_test100), color = "green") + 
  geom_line(aes(y = pred_test150), color = "violet") + 
  geom_line(aes(y = pred_test200), color = "cyan") + 
  geom_line(aes(y = pred_test250), color = "red") + 
  geom_line(aes(y = pred_test300), color = "green") + 
  geom_line(aes(y = pred_test350), color = "violet") + 
  geom_line(aes(y = pred_test400), color = "cyan") + 
  geom_line(aes(y = pred_test450), color = "red") + 
  geom_line(aes(y = pred_test500), color = "green") + 
  geom_line(aes(y = pred_test550), color = "violet") + 
  ggtitle("Predictions on the testing set")

Backtesting the model on all splits

To obtain predictions on all splits, we move the code into a function and apply it to all splits.

obtain_predictions <- function(split) {
  df_trn <- rsample::analysis(split)[1:800, , drop = FALSE]
  df_val <- rsample::analysis(split)[801:1200, , drop = FALSE]
  df_tst <- rsample::assessment(split)
  
  df <- bind_rows(
    df_trn %>% add_column(key = "training"),
    df_val %>% add_column(key = "validation"),
    df_tst %>% add_column(key = "testing")
    ) %>%
    tibbletime::as_tbl_time(index = index)
  
  rec_obj <- recipes::recipe(value ~ ., df) %>%
    recipes::step_sqrt(value) %>% #to reduce variane and remove outliers
    recipes::step_center(value) %>%
    recipes::step_scale(value) %>%
    recipes::prep()
    
    #bake the recipe
    
  df_processed_tlb <- recipes::bake(rec_obj, df)
  
  center_history <- rec_obj$steps[[2]]$means["value"]
  scale_history <- rec_obj$steps[[3]]$sds["value"]
  
  FLAGS <- tfruns::flags(
    flag_boolean("stateful", FALSE),
    flag_boolean("stack_layers", FALSE),
    # should be use several layers of LSTM
    flag_integer("batch_size", 10),
    # number of samples fed to model in one go
    flag_integer("n_timesteps", 12),
    #size of the hidden state, equals size of predictions
    flag_integer("n_epochs", 100),
    #how many epochs to train for
    flag_numeric("dropout", 0.2),
    flag_numeric("recurrent_dropout", 0.2),
    flag_string("loss", "logcosh"),
    #this particular method worked better on the task
    flag_string("optimizer_type", "sgd"),
    flag_integer("n_units", 128),
    flag_numeric("lr", 0.003),
    flag_numeric("momentum", 0.9),
    flag_integer("patience", 10) #parameter to the early stopping callback
    
    )
  
  n_predictions <- FLAGS$n_timesteps
  n_features <- 1
  optimizer <- switch(FLAGS$optimizer_type, 
                    sgd = optimizer_sgd(lr = FLAGS$lr,
                                        momentum = FLAGS$momentum))
  callbacks <- list(callback_early_stopping(patience = FLAGS$patience))
  
  train_vals <- df_processed_tlb %>%
  filter()
  
  #extract values from data frame
  train_vals <- df_processed_tlb %>%
  filter(key == "training") %>%
  select(value) %>%
  dplyr::pull() #converts to a vector
  
  valid_vals <- df_processed_tlb %>%
  filter(key == "validation") %>%
  select(value) %>%
  dplyr::pull()
  
  test_vals <- df_processed_tlb %>%
  filter(key == "testing") %>%
  select(value) %>%
  dplyr::pull()
  
  #build the windowed matrices
  train_matrix <-
  build_matrix(train_vals, n_timesteps + n_predictions)
  valid_matrix <-
  build_matrix(valid_vals, n_timesteps + n_predictions)
  test_matrix <- build_matrix(test_vals, n_timesteps + n_predictions)
  
  #separate matrices into training and testing parts
  #discard last batch, if there fewer than batch_size samples
  
  X_train <- train_matrix[, 1:n_timesteps]
  y_train <- train_matrix[, (n_timesteps + 1):(n_timesteps * 2)]
  X_train <- X_train[1:(nrow(X_train) %/% batch_size * batch_size),]
  y_train <- X_train[1:(nrow(y_train) %/% batch_size * batch_size),]
  
  X_valid <- valid_matrix[, 1:n_timesteps]
  y_valid <- valid_matrix[, (n_timesteps + 1):(n_timesteps * 2)]
  X_valid <- X_valid[1:(nrow(X_valid) %/% batch_size * batch_size),]
  y_valid <- X_valid[1:(nrow(y_valid) %/% batch_size * batch_size),]
  
  
  X_test <- test_matrix[, 1:n_timesteps]
  y_test <- test_matrix[, (n_timesteps + 1):(n_timesteps * 2)]
  X_test <- X_test[1:(nrow(X_test) %/% batch_size * batch_size),]
  y_test <- X_test[1:(nrow(y_test) %/% batch_size * batch_size),]
  
  #add on the required third axis
  X_train <- reshape_X_3d(X_train)
  X_valid <- reshape_X_3d(X_valid)
  X_test <- reshape_X_3d(X_test)
  
  y_train <- reshape_X_3d(y_train)
  y_valid <- reshape_X_3d(y_valid)
  y_test <- reshape_X_3d(y_test)
  
  model <- keras_model_sequential()
  model %>% 
    layer_lstm(
      units <- FLAGS$n_units,
      batch_input_shape = c(FLAGS$batch_size, FLAGS$n_timesteps, n_features),
      dropout = FLAGS$dropout,
      recurrent_dropout = FLAGS$recurrent_dropout, 
      return_sequences = TRUE
    ) %>% time_distributed(layer_dense(units = 1))
  
  
  model %>% 
    compile(
      loss = FLAGS$loss,
      optimizer = optimizer, 
      metrics = list("mean_squared_error")
    )
  
  model %>% fit(
    x = X_train, 
    y = y_train, 
    validation_data = list(X_valid, y_valid), 
    batch_size = FLAGS$batch_size,
    epochs     = FLAGS$n_epochs,
    callbacks = callbacks
  )
  
  pred_train <- model %>% 
  predict(X_train, batch_size = FLAGS$batch_size) %>% 
  .[, , 1]
  #retransform values to original scale
  pred_train <- (pred_train * scale_history + center_history) ^ 2
  compare_train <- df %>% 
    filter(key == "training")
  
  #build a dataframe that has both actual and predicted values
  for(i in 1:nrow(pred_train)) {
    varname <- paste0("pred_train", i)
    compare_train <- 
      mutate(compare_train, !!varname := c(
        rep(NA, FLAGS$n_timesteps + i - 1), 
        pred_train[i, ], 
        rep(NA, nrow(compare_train) - FLAGS$n_timesteps * 2 - i + 1)
      ))
  }
  
  pred_test <- model %>% 
  predict(X_test, batch_size = FLAGS$batch_size) %>% 
  .[, , 1]
#retransform values to original scale
pred_test <- (pred_test * scale_history + center_history) ^ 2
compare_test <- df %>% 
  filter(key == "testing")
#build a dataframe that has both actual and predicted values
for(i in 1:nrow(pred_test)) {
  varname <- paste0("pred_test", i)
  compare_test <- 
    mutate(compare_test, !!varname := c(
      rep(NA, FLAGS$n_timesteps + i - 1), 
      pred_test[i, ], 
      rep(NA, nrow(compare_test) - FLAGS$n_timesteps * 2 - i + 1)
    ))
}
list(train = compare_train, test = compare_test)
  
}

Mapping the function over all splits yields a list of all predictions:

Calculate RMSE on all splits:

all_split_rmses_train <- all_slits_preds_train %>% 
  mutate(rmse = map_dbl(predict, calc_rmse)) %>% 
  select(id, rmse)
all_split_rmses_train <- all_slits_preds_train %>% 
  mutate(rmse = map_dbl(predict, calc_rmse)) %>% 
  select(id, rmse)
all_split_rmses_test <- all_split_rmses_test %>% 
  mutate(rmse = map_dbl(predict, calc_rmse)) %>% 
  select(id, rmse)

Error in eval(lhs, parent, parent) : 
  object 'all_split_rmses_test' not found

Here how it looks - RMSE on the training set for the 6 splits:

all_split_rmses_train
all_split_rmses_test

Let’s post all predictions on training sets:

---
title: "LTSM time series forecasting with Keras"
output:
  html_notebook: default
  word_document: default
---

```{r, message=FALSE}
# Core Tidyverse
library(tidyverse)
library(glue)
library(forcats)

# Time Series
library(timetk)
library(tidyquant)
library(tibbletime)

# Visualization
library(cowplot)

# Preprocessing
library(recipes)

# Sampling / Accuracy
library(rsample)
library(yardstick) 

# Modeling
library(keras)
library(tfruns)
```

# Prepare Data

```{r}
sun_spots <- datasets::sunspot.month %>% 
  timetk::tk_tbl() %>% 
  mutate(index = as_date(index)) %>% 
  tibbletime::as_tbl_time(index = index)
```


# Exploratory Data Analysis

We’ll make two ggplots and combine them using `cowplot::plot_grid()`. Note that for the zoomed in plot, we make use of `tibbletime::time_filter()`, which is an easy way to perform time-based filtering.

```{r}
p1 <- sun_spots %>% 
  ggplot(aes(index, value)) + 
  geom_point(alpha = 0.5) + 
  labs(
        title = "From 1749 to 2013 (Full Data Set)"
    )

p2 <- sun_spots %>% 
  filter(index < "1800-01-01") %>% 
  #filter_time("start" ~ "1800") %>%
  ggplot(aes(index, value)) + 
  geom_line(color = palette_light()[[1]], alpha = 0.5) +
    geom_point(color = palette_light()[[1]]) +
    geom_smooth(method = "loess", span = 0.2, se = FALSE) + 
  labs(
        title = "1749 to 1759 (Zoomed In To Show Changes over the Year)",
        caption = "datasets::sunspot.month"
    )

p_title <- cowplot::ggdraw() + 
  draw_label("Sunspots", size = 18, fontface = "bold")

cowplot::plot_grid(p_title, 
                   p1, p2, 
                   ncol = 1, 
                   rel_heights = c(0.1, 1, 1))
```

# Backtesting: time series cross validation

Can be done with `rsample` package which includes facilities for backtesting time series. The `rolling_origin()` function is used to created samples deigned for time series cross validation.

## Developing a backtesting strategy

The sampling strategy: we use 50 years (`initial = 12 x 50` samples) for training set and 10 years (`assess = 12 x 10` samples) for testing (validation) set. The `skip` span of about 20 years (`skip = 12 x 20 - 1`) to approximately evenly distribute the samples into 6 sets that span the entire 265 years of sunspot history. And finally we select `cumulative = FALSE` to allow the origin to shift which ensures that models on more resetl data are not given an unfair advantage (more observations) over those operation on less recent data.


```{r}
periods_train <- 12 * 100
periods_test <- 12 * 50
skip_span = 12 * 22 - 1

rolling_origin_resamples <- rsample::rolling_origin(
  data = sun_spots,
  initial = periods_train,
  assess = periods_test,
  cumulative = FALSE,
  skip = skip_span
)

rolling_origin_resamples %>% head()
```

## Visualizing the backtesting strategy

The resamples can be visualized with two custom functions: 

* `plot_split()` plots one of the resampling splits using `ggplot2`. The `expand_y_axis` argument is added to expand the date range to the full `sun_spots` dataset date range.

```{r}
#plotting function for a single split
plot_split <- function(split, expand_y_axis = TRUE, alpha = 1, size = 1, base_size = 14) {
  
  #manipulate data
  train_tbl <- rsample::training(split) %>% 
    tibble::add_column(key = "training")
  
   test_tbl <- rsample::testing(split) %>% 
    tibble::add_column(key = "testing")
   
   data_manipulated <- bind_rows(train_tbl, test_tbl) %>% 
     tibbletime::as_tbl_time(index = index) %>% 
     mutate(key = forcats::fct_relevel(key, "training", "testing"))
   
   #collect attributes
   train_time_summary <- train_tbl %>% 
     timetk::tk_index() %>% 
     timetk::tk_get_timeseries_summary()
   
   test_time_summary <- test_tbl %>% 
     timetk::tk_index() %>% 
     timetk::tk_get_timeseries_summary()
   
   #visualize
   g <- data_manipulated %>% 
     ggplot(aes(x = index, y = value, color = key)) + 
     geom_line(size = size, alpha = alpha) + 
     tidyquant::theme_tq(base_size = base_size) + 
     tidyquant::scale_color_tq() + 
     labs(
       title = glue::glue("Split: {split$id}"),
       subtitle = glue::glue("{train_time_summary$start} to {test_time_summary$end}"),
       y = "", x = ""
     ) + 
     theme(legend.position = "none") 
   
   if(expand_y_axis) {
     sun_spots_time_summary <- sun_spots %>% 
       timetk::tk_index() %>% 
       timetk::tk_get_timeseries_summary()
     
     g <- g +
       scale_x_date(limits = c(sun_spots_time_summary$start,
                               sun_spots_time_summary$end))
   }
   
   return(g)
}
```

The `plot_split()` takes one split and return a visual of the sampling strategy. 

```{r}
rolling_origin_resamples$splits[[1]] %>% 
  plot_split(expand_y_axis = TRUE) + 
  theme(legend.position = "bottom")
```

* `plot_sampling_plan()` scales the `plot_split()` to all the samples via `purrr` and `cowplot`.

```{r}
#plotting function that scales to all splits
plot_sampling_plan <- function(sampling_tbl, expand_y_axis = TRUE, 
                               ncol = 3, alpha = 1, size = 1, base_size = 14,
                               title = "Sampling Plan") {
  
  #map plot_slit() to sampling tbl
  sampling_tbl_with_plots <- sampling_tbl %>% 
    mutate(gg_plots = map(splits, plot_split, 
                           expand_y_axis = expand_y_axis, 
                           alpha = alpha, base_size = base_size))
  
  #make plots with cowplot
  plot_list <- sampling_tbl_with_plots$gg_plots
  
  p_temp <- plot_list[[1]] + 
    theme(legend.position = "bottom")
  
  legend <- cowplot::get_legend(p_temp)
  
  p_body <- cowplot::plot_grid(plotlist = plot_list, ncol = ncol)

  p_title <- cowplot::ggdraw() + 
    draw_label(title, size = 14, colour = palette_light()[[1]], fontface = "bold")
  
  
  g <- cowplot::plot_grid(p_title, p_body, ncol = 1, rel_heights = c(0.05, 1, 0.05))
  
  return(g)
  }
```


Now we can visualize the entire backtesting strategy with `plot_sampling_plan()`. 

```{r}
rolling_origin_resamples %>% 
  plot_sampling_plan(expand_y_axis = TRUE, ncol = 3, alpha = 1, size = 1,  base_size = 10, 
                     title = "Backtesting Strategy: Rolling Origin Sampling Plan") 
```

We can zoom in by setting `expand_y_axis = FALSE`:

```{r}
rolling_origin_resamples %>% 
  plot_sampling_plan(expand_y_axis = FALSE, ncol = 3, alpha = 1, size = 1,  base_size = 10, 
                     title = "Backtesting Strategy: Zoomed In")
```


# The LSTM Model

To begin, we'll develop and LSTM model on a single sample from backtesting strategy (the recent one) and then apply the model to all samples to investigate modeling performance.

```{r}
example_split <- rolling_origin_resamples$splits[[6]]
example_split_id <- rolling_origin_resamples$id[[6]]
```

Let's reuse the `plot_split()` to visualize the split.

```{r}
plot_split(example_split, expand_y_axis = FALSE, size = 0.5) + 
  theme(legend.position = "bottom") + 
  ggtitle(glue::glue("Split: {example_split_id}"))
```

## Data Setup

To aid hyperparameter tuning, we need to create a validation set as well. 
So we'll dedicate 2/3 of training set to training, and remaining 1/3 to validation.

```{r}
df_trn <- rsample::analysis(example_split)[1:800, , drop = FALSE]
df_val <- rsample::analysis(example_split)[801:1200, , drop = FALSE]
df_tst <- rsample::assessment(example_split)
```

First, let's combine the training and testing sets into a single dataset with a column `key` that specifies where they came from (train or test). 

```{r}
df <- bind_rows(
  df_trn %>% add_column(key = "training"), 
  df_val %>% add_column(key = "validation"), 
  df_tst %>% add_column(key = "testing")
) %>% 
  tibbletime::as_tbl_time(index = index)
```

## Preprocessing with recipes

The LSTM works better if the input data has been centered and scaled. This (and many other useful transformations) can be done with `recipes` package.

```{r}
rec_obj <- recipes::recipe(value ~ ., df) %>% 
  recipes::step_sqrt(value) %>% #to reduce variane and remove outliers
  recipes::step_center(value) %>% 
  recipes::step_scale(value) %>% 
  recipes::prep()

#bake the recipe

df_processed_tlb <- recipes::bake(rec_obj, df)
```

Now, let's capture the original center and scale so we can invert the steps after modeling. The square root step can then simply be undone by squaring the back transformed data.

```{r}
center_history <- rec_obj$steps[[2]]$means["value"]
scale_history <- rec_obj$steps[[3]]$sds["value"]
c("center" = center_history, "scale" = scale_history)
```

## Reshaping the data

Keras LSTM expects the input as well as the target data to be in a specific shape. The input has to be a 3D array of size `num_samples`, `num_timestamps`, `num_features`.

* `num_samples` - the number of observations in the set. This will get fed to the model in portions of `batch_size`
* `num_timesteps` - the lenght of the hidden state
* `num_features` - number of predictions we're using. For univariate time series, this is 1.

Suppose we wanted to forecaset 12 months ahead. The way we can do this, with Keras, is by wiring the LSTM hidden states to sets of consecutive outputs of the same lenght. Thus, if we want to produce predictions for 12 months, our LSTM should have a hidden state length of 12. 

These 12 time steps will then get wired to 12 linear predictor unites using `keras::time_districuted()` wrapper.
That wrapper's task is to apply the same calculation (i.e., the same weight matrix) ti every state input it receives.

The target array's format should be 3-dimensional: 

1. **Dim 1** - batch dimension
2. **Dim 2** - corresponds to the number of timestamps (the forecasted ones)
3. **Dim 3** - the size of the wrapped layer. In our case, the wrapped layer is a `layer_dense()` of a single unit, as we want exactly one prediction per point in time. 

So let's reshape the data. The main action here is creating the sliding windows of 12 steps of input, followed by 12 steps of output each. 

```{r}
n_timesteps <- 12
n_predictions <- n_timesteps
batch_size <- 10

#function used
build_matrix <- function(tseries, overall_timesteps) {
  
  t(sapply(1:(length(tseries) - overall_timesteps + 1), 
    function(x) tseries[x:(x + overall_timesteps - 1)]))

}

reshape_X_3d <- function(X) {
  dim(X) <- c(dim(X)[1], dim(X)[2], 1)
  X
}

#extract values from data frame
train_vals <- df_processed_tlb %>% 
  filter(key == "training") %>% 
  select(value) %>% 
  dplyr::pull() #converts to a vector

valid_vals <- df_processed_tlb %>% 
  filter(key == "validation") %>% 
  select(value) %>% 
  dplyr::pull()

test_vals <- df_processed_tlb %>% 
  filter(key == "testing") %>% 
  select(value) %>% 
  dplyr::pull()

#build the windowed matrices
train_matrix <- build_matrix(train_vals, n_timesteps + n_predictions)
valid_matrix <- build_matrix(valid_vals, n_timesteps + n_predictions)
test_matrix <- build_matrix(test_vals, n_timesteps + n_predictions)

#separate matrices into training and testing parts
#discard last batch, if there fewer than batch_size samples

X_train <- train_matrix[, 1:n_timesteps]
y_train <- train_matrix[, (n_timesteps + 1):(n_timesteps * 2)]
X_train <- X_train[1:(nrow(X_train) %/% batch_size * batch_size), ]
y_train <- X_train[1:(nrow(y_train) %/% batch_size * batch_size), ]

X_valid <- valid_matrix[, 1:n_timesteps]
y_valid <- valid_matrix[, (n_timesteps + 1):(n_timesteps * 2)]
X_valid <- X_valid[1:(nrow(X_valid) %/% batch_size * batch_size), ]
y_valid <- X_valid[1:(nrow(y_valid) %/% batch_size * batch_size), ]


X_test <- test_matrix[, 1:n_timesteps]
y_test <- test_matrix[, (n_timesteps + 1):(n_timesteps * 2)]
X_test <- X_test[1:(nrow(X_test) %/% batch_size * batch_size), ]
y_test <- X_test[1:(nrow(y_test) %/% batch_size * batch_size), ]

#add on the required third axis
X_train <- reshape_X_3d(X_train)
X_valid <- reshape_X_3d(X_valid)
X_test <- reshape_X_3d(X_test)

y_train <- reshape_X_3d(y_train)
y_valid <- reshape_X_3d(y_valid)
y_test <- reshape_X_3d(y_test)
```

## Building LSTM model

Instead of coding the hyperparameters, we'll use `tfruns` to set up an environment where we could easily perform a grid search.

```{r}
FLAGS <- tfruns::flags(
  flag_boolean("stateful", FALSE),
  flag_boolean("stack_layers", FALSE), # should be use several layers of LSTM
  flag_integer("batch_size", 10), # number of samples fed to model in one go
  flag_integer("n_timesteps", 12), #size of the hidden state, equals size of predictions
  flag_integer("n_epochs", 100), #how many epochs to train for
  flag_numeric("dropout", 0.2), 
  flag_numeric("recurrent_dropout", 0.2), 
  flag_string("loss", "logcosh"), #this particular method worked better on the task
  flag_string("optimizer_type", "sgd"), 
  flag_integer("n_units", 128), 
  flag_numeric("lr", 0.003), 
  flag_numeric("momentum", 0.9),
  flag_integer("patience", 10) #parameter to the early stopping callback
  
)

n_predictions <- FLAGS$n_timesteps
n_features <- 1
optimizer <- switch(FLAGS$optimizer_type, 
                    sgd = optimizer_sgd(lr = FLAGS$lr,
                                        momentum = FLAGS$momentum))
callbacks <- list(
  callback_early_stopping(patience = FLAGS$patience))
```


```{r}
model <- keras_model_sequential()

model %>% 
  layer_lstm(
    units <- FLAGS$n_units,
    batch_input_shape = c(FLAGS$batch_size, FLAGS$n_timesteps, n_features),
    dropout = FLAGS$dropout,
    recurrent_dropout = FLAGS$recurrent_dropout, 
    return_sequences = TRUE
  ) %>% time_distributed(layer_dense(units = 1))


model %>% 
  compile(
    loss = FLAGS$loss,
    optimizer = optimizer, 
    metrics = list("mean_squared_error")
  )

history <- model %>% fit(
  x = X_train, 
  y = y_train, 
  validation_data = list(X_valid, y_valid), 
  batch_size = FLAGS$batch_size,
  epochs     = FLAGS$n_epochs,
  callbacks = callbacks
)
```

```{r}
plot(history, metrics = "loss")
```

Now let's see how well the model was able to capute the characterics of the training set.

```{r}
pred_train <- model %>% 
  predict(X_train, batch_size = FLAGS$batch_size) %>% 
  .[, , 1]

#retransform values to original scale
pred_train <- (pred_train * scale_history + center_history) ^ 2
compare_train <- df %>% 
  filter(key == "training")

#build a dataframe that has both actual and predicted values
for(i in 1:nrow(pred_train)) {
  varname <- paste0("pred_train", i)
  compare_train <- 
    mutate(compare_train, !!varname := c(
      rep(NA, FLAGS$n_timesteps + i - 1), 
      pred_train[i, ], 
      rep(NA, nrow(compare_train) - FLAGS$n_timesteps * 2 - i + 1)
    ))
}
```

We compute the evarage RSME over all sequences of predictions.

```{r}
coln <- colnames(compare_train)[4:ncol(compare_train)]
cols <- map(coln, dplyr::quo(dplyr::sym(.)))

rmse_train <- 
  map_dbl(cols, function(col)
    yardstick::rmse(
    compare_train, 
    truth = value, 
    estimate = !!col,
    na.rm = TRUE
  )) %>% mean()

rmse_train
```

How do there predictions really look? Let's took some random start points at regular intervals:

```{r, warning=FALSE}
compare_train %>% 
  ggplot(aes(x = index, y = value)) + 
  geom_line() + 
  geom_line(aes(y = pred_train1), color = "cyan") + 
  geom_line(aes(y = pred_train50), color = "red") + 
  geom_line(aes(y = pred_train100), color = "green") + 
  geom_line(aes(y = pred_train150), color = "violet") + 
  geom_line(aes(y = pred_train200), color = "cyan") + 
  geom_line(aes(y = pred_train250), color = "red") + 
  geom_line(aes(y = pred_train300), color = "green") + 
  geom_line(aes(y = pred_train350), color = "violet") + 
  geom_line(aes(y = pred_train400), color = "cyan") + 
  geom_line(aes(y = pred_train450), color = "red") + 
  geom_line(aes(y = pred_train500), color = "green") + 
  geom_line(aes(y = pred_train550), color = "violet") + 
  geom_line(aes(y = pred_train600), color = "cyan") + 
  geom_line(aes(y = pred_train650), color = "red") + 
  geom_line(aes(y = pred_train700), color = "green") + 
  geom_line(aes(y = pred_train750), color = "violet") +
  ggtitle("Predictions on the training set")

```

Let's do the same with test set:

```{r, warning=FALSE}
pred_test <- model %>% 
  predict(X_test, batch_size = FLAGS$batch_size) %>% 
  .[, , 1]

#retransform values to original scale
pred_test <- (pred_test * scale_history + center_history) ^ 2
compare_test <- df %>% 
  filter(key == "testing")

#build a dataframe that has both actual and predicted values
for(i in 1:nrow(pred_test)) {
  varname <- paste0("pred_test", i)
  compare_test <- 
    mutate(compare_test, !!varname := c(
      rep(NA, FLAGS$n_timesteps + i - 1), 
      pred_test[i, ], 
      rep(NA, nrow(compare_test) - FLAGS$n_timesteps * 2 - i + 1)
    ))
}


# compare_test %>% 
#   write_csv(str_replace(model_path, ".hdf5", ".test.csv"))

compare_test[FLAGS$n_timesteps:(FLAGS$n_timesteps + 10), c(2, 4:8)] %>% print()

coln <- colnames(compare_test)[4:ncol(compare_test)]
cols <- map(coln, dplyr::quo(dplyr::sym(.)))

rmse_test <- 
  map_dbl(cols, function(col)
    yardstick::rmse(
    compare_test, 
    truth = value, 
    estimate = !!col,
    na.rm = TRUE
  )) %>% mean()

rmse_test

compare_test %>% 
  ggplot(aes(x = index, y = value)) + 
  geom_line() + 
  geom_line(aes(y = pred_test1), color = "cyan") + 
  geom_line(aes(y = pred_test50), color = "red") + 
  geom_line(aes(y = pred_test100), color = "green") + 
  geom_line(aes(y = pred_test150), color = "violet") + 
  geom_line(aes(y = pred_test200), color = "cyan") + 
  geom_line(aes(y = pred_test250), color = "red") + 
  geom_line(aes(y = pred_test300), color = "green") + 
  geom_line(aes(y = pred_test350), color = "violet") + 
  geom_line(aes(y = pred_test400), color = "cyan") + 
  geom_line(aes(y = pred_test450), color = "red") + 
  geom_line(aes(y = pred_test500), color = "green") + 
  geom_line(aes(y = pred_test550), color = "violet") + 
  ggtitle("Predictions on the testing set")
```

# Backtesting the model on all splits

To obtain predictions on all splits, we move the code into a function and apply it to all splits.

```{r}
obtain_predictions <- function(split) {
  df_trn <- rsample::analysis(split)[1:800, , drop = FALSE]
  df_val <- rsample::analysis(split)[801:1200, , drop = FALSE]
  df_tst <- rsample::assessment(split)
  
  df <- bind_rows(
    df_trn %>% add_column(key = "training"),
    df_val %>% add_column(key = "validation"),
    df_tst %>% add_column(key = "testing")
    ) %>%
    tibbletime::as_tbl_time(index = index)
  
  rec_obj <- recipes::recipe(value ~ ., df) %>%
    recipes::step_sqrt(value) %>% #to reduce variane and remove outliers
    recipes::step_center(value) %>%
    recipes::step_scale(value) %>%
    recipes::prep()
    
    #bake the recipe
    
  df_processed_tlb <- recipes::bake(rec_obj, df)
  
  center_history <- rec_obj$steps[[2]]$means["value"]
  scale_history <- rec_obj$steps[[3]]$sds["value"]
  
  FLAGS <- tfruns::flags(
    flag_boolean("stateful", FALSE),
    flag_boolean("stack_layers", FALSE),
    # should be use several layers of LSTM
    flag_integer("batch_size", 10),
    # number of samples fed to model in one go
    flag_integer("n_timesteps", 12),
    #size of the hidden state, equals size of predictions
    flag_integer("n_epochs", 100),
    #how many epochs to train for
    flag_numeric("dropout", 0.2),
    flag_numeric("recurrent_dropout", 0.2),
    flag_string("loss", "logcosh"),
    #this particular method worked better on the task
    flag_string("optimizer_type", "sgd"),
    flag_integer("n_units", 128),
    flag_numeric("lr", 0.003),
    flag_numeric("momentum", 0.9),
    flag_integer("patience", 10) #parameter to the early stopping callback
    
    )
  
  n_predictions <- FLAGS$n_timesteps
  n_features <- 1
  optimizer <- switch(FLAGS$optimizer_type, 
                    sgd = optimizer_sgd(lr = FLAGS$lr,
                                        momentum = FLAGS$momentum))
  callbacks <- list(callback_early_stopping(patience = FLAGS$patience))
  
  train_vals <- df_processed_tlb %>%
  filter()
  
  #extract values from data frame
  train_vals <- df_processed_tlb %>%
  filter(key == "training") %>%
  select(value) %>%
  dplyr::pull() #converts to a vector
  
  valid_vals <- df_processed_tlb %>%
  filter(key == "validation") %>%
  select(value) %>%
  dplyr::pull()
  
  test_vals <- df_processed_tlb %>%
  filter(key == "testing") %>%
  select(value) %>%
  dplyr::pull()
  
  #build the windowed matrices
  train_matrix <-
  build_matrix(train_vals, n_timesteps + n_predictions)
  valid_matrix <-
  build_matrix(valid_vals, n_timesteps + n_predictions)
  test_matrix <- build_matrix(test_vals, n_timesteps + n_predictions)
  
  #separate matrices into training and testing parts
  #discard last batch, if there fewer than batch_size samples
  
  X_train <- train_matrix[, 1:n_timesteps]
  y_train <- train_matrix[, (n_timesteps + 1):(n_timesteps * 2)]
  X_train <- X_train[1:(nrow(X_train) %/% batch_size * batch_size),]
  y_train <- X_train[1:(nrow(y_train) %/% batch_size * batch_size),]
  
  X_valid <- valid_matrix[, 1:n_timesteps]
  y_valid <- valid_matrix[, (n_timesteps + 1):(n_timesteps * 2)]
  X_valid <- X_valid[1:(nrow(X_valid) %/% batch_size * batch_size),]
  y_valid <- X_valid[1:(nrow(y_valid) %/% batch_size * batch_size),]
  
  
  X_test <- test_matrix[, 1:n_timesteps]
  y_test <- test_matrix[, (n_timesteps + 1):(n_timesteps * 2)]
  X_test <- X_test[1:(nrow(X_test) %/% batch_size * batch_size),]
  y_test <- X_test[1:(nrow(y_test) %/% batch_size * batch_size),]
  
  #add on the required third axis
  X_train <- reshape_X_3d(X_train)
  X_valid <- reshape_X_3d(X_valid)
  X_test <- reshape_X_3d(X_test)
  
  y_train <- reshape_X_3d(y_train)
  y_valid <- reshape_X_3d(y_valid)
  y_test <- reshape_X_3d(y_test)
  
  model <- keras_model_sequential()

  model %>% 
    layer_lstm(
      units <- FLAGS$n_units,
      batch_input_shape = c(FLAGS$batch_size, FLAGS$n_timesteps, n_features),
      dropout = FLAGS$dropout,
      recurrent_dropout = FLAGS$recurrent_dropout, 
      return_sequences = TRUE
    ) %>% time_distributed(layer_dense(units = 1))
  
  
  model %>% 
    compile(
      loss = FLAGS$loss,
      optimizer = optimizer, 
      metrics = list("mean_squared_error")
    )
  
  model %>% fit(
    x = X_train, 
    y = y_train, 
    validation_data = list(X_valid, y_valid), 
    batch_size = FLAGS$batch_size,
    epochs     = FLAGS$n_epochs,
    callbacks = callbacks
  )
  
  pred_train <- model %>% 
  predict(X_train, batch_size = FLAGS$batch_size) %>% 
  .[, , 1]

  #retransform values to original scale
  pred_train <- (pred_train * scale_history + center_history) ^ 2
  compare_train <- df %>% 
    filter(key == "training")
  
  #build a dataframe that has both actual and predicted values
  for(i in 1:nrow(pred_train)) {
    varname <- paste0("pred_train", i)
    compare_train <- 
      mutate(compare_train, !!varname := c(
        rep(NA, FLAGS$n_timesteps + i - 1), 
        pred_train[i, ], 
        rep(NA, nrow(compare_train) - FLAGS$n_timesteps * 2 - i + 1)
      ))
  }
  
  pred_test <- model %>% 
  predict(X_test, batch_size = FLAGS$batch_size) %>% 
  .[, , 1]

#retransform values to original scale
pred_test <- (pred_test * scale_history + center_history) ^ 2
compare_test <- df %>% 
  filter(key == "testing")

#build a dataframe that has both actual and predicted values
for(i in 1:nrow(pred_test)) {
  varname <- paste0("pred_test", i)
  compare_test <- 
    mutate(compare_test, !!varname := c(
      rep(NA, FLAGS$n_timesteps + i - 1), 
      pred_test[i, ], 
      rep(NA, nrow(compare_test) - FLAGS$n_timesteps * 2 - i + 1)
    ))
}
list(train = compare_train, test = compare_test)
  
}
```


Mapping the function over all splits yields a list of all predictions:

```{r, echo = TRUE, results="hide"}
all_split_preds <- rolling_origin_resamples %>% 
  mutate(predict = map(splits, obtain_predictions))
```

Calculate RMSE on all splits:

```{r}
calc_rmse <- function(df) {
  coln <- colnames(df)[4:ncol(df)]
  cols <- map(coln, dplyr::quo(dplyr::sym(.)))

  map_dbl(cols, function(col)
    yardstick::rmse(
    df,
    truth = value,
    estimate = !!col,
    na.rm = TRUE
    )) %>% mean()
}

all_split_preds <- all_split_preds %>% unnest(predict)
all_slits_preds_train <- all_split_preds[seq(1, 11, by = 2), ]
all_slits_preds_test <- all_split_preds[seq(2, 12, by = 2), ]

all_split_rmses_train <- all_slits_preds_train %>% 
  mutate(rmse = map_dbl(predict, calc_rmse)) %>% 
  select(id, rmse)

all_split_rmses_test <- all_slits_preds_test %>% 
  mutate(rmse = map_dbl(predict, calc_rmse)) %>% 
  select(id, rmse)
```

Here how it looks - RMSE on the training set for the 6 splits:

```{r}
all_split_rmses_train
all_split_rmses_test
```

Let's post all predictions on training sets:

```{r, message=FALSE}
#construct functions
plot_train <- function(slice, name) {
  slice %>%
    ggplot(aes(x = index, y = value)) +
    geom_line() +
    geom_line(aes(y = pred_train1), color = "cyan") +
    geom_line(aes(y = pred_train50), color = "red") +
    geom_line(aes(y = pred_train100), color = "green") +
    geom_line(aes(y = pred_train150), color = "violet") +
    geom_line(aes(y = pred_train200), color = "cyan") +
    geom_line(aes(y = pred_train250), color = "red") +
    geom_line(aes(y = pred_train300), color = "green") +
    geom_line(aes(y = pred_train350), color = "violet") +
    geom_line(aes(y = pred_train400), color = "cyan") +
    geom_line(aes(y = pred_train450), color = "red") +
    geom_line(aes(y = pred_train500), color = "green") +
    geom_line(aes(y = pred_train550), color = "violet") +
    geom_line(aes(y = pred_train600), color = "cyan") +
    geom_line(aes(y = pred_train650), color = "red") +
    geom_line(aes(y = pred_train700), color = "green") +
    geom_line(aes(y = pred_train750), color = "violet") +
    ggtitle(name)
} 

plot_test <- function(slice, name) {
  slice %>%
    ggplot(aes(x = index, y = value)) +
    geom_line() +
    geom_line(aes(y = pred_test1), color = "cyan") +
    geom_line(aes(y = pred_test50), color = "red") +
    geom_line(aes(y = pred_test100), color = "green") +
    geom_line(aes(y = pred_test150), color = "violet") +
    geom_line(aes(y = pred_test200), color = "cyan") +
    geom_line(aes(y = pred_test250), color = "red") +
    geom_line(aes(y = pred_test300), color = "green") +
    geom_line(aes(y = pred_test350), color = "violet") +
    geom_line(aes(y = pred_test400), color = "cyan") +
    geom_line(aes(y = pred_test450), color = "red") +
    geom_line(aes(y = pred_test500), color = "green") +
    geom_line(aes(y = pred_test550), color = "violet") +
    ggtitle(name)
}

train_plots <- map2(all_slits_preds_train$predict, all_split_rmses_train$id, plot_train)
p_body_train <- cowplot::plot_grid(plotlist = train_plots, ncol = 3)
p_title_train <- cowplot::ggdraw() + 
  draw_label("Backtested Predictions: Training Sets", size = 18, fontface = "bold")

plot_grid(p_title_train, p_body_train, ncol = 1, rel_heights = c(0.05, 1, 0.05))
```

```{r, message=FALSE}
test_plots <- map2(all_slits_preds_test$predict, all_split_rmses_test$id, plot_test)
p_body_test <- cowplot::plot_grid(plotlist = test_plots, ncol = 3)
p_title_test <- cowplot::ggdraw() + 
  draw_label("Backtested Predictions: Test Sets", size = 18, fontface = "bold")


plot_grid(p_title_test, p_body_test, ncol = 1, rel_heights = c(0.05, 1, 0.05))
 
```



LTSM time series forecasting with Keras