data(mtcars)

mtcars$cyl <- factor(mtcars$cyl)
mtcars$am  <- factor(mtcars$am)

## Numeric correlation (Pearson, pairwise-complete) --------------------------
num_cols <- c("mpg", "disp", "hp", "wt", "qsec")
M     <- cor(mtcars[, num_cols], use = "pairwise.complete.obs", method = "pearson")
p_mat <- corrplot::cor.mtest(mtcars[, num_cols], method = "pearson")$p
corrplot::corrplot(M, method = "circle", type = "full",
                   p.mat = p_mat, sig.level = 0.05, insig = "blank")

## Categorical association (bias-corrected Cramer's V) -----------------------
cramers_v <- function(x, y) {
  x <- as.factor(x); y <- as.factor(y)
  ok <- !(is.na(x) | is.na(y)); x <- x[ok]; y <- y[ok]
  tbl <- table(x, y)
  chi <- suppressWarnings(stats::chisq.test(tbl, correct = FALSE)$statistic)
  n <- sum(tbl); r <- nrow(tbl); k <- ncol(tbl)
  phi2     <- as.numeric(chi) / n
  phi2corr <- max(0, phi2 - (r - 1) * (k - 1) / (n - 1))
  rcorr <- r - (r - 1)^2 / (n - 1)
  kcorr <- k - (k - 1)^2 / (n - 1)
  sqrt(phi2corr / min(kcorr - 1, rcorr - 1))
}
cramers_v(mtcars$cyl, mtcars$am)   # association between cylinder count and transmission

standard_scale_append <- function(df, col) {
  x <- df[[col]]
  df[[paste0(col, "_zscore")]] <- (x - mean(x, na.rm = TRUE)) / sd(x, na.rm = TRUE)
  df
}
minmax_scale_append <- function(df, col, range_min = 0, range_max = 1) {
  x  <- df[[col]]
  mn <- min(x, na.rm = TRUE); mx <- max(x, na.rm = TRUE)
  df[[paste0(col, "_minmax")]] <- (x - mn) / (mx - mn) * (range_max - range_min) + range_min
  df
}
robust_scale_append <- function(df, col) {
  x <- df[[col]]
  df[[paste0(col, "_robust")]] <- (x - median(x, na.rm = TRUE)) / IQR(x, na.rm = TRUE)
  df
}

mtcars_fe <- standard_scale_append(mtcars,    "hp")   # default: Standardisation (Z-score)
mtcars_fe <- minmax_scale_append(mtcars_fe,   "hp")   # default range [0, 1]
mtcars_fe <- robust_scale_append(mtcars_fe,   "hp")   # median / IQR
head(mtcars_fe[c("hp", "hp_zscore", "hp_minmax", "hp_robust")])

label_encode_append <- function(df, col) {
  df[[paste0(col, "_label")]] <- as.integer(factor(df[[col]]))
  df
}
onehot_encode_append <- function(df, col, drop_first = FALSE) {
  vals <- as.character(df[[col]])
  levs <- sort(unique(na.omit(vals)))
  if (isTRUE(drop_first) && length(levs) > 1) levs <- levs[-1]
  for (lv in levs) df[[paste0(col, "_oh_", make.names(lv))]] <- as.integer(vals == lv)
  df
}

mtcars_fe <- label_encode_append(mtcars_fe,  "cyl")   # default: Label Encoding
mtcars_fe <- onehot_encode_append(mtcars_fe, "cyl")   # One-Hot Encoding, drop_first = FALSE
head(mtcars_fe[grepl("^cyl", names(mtcars_fe))])

equal_width_bin_append <- function(df, col, n_bins = 4) {
  x    <- df[[col]]
  brks <- unique(round(seq(min(x, na.rm = TRUE), max(x, na.rm = TRUE), length.out = n_bins + 1), 2))
  df[[paste0(col, "_class")]] <- cut(x, breaks = brks, include.lowest = TRUE, dig.lab = 10)
  df
}
kmeans_bin_append <- function(df, col, n_bins = 4) {
  x <- df[[col]]
  set.seed(123)                                   # fixed seed for reproducible clusters
  km  <- kmeans(x, centers = n_bins)
  ord <- order(km$centers)                        # relabel classes low -> high
  df[[paste0(col, "_class")]] <- factor(match(km$cluster, ord),
                                        labels = paste0("Class_", seq_len(n_bins)))
  df
}

mtcars_fe <- equal_width_bin_append(mtcars_fe, "hp")   # default: Equal Width, 4 classes
mtcars_fe <- kmeans_bin_append(mtcars_fe,      "hp")   # K-Means, seed fixed at 123
table(mtcars_fe$hp_class)

library(h2o)

# Cluster is started once in global.R with these settings
h2o.init(
  nthreads      = -1,
  max_mem_size  = "3G",
  min_mem_size  = "512m",
  ice_root      = tempdir(),
  log_dir       = tempdir(),
  startH2O      = TRUE
)

# RAISINS writes the cleaned data.frame to a temporary CSV, then imports it
# with h2o.importFile(path, na.strings = ""); as.h2o() is the local equivalent.
mtcars_h2o <- as.h2o(mtcars)

y <- "am"                                             # dependent (target) variable
x <- setdiff(c("mpg", "hp", "wt", "qsec", "cyl"), y)  # independent (predictor) variables

train_pct               <- 0.80   # default: Training set percentage
valid_frac_of_remainder <- 0.50   # default: Validation as % of the held-out portion

splits <- h2o.splitFrame(
  mtcars_h2o,
  ratios = c(train_pct, (1 - train_pct) * valid_frac_of_remainder),
  seed   = 42
)
train <- h2o.assign(splits[[1]], "raisins_train")
valid <- h2o.assign(splits[[2]], "raisins_valid")
test  <- h2o.assign(splits[[3]], "raisins_test")

aml <- h2o.automl(
  x                = x,
  y                = y,
  training_frame   = train,
  validation_frame = valid,
  max_models       = 50,      # default (Custom settings range: 15-100)
  max_runtime_secs = 300,     # default: 5 minutes (Custom settings range: 1-25 min)
  seed             = 42,
  exclude_algos    = NULL,    # user may exclude DeepLearning / StackedEnsemble / XGBoost
  nfolds           = 0,       # forced to 0 whenever a validation_frame is supplied
  stopping_metric  = "AUTO",
  sort_metric      = "AUTO"   # AUTO -> AUC for this binary target
)

lb         <- as.data.frame(aml@leaderboard)   # leaderboard, ranked by sort_metric
best_model <- h2o.getModel(lb$model_id[1])

perf_train <- h2o.performance(best_model, newdata = train)
perf_valid <- h2o.performance(best_model, newdata = valid)
perf_test  <- h2o.performance(best_model, newdata = test)

get_metrics <- function(perf_obj) {
  c(
    RMSE                     = tryCatch(h2o.rmse(perf_obj),                   error = function(e) NA),
    MSE                      = tryCatch(h2o.mse(perf_obj),                    error = function(e) NA),
    MAE                      = tryCatch(h2o.mae(perf_obj),                    error = function(e) NA),
    RMSLE                    = tryCatch(h2o.rmsle(perf_obj),                  error = function(e) NA),
    `Mean Residual Deviance` = tryCatch(h2o.mean_residual_deviance(perf_obj), error = function(e) NA),
    `R-Square`               = tryCatch(h2o.r2(perf_obj),                     error = function(e) NA),
    AUC                      = tryCatch(h2o.auc(perf_obj),                    error = function(e) NA),
    AUCPR                    = tryCatch(h2o.aucpr(perf_obj),                  error = function(e) NA),
    LogLoss                  = tryCatch(h2o.logloss(perf_obj),                error = function(e) NA)
  )
}

rbind(Train = get_metrics(perf_train),
      Validation = get_metrics(perf_valid),
      Test = get_metrics(perf_test))

h2o.confusionMatrix(best_model, test)                              # classification only
as.data.frame(perf_test@metrics$max_criteria_and_metric_scores)     # binary-only threshold scores