further changes for #431

Author: topepo

NEWS.md

@@ -1,21 +1,33 @@
 # parsnip (development version)
 
-* `generics::required_pkgs()` was extended for `parsnip` objects. 
-
-* The `liquidSVM` engine for `svm_rbf()` was deprecated due to that package's removal from CRAN. (#425)
+## Model Specification Changes
 
 * A new linear SVM model `svm_linear()` is now available with the `LiblineaR` engine (#424) and the `kernlab` engine (#438), and the `LiblineaR` engine is available for `logistic_reg()` as well (#429). These models can use sparse matrices via `fit_xy()` (#447) and have a `tidy` method (#474).
 
+* For models with `glmnet` engines: 
+
+  - A single value is required for `penalty` (either a single numeric value or a value of `tune()`) (#481)
+  - A special argument called `path_values` can be used to set the `lambda` path is a specific set of numbers (independent of the value of `penalty`). A pure ridge regression models (i.e., `mixture = 1`) will generate incorrect values if the path does not include zero. See issue #431.
+  
+* The `liquidSVM` engine for `svm_rbf()` was deprecated due to that package's removal from CRAN. (#425)
+
 * New model specification `survival_reg()` for the new mode `"censored regression"` (#444). `surv_reg()` is now soft-deprecated (#448).
 
 * New model specification `proportional_hazards()` for the `"censored regression"` mode (#451).
 
+## Other Changes
+
 * Re-licensed package from GPL-2 to MIT. See [consent from copyright holders here](https://github.com/tidymodels/parsnip/issues/462).
 
 * `set_mode()` now checks if `mode` is compatible with the model class, similar to `new_model_spec()` (@jtlandis, #467).
 
 * Re-organized model documentation for `update` methods (#479).
 
+ 
+  
+* `generics::required_pkgs()` was extended for `parsnip` objects. 
+
+
 
 # parsnip 0.1.5
 

R/logistic_reg.R

@@ -108,10 +108,19 @@ translate.logistic_reg <- function(x, engine = x$engine, ...) {
   arg_vals <- x$method$fit$args
   arg_names <- names(arg_vals)
 
-
   if (engine == "glmnet") {
-    # See discussion in https://github.com/tidymodels/parsnip/issues/195
-    arg_vals$lambda <- NULL
+    if (any(names(x$eng_args) == "path_values")) {
+      # Since we decouple the parsnip `penalty` argument from being the same
+      # as the glmnet `lambda` value, this allows users to set the path
+      # differently from the default that glmnet uses. See
+      # https://github.com/tidymodels/parsnip/issues/431
+      x$method$fit$args$lambda <- x$eng_args$path_values
+      x$eng_args$path_values <- NULL
+      x$method$fit$args$path_values <- NULL
+    } else {
+      # See discussion in https://github.com/tidymodels/parsnip/issues/195
+      x$method$fit$args$lambda <- NULL
+    }
     # Since the `fit` information is gone for the penalty, we need to have an
     # evaluated value for the parameter.
     x$args$penalty <- rlang::eval_tidy(x$args$penalty)
@@ -133,11 +142,8 @@ translate.logistic_reg <- function(x, engine = x$engine, ...) {
           rlang::abort("For the LiblineaR engine, mixture must be 0 or 1.")
         }
     }
-
+    x$method$fit$args <- arg_vals
   }
-
-  x$method$fit$args <- arg_vals
-
   x
 }
 

R/multinom_reg.R

@@ -96,7 +96,28 @@ print.multinom_reg <- function(x, ...) {
 }
 
 #' @export
-translate.multinom_reg <- translate.linear_reg
+translate.multinom_reg <- function(x, engine = x$engine, ...) {
+  x <- translate.default(x, engine, ...)
+
+  if (engine == "glmnet") {
+    if (any(names(x$eng_args) == "path_values")) {
+      # Since we decouple the parsnip `penalty` argument from being the same
+      # as the glmnet `lambda` value, this allows users to set the path
+      # differently from the default that glmnet uses. See
+      # https://github.com/tidymodels/parsnip/issues/431
+      x$method$fit$args$lambda <- x$eng_args$path_values
+      x$eng_args$path_values <- NULL
+      x$method$fit$args$path_values <- NULL
+    } else {
+      # See discussion in https://github.com/tidymodels/parsnip/issues/195
+      x$method$fit$args$lambda <- NULL
+    }
+    # Since the `fit` information is gone for the penalty, we need to have an
+    # evaluated value for the parameter.
+    x$args$penalty <- rlang::eval_tidy(x$args$penalty)
+  }
+  x
+}
 
 # ------------------------------------------------------------------------------
 

man/contr_one_hot.Rd

@@ -33,10 +33,13 @@ the value given in `linear_reg(penalty)`. For example:
 ```{r glmnet-path}
 linear_reg(penalty = .1) %>% 
   set_engine("glmnet", path_values = c(0, 10^seq(-10, 1, length.out = 20))) %>% 
-  set_mode("regression") %>% 
   translate()
 ```
 
+When fitting a pure ridge regression model (i.e., `penalty = 0`), we _strongly
+suggest_ that you pass in a vector for `path_values` that includes zero. See 
+[issue #431](https://github.com/tidymodels/parsnip/issues/431) for a discussion. 
+
 When using `predict()`, the single penalty value used for prediction is the one 
 given to `linear_reg()`. 
 
@@ -49,7 +52,6 @@ with all of the penalty results.
 ```{r stan-reg}
 linear_reg() %>% 
   set_engine("stan") %>% 
-  set_mode("regression") %>% 
   translate()
 ```
 

man/linear_reg.Rd

@@ -20,18 +20,32 @@ logistic_reg() %>%
 ```{r glmnet-csl}
 logistic_reg() %>% 
   set_engine("glmnet") %>% 
-  set_mode("classification") %>% 
   translate()
 ```
 
-For `glmnet` models, the full regularization path is always fit regardless of the
-value given to `penalty`. Also, there is the option to pass  multiple values (or
-no values) to the `penalty` argument. When using the  `predict()` method in these
-cases, the return value depends on  the value of `penalty`. When using
-`predict()`, only a single  value of the penalty can be used. When predicting on
-multiple  penalties, the `multi_predict()` function can be used. It  returns a
-tibble with a list column called `.pred` that contains  a tibble with all of the
-penalty results.
+`logistic_reg()` requires a single value for the `penalty` argument (a number
+or `tune()`). Despite this, the full regularization path is always fit
+regardless of the value given to `penalty`. To pass in a custom sequence of
+values for `lambda`, use the argument `path_values` in `set_engine()`. This
+will assign the value of the glmnet `lambda` parameter without disturbing
+the value given in `logistic_reg(penalty)`. For example: 
+
+```{r glmnet-path}
+logistic_reg(penalty = .1) %>% 
+  set_engine("glmnet", path_values = c(0, 10^seq(-10, 1, length.out = 20))) %>% 
+  translate()
+```
+
+When fitting a pure ridge regression model (i.e., `penalty = 0`), we _strongly
+suggest_ that you pass in a vector for `path_values` that includes zero. See 
+[issue #431](https://github.com/tidymodels/parsnip/issues/431) for a discussion. 
+
+When using `predict()`, the single penalty value used for prediction is the one 
+given to `logistic_reg()`. 
+
+To predict on multiple  penalties, the `multi_predict()` function can be used. 
+It  returns a tibble with a list column called `.pred` that contains  a tibble 
+with all of the penalty results.
 
 ## LiblineaR
 

man/logistic_reg.Rd

@@ -11,18 +11,32 @@ For this type of model, the template of the fit calls are below.
 ```{r glmnet-cls}
 multinom_reg() %>% 
   set_engine("glmnet") %>% 
-  set_mode("classification") %>% 
   translate()
 ```
 
-For `glmnet` models, the full regularization path is always fit regardless of the
-value given to `penalty`. Also, there is the option to pass  multiple values (or
-no values) to the `penalty` argument. When using the  `predict()` method in these
-cases, the return value depends on  the value of `penalty`. When using
-`predict()`, only a single  value of the penalty can be used. When predicting on
-multiple  penalties, the `multi_predict()` function can be used. It  returns a
-tibble with a list column called `.pred` that contains  a tibble with all of the
-penalty results.
+`multinom_reg()` requires a single value for the `penalty` argument (a number
+or `tune()`). Despite this, the full regularization path is always fit
+regardless of the value given to `penalty`. To pass in a custom sequence of
+values for `lambda`, use the argument `path_values` in `set_engine()`. This
+will assign the value of the glmnet `lambda` parameter without disturbing
+the value given in `multinom_reg(penalty)`. For example: 
+
+```{r glmnet-path}
+multinom_reg(penalty = .1) %>% 
+  set_engine("glmnet", path_values = c(0, 10^seq(-10, 1, length.out = 20))) %>% 
+  translate()
+```
+
+When fitting a pure ridge regression model (i.e., `penalty = 0`), we _strongly
+suggest_ that you pass in a vector for `path_values` that includes zero. See 
+[issue #431](https://github.com/tidymodels/parsnip/issues/431) for a discussion. 
+
+When using `predict()`, the single penalty value used for prediction is the one 
+given to `multinom_reg()`. 
+
+To predict on multiple  penalties, the `multi_predict()` function can be used. 
+It  returns a tibble with a list column called `.pred` that contains  a tibble 
+with all of the penalty results.
 
 ## nnet