tests/testthat/_snaps/translate.md

In topepo/parsnip: A Common API to Modeling and Analysis Functions

arguments (boost_tree)

Code
  translate_args(basic_class %>% set_engine("xgboost"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $nthread
  [1] 1

  $verbose
  [1] 0

Code
  translate_args(basic_class %>% set_engine("C5.0"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

Code
  translate_args(basic_class %>% set_engine("C5.0", rules = TRUE))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $rules
  <quosure>
  expr: ^TRUE
  env:  empty

Code
  translate_args(basic_reg %>% set_engine("xgboost", print_every_n = 10L))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $print_every_n
  <quosure>
  expr: ^10L
  env:  empty

  $nthread
  [1] 1

  $verbose
  [1] 0

Code
  translate_args(trees %>% set_engine("C5.0"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $trials
  <quosure>
  expr: ^15
  env:  empty

Code
  translate_args(trees %>% set_engine("xgboost"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $nrounds
  <quosure>
  expr: ^15
  env:  empty

  $nthread
  [1] 1

  $verbose
  [1] 0

Code
  translate_args(split_num %>% set_engine("C5.0"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $minCases
  <quosure>
  expr: ^15
  env:  empty

Code
  translate_args(split_num %>% set_engine("xgboost"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $min_child_weight
  <quosure>
  expr: ^15
  env:  empty

  $nthread
  [1] 1

  $verbose
  [1] 0

arguments (decision_tree)

Code
  translate_args(basic_class %>% set_engine("rpart"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

Code
  translate_args(basic_class %>% set_engine("C5.0"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $trials
  [1] 1

Code
  translate_args(basic_class %>% set_engine("C5.0", rules = TRUE))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $rules
  <quosure>
  expr: ^TRUE
  env:  empty

  $trials
  [1] 1

Code
  translate_args(basic_reg %>% set_engine("rpart", model = TRUE))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $model
  <quosure>
  expr: ^TRUE
  env:  empty

Code
  translate_args(cost_complexity %>% set_engine("rpart"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $cp
  <quosure>
  expr: ^15
  env:  empty

Code
  translate_args(split_num %>% set_engine("C5.0"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $minCases
  <quosure>
  expr: ^15
  env:  empty

  $trials
  [1] 1

Code
  translate_args(split_num %>% set_engine("rpart"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $minsplit
  min_rows(15, data)

arguments (default)

Code
  translate_args(basic %>% set_engine("parsnip"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

Code
  translate_args(basic %>% set_engine("parsnip", keepxy = FALSE))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $keepxy
  <quosure>
  expr: ^FALSE
  env:  empty

arguments (linear_reg)

Code
  translate_args(basic %>% set_engine("lm"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

Code
  translate_args(basic %>% set_engine("lm", model = FALSE))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $model
  <quosure>
  expr: ^FALSE
  env:  empty

Code
  translate_args(basic %>% set_engine("glm"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $family
  stats::gaussian

Code
  translate_args(basic %>% set_engine("glm", family = "quasipoisson"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $family
  <quosure>
  expr: ^"quasipoisson"
  env:  empty

Code
  translate_args(basic %>% set_engine("stan"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $family
  stats::gaussian

  $refresh
  [1] 0

Code
  translate_args(basic %>% set_engine("stan", chains = 1, iter = 5))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $chains
  <quosure>
  expr: ^1
  env:  empty

  $iter
  <quosure>
  expr: ^5
  env:  empty

  $family
  stats::gaussian

  $refresh
  [1] 0

Code
  translate_args(basic %>% set_engine("spark"))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $weights
  missing_arg()

Code
  translate_args(basic %>% set_engine("spark", max_iter = 20))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $weights
  missing_arg()

  $max_iter
  <quosure>
  expr: ^20
  env:  empty

Code
  translate_args(basic %>% set_engine("glmnet"))
Condition
  Error in `.check_glmnet_penalty_fit()`:
  ! For the glmnet engine, `penalty` must be a single number (or a value of `tune()`).
  * There are 0 values for `penalty`.
  * To try multiple values for total regularization, use the tune package.
  * To predict multiple penalties, use `multi_predict()`

Code
  translate_args(mixture %>% set_engine("spark"))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $weights
  missing_arg()

  $elastic_net_param
  <quosure>
  expr: ^0.128
  env:  empty

Code
  translate_args(mixture_v %>% set_engine("spark"))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $weights
  missing_arg()

  $elastic_net_param
  <quosure>
  expr: ^tune()
  env:  empty

Code
  translate_args(mixture %>% set_engine("glmnet"))
Condition
  Error in `.check_glmnet_penalty_fit()`:
  ! For the glmnet engine, `penalty` must be a single number (or a value of `tune()`).
  * There are 0 values for `penalty`.
  * To try multiple values for total regularization, use the tune package.
  * To predict multiple penalties, use `multi_predict()`

Code
  translate_args(penalty %>% set_engine("glmnet"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $family
  [1] "gaussian"

Code
  translate_args(penalty %>% set_engine("glmnet", nlambda = 10))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $nlambda
  <quosure>
  expr: ^10
  env:  empty

  $family
  [1] "gaussian"

Code
  translate_args(penalty %>% set_engine("glmnet", path_values = 4:2))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $lambda
  <quosure>
  expr: ^4:2
  env:  empty

  $family
  [1] "gaussian"

Code
  translate_args(penalty %>% set_engine("spark"))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $weights
  missing_arg()

  $reg_param
  <quosure>
  expr: ^1
  env:  empty

arguments (logistic_reg)

Code
  translate_args(basic %>% set_engine("glm"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $family
  stats::binomial

Code
  translate_args(basic %>% set_engine("glm", family = binomial(link = "probit")))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $family
  <quosure>
  expr: ^binomial(link = "probit")
  env:  empty

Code
  translate_args(basic %>% set_engine("glmnet"))
Condition
  Error in `.check_glmnet_penalty_fit()`:
  ! For the glmnet engine, `penalty` must be a single number (or a value of `tune()`).
  * There are 0 values for `penalty`.
  * To try multiple values for total regularization, use the tune package.
  * To predict multiple penalties, use `multi_predict()`

Code
  translate_args(basic %>% set_engine("LiblineaR"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $verbose
  [1] FALSE

Code
  translate_args(basic %>% set_engine("LiblineaR", bias = 0))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $bias
  <quosure>
  expr: ^0
  env:  empty

  $verbose
  [1] FALSE

Code
  translate_args(basic %>% set_engine("stan"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $family
  stats::binomial

  $refresh
  [1] 0

Code
  translate_args(basic %>% set_engine("stan", chains = 1, iter = 5))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $chains
  <quosure>
  expr: ^1
  env:  empty

  $iter
  <quosure>
  expr: ^5
  env:  empty

  $family
  stats::binomial

  $refresh
  [1] 0

Code
  translate_args(basic %>% set_engine("spark"))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $weights
  missing_arg()

  $family
  [1] "binomial"

Code
  translate_args(basic %>% set_engine("spark", max_iter = 20))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $weights
  missing_arg()

  $max_iter
  <quosure>
  expr: ^20
  env:  empty

  $family
  [1] "binomial"

Code
  translate_args(mixture %>% set_engine("glmnet"))
Condition
  Error in `.check_glmnet_penalty_fit()`:
  ! For the glmnet engine, `penalty` must be a single number (or a value of `tune()`).
  * There are 0 values for `penalty`.
  * To try multiple values for total regularization, use the tune package.
  * To predict multiple penalties, use `multi_predict()`

Code
  translate_args(mixture %>% set_engine("spark"))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $weights
  missing_arg()

  $elastic_net_param
  <quosure>
  expr: ^0.128
  env:  empty

  $family
  [1] "binomial"

Code
  translate_args(penalty %>% set_engine("glmnet"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $family
  [1] "binomial"

Code
  translate_args(penalty %>% set_engine("glmnet", nlambda = 10))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $nlambda
  <quosure>
  expr: ^10
  env:  empty

  $family
  [1] "binomial"

Code
  translate_args(penalty %>% set_engine("glmnet", path_values = 4:2))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $lambda
  <quosure>
  expr: ^4:2
  env:  empty

  $family
  [1] "binomial"

Code
  translate_args(penalty %>% set_engine("LiblineaR"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $cost
  <quosure>
  expr: ^1
  env:  empty

  $verbose
  [1] FALSE

Code
  translate_args(penalty %>% set_engine("spark"))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $weights
  missing_arg()

  $reg_param
  <quosure>
  expr: ^1
  env:  empty

  $family
  [1] "binomial"

Code
  translate_args(mixture_v %>% set_engine("glmnet"))
Condition
  Error in `.check_glmnet_penalty_fit()`:
  ! For the glmnet engine, `penalty` must be a single number (or a value of `tune()`).
  * There are 0 values for `penalty`.
  * To try multiple values for total regularization, use the tune package.
  * To predict multiple penalties, use `multi_predict()`

Code
  translate_args(mixture_v %>% set_engine("LiblineaR"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $type
  <quosure>
  expr: ^tune()
  env:  empty

  $verbose
  [1] FALSE

Code
  translate_args(mixture_v %>% set_engine("spark"))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $weights
  missing_arg()

  $elastic_net_param
  <quosure>
  expr: ^tune()
  env:  empty

  $family
  [1] "binomial"

arguments (mars)

Code
  translate_args(basic %>% set_engine("earth"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $keepxy
  [1] TRUE

Code
  translate_args(basic %>% set_engine("earth", keepxy = FALSE))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $keepxy
  <quosure>
  expr: ^FALSE
  env:  empty

Code
  translate_args(num_terms %>% set_engine("earth"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $nprune
  <quosure>
  expr: ^4
  env:  empty

  $glm
  <quosure>
  expr: ^list(family = stats::binomial)
  env:  empty

  $keepxy
  [1] TRUE

Code
  translate_args(prod_degree %>% set_engine("earth"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $degree
  <quosure>
  expr: ^1
  env:  empty

  $keepxy
  [1] TRUE

Code
  translate_args(prune_method_v %>% set_engine("earth"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $pmethod
  <quosure>
  expr: ^tune()
  env:  empty

  $keepxy
  [1] TRUE

arguments (mlp)

Code
  translate_args(hidden_units %>% set_engine("nnet"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $size
  <quosure>
  expr: ^4
  env:  empty

  $trace
  [1] FALSE

  $linout
  [1] TRUE

Code
  translate_args(hidden_units %>% set_engine("keras"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $hidden_units
  <quosure>
  expr: ^4
  env:  empty

Code
  translate_args(no_hidden_units %>% set_engine("nnet"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $size
  [1] 5

  $trace
  [1] FALSE

  $linout
  [1] TRUE

Code
  translate_args(no_hidden_units %>% set_engine("nnet", abstol = tune()))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $size
  [1] 5

  $abstol
  <quosure>
  expr: ^tune()
  env:  empty

  $trace
  [1] FALSE

  $linout
  [1] TRUE

Code
  translate_args(no_hidden_units %>% set_engine("keras", validation_split = 0.2))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $validation_split
  <quosure>
  expr: ^0.2
  env:  empty

Code
  translate_args(hess %>% set_engine("nnet", Hess = TRUE))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $size
  [1] 5

  $Hess
  <quosure>
  expr: ^TRUE
  env:  empty

  $trace
  [1] FALSE

  $linout
  [1] FALSE

Code
  translate_args(all_args %>% set_engine("nnet"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $size
  <quosure>
  expr: ^4
  env:  empty

  $decay
  <quosure>
  expr: ^1e-04
  env:  empty

  $maxit
  <quosure>
  expr: ^2
  env:  empty

  $trace
  [1] FALSE

  $linout
  [1] FALSE

Code
  translate_args(all_args %>% set_engine("keras"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $hidden_units
  <quosure>
  expr: ^4
  env:  empty

  $penalty
  <quosure>
  expr: ^1e-04
  env:  empty

  $dropout
  <quosure>
  expr: ^0
  env:  empty

  $epochs
  <quosure>
  expr: ^2
  env:  empty

  $activation
  <quosure>
  expr: ^"softmax"
  env:  empty

arguments (multinom_reg)

Code
  translate_args(basic %>% set_engine("glmnet"))
Condition
  Error in `.check_glmnet_penalty_fit()`:
  ! For the glmnet engine, `penalty` must be a single number (or a value of `tune()`).
  * There are 0 values for `penalty`.
  * To try multiple values for total regularization, use the tune package.
  * To predict multiple penalties, use `multi_predict()`

Code
  translate_args(mixture %>% set_engine("glmnet"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $alpha
  <quosure>
  expr: ^0.128
  env:  empty

  $family
  [1] "multinomial"

Code
  translate_args(penalty %>% set_engine("glmnet"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $family
  [1] "multinomial"

Code
  translate_args(penalty %>% set_engine("glmnet", path_values = 4:2))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $lambda
  <quosure>
  expr: ^4:2
  env:  empty

  $family
  [1] "multinomial"

Code
  translate_args(penalty %>% set_engine("glmnet", nlambda = 10))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $nlambda
  <quosure>
  expr: ^10
  env:  empty

  $family
  [1] "multinomial"

Code
  translate_args(mixture_v %>% set_engine("glmnet"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $alpha
  <quosure>
  expr: ^tune()
  env:  empty

  $family
  [1] "multinomial"

arguments (nearest_neighbor)

Code
  translate_args(basic %>% set_engine("kknn"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $ks
  min_rows(5, data, 5)

Code
  translate_args(neighbors %>% set_engine("kknn"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $ks
  min_rows(2, data, 5)

Code
  translate_args(neighbors %>% set_engine("kknn", scale = FALSE))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $ks
  min_rows(2, data, 5)

  $scale
  <quosure>
  expr: ^FALSE
  env:  empty

Code
  translate_args(weight_func %>% set_engine("kknn"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $kernel
  <quosure>
  expr: ^"triangular"
  env:  empty

  $ks
  min_rows(5, data, 5)

Code
  translate_args(dist_power %>% set_engine("kknn"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $distance
  <quosure>
  expr: ^2
  env:  empty

  $ks
  min_rows(5, data, 5)

arguments (proportional_hazards)

Code
  basic %>% translate_args()
Output
  list()

Code
  basic_incomplete %>% translate_args()
Condition
  Error in `.check_glmnet_penalty_fit()`:
  ! For the glmnet engine, `penalty` must be a single number (or a value of `tune()`).
  * There are 0 values for `penalty`.
  * To try multiple values for total regularization, use the tune package.
  * To predict multiple penalties, use `multi_predict()`

arguments (rand_forest)

Code
  translate_args(basic %>% set_engine("randomForest", norm.votes = FALSE))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $norm.votes
  <quosure>
  expr: ^FALSE
  env:  empty

Code
  translate_args(basic %>% set_engine("spark", min_info_gain = 2))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $type
  [1] "regression"

  $min_info_gain
  <quosure>
  expr: ^2
  env:  empty

  $seed
  sample.int(10^5, 1)

Code
  translate_args(mtry %>% set_engine("ranger"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $mtry
  min_cols(~4, x)

  $num.threads
  [1] 1

  $verbose
  [1] FALSE

  $seed
  sample.int(10^5, 1)

Code
  translate_args(mtry %>% set_engine("randomForest"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $mtry
  min_cols(~4, x)

Code
  translate_args(mtry %>% set_engine("spark"))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $type
  [1] "regression"

  $feature_subset_strategy
  [1] "4"

  $seed
  sample.int(10^5, 1)

Code
  translate_args(trees %>% set_engine("ranger"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $num.trees
  <quosure>
  expr: ^1000
  env:  empty

  $num.threads
  [1] 1

  $verbose
  [1] FALSE

  $seed
  sample.int(10^5, 1)

  $probability
  [1] TRUE

Code
  translate_args(trees %>% set_engine("ranger", importance = "impurity"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $num.trees
  <quosure>
  expr: ^1000
  env:  empty

  $importance
  <quosure>
  expr: ^"impurity"
  env:  empty

  $num.threads
  [1] 1

  $verbose
  [1] FALSE

  $seed
  sample.int(10^5, 1)

  $probability
  [1] TRUE

Code
  translate_args(trees %>% set_engine("randomForest"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $ntree
  <quosure>
  expr: ^1000
  env:  empty

Code
  translate_args(trees %>% set_engine("spark"))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $type
  [1] "classification"

  $num_trees
  <quosure>
  expr: ^1000
  env:  empty

  $seed
  sample.int(10^5, 1)

Code
  translate_args(min_n %>% set_engine("ranger"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $weights
  missing_arg()

  $min.node.size
  min_rows(~5, x)

  $num.threads
  [1] 1

  $verbose
  [1] FALSE

  $seed
  sample.int(10^5, 1)

Code
  translate_args(min_n %>% set_engine("randomForest"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $nodesize
  min_rows(~5, x)

Code
  translate_args(min_n %>% set_engine("spark"))
Output
  $x
  missing_arg()

  $formula
  missing_arg()

  $type
  [1] "regression"

  $min_instances_per_node
  min_rows(~5, x)

  $seed
  sample.int(10^5, 1)

arguments (surv_reg)

Code
  translate_args(basic %>% set_engine("flexsurv"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

Code
  translate_args(basic %>% set_engine("flexsurv", cl = 0.99))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $cl
  <quosure>
  expr: ^0.99
  env:  empty

Code
  translate_args(normal %>% set_engine("flexsurv"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $dist
  <quosure>
  expr: ^"lnorm"
  env:  empty

Code
  translate_args(dist_v %>% set_engine("flexsurv"))
Output
  $formula
  missing_arg()

  $data
  missing_arg()

  $weights
  missing_arg()

  $dist
  <quosure>
  expr: ^tune()
  env:  empty

arguments (survival_reg)

Code
  basic %>% translate_args()
Output
  list()

arguments (svm_linear)

Code
  translate_args(basic %>% set_engine("LiblineaR"))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $type
  [1] 11

  $svr_eps
  [1] 0.1

Code
  translate_args(basic %>% set_engine("LiblineaR", type = 12))
Output
  $x
  missing_arg()

  $y
  missing_arg()

  $type
  <quosure>
  expr: ^12
  env:  empty

  $svr_eps
  [1] 0.1

Code
  translate_args(basic %>% set_engine("kernlab"))
Output
  $x
  missing_arg()

  $data
  missing_arg()

  $kernel
  [1] "vanilladot"

Code
  translate_args(basic %>% set_engine("kernlab", cross = 10))
Output
  $x
  missing_arg()

  $data
  missing_arg()

  $cross
  <quosure>
  expr: ^10
  env:  empty

  $kernel
  [1] "vanilladot"

arguments (svm_poly)

Code
  translate_args(basic %>% set_engine("kernlab"))
Output
  $x
  missing_arg()

  $data
  missing_arg()

  $kernel
  [1] "polydot"

Code
  translate_args(basic %>% set_engine("kernlab", cross = 10))
Output
  $x
  missing_arg()

  $data
  missing_arg()

  $cross
  <quosure>
  expr: ^10
  env:  empty

  $kernel
  [1] "polydot"

Code
  translate_args(degree %>% set_engine("kernlab"))
Output
  $x
  missing_arg()

  $data
  missing_arg()

  $kernel
  [1] "polydot"

  $kpar
  list(degree = ~2)

Code
  translate_args(degree_scale %>% set_engine("kernlab"))
Output
  $x
  missing_arg()

  $data
  missing_arg()

  $kernel
  [1] "polydot"

  $kpar
  list(degree = ~2, scale = ~1.2)

arguments (svm_rbf)

Code
  translate_args(basic %>% set_engine("kernlab"))
Output
  $x
  missing_arg()

  $data
  missing_arg()

  $kernel
  [1] "rbfdot"

Code
  translate_args(basic %>% set_engine("kernlab", cross = 10))
Output
  $x
  missing_arg()

  $data
  missing_arg()

  $cross
  <quosure>
  expr: ^10
  env:  empty

  $kernel
  [1] "rbfdot"

Code
  translate_args(rbf_sigma %>% set_engine("kernlab"))
Output
  $x
  missing_arg()

  $data
  missing_arg()

  $kernel
  [1] "rbfdot"

  $kpar
  list(sigma = ~0.2)

translate tuning paramter names

Code
  .model_param_name_key(mod)
Output
  # A tibble: 2 x 3
    user            parsnip engine          
    <chr>           <chr>   <chr>           
  1 number of trees trees   nrounds         
  2 min_n           min_n   min_child_weight

Code
  .model_param_name_key(mod, as_tibble = FALSE)
Output
  $user_to_parsnip
              trees             min_n 
  "number of trees"           "min_n"

  $parsnip_to_engine
           nrounds min_child_weight 
           "trees"          "min_n"

Code
  .model_param_name_key(linear_reg())
Output
  # A tibble: 0 x 3
  # i 3 variables: user <chr>, parsnip <chr>, engine <chr>

Code
  .model_param_name_key(linear_reg(), as_tibble = FALSE)
Output
  $user_to_parsnip
  named character(0)

  $parsnip_to_engine
  named character(0)

'object' should be a model specification or workflow.

topepo/parsnip documentation built on April 16, 2024, 3:23 a.m.