Running examples in ‘alookr-Ex.R’ failed
The error most likely occurred in:

> base::assign(".ptime", proc.time(), pos = "CheckExEnv")
> ### Name: run_models
> ### Title: Fit binary classification model
> ### Aliases: run_models
> 
> ### ** Examples
> 
> library(dplyr)

Attaching package: ‘dplyr’

The following object is masked from ‘package:randomForest’:

    combine

The following objects are masked from ‘package:stats’:

    filter, lag

The following objects are masked from ‘package:base’:

    intersect, setdiff, setequal, union

> 
> # Divide the train data set and the test data set.
> sb <- rpart::kyphosis %>%
+   split_by(Kyphosis)
> 
> # Extract the train data set from original data set.
> train <- sb %>%
+   extract_set(set = "train")
> 
> # Extract the test data set from original data set.
> test <- sb %>%
+   extract_set(set = "test")
> 
> # Sampling for unbalanced data set using SMOTE(synthetic minority over-sampling technique).
> train <- sb %>%
+   sampling_target(seed = 1234L, method = "ubSMOTE")
> 
> # Cleaning the set.
> train <- train %>%
+   cleanse
── Checking unique value ─────────────────────────── unique value is one ──
No variables that unique value is one.

── Checking unique rate ─────────────────────────────── high unique rate ──
No variables that high unique rate.

── Checking character variables ─────────────────────── categorical data ──
No character variables.

> 
> # Run the model fitting.
> result <- run_models(.data = train, target = "Kyphosis", positive = "present")
> result
# A tibble: 5 x 5
  step     model_id     target   positive fitted_model
  <chr>    <chr>        <chr>    <chr>    <list>      
1 1.Fitted logistic     Kyphosis present  <glm>       
2 1.Fitted rpart        Kyphosis present  <rpart>     
3 1.Fitted ctree        Kyphosis present  <BinaryTr>  
4 1.Fitted randomForest Kyphosis present  <rndmFrs.>  
5 1.Fitted ranger       Kyphosis present  <ranger>    
> 
> # Run the several kinds model fitting by dplyr
> train %>%
+   run_models(target = "Kyphosis", positive = "present")

 *** caught segfault ***
address 0x6500000073, cause 'memory not mapped'

Traceback:
 1: mcfork(detached)
 2: (function (expr, name, mc.set.seed = TRUE, silent = FALSE, mc.affinity = NULL,     mc.interactive = FALSE, detached = FALSE) {    f <- mcfork(detached)    env <- parent.frame()    if (isTRUE(mc.set.seed))         mc.advance.stream()    if (inherits(f, "masterProcess")) {        on.exit(mcexit(1L, structure("fatal error in wrapper code",             class = "try-error")))        if (isTRUE(mc.set.seed))             mc.set.stream()        mc.interactive <- as.logical(mc.interactive)        if (isTRUE(mc.interactive))             mcinteractive(TRUE)        if (isTRUE(!mc.interactive))             mcinteractive(FALSE)        if (!is.null(mc.affinity))             mcaffinity(mc.affinity)        if (isTRUE(silent))             closeStdout(TRUE)        if (detached) {            on.exit(mcexit(1L))            eval(expr, env)            mcexit(0L)        }        sendMaster(try(eval(expr, env), silent = TRUE))        mcexit(0L)    }    if (!missing(name) && !is.null(name))         f$name <- as.character(name)[1L]    class(f) <- c("parallelJob", class(f))    f})({    {        ...future.startTime <- base::Sys.time()        ...future.oldOptions <- base::options(future.startup.script = FALSE,             future.globals.onMissing = "ignore", future.globals.maxSize = NULL,             future.globals.method = NULL, future.globals.onMissing = NULL,             future.globals.onReference = NULL, future.globals.resolve = NULL,             future.resolve.recursive = NULL, width = 80L)        {            {                {                  has_future <- base::requireNamespace("future",                     quietly = TRUE)                  version <- if (has_future)                     utils::packageVersion("future")                  else NULL                  if (!has_future || version < "1.8.0") {                    info <- base::c(r_version = base::gsub("R version ",                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer),                       os = base::paste(base::Sys.info()[base::c("sysname",                         "release", "version")], collapse = " "),                       hostname = base::Sys.info()[["nodename"]])                    info <- base::sprintf("%s: %s", base::names(info),                       info)                    info <- base::paste(info, collapse = "; ")                    if (!has_future) {                      msg <- base::sprintf("Package 'future' is not installed on worker (%s)",                         info)                    }                    else {                      msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",                         info, version)                    }                    base::stop(msg)                  }                }                ...future.mc.cores.old <- base::getOption("mc.cores")                base::options(mc.cores = 1L)            }            future::plan("default", .cleanup = FALSE, .init = FALSE)        }    }    if (base::is.na(TRUE)) {    }    else {        if (TRUE) {            ...future.stdout <- base::rawConnection(base::raw(0L),                 open = "w")        }        else {            ...future.stdout <- base::file(base::switch(.Platform$OS.type,                 windows = "NUL", "/dev/null"), open = "w")        }        base::sink(...future.stdout, type = "output", split = FALSE)        base::on.exit(if (!base::is.null(...future.stdout)) {            base::sink(type = "output", split = FALSE)            base::close(...future.stdout)        }, add = TRUE)    }    ...future.frame <- base::sys.nframe()    ...future.conditions <- base::list()    ...future.rng <- base::globalenv()$.Random.seed    ...future.result <- base::tryCatch({        base::withCallingHandlers({            ...future.value <- base::withVisible(base::local(classifier_dispatch(.x,                 .data, target)))            future::FutureResult(value = ...future.value$value,                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,                   ...future.rng), started = ...future.startTime,                 version = "1.8")        }, condition = base::local({            c <- base::c            inherits <- base::inherits            invokeRestart <- base::invokeRestart            length <- base::length            list <- base::list            seq.int <- base::seq.int            signalCondition <- base::signalCondition            sys.calls <- base::sys.calls            Sys.time <- base::Sys.time            `[[` <- base::`[[`            `+` <- base::`+`            `<<-` <- base::`<<-`            sysCalls <- function(calls = sys.calls(), from = 1L) {                calls[seq.int(from = from + 12L, to = length(calls) -                   3L)]            }            function(cond) {                if (inherits(cond, "error")) {                  ...future.conditions[[length(...future.conditions) +                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),                     cond$call), timestamp = Sys.time(), signaled = 0L)                  signalCondition(cond)                }                else if (inherits(cond, "condition")) {                  signal <- FALSE && inherits(cond, character(0))                  ...future.conditions[[length(...future.conditions) +                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))                  if (!signal) {                    muffleCondition <- function (cond)                     {                      inherits <- base::inherits                      invokeRestart <- base::invokeRestart                      muffled <- FALSE                      if (inherits(cond, "message")) {                        invokeRestart("muffleMessage")                        muffled <- TRUE                      }                      else if (inherits(cond, "warning")) {                        invokeRestart("muffleWarning")                        muffled <- TRUE                      }                      else if (inherits(cond, "condition")) {                        computeRestarts <- base::computeRestarts                        grepl <- base::grepl                        is.null <- base::is.null                        restarts <- computeRestarts(cond)                        for (restart in restarts) {                          name <- restart$name                          if (is.null(name))                             next                          if (!grepl("^muffle", name))                             next                          invokeRestart(restart)                          muffled <- TRUE                          break                        }                      }                      invisible(muffled)                    }                    muffleCondition(cond)                  }                }            }        }))    }, error = function(ex) {        base::structure(base::list(value = NULL, visible = NULL,             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,                 ...future.rng), version = "1.8"), class = "FutureResult")    }, finally = {        {            {                base::options(mc.cores = ...future.mc.cores.old)            }            future::plan(list(function (expr, envir = parent.frame(),                 substitute = TRUE, lazy = FALSE, seed = NULL,                 globals = TRUE, workers = availableCores(), gc = FALSE,                 earlySignal = FALSE, label = NULL, ...)             {                if (substitute)                   expr <- substitute(expr)                fun <- if (supportsMulticore(warn = TRUE))                   multicore                else multisession                fun(expr = expr, envir = envir, substitute = FALSE,                   lazy = lazy, seed = seed, globals = globals,                   workers = workers, gc = gc, earlySignal = earlySignal,                   label = label, ...)            }), .cleanup = FALSE, .init = FALSE)        }        base::options(...future.oldOptions)    })    Sys.time    if (base::is.na(TRUE)) {    }    else {        base::sink(type = "output", split = FALSE)        if (TRUE) {            ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))        }        else {            ...future.result["stdout"] <- base::list(NULL)        }        base::close(...future.stdout)        ...future.stdout <- NULL    }    ...future.result$conditions <- ...future.conditions    ...future.result})
 3: do.call(parallel::mcparallel, args = future.args, envir = envir)
 4: run.MulticoreFuture(future)
 5: run(future)
 6: fun(expr = expr, envir = envir, substitute = FALSE, lazy = lazy,     seed = seed, globals = globals, workers = workers, gc = gc,     earlySignal = earlySignal, label = label, ...)
 7: makeFuture(...)
 8: .makeFuture(expr, substitute = FALSE, envir = envir, globals = globals,     packages = packages, seed = seed, lazy = lazy, ...)
 9: future::future(classifier_dispatch(.x, .data, target))
10: .f(.x[[i]], ...)
11: purrr::map(models, ~future::future(classifier_dispatch(.x, .data,     target)))
12: eval(lhs, parent, parent)
13: eval(lhs, parent, parent)
14: purrr::map(models, ~future::future(classifier_dispatch(.x, .data,     target))) %>% tibble::tibble(step = "1.Fitted", model_id = models,     target = target, positive = positive, fitted_model = purrr::map(.,         ~future::value(.x)))
15: run_models(., target = "Kyphosis", positive = "present")
16: function_list[[k]](value)
17: withVisible(function_list[[k]](value))
18: freduce(value, `_function_list`)
19: `_fseq`(`_lhs`)
20: eval(quote(`_fseq`(`_lhs`)), env, env)
21: eval(quote(`_fseq`(`_lhs`)), env, env)
22: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
23: train %>% run_models(target = "Kyphosis", positive = "present")
An irrecoverable exception occurred. R is aborting now ...
Segmentation fault
Error in sendMaster(try(eval(expr, env), silent = TRUE)) : 
  write error, closing pipe to the master
Calls: %>% ... run.MulticoreFuture -> do.call -> <Anonymous> -> sendMaster