diff --git a/tests/testthat/test_boost_tree_spark.R b/tests/testthat/test_boost_tree_spark.R deleted file mode 100644 index 993578f55..000000000 --- a/tests/testthat/test_boost_tree_spark.R +++ /dev/null @@ -1,182 +0,0 @@ -library(testthat) -library(parsnip) -library(dplyr) - -# ------------------------------------------------------------------------------ - -context("boosted tree execution with spark") -source(test_path("helper-objects.R")) -hpc <- hpc_data[1:150, c(2:5, 8)] - -# ------------------------------------------------------------------------------ - -test_that('spark execution', { - - skip_if_not_installed("sparklyr") - library(sparklyr) - - sc <- try(spark_connect(master = "local"), silent = TRUE) - - skip_if(inherits(sc, "try-error")) - - hpc_bt_tr <- copy_to(sc, hpc[-(1:4), ], "hpc_bt_tr", overwrite = TRUE) - hpc_bt_te <- copy_to(sc, hpc[ 1:4 , -1], "hpc_bt_te", overwrite = TRUE) - - # ---------------------------------------------------------------------------- - - expect_error( - spark_reg_fit <- - fit( - boost_tree(trees = 5, mode = "regression") %>% - set_engine("spark", seed = 12), - control = ctrl, - compounds ~ ., - data = hpc_bt_tr - ), - regexp = NA - ) - - # check for reproducibility and passing extra arguments - expect_error( - spark_reg_fit_dup <- - fit( - boost_tree(trees = 5, mode = "regression") %>% - set_engine("spark", seed = 12), - control = ctrl, - compounds ~ ., - data = hpc_bt_tr - ), - regexp = NA - ) - - expect_error( - spark_reg_pred <- predict(spark_reg_fit, hpc_bt_te), - regexp = NA - ) - - expect_error( - spark_reg_pred_num <- parsnip:::predict_numeric.model_fit(spark_reg_fit, hpc_bt_te), - regexp = NA - ) - - expect_error( - spark_reg_dup <- predict(spark_reg_fit_dup, hpc_bt_te), - regexp = NA - ) - - expect_error( - spark_reg_num_dup <- parsnip:::predict_numeric.model_fit(spark_reg_fit_dup, hpc_bt_te), - regexp = NA - ) - - expect_equal(colnames(spark_reg_pred), "pred") - - expect_equal( - as.data.frame(spark_reg_pred)$pred, - as.data.frame(spark_reg_dup)$pred - ) - expect_equal( - as.data.frame(spark_reg_pred_num)$pred, - as.data.frame(spark_reg_num_dup)$pred - ) - - - # ---------------------------------------------------------------------------- - - # same for classification - - churn_bt_tr <- copy_to(sc, wa_churn[ 5:100, ], "churn_bt_tr", overwrite = TRUE) - churn_bt_te <- copy_to(sc, wa_churn[ 1:4, -1], "churn_bt_te", overwrite = TRUE) - - # ---------------------------------------------------------------------------- - - expect_error( - spark_class_fit <- - fit( - boost_tree(trees = 5, mode = "classification") %>% - set_engine("spark", seed = 12), - control = ctrl, - churn ~ ., - data = churn_bt_tr - ), - regexp = NA - ) - - # check for reproducibility and passing extra arguments - expect_error( - spark_class_fit_dup <- - fit( - boost_tree(trees = 5, mode = "classification") %>% - set_engine("spark", seed = 12), - control = ctrl, - churn ~ ., - data = churn_bt_tr - ), - regexp = NA - ) - - expect_error( - spark_class_pred <- predict(spark_class_fit, churn_bt_te), - regexp = NA - ) - - expect_error( - spark_class_pred_class <- parsnip:::predict_class.model_fit(spark_class_fit, churn_bt_te), - regexp = NA - ) - - expect_error( - spark_class_dup <- predict(spark_class_fit_dup, churn_bt_te), - regexp = NA - ) - - expect_error( - spark_class_dup_class <- parsnip:::predict_class.model_fit(spark_class_fit_dup, churn_bt_te), - regexp = NA - ) - - expect_equal(colnames(spark_class_pred), "pred_class") - - expect_equal( - as.data.frame(spark_class_pred)$pred_class, - as.data.frame(spark_class_dup)$pred_class - ) - expect_equal( - as.data.frame(spark_class_pred_class)$pred_class, - as.data.frame(spark_class_dup_class)$pred_class - ) - - - expect_error( - spark_class_prob <- predict(spark_class_fit, churn_bt_te, type = "prob"), - regexp = NA - ) - - expect_error( - spark_class_prob_classprob <- parsnip:::predict_classprob.model_fit(spark_class_fit, churn_bt_te), - regexp = NA - ) - - expect_error( - spark_class_dup <- predict(spark_class_fit_dup, churn_bt_te, type = "prob"), - regexp = NA - ) - - expect_error( - spark_class_dup_classprob <- parsnip:::predict_classprob.model_fit(spark_class_fit_dup, churn_bt_te), - regexp = NA - ) - - expect_equal(colnames(spark_class_prob), c("pred_No", "pred_Yes")) - - expect_equivalent( - as.data.frame(spark_class_prob), - as.data.frame(spark_class_dup) - ) - expect_equal( - as.data.frame(spark_class_prob_classprob), - as.data.frame(spark_class_dup_classprob) - ) - -}) - diff --git a/tests/testthat/test_descriptors.R b/tests/testthat/test_descriptors.R index 3fc3a00f4..e983b5b12 100644 --- a/tests/testthat/test_descriptors.R +++ b/tests/testthat/test_descriptors.R @@ -182,56 +182,6 @@ test_that("numeric y and dummy vars", { # ------------------------------------------------------------------------------ -context("spark descriptors") - -test_that("spark descriptor", { - - skip_if_not_installed("sparklyr") - - library(sparklyr) - library(dplyr) - - sc <- try(spark_connect(master = "local"), silent = TRUE) - - skip_if(inherits(sc, "try-error")) - - npk_descr <- copy_to(sc, npk[, 1:4], "npk_descr", overwrite = TRUE) - hpc_descr <- copy_to(sc, hpc, "hpc_descr", overwrite = TRUE) - - # spark does not allow .x, .y, .dat; spark handles factors differently - template2 <- purrr::partial(template, x = NULL, y = NULL, dat = NULL) - eval_descrs2 <- purrr::partial(eval_descrs, not = c(".x", ".y", ".dat")) - class_tab2 <- table(as.character(hpc$class), dnn = NULL) - - expect_equal( - template2(6, 4, 150, NA, 1), - eval_descrs2(get_descr_form(compounds ~ ., data = hpc_descr)) - ) - expect_equal( - template2(3, 1, 150, NA, 1), - eval_descrs2(get_descr_form(compounds ~ class, data = hpc_descr)) - ) - expect_equal( - template2(1, 1, 150, NA, 0), - eval_descrs2(get_descr_form(compounds ~ input_fields, data = hpc_descr)) - ) - expect_equivalent( - template2(4, 4, 150, class_tab2, 0), - eval_descrs2(get_descr_form(class ~ ., data = hpc_descr)) - ) - expect_equal( - template2(1, 1, 150, class_tab2, 0), - eval_descrs2(get_descr_form(class ~ input_fields, data = hpc_descr)) - ) - expect_equivalent( - template2(7, 3, 24, rev(table(npk$K, dnn = NULL)), 3), - eval_descrs2(get_descr_form(K ~ ., data = npk_descr)) - ) - -}) - -# ------------------------------------------------------------------------------ - context("Descriptor helpers") test_that("can be temporarily overriden at evaluation time", { diff --git a/tests/testthat/test_linear_reg_spark.R b/tests/testthat/test_linear_reg_spark.R deleted file mode 100644 index bf0420f73..000000000 --- a/tests/testthat/test_linear_reg_spark.R +++ /dev/null @@ -1,56 +0,0 @@ -library(testthat) -library(parsnip) -library(dplyr) - -# ------------------------------------------------------------------------------ - -context("linear regression execution with spark") -source(test_path("helper-objects.R")) -hpc <- hpc_data[1:150, c(2:5, 8)] - -# ------------------------------------------------------------------------------ - -test_that('spark execution', { - - skip_if_not_installed("sparklyr") - - library(sparklyr) - - sc <- try(spark_connect(master = "local"), silent = TRUE) - - skip_if(inherits(sc, "try-error")) - - hpc_linreg_tr <- copy_to(sc, hpc[-(1:4), ], "hpc_linreg_tr", overwrite = TRUE) - hpc_linreg_te <- copy_to(sc, hpc[ 1:4 , -1], "hpc_linreg_te", overwrite = TRUE) - - expect_error( - spark_fit <- - fit( - linear_reg() %>% set_engine("spark"), - control = ctrl, - compounds ~ ., - data = hpc_linreg_tr - ), - regexp = NA - ) - - expect_false(has_multi_predict(spark_fit)) - expect_equal(multi_predict_args(spark_fit), NA_character_) - - expect_error( - spark_pred <- predict(spark_fit, hpc_linreg_te), - regexp = NA - ) - - expect_error( - spark_pred_num <- predict(spark_fit, hpc_linreg_te), - regexp = NA - ) - - lm_fit <- lm(compounds ~ ., data = hpc[-(1:4), ]) - lm_pred <- unname(predict(lm_fit, hpc[ 1:4 , -1])) - - expect_equal(as.data.frame(spark_pred)$pred, lm_pred) - expect_equal(as.data.frame(spark_pred_num)$pred, lm_pred) -}) - diff --git a/tests/testthat/test_logistic_reg_spark.R b/tests/testthat/test_logistic_reg_spark.R deleted file mode 100644 index d7cba9482..000000000 --- a/tests/testthat/test_logistic_reg_spark.R +++ /dev/null @@ -1,88 +0,0 @@ -library(testthat) -library(parsnip) -library(dplyr) - -# ------------------------------------------------------------------------------ - -context("logistic regression execution with spark") -source(test_path("helper-objects.R")) -hpc <- hpc_data[1:150, c(2:5, 8)] - -# ------------------------------------------------------------------------------ - -test_that('spark execution', { - - skip_if_not_installed("sparklyr") - - library(sparklyr) - - sc <- try(spark_connect(master = "local"), silent = TRUE) - - skip_if(inherits(sc, "try-error")) - - churn_logit_tr <- copy_to(sc, wa_churn[ 5:100, ], "churn_logit_tr", overwrite = TRUE) - churn_logit_te <- copy_to(sc, wa_churn[ 1:4, -1], "churn_logit_te", overwrite = TRUE) - - # ---------------------------------------------------------------------------- - - expect_error( - spark_class_fit <- - fit( - logistic_reg() %>% set_engine("spark"), - control = ctrl, - churn ~ ., - data = churn_logit_tr - ), - regexp = NA - ) - - # check for reproducibility and passing extra arguments - expect_error( - spark_class_fit_dup <- - fit( - logistic_reg() %>% set_engine("spark"), - control = ctrl, - churn ~ ., - data = churn_logit_tr - ), - regexp = NA - ) - - expect_error( - spark_class_pred <- predict(spark_class_fit, churn_logit_te), - regexp = NA - ) - - expect_error( - spark_class_pred_class <- predict(spark_class_fit, churn_logit_te), - regexp = NA - ) - - expect_equal(colnames(spark_class_pred), "pred_class") - - expect_equal( - as.data.frame(spark_class_pred)$pred_class, - as.data.frame(spark_class_pred_class)$pred_class - ) - - expect_error( - spark_class_prob <- predict(spark_class_fit, churn_logit_te, type = "prob"), - regexp = NA - ) - - expect_error( - spark_class_prob_classprob <- predict(spark_class_fit, churn_logit_te, type = "prob"), - regexp = NA - ) - - expect_equal(colnames(spark_class_prob), c("pred_No", "pred_Yes")) - - expect_equivalent( - as.data.frame(spark_class_prob), - as.data.frame(spark_class_prob_classprob) - ) - - -}) - - diff --git a/tests/testthat/test_multinom_reg_spark.R b/tests/testthat/test_multinom_reg_spark.R deleted file mode 100644 index e70a4a45f..000000000 --- a/tests/testthat/test_multinom_reg_spark.R +++ /dev/null @@ -1,77 +0,0 @@ -library(testthat) -library(parsnip) -library(dplyr) - -# ------------------------------------------------------------------------------ - -context("multinomial regression execution with spark") -source(test_path("helper-objects.R")) -hpc <- hpc_data[1:150, c(2:5, 8)] - -# ------------------------------------------------------------------------------ - -test_that('spark execution', { - - skip_if_not_installed("sparklyr") - - library(sparklyr) - - sc <- try(spark_connect(master = "local"), silent = TRUE) - - skip_if(inherits(sc, "try-error")) - - hpc_rows <- c(1, 51, 101) - hpc_tr <- copy_to(sc, hpc[-hpc_rows, ], "hpc_tr", overwrite = TRUE) - hpc_te <- copy_to(sc, hpc[ hpc_rows, -5], "hpc_te", overwrite = TRUE) - - # ---------------------------------------------------------------------------- - - expect_error( - spark_class_fit <- - fit( - multinom_reg() %>% set_engine("spark"), - control = ctrl, - class ~ ., - data = hpc_tr - ), - regexp = NA - ) - - expect_error( - spark_class_pred <- predict(spark_class_fit, hpc_te), - regexp = NA - ) - - expect_error( - spark_class_pred_class <- predict(spark_class_fit, hpc_te), - regexp = NA - ) - - expect_equal(colnames(spark_class_pred), "pred_class") - - expect_equal( - as.data.frame(spark_class_pred)$pred_class, - as.data.frame(spark_class_pred_class)$pred_class - ) - - expect_error( - spark_class_prob <- predict(spark_class_fit, hpc_te, type = "prob"), - regexp = NA - ) - - expect_error( - spark_class_prob_classprob <- predict(spark_class_fit, hpc_te, type = "prob"), - regexp = NA - ) - - expect_equal( - colnames(spark_class_prob), - c("pred_VF", "pred_F", "pred_L", "pred_M") - ) - - expect_equivalent( - as.data.frame(spark_class_prob), - as.data.frame(spark_class_prob_classprob) - ) -}) - diff --git a/tests/testthat/test_rand_forest_spark.R b/tests/testthat/test_rand_forest_spark.R deleted file mode 100644 index a1c514a42..000000000 --- a/tests/testthat/test_rand_forest_spark.R +++ /dev/null @@ -1,182 +0,0 @@ -library(testthat) -library(parsnip) -library(dplyr) - -# ------------------------------------------------------------------------------ - -context("random forest execution with spark") -source(test_path("helper-objects.R")) -hpc <- hpc_data[1:150, c(2:5, 8)] - -# ------------------------------------------------------------------------------ - -test_that('spark execution', { - - skip_if_not_installed("sparklyr") - - library(sparklyr) - - sc <- try(spark_connect(master = "local"), silent = TRUE) - - skip_if(inherits(sc, "try-error")) - - hpc_rf_tr <- copy_to(sc, hpc[-(1:4), ], "hpc_rf_tr", overwrite = TRUE) - hpc_rf_te <- copy_to(sc, hpc[ 1:4 , -1], "hpc_rf_te", overwrite = TRUE) - - # ---------------------------------------------------------------------------- - - expect_error( - spark_reg_fit <- - fit( - rand_forest(trees = 5, mode = "regression") %>% - set_engine("spark", seed = 12), - control = ctrl, - compounds ~ ., - data = hpc_rf_tr - ), - regexp = NA - ) - - # check for reproducibility and passing extra arguments - expect_error( - spark_reg_fit_dup <- - fit( - rand_forest(trees = 5, mode = "regression") %>% - set_engine("spark", seed = 12), - control = ctrl, - compounds ~ ., - data = hpc_rf_tr - ), - regexp = NA - ) - - expect_error( - spark_reg_pred <- predict(spark_reg_fit, hpc_rf_te), - regexp = NA - ) - - expect_error( - spark_reg_pred_num <- predict(spark_reg_fit, hpc_rf_te), - regexp = NA - ) - - expect_error( - spark_reg_dup <- predict(spark_reg_fit_dup, hpc_rf_te), - regexp = NA - ) - - expect_error( - spark_reg_num_dup <- predict(spark_reg_fit_dup, hpc_rf_te), - regexp = NA - ) - - expect_equal(colnames(spark_reg_pred), "pred") - - expect_equal( - as.data.frame(spark_reg_pred)$pred, - as.data.frame(spark_reg_dup)$pred - ) - expect_equal( - as.data.frame(spark_reg_pred_num)$pred, - as.data.frame(spark_reg_num_dup)$pred - ) - - - # ---------------------------------------------------------------------------- - - # same for classification - - churn_rf_tr <- copy_to(sc, wa_churn[ 5:100, ], "churn_rf_tr", overwrite = TRUE) - churn_rf_te <- copy_to(sc, wa_churn[ 1:4, -1], "churn_rf_te", overwrite = TRUE) - - # ---------------------------------------------------------------------------- - - expect_error( - spark_class_fit <- - fit( - rand_forest(trees = 5, mode = "classification") %>% - set_engine("spark", seed = 12), - control = ctrl, - churn ~ ., - data = churn_rf_tr - ), - regexp = NA - ) - - # check for reproducibility and passing extra arguments - expect_error( - spark_class_fit_dup <- - fit( - rand_forest(trees = 5, mode = "classification") %>% - set_engine("spark", seed = 12), - control = ctrl, - churn ~ ., - data = churn_rf_tr - ), - regexp = NA - ) - - expect_error( - spark_class_pred <- predict(spark_class_fit, churn_rf_te), - regexp = NA - ) - - expect_error( - spark_class_pred_class <- predict(spark_class_fit, churn_rf_te), - regexp = NA - ) - - expect_error( - spark_class_dup <- predict(spark_class_fit_dup, churn_rf_te), - regexp = NA - ) - - expect_error( - spark_class_dup_class <- predict(spark_class_fit_dup, churn_rf_te), - regexp = NA - ) - - expect_equal(colnames(spark_class_pred), "pred_class") - - expect_equal( - as.data.frame(spark_class_pred)$pred_class, - as.data.frame(spark_class_dup)$pred_class - ) - expect_equal( - as.data.frame(spark_class_pred_class)$pred_class, - as.data.frame(spark_class_dup_class)$pred_class - ) - - - expect_error( - spark_class_prob <- predict(spark_class_fit, churn_rf_te, type = "prob"), - regexp = NA - ) - - expect_error( - spark_class_dup <- predict(spark_class_fit_dup, churn_rf_te, type = "prob"), - regexp = NA - ) - - expect_error( - spark_class_dup_classprob <- predict(spark_class_fit_dup, churn_rf_te, type = "prob"), - regexp = NA - ) - expect_error( - spark_class_prob_classprob <- predict(spark_class_fit, churn_rf_te, type = "prob"), - regexp = NA - ) - - expect_equal(colnames(spark_class_prob), c("pred_No", "pred_Yes")) - - expect_equivalent( - as.data.frame(spark_class_prob), - as.data.frame(spark_class_dup) - ) - expect_equal( - as.data.frame(spark_class_prob_classprob), - as.data.frame(spark_class_dup_classprob) - ) - -}) -