context("training")

test_that("Sucessful training from a dummy model", {

   #testthat::skip_if_not_installed("tensorflow")

   testthat::skip_if_not(reticulate::py_module_available("tensorflow"))

   # language model

   maxlen <- 30

   batch_size <- 10

   model <- create_model_lstm_cnn(

      maxlen = maxlen,

      layer_dense = 4,

      layer_lstm = 8,

      solver = "adam",

      vocabulary_size = 4,

      compile = TRUE)

   trainedNetwork <- train_model(reduce_lr_on_plateau = FALSE,

                                 train_type = "lm",

                                 path = "fasta",

                                 path_val = "fasta",

                                 model = model,

                                 train_val_ratio = 0.2,

                                 steps_per_epoch = 3,

                                 batch_size = batch_size,

                                 epochs = 1)

   expect_type(trainedNetwork, "list")

   expect_type(trainedNetwork[["metrics"]][["loss"]], "double")

   expect_gte(trainedNetwork[["metrics"]][["loss"]], 0)

   expect_type(trainedNetwork[["metrics"]][["val_loss"]], "double")

   expect_gte(trainedNetwork[["metrics"]][["val_loss"]], 0)

   # label folder

   model <- create_model_lstm_cnn(

      maxlen = maxlen,

      kernel_size = c(4,4),

      pool_size = c(2,2),

      filters = c(2,4),

      layer_dense = 2,

      layer_lstm = 8,

      solver = "adam",

      vocabulary_size = 4,

      compile = TRUE)

   trainedNetwork <- train_model(reduce_lr_on_plateau = FALSE,

                                 train_type = "label_folder",

                                 path = rep("fasta", 2),

                                 path_val = rep("fasta", 2),

                                 model = model,

                                 vocabulary_label = c("A", "B"),

                                 train_val_ratio = 0.2,

                                 steps_per_epoch = 3,

                                 batch_size = batch_size,

                                 epochs = 1)

   expect_type(trainedNetwork, "list")

   expect_type(trainedNetwork[["metrics"]][["loss"]], "double")

   expect_gte(trainedNetwork[["metrics"]][["loss"]], 0)

   expect_type(trainedNetwork[["metrics"]][["val_loss"]], "double")

   expect_gte(trainedNetwork[["metrics"]][["val_loss"]], 0)

   # train/val split with csv

   maxlen <- 3

   model <- create_model_lstm_cnn(

      maxlen = maxlen,

      layer_dense = 2,

      layer_lstm = 6,

      solver = "adam",

      vocabulary_size = 4,

      compile = TRUE)

   files <- as.list(list.files(c("fasta_2", "fasta"), full.names = TRUE))

   # target csv

   A <- sample(c(0,1), length(files), replace = TRUE)

   B <- ifelse(A == 0, 1, 0)

   target_df <- data.frame(file = basename(unlist(files)), A = A, B = B)

   target_from_csv <- tempfile(fileext = ".csv")

   write.csv(target_df, target_from_csv, row.names = FALSE)

   # train/val csv

   train_val_split_csv <- tempfile(fileext = ".csv")

   ttv_df <- data.frame(file = basename(unlist(files)), 

                        type = rep(c("train", "validation"), each = 2))

   train_files <- ttv_df$file[ttv_df$type == "train"]

   val_files <- ttv_df$file[ttv_df$type == "validation"]

   write.csv(ttv_df, train_val_split_csv, row.names = FALSE)

   path_file_log <- tempfile(fileext = ".csv")

   trainedNetwork <- train_model(reduce_lr_on_plateau = FALSE,

                                 train_type = "label_csv",

                                 path = files,

                                 path_val = files,

                                 model = model,

                                 vocabulary_label = c("A", "B"),

                                 train_val_ratio = 0.2,

                                 steps_per_epoch = 3,

                                 batch_size = 4,

                                 max_samples = 2,

                                 target_from_csv = target_from_csv,

                                 train_val_split_csv = train_val_split_csv,

                                 path_file_log = path_file_log,

                                 epochs = 2)

   file_log <- read.csv(path_file_log)

   train_file_log <- unique(basename(file_log[,1]))

   expect_true(all(sort(train_file_log) == sort(train_files)))

   expect_true(all(sort(train_file_log) != sort(val_files)))

})