# Set up Keras you probably have not put in earlier than
install_keras()

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

sun_spots

p1 <- sun_spots %>%
    ggplot(aes(index, worth)) +
    geom_point(coloration = palette_light()[[1]], alpha = 0.5) +
    theme_tq() +
    labs(
        title = "From 1749 to 2013 (Full Knowledge Set)"
    )

p2 <- sun_spots %>%
    filter_time("begin" ~ "1800") %>%
    ggplot(aes(index, worth)) +
    geom_line(coloration = palette_light()[[1]], alpha = 0.5) +
    geom_point(coloration = palette_light()[[1]]) +
    geom_smooth(methodology = "loess", span = 0.2, se = FALSE) +
    theme_tq() +
    labs(
        title = "1749 to 1759 (Zoomed In To Present Adjustments over the Yr)",
        caption = "datasets::sunspot.month"
    )

p_title <- ggdraw() + 
  draw_label("Sunspots", dimension = 18, fontface = "daring", 
             color = palette_light()[[1]])

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

periods_train <- 12 * 100
periods_test  <- 12 * 50
skip_span     <- 12 * 22 - 1

rolling_origin_resamples <- rolling_origin(
  sun_spots,
  preliminary    = periods_train,
  assess     = periods_test,
  cumulative = FALSE,
  skip       = skip_span
)

rolling_origin_resamples

# Plotting perform for a single break up
plot_split <- perform(break up, expand_y_axis = TRUE, 
                       alpha = 1, dimension = 1, base_size = 14) {
    
    # Manipulate knowledge
    train_tbl <- coaching(break up) %>%
        add_column(key = "coaching") 
    
    test_tbl  <- testing(break up) %>%
        add_column(key = "testing") 
    
    data_manipulated <- bind_rows(train_tbl, test_tbl) %>%
        as_tbl_time(index = index) %>%
        mutate(key = fct_relevel(key, "coaching", "testing"))
        
    # Gather attributes
    train_time_summary <- train_tbl %>%
        tk_index() %>%
        tk_get_timeseries_summary()
    
    test_time_summary <- test_tbl %>%
        tk_index() %>%
        tk_get_timeseries_summary()
    
    # Visualize
    g <- data_manipulated %>%
        ggplot(aes(x = index, y = worth, coloration = key)) +
        geom_line(dimension = dimension, alpha = alpha) +
        theme_tq(base_size = base_size) +
        scale_color_tq() +
        labs(
          title    = glue("Break up: {break up$id}"),
          subtitle = glue("{train_time_summary$begin} to ", 
                          "{test_time_summary$finish}"),
            y = "", x = ""
        ) +
        theme(legend.place = "none") 
    
    if (expand_y_axis) {
        
        sun_spots_time_summary <- sun_spots %>% 
            tk_index() %>% 
            tk_get_timeseries_summary()
        
        g <- g +
            scale_x_date(limits = c(sun_spots_time_summary$begin, 
                                    sun_spots_time_summary$finish))
    }
    
    g
}

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

# Plotting perform that scales to all splits 
plot_sampling_plan <- perform(sampling_tbl, expand_y_axis = TRUE, 
                               ncol = 3, alpha = 1, dimension = 1, base_size = 14, 
                               title = "Sampling Plan") {
    
    # Map plot_split() 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.place = "backside")
    legend <- get_legend(p_temp)
    
    p_body  <- plot_grid(plotlist = plot_list, ncol = ncol)
    
    p_title <- ggdraw() + 
        draw_label(title, dimension = 14, fontface = "daring", 
                   color = palette_light()[[1]])
    
    g <- plot_grid(p_title, p_body, legend, ncol = 1, 
                   rel_heights = c(0.05, 1, 0.05))
    
    g
    
}

rolling_origin_resamples %>%
    plot_sampling_plan(expand_y_axis = T, ncol = 3, alpha = 1, dimension = 1, base_size = 10, 
                       title = "Backtesting Technique: Rolling Origin Sampling Plan")

rolling_origin_resamples %>%
    plot_sampling_plan(expand_y_axis = F, ncol = 3, alpha = 1, dimension = 1, base_size = 10, 
                       title = "Backtesting Technique: Zoomed In")

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

plot_split(example_split, expand_y_axis = FALSE, dimension = 0.5) +
    theme(legend.place = "backside") +
    ggtitle(glue("Break up: {example_split_id}"))

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

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

df

rec_obj <- recipe(worth ~ ., df) %>%
    step_sqrt(worth) %>%
    step_center(worth) %>%
    step_scale(worth) %>%
    prep()

df_processed_tbl <- bake(rec_obj, df)

df_processed_tbl

center_history <- rec_obj$steps[[2]]$means["value"]
scale_history  <- rec_obj$steps[[3]]$sds["value"]

c("heart" = center_history, "scale" = scale_history)

# these variables are being outlined simply due to the order through which
# we current issues on this submit (first the info, then the mannequin)
# they are going to be outdated by FLAGS$n_timesteps, FLAGS$batch_size and n_predictions
# within the following snippet
n_timesteps <- 12
n_predictions <- n_timesteps
batch_size <- 10

# features used
build_matrix <- perform(tseries, overall_timesteps) {
  t(sapply(1:(size(tseries) - overall_timesteps + 1), perform(x) 
    tseries[x:(x + overall_timesteps - 1)]))
}

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

# extract values from knowledge body
train_vals <- df_processed_tbl %>%
  filter(key == "coaching") %>%
  choose(worth) %>%
  pull()
valid_vals <- df_processed_tbl %>%
  filter(key == "validation") %>%
  choose(worth) %>%
  pull()
test_vals <- df_processed_tbl %>%
  filter(key == "testing") %>%
  choose(worth) %>%
  pull()


# construct 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 coaching and testing components
# additionally, discard final batch if there are fewer than batch_size samples
# (a purely technical requirement)
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 <- y_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 <- y_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 <- y_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)

FLAGS <- flags(
  # There's a so-called "stateful LSTM" in Keras. Whereas LSTM is stateful
  # per se, this provides an additional tweak the place the hidden states get 
  # initialized with values from the merchandise at similar place within the earlier
  # batch. That is useful slightly below particular circumstances, or if you need
  # to create an "infinite stream" of states, through which case you'd use 1 as 
  # the batch dimension. Under, we present how the code must be modified to
  # use this, nevertheless it will not be additional mentioned right here.
  flag_boolean("stateful", FALSE),
  # Ought to we use a number of layers of LSTM?
  # Once more, simply included for completeness, it didn't yield any superior 
  # efficiency on this process.
  # This may truly stack precisely one extra layer of LSTM items.
  flag_boolean("stack_layers", FALSE),
  # variety of samples fed to the mannequin in a single go
  flag_integer("batch_size", 10),
  # dimension of the hidden state, equals dimension of predictions
  flag_integer("n_timesteps", 12),
  # what number of epochs to coach for
  flag_integer("n_epochs", 100),
  # fraction of the items to drop for the linear transformation of the inputs
  flag_numeric("dropout", 0.2),
  # fraction of the items to drop for the linear transformation of the 
  # recurrent state
  flag_numeric("recurrent_dropout", 0.2),
  # loss perform. Discovered to work higher for this particular case than imply
  # squared error
  flag_string("loss", "logcosh"),
  # optimizer = stochastic gradient descent. Appeared to work higher than adam 
  # or rmsprop right here (as indicated by restricted testing)
  flag_string("optimizer_type", "sgd"),
  # dimension of the LSTM layer
  flag_integer("n_units", 128),
  # studying fee
  flag_numeric("lr", 0.003),
  # momentum, a further parameter to the SGD optimizer
  flag_numeric("momentum", 0.9),
  # parameter to the early stopping callback
  flag_integer("endurance", 10)
)

# the variety of predictions we'll make equals the size of the hidden state
n_predictions <- FLAGS$n_timesteps
# what number of options = predictors now we have
n_features <- 1
# simply in case we wished to attempt totally different optimizers, we might add right here
optimizer <- change(FLAGS$optimizer_type,
                    sgd = optimizer_sgd(lr = FLAGS$lr, 
                                        momentum = FLAGS$momentum)
                    )

# callbacks to be handed to the match() perform
# We simply use one right here: we might cease earlier than n_epochs if the loss on the
# validation set doesn't lower (by a configurable quantity, over a 
# configurable time)
callbacks <- checklist(
  callback_early_stopping(endurance = FLAGS$endurance)
)

mannequin <- keras_model_sequential()

mannequin %>%
  layer_lstm(
    items = 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,
    stateful = FLAGS$stateful
  )

if (FLAGS$stack_layers) {
  mannequin %>%
    layer_lstm(
      items = FLAGS$n_units,
      dropout = FLAGS$dropout,
      recurrent_dropout = FLAGS$recurrent_dropout,
      return_sequences = TRUE,
      stateful = FLAGS$stateful
    )
}
mannequin %>% time_distributed(layer_dense(items = 1))

mannequin %>%
  compile(
    loss = FLAGS$loss,
    optimizer = optimizer,
    metrics = checklist("mean_squared_error")
  )

if (!FLAGS$stateful) {
  mannequin %>% match(
    x          = X_train,
    y          = y_train,
    validation_data = checklist(X_valid, y_valid),
    batch_size = FLAGS$batch_size,
    epochs     = FLAGS$n_epochs,
    callbacks = callbacks
  )
  
} else {
  for (i in 1:FLAGS$n_epochs) {
    mannequin %>% match(
      x          = X_train,
      y          = y_train,
      validation_data = checklist(X_valid, y_valid),
      callbacks = callbacks,
      batch_size = FLAGS$batch_size,
      epochs     = 1,
      shuffle    = FALSE
    )
    mannequin %>% reset_states()
  }
}

if (FLAGS$stateful)
  mannequin %>% reset_states()

# create the mannequin
mannequin <- keras_model_sequential()

# add layers
# now we have simply two, the LSTM and the time_distributed 
mannequin %>%
  layer_lstm(
    items = FLAGS$n_units, 
    # the primary layer in a mannequin must know the form of the enter knowledge
    batch_input_shape  = c(FLAGS$batch_size, FLAGS$n_timesteps, n_features),
    dropout = FLAGS$dropout,
    recurrent_dropout = FLAGS$recurrent_dropout,
    # by default, an LSTM simply returns the ultimate state
    return_sequences = TRUE
  ) %>% time_distributed(layer_dense(items = 1))

mannequin %>%
  compile(
    loss = FLAGS$loss,
    optimizer = optimizer,
    # along with the loss, Keras will inform us about present 
    # MSE whereas coaching
    metrics = checklist("mean_squared_error")
  )

historical past <- mannequin %>% match(
  x          = X_train,
  y          = y_train,
  validation_data = checklist(X_valid, y_valid),
  batch_size = FLAGS$batch_size,
  epochs     = FLAGS$n_epochs,
  callbacks = callbacks
)

plot(historical past, metrics = "loss")

pred_train <- mannequin %>%
  predict(X_train, batch_size = FLAGS$batch_size) %>%
  .[, , 1]

# Retransform values to unique scale
pred_train <- (pred_train * scale_history + center_history) ^2
compare_train <- df %>% filter(key == "coaching")

# construct a dataframe that has each precise 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)
    ))
}

coln <- colnames(compare_train)[4:ncol(compare_train)]
cols <- map(coln, quo(sym(.)))
rsme_train <-
  map_dbl(cols, perform(col)
    rmse(
      compare_train,
      reality = worth,
      estimate = !!col,
      na.rm = TRUE
    )) %>% imply()

rsme_train

ggplot(compare_train, aes(x = index, y = worth)) + geom_line() +
  geom_line(aes(y = pred_train1), coloration = "cyan") +
  geom_line(aes(y = pred_train50), coloration = "purple") +
  geom_line(aes(y = pred_train100), coloration = "inexperienced") +
  geom_line(aes(y = pred_train150), coloration = "violet") +
  geom_line(aes(y = pred_train200), coloration = "cyan") +
  geom_line(aes(y = pred_train250), coloration = "purple") +
  geom_line(aes(y = pred_train300), coloration = "purple") +
  geom_line(aes(y = pred_train350), coloration = "inexperienced") +
  geom_line(aes(y = pred_train400), coloration = "cyan") +
  geom_line(aes(y = pred_train450), coloration = "purple") +
  geom_line(aes(y = pred_train500), coloration = "inexperienced") +
  geom_line(aes(y = pred_train550), coloration = "violet") +
  geom_line(aes(y = pred_train600), coloration = "cyan") +
  geom_line(aes(y = pred_train650), coloration = "purple") +
  geom_line(aes(y = pred_train700), coloration = "purple") +
  geom_line(aes(y = pred_train750), coloration = "inexperienced") +
  ggtitle("Predictions on the coaching set")

pred_test <- mannequin %>%
  predict(X_test, batch_size = FLAGS$batch_size) %>%
  .[, , 1]

# Retransform values to unique scale
pred_test <- (pred_test * scale_history + center_history) ^2
pred_test[1:10, 1:5] %>% print()
compare_test <- df %>% filter(key == "testing")

# construct a dataframe that has each precise 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", ".take a look at.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, quo(sym(.)))
rsme_test <-
  map_dbl(cols, perform(col)
    rmse(
      compare_test,
      reality = worth,
      estimate = !!col,
      na.rm = TRUE
    )) %>% imply()

rsme_test

ggplot(compare_test, aes(x = index, y = worth)) + geom_line() +
  geom_line(aes(y = pred_test1), coloration = "cyan") +
  geom_line(aes(y = pred_test50), coloration = "purple") +
  geom_line(aes(y = pred_test100), coloration = "inexperienced") +
  geom_line(aes(y = pred_test150), coloration = "violet") +
  geom_line(aes(y = pred_test200), coloration = "cyan") +
  geom_line(aes(y = pred_test250), coloration = "purple") +
  geom_line(aes(y = pred_test300), coloration = "inexperienced") +
  geom_line(aes(y = pred_test350), coloration = "cyan") +
  geom_line(aes(y = pred_test400), coloration = "purple") +
  geom_line(aes(y = pred_test450), coloration = "inexperienced") +  
  geom_line(aes(y = pred_test500), coloration = "cyan") +
  geom_line(aes(y = pred_test550), coloration = "violet") +
  ggtitle("Predictions on take a look at set")

obtain_predictions <- perform(break up) {
  df_trn <- evaluation(break up)[1:800, , drop = FALSE]
  df_val <- evaluation(break up)[801:1200, , drop = FALSE]
  df_tst <- evaluation(break up)
  
  df <- bind_rows(
    df_trn %>% add_column(key = "coaching"),
    df_val %>% add_column(key = "validation"),
    df_tst %>% add_column(key = "testing")
  ) %>%
    as_tbl_time(index = index)
  
  rec_obj <- recipe(worth ~ ., df) %>%
    step_sqrt(worth) %>%
    step_center(worth) %>%
    step_scale(worth) %>%
    prep()
  
  df_processed_tbl <- bake(rec_obj, df)
  
  center_history <- rec_obj$steps[[2]]$means["value"]
  scale_history  <- rec_obj$steps[[3]]$sds["value"]
  
  FLAGS <- flags(
    flag_boolean("stateful", FALSE),
    flag_boolean("stack_layers", FALSE),
    flag_integer("batch_size", 10),
    flag_integer("n_timesteps", 12),
    flag_integer("n_epochs", 100),
    flag_numeric("dropout", 0.2),
    flag_numeric("recurrent_dropout", 0.2),
    flag_string("loss", "logcosh"),
    flag_string("optimizer_type", "sgd"),
    flag_integer("n_units", 128),
    flag_numeric("lr", 0.003),
    flag_numeric("momentum", 0.9),
    flag_integer("endurance", 10)
  )
  
  n_predictions <- FLAGS$n_timesteps
  n_features <- 1
  
  optimizer <- change(FLAGS$optimizer_type,
                      sgd = optimizer_sgd(lr = FLAGS$lr, momentum = FLAGS$momentum))
  callbacks <- checklist(
    callback_early_stopping(endurance = FLAGS$endurance)
  )
  
  train_vals <- df_processed_tbl %>%
    filter(key == "coaching") %>%
    choose(worth) %>%
    pull()
  valid_vals <- df_processed_tbl %>%
    filter(key == "validation") %>%
    choose(worth) %>%
    pull()
  test_vals <- df_processed_tbl %>%
    filter(key == "testing") %>%
    choose(worth) %>%
    pull()
  
  train_matrix <-
    build_matrix(train_vals, FLAGS$n_timesteps + n_predictions)
  valid_matrix <-
    build_matrix(valid_vals, FLAGS$n_timesteps + n_predictions)
  test_matrix <-
    build_matrix(test_vals, FLAGS$n_timesteps + n_predictions)
  
  X_train <- train_matrix[, 1:FLAGS$n_timesteps]
  y_train <-
    train_matrix[, (FLAGS$n_timesteps + 1):(FLAGS$n_timesteps * 2)]
  X_train <-
    X_train[1:(nrow(X_train) %/% FLAGS$batch_size * FLAGS$batch_size),]
  y_train <-
    y_train[1:(nrow(y_train) %/% FLAGS$batch_size * FLAGS$batch_size),]
  
  X_valid <- valid_matrix[, 1:FLAGS$n_timesteps]
  y_valid <-
    valid_matrix[, (FLAGS$n_timesteps + 1):(FLAGS$n_timesteps * 2)]
  X_valid <-
    X_valid[1:(nrow(X_valid) %/% FLAGS$batch_size * FLAGS$batch_size),]
  y_valid <-
    y_valid[1:(nrow(y_valid) %/% FLAGS$batch_size * FLAGS$batch_size),]
  
  X_test <- test_matrix[, 1:FLAGS$n_timesteps]
  y_test <-
    test_matrix[, (FLAGS$n_timesteps + 1):(FLAGS$n_timesteps * 2)]
  X_test <-
    X_test[1:(nrow(X_test) %/% FLAGS$batch_size * FLAGS$batch_size),]
  y_test <-
    y_test[1:(nrow(y_test) %/% FLAGS$batch_size * FLAGS$batch_size),]
  
  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)
  
  mannequin <- keras_model_sequential()
  
  mannequin %>%
    layer_lstm(
      items            = 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(items = 1))
  
  mannequin %>%
    compile(
      loss = FLAGS$loss,
      optimizer = optimizer,
      metrics = checklist("mean_squared_error")
    )
  
  mannequin %>% match(
    x          = X_train,
    y          = y_train,
    validation_data = checklist(X_valid, y_valid),
    batch_size = FLAGS$batch_size,
    epochs     = FLAGS$n_epochs,
    callbacks = callbacks
  )
  
  
  pred_train <- mannequin %>%
    predict(X_train, batch_size = FLAGS$batch_size) %>%
    .[, , 1]
  
  # Retransform values
  pred_train <- (pred_train * scale_history + center_history) ^ 2
  compare_train <- df %>% filter(key == "coaching")
  
  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 <- mannequin %>%
    predict(X_test, batch_size = FLAGS$batch_size) %>%
    .[, , 1]
  
  # Retransform values
  pred_test <- (pred_test * scale_history + center_history) ^ 2
  compare_test <- df %>% filter(key == "testing")
  
  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)
      ))
  }
  checklist(practice = compare_train, take a look at = compare_test)
  
}

all_split_preds <- rolling_origin_resamples %>%
     mutate(predict = map(splits, obtain_predictions))

calc_rmse <- perform(df) {
  coln <- colnames(df)[4:ncol(df)]
  cols <- map(coln, quo(sym(.)))
  map_dbl(cols, perform(col)
    rmse(
      df,
      reality = worth,
      estimate = !!col,
      na.rm = TRUE
    )) %>% imply()
}

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

all_split_rmses_train <- all_split_preds_train %>%
  mutate(rmse = map_dbl(predict, calc_rmse)) %>%
  choose(id, rmse)

all_split_rmses_test <- all_split_preds_test %>%
  mutate(rmse = map_dbl(predict, calc_rmse)) %>%
  choose(id, rmse)

plot_train <- perform(slice, identify) {
  ggplot(slice, aes(x = index, y = worth)) + geom_line() +
    geom_line(aes(y = pred_train1), coloration = "cyan") +
    geom_line(aes(y = pred_train50), coloration = "purple") +
    geom_line(aes(y = pred_train100), coloration = "inexperienced") +
    geom_line(aes(y = pred_train150), coloration = "violet") +
    geom_line(aes(y = pred_train200), coloration = "cyan") +
    geom_line(aes(y = pred_train250), coloration = "purple") +
    geom_line(aes(y = pred_train300), coloration = "purple") +
    geom_line(aes(y = pred_train350), coloration = "inexperienced") +
    geom_line(aes(y = pred_train400), coloration = "cyan") +
    geom_line(aes(y = pred_train450), coloration = "purple") +
    geom_line(aes(y = pred_train500), coloration = "inexperienced") +
    geom_line(aes(y = pred_train550), coloration = "violet") +
    geom_line(aes(y = pred_train600), coloration = "cyan") +
    geom_line(aes(y = pred_train650), coloration = "purple") +
    geom_line(aes(y = pred_train700), coloration = "purple") +
    geom_line(aes(y = pred_train750), coloration = "inexperienced") +
    ggtitle(identify)
}

train_plots <- map2(all_split_preds_train$predict, all_split_preds_train$id, plot_train)
p_body_train  <- plot_grid(plotlist = train_plots, ncol = 3)
p_title_train <- ggdraw() + 
  draw_label("Backtested Predictions: Coaching Units", dimension = 18, fontface = "daring")

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

plot_test <- perform(slice, identify) {
  ggplot(slice, aes(x = index, y = worth)) + geom_line() +
    geom_line(aes(y = pred_test1), coloration = "cyan") +
    geom_line(aes(y = pred_test50), coloration = "purple") +
    geom_line(aes(y = pred_test100), coloration = "inexperienced") +
    geom_line(aes(y = pred_test150), coloration = "violet") +
    geom_line(aes(y = pred_test200), coloration = "cyan") +
    geom_line(aes(y = pred_test250), coloration = "purple") +
    geom_line(aes(y = pred_test300), coloration = "inexperienced") +
    geom_line(aes(y = pred_test350), coloration = "cyan") +
    geom_line(aes(y = pred_test400), coloration = "purple") +
    geom_line(aes(y = pred_test450), coloration = "inexperienced") +  
    geom_line(aes(y = pred_test500), coloration = "cyan") +
    geom_line(aes(y = pred_test550), coloration = "violet") +
    ggtitle(identify)
}

test_plots <- map2(all_split_preds_test$predict, all_split_preds_test$id, plot_test)

p_body_test  <- plot_grid(plotlist = test_plots, ncol = 3)
p_title_test <- ggdraw() + 
  draw_label("Backtested Predictions: Check Units", dimension = 18, fontface = "daring")

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