Merge branch 'master' into rlang-tibble-updates

Author: topepo

DESCRIPTION

@@ -1,5 +1,5 @@
 Package: parsnip
-Version: 0.0.2.9000
+Version: 0.0.3
 Title: A Common API to Modeling and Analysis Functions
 Description: A common interface is provided to allow users to specify a model without having to remember the different argument names across different functions or computational engines (e.g. 'R', 'Spark', 'Stan', etc). 
 Authors@R: c(

NAMESPACE

@@ -2,13 +2,26 @@
 
 S3method(fit,model_spec)
 S3method(fit_xy,model_spec)
+S3method(has_multi_predict,default)
+S3method(has_multi_predict,model_fit)
+S3method(has_multi_predict,workflow)
+S3method(min_grid,boost_tree)
+S3method(min_grid,linear_reg)
+S3method(min_grid,logistic_reg)
+S3method(min_grid,mars)
+S3method(min_grid,multinom_reg)
+S3method(min_grid,nearest_neighbor)
 S3method(multi_predict,"_C5.0")
 S3method(multi_predict,"_earth")
 S3method(multi_predict,"_elnet")
 S3method(multi_predict,"_lognet")
 S3method(multi_predict,"_multnet")
+S3method(multi_predict,"_train.kknn")
 S3method(multi_predict,"_xgb.Booster")
 S3method(multi_predict,default)
+S3method(multi_predict_args,default)
+S3method(multi_predict_args,model_fit)
+S3method(multi_predict_args,workflow)
 S3method(nullmodel,default)
 S3method(predict,"_elnet")
 S3method(predict,"_lognet")
@@ -43,8 +56,11 @@ S3method(print,svm_rbf)
 S3method(translate,boost_tree)
 S3method(translate,decision_tree)
 S3method(translate,default)
+S3method(translate,linear_reg)
+S3method(translate,logistic_reg)
 S3method(translate,mars)
 S3method(translate,mlp)
+S3method(translate,multinom_reg)
 S3method(translate,nearest_neighbor)
 S3method(translate,rand_forest)
 S3method(translate,surv_reg)
@@ -91,14 +107,23 @@ export(get_fit)
 export(get_from_env)
 export(get_model_env)
 export(get_pred_type)
+export(has_multi_predict)
 export(keras_mlp)
 export(linear_reg)
 export(logistic_reg)
 export(make_classes)
 export(mars)
+export(min_grid)
+export(min_grid.boost_tree)
+export(min_grid.linear_reg)
+export(min_grid.logistic_reg)
+export(min_grid.mars)
+export(min_grid.multinom_reg)
+export(min_grid.nearest_neighbor)
 export(mlp)
 export(model_printer)
 export(multi_predict)
+export(multi_predict_args)
 export(multinom_reg)
 export(nearest_neighbor)
 export(null_model)
@@ -210,4 +235,5 @@ importFrom(utils,capture.output)
 importFrom(utils,getFromNamespace)
 importFrom(utils,globalVariables)
 importFrom(utils,head)
+importFrom(utils,methods)
 importFrom(vctrs,vec_unique)

NEWS.md

@@ -1,17 +1,27 @@
-# parsnip 0.0.2.9000
+# parsnip 0.0.3
+
+Unplanned release based on CRAN requirements for Solaris.
 
 ## Breaking Changes
 
- * The method that `parsnip` stores the model information has changed. Any custom models from previous versions will need to use the new method for registering models. The methods are detailed in `?get_model_env()` and the [package vignette for adding models](https://tidymodels.github.io/parsnip/articles/articles/Scratch.html).
- * The mode need to be declared for models that can be used for more than one mode prior to fitting and/or translation). 
+ * The method that `parsnip` stores the model information has changed. Any custom models from previous versions will need to use the new method for registering models. The methods are detailed in `?get_model_env` and the [package vignette for adding models](https://tidymodels.github.io/parsnip/articles/articles/Scratch.html).
+
+ * The mode needs to be declared for models that can be used for more than one mode prior to fitting and/or translation. 
+
  * For `surv_reg()`, the engine that uses the `survival` package is now called `survival` instead of `survreg`.  
 
+ * For `glmnet` models, the full regularization path is always fit regardless of the value given to `penalty`. Previously, the model was fit with passing `penalty` to `glmnet`'s `lambda` argument and the model could only make predictions at those specific values. [(#195)](https://github.com/tidymodels/parsnip/issues/195)
+
 ## New Features
 
  * `add_rowindex()` can create a column called `.row` to a data frame. 
 
  * If a computational engine is not explicitly set, a default will be used. Each default is documented on the corresponding model page. A warning is issued at fit time unless verbosity is zero.  
 
+ * `nearest_neighbor()` gained a `multi_predict` method. The `multi_predict()` documentation is a little better organized.  
+ 
+ * A suite of internal functions were added to help with upcoming model tuning features.  
+
 
 # parsnip 0.0.2
 

R/aaa.R

@@ -21,9 +21,102 @@ convert_stan_interval <- function(x, level = 0.95, lower = TRUE) {
 }
 
 # ------------------------------------------------------------------------------
+# min_grid generic - put here so that the generic shows up first in the man file
+
+#' Determine the minimum set of model fits
+#'
+#' `min_grid` determines exactly what models should be fit in order to
+#'  evaluate the entire set of tuning parameter combinations. This is for
+#'  internal use only and the API may change in the near future.
+#' @param x A model specification.
+#' @param grid A tibble with tuning parameter combinations.
+#' @param ... Not currently used.
+#' @return A tibble with the minimum tuning parameters to fit and an additional
+#' list column with the parameter combinations used for prediction.
+#' @keywords internal
+#' @export
+min_grid <- function(x, grid, ...) {
+  # x is a `model_spec` object from parsnip
+  # grid is a tibble of tuning parameter values with names
+  #  matching the parameter names.
+  UseMethod("min_grid")
+}
+
+# As an example, if we fit a boosted tree  model and tune over
+# trees = 1:20 and min_n = c(20, 30)
+# we should only have to fit two models:
+#
+#   trees = 20 & min_n = 20
+#   trees = 20 & min_n = 30
+#
+# The logic related to how this "mini grid" gets made is model-specific.
+#
+# To get the full set of predictions, we need to know, for each of these two
+# models, what values of num_terms to give to the multi_predict() function.
+#
+# The current idea is to have a list column of the extra models for prediction.
+# For the example above:
+#
+#   # A tibble: 2 x 3
+#     trees min_n .submodels
+#     <dbl> <dbl> <list>
+#   1    20    20 <named list [1]>
+#   2    20    30 <named list [1]>
+#
+# and the .submodels would both be
+#
+#  list(trees = 1:19)
+#
+# There are a lot of other things to consider in future versions like grids
+# where there are multiple columns with the same name (maybe the results of
+# a recipe) and so on.
+
+# ------------------------------------------------------------------------------
+# helper functions
+
+# Template for model results that do no have the sub-model feature
+blank_submodels <- function(grid) {
+  grid %>%
+    dplyr::mutate(.submodels = map(1:nrow(grid), ~ list()))
+}
+
+get_fixed_args <- function(info) {
+  # Get non-sub-model columns to iterate over
+  fixed_args <- info$name[!info$has_submodel]
+}
+
+get_submodel_info <- function(spec, grid) {
+  param_info <-
+    get_from_env(paste0(class(spec)[1], "_args")) %>%
+    dplyr::filter(engine == spec$engine) %>%
+    dplyr::select(name = parsnip, has_submodel)
+
+  # In case a recipe or other activity has grid parameter columns,
+  # add those to the results
+  grid_names <- names(grid)
+  is_mod_param <- grid_names %in% param_info$name
+  if (any(!is_mod_param)) {
+    param_info <-
+      param_info %>%
+      dplyr::bind_rows(
+        tibble::tibble(name = grid_names[!is_mod_param],
+                       has_submodel = FALSE)
+      )
+  }
+  param_info %>% dplyr::filter(name %in% grid_names)
+}
+
+
+# ------------------------------------------------------------------------------
+# nocov
 
 #' @importFrom utils globalVariables
 utils::globalVariables(
   c('.', '.label', '.pred', '.row', 'data', 'engine', 'engine2', 'group',
-    'lab', 'original', 'predicted_label', 'prediction', 'value', 'type')
+    'lab', 'original', 'predicted_label', 'prediction', 'value', 'type',
+    "neighbors", ".submodels", "has_submodel", "max_neighbor", "max_penalty",
+    "max_terms", "max_tree", "name", "num_terms", "penalty", "trees",
+    "sub_neighbors")
   )
+
+# nocov end

R/aaa_multi_predict.R

@@ -0,0 +1,134 @@
+# Define a generic to make multiple predictions for the same model object ------
+
+#' Model predictions across many sub-models
+#'
+#' For some models, predictions can be made on sub-models in the model object.
+#' @param object A `model_fit` object.
+#' @param new_data A rectangular data object, such as a data frame.
+#' @param type A single character value or `NULL`. Possible values
+#'  are "numeric", "class", "prob", "conf_int", "pred_int", "quantile",
+#'  or "raw". When `NULL`, `predict()` will choose an appropriate value
+#'  based on the model's mode.
+#' @param ... Optional arguments to pass to `predict.model_fit(type = "raw")`
+#'  such as `type`.
+#' @return A tibble with the same number of rows as the data being predicted.
+#'  Mostly likely, there is a list-column named `.pred` that is a tibble with
+#'  multiple rows per sub-model.
+#' @export
+multi_predict <- function(object, ...) {
+  if (inherits(object$fit, "try-error")) {
+    warning("Model fit failed; cannot make predictions.", call. = FALSE)
+    return(NULL)
+  }
+  UseMethod("multi_predict")
+}
+
+#' @export
+#' @rdname multi_predict
+multi_predict.default <- function(object, ...)
+  stop("No `multi_predict` method exists for objects with classes ",
+       paste0("'", class(), "'", collapse = ", "), call. = FALSE)
+
+#' @export
+predict.model_spec <- function(object, ...) {
+  stop("You must use `fit()` on your model specification before you can use `predict()`.", call. = FALSE)
+}
+
+#' Tools for models that predict on sub-models
+#'
+#' `has_multi_predict()` tests to see if an object can make multiple
+#'  predictions on submodels from the same object. `multi_predict_args()`
+#'  returns the names of the argments to `multi_predict()` for this model
+#'  (if any).
+#' @param object An object to test.
+#' @param ... Not currently used.
+#' @return `has_multi_predict()` returns single logical value while
+#'  `multi_predict()` returns a character vector of argument names (or `NA`
+#'  if none exist).
+#' @keywords internal
+#' @examples
+#' lm_model_idea <- linear_reg() %>% set_engine("lm")
+#' has_multi_predict(lm_model_idea)
+#' lm_model_fit <- fit(lm_model_idea, mpg ~ ., data = mtcars)
+#' has_multi_predict(lm_model_fit)
+#'
+#' multi_predict_args(lm_model_fit)
+#'
+#' library(kknn)
+#'
+#' knn_fit <-
+#'   nearest_neighbor(mode = "regression", neighbors = 5) %>%
+#'   set_engine("kknn") %>%
+#'   fit(mpg ~ ., mtcars)
+#'
+#' multi_predict_args(knn_fit)
+#'
+#' multi_predict(knn_fit, mtcars[1, -1], neighbors = 1:4)$.pred
+#' @importFrom utils methods
+#' @export
+has_multi_predict <- function(object, ...) {
+  UseMethod("has_multi_predict")
+}
+
+#' @export
+#' @rdname has_multi_predict
+has_multi_predict.default <- function(object, ...) {
+  FALSE
+}
+
+#' @export
+#' @rdname has_multi_predict
+has_multi_predict.model_fit <- function(object, ...) {
+  existing_mthds <- utils::methods("multi_predict")
+  tst <- paste0("multi_predict.", class(object))
+  any(tst %in% existing_mthds)
+}
+
+#' @export
+#' @rdname has_multi_predict
+has_multi_predict.workflow <- function(object, ...) {
+  has_multi_predict(object$fit$model$model)
+}
+
+
+#' @rdname has_multi_predict
+#' @export
+#' @rdname has_multi_predict
+multi_predict_args <- function(object, ...) {
+  UseMethod("multi_predict_args")
+}
+
+#' @export
+#' @rdname has_multi_predict
+multi_predict_args.default <- function(object, ...) {
+  if (inherits(object, "model_fit")) {
+    res <- multi_predict_args.model_fit(object, ...)
+  } else {
+    res <- NA_character_
+  }
+  res
+}
+
+#' @export
+#' @rdname has_multi_predict
+multi_predict_args.model_fit <- function(object, ...) {
+  existing_mthds <- methods("multi_predict")
+  cls <- class(object)
+  tst <- paste0("multi_predict.", cls)
+  .fn <- tst[tst %in% existing_mthds]
+  if (length(.fn) == 0) {
+    return(NA_character_)
+  }
+
+  .fn <- getFromNamespace(.fn, ns = "parsnip")
+  omit <- c('object', 'new_data', 'type', '...')
+  args <- names(formals(.fn))
+  args[!(args %in% omit)]
+}
+
+#' @export
+#' @rdname has_multi_predict
+multi_predict_args.workflow <- function(object, ...) {
+  object <- object$fit$model$model
+
+}