As an example of a model with multiple engines, here is the object for logistic regression:
parsnip:::logistic_reg_arg_key
-#> glm glmnet spark stan
-#> penalty NA lambda reg_param NA
-#> mixture NA alpha elastic_net_param NAThe internals of parsnip will use these objects during the creation of the model code.
pred moduleThis is defined only for regression models (so is not added to the list). The convention used here is very similar to the two that are detailed in the next section. For pred, the model requires an unnamed numeric vector output (usually).
numeric module
+This is defined only for regression models (so is not added to the list). The convention used here is very similar to the two that are detailed in the next section. For numeric, the model requires an unnamed numeric vector output (usually).
For multivariate models, the return value should be a matrix or data frame (otherwise a vector should be the results).
-Note that the pred module maps to the predict_num function in parsnip. However, the user-facing predict function is used to generate predictions and returns a tibble with a column named .pred (see the example below). When creating new models, you don’t have to write code for that part.
Note that the numeric module maps to the predict_numeric function in parsnip. However, the user-facing predict function is used to generate predictions and returns a tibble with a column named .pred (see the example below). When creating new models, you don’t have to write code for that part.
classes moduleTo make hard class predictions, the classes object contains the details. The elements of the list are:
class module
+To make hard class predictions, the class object contains the details. The elements of the list are:
pre and post are optional functions that can preprocess the data being fed to the prediction code and to postprocess the raw output of the predictions. These won’t be need for this example, but a section below has examples of how these can be used when the model code is not easy to use. If the data being predicted has a simple type requirement, you can avoid using a pre function with the args below.args is a list of arguments to pass to the prediction function. These will mostly likely be wrapped in rlang::expr so that they are not evaluated when defining the method. For mda, the code would be predict(object, newdata, type = "class"). What is actually given to the function is the parsnip model fit object, which includes a sub-object called fit and this houses the mda model object. If the data need to be a matrix or data frame, you could also use new_data = quote(as.data.frame(new_data)) and so on.mixture_da_mda_data$classes <-
+mixture_da_mda_data$class <-
list(
pre = NULL,
post = NULL,
@@ -253,12 +253,12 @@
)
The predict_class function will expect the result to be an unnamed character string or factor. This will be coerced to a factor with the same levels as the original data. As with the pred module, the user doesn’t call predict_class but uses predict instead and this produces a tibble with a column named .pred_class per the model guidlines.
prob moduleThis defines the class probabilities (if they can be computed). The format is identical to the classes module but the output is expected to be a tibble with columns for each factor level.
classprob module
+This defines the class probabilities (if they can be computed). The format is identical to the class module but the output is expected to be a tibble with columns for each factor level.
As an example of the post function, the data frame created by mda:::predict.mda will be converted to a tibble. The arguments are x (the raw results coming from the predict method) and object (the parsnip model fit object). The latter has a sub-object called lvl which is a character string of the outcome’s factor levels (if any).
mixture_da_mda_data$prob <-
+mixture_da_mda_data$classprob <-
list(
pre = NULL,
post = function(x, object) {
@@ -371,9 +371,9 @@
Do I have to return a simple vector for predict_num and predict_class?
-Previously, when discussing the pred information:
+Previously, when discussing the numeric information:
-For pred, the model requires an unnamed numeric vector output (usually).
+For numeric, the model requires an unnamed numeric vector output (usually).
There are some occasions where a prediction for a single new sample may be multidimensional. Examples are enumerated here but some easy examples are:
diff --git a/docs/reference/index.html b/docs/reference/index.html
index df9884277..3682273be 100644
--- a/docs/reference/index.html
+++ b/docs/reference/index.html
@@ -190,6 +190,18 @@ surv_reg() update(<surv_reg>)
General Interface for Parametric Survival Models
+
+
+
+
+ General interface for polynomial support vector machines
+
+
+
+
+ General interface for radial basis function support vector machines
diff --git a/docs/reference/linear_reg.html b/docs/reference/linear_reg.html
index b8d391464..b6961b5fd 100644
--- a/docs/reference/linear_reg.html
+++ b/docs/reference/linear_reg.html
@@ -33,10 +33,10 @@
Arg
penalty
- An non-negative number representing the
-total amount of regularization (glmnet and spark only).
An non-negative number representing the total
+amount of regularization (glmnet, keras, and spark only).
+For keras models, this corresponds to purely L2 regularization
+(aka weight decay) while the other models can be a combination
+of L1 and L2 (depending on the value of mixture).
mixture
@@ -209,6 +212,7 @@ Details
R: "lm" or "glmnet"
Stan: "stan"
Spark: "spark"
keras: "keras"
Note
@@ -251,6 +255,11 @@ keras
+
+parsnip::keras_mlp(x = missing_arg(), y = missing_arg(), hidden_units = 1,
+ act = "linear")
+
When using glmnet models, there is the option to pass
multiple values (or no values) to the penalty argument.
This can have an effect on the model object results. When using
diff --git a/docs/reference/logistic_reg.html b/docs/reference/logistic_reg.html
index 122fc482c..626830342 100644
--- a/docs/reference/logistic_reg.html
+++ b/docs/reference/logistic_reg.html
@@ -33,8 +33,8 @@
Arg
penalty
- An non-negative number representing the
-total amount of regularization (glmnet and spark only).
An non-negative number representing the total
+amount of regularization (glmnet, keras, and spark only).
+For keras models, this corresponds to purely L2 regularization
+(aka weight decay) while the other models can be a combination
+of L1 and L2 (depending on the value of mixture).
mixture
@@ -207,6 +210,7 @@ Details
R: "glm" or "glmnet"
Stan: "stan"
Spark: "spark"
keras: "keras"
Note
@@ -250,6 +254,11 @@
+keras
+
+parsnip::keras_mlp(x = missing_arg(), y = missing_arg(), hidden_units = 1,
+ act = "linear")
+
When using glmnet models, there is the option to pass
multiple values (or no values) to the penalty argument.
This can have an effect on the model object results. When using
diff --git a/docs/reference/multinom_reg.html b/docs/reference/multinom_reg.html
index 6765274a5..87e2cfd61 100644
--- a/docs/reference/multinom_reg.html
+++ b/docs/reference/multinom_reg.html
@@ -33,7 +33,7 @@
Arg
penalty
- An non-negative number representing the
-total amount of regularization.
An non-negative number representing the total
+amount of regularization (glmnet, keras, and spark only).
+For keras models, this corresponds to purely L2 regularization
+(aka weight decay) while the other models can be a combination
+of L1 and L2 (depending on the value of mixture).
mixture
@@ -206,6 +209,7 @@ Details
following engines:
R: "glmnet"
Stan: "stan"
keras: "keras"
Note
@@ -239,6 +243,11 @@
+keras
+
+parsnip::keras_mlp(x = missing_arg(), y = missing_arg(), hidden_units = 1,
+ act = "linear")
+
When using glmnet models, there is the option to pass
multiple values (or no values) to the penalty argument.
This can have an effect on the model object results. When using
diff --git a/docs/reference/other_predict.html b/docs/reference/other_predict.html
index 15d418104..c0a7c3c1c 100644
--- a/docs/reference/other_predict.html
+++ b/docs/reference/other_predict.html
@@ -155,9 +155,9 @@
Other predict methods.
predict_predint(object, ...)
# S3 method for model_fit
-predict_num(object, new_data, ...)
+predict_numeric(object, new_data, ...)
-predict_num(object, ...)
+predict_numeric(object, ...)
# S3 method for model_fit
predict_quantile(object, new_data,
diff --git a/docs/reference/svm_poly.html b/docs/reference/svm_poly.html
new file mode 100644
index 000000000..083ceedcc
--- /dev/null
+++ b/docs/reference/svm_poly.html
@@ -0,0 +1,304 @@
+
+
+
+
+
+
+
+
+General interface for polynomial support vector machines — svm_poly • parsnip
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ General interface for polynomial support vector machines
+
+ svm_poly.Rd
+
+
+
+
+ svm_poly is a way to generate a specification of a model
+before fitting and allows the model to be created using
+different packages in R or via Spark. The main arguments for the
+model are:
+cost: The cost of predicting a sample within or on the
+wrong side of the margin.
degree: The polynomial degree.
scale_factor: A scaling factor for the kernel.
margin: The epsilon in the SVM insensitive loss function
+(regression only)
These arguments are converted to their specific names at the
+time that the model is fit. Other options and argument can be
+set using set_engine. If left to their defaults
+here (NULL), the values are taken from the underlying model
+functions. If parameters need to be modified, update can be used
+in lieu of recreating the object from scratch.
+
+
+
+ svm_poly(mode = "unknown", cost = NULL, degree = NULL,
+ scale_factor = NULL, margin = NULL)
+
+# S3 method for svm_poly
+update(object, cost = NULL, degree = NULL,
+ scale_factor = NULL, margin = NULL, fresh = FALSE, ...)
+
+ Arguments
+
+
+ mode
+ A single character string for the type of model.
+Possible values for this model are "unknown", "regression", or
+"classification".
+
+ cost
+ A positive number for the cost of predicting a sample within
+or on the wrong side of the margin
+
+ degree
+ A positive number for polynomial degree.
+
+ scale_factor
+ A positive number for the polynomial scaling factor.
+
+ margin
+ A positive number for the epsilon in the SVM insensitive
+loss function (regression only)
+
+ object
+ A polynomial SVM model specification.
+
+ fresh
+ A logical for whether the arguments should be
+modified in-place of or replaced wholesale.
+
+ ...
+ Not used for update.
+
+
+ Details
+
+ The model can be created using the fit() function using the
+following engines:
+R: "kernlab"
+
+ Engine Details
+
+
+ Engines may have pre-set default arguments when executing the
+model fit call. For this type of
+model, the template of the fit calls are::
+kernlab classification
+
+kernlab::ksvm(x = missing_arg(), y = missing_arg(), kernel = "polydot",
+ prob.model = TRUE)
+
+kernlab regression
+
+kernlab::ksvm(x = missing_arg(), y = missing_arg(), kernel = "polydot")
+
+
+ See also
+
+
+
+
+ Examples
+ svm_poly(mode = "classification", degree = 1.2)#> Polynomial Support Vector Machine Specification (classification)
+#>
+#> Main Arguments:
+#> degree = 1.2
+#> #> Polynomial Support Vector Machine Specification (regression)
+#>
+#> Main Arguments:
+#> cost = varying()
+#> model <- svm_poly(cost = 10, scale_factor = 0.1)
+model#> Polynomial Support Vector Machine Specification (unknown)
+#>
+#> Main Arguments:
+#> cost = 10
+#> scale_factor = 0.1
+#> update(model, cost = 1)#> Polynomial Support Vector Machine Specification (unknown)
+#>
+#> Main Arguments:
+#> cost = 1
+#> scale_factor = 0.1
+#> update(model, cost = 1, fresh = TRUE)#> Polynomial Support Vector Machine Specification (unknown)
+#>
+#> Main Arguments:
+#> cost = 1
+#>
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/reference/svm_rbf.html b/docs/reference/svm_rbf.html
new file mode 100644
index 000000000..661ff3f5c
--- /dev/null
+++ b/docs/reference/svm_rbf.html
@@ -0,0 +1,300 @@
+
+
+
+
+
+
+
+
+General interface for radial basis function support vector machines — svm_rbf • parsnip
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ General interface for radial basis function support vector machines
+
+ svm_rbf.Rd
+
+
+
+
+ svm_rbf is a way to generate a specification of a model
+before fitting and allows the model to be created using
+different packages in R or via Spark. The main arguments for the
+model are:
+cost: The cost of predicting a sample within or on the
+wrong side of the margin.
rbf_sigma: The precision parameter for the radial basis
+function.
margin: The epsilon in the SVM insensitive loss function
+(regression only)
These arguments are converted to their specific names at the
+time that the model is fit. Other options and argument can be
+set using set_engine. If left to their defaults
+here (NULL), the values are taken from the underlying model
+functions. If parameters need to be modified, update can be used
+in lieu of recreating the object from scratch.
+
+
+
+ svm_rbf(mode = "unknown", cost = NULL, rbf_sigma = NULL,
+ margin = NULL)
+
+# S3 method for svm_rbf
+update(object, cost = NULL, rbf_sigma = NULL,
+ margin = NULL, fresh = FALSE, ...)
+
+ Arguments
+
+
+ mode
+ A single character string for the type of model.
+Possible values for this model are "unknown", "regression", or
+"classification".
+
+ cost
+ A positive number for the cost of predicting a sample within
+or on the wrong side of the margin
+
+ rbf_sigma
+ A positive number for radial basis function.
+
+ margin
+ A positive number for the epsilon in the SVM insensitive
+loss function (regression only)
+
+ object
+ A radial basis function SVM model specification.
+
+ fresh
+ A logical for whether the arguments should be
+modified in-place of or replaced wholesale.
+
+ ...
+ Not used for update.
+
+
+ Details
+
+ The model can be created using the fit() function using the
+following engines:
+R: "kernlab"
+
+ Engine Details
+
+
+ Engines may have pre-set default arguments when executing the
+model fit call. For this type of
+model, the template of the fit calls are::
+kernlab classification
+
+kernlab::ksvm(x = missing_arg(), y = missing_arg(), kernel = "rbfdot",
+ prob.model = TRUE)
+
+kernlab regression
+
+kernlab::ksvm(x = missing_arg(), y = missing_arg(), kernel = "rbfdot")
+
+
+ See also
+
+
+
+
+ Examples
+ svm_rbf(mode = "classification", rbf_sigma = 0.2)#> Radial Basis Function Support Vector Machine Specification (classification)
+#>
+#> Main Arguments:
+#> rbf_sigma = 0.2
+#> #> Radial Basis Function Support Vector Machine Specification (regression)
+#>
+#> Main Arguments:
+#> cost = varying()
+#> model <- svm_rbf(cost = 10, rbf_sigma = 0.1)
+model#> Radial Basis Function Support Vector Machine Specification (unknown)
+#>
+#> Main Arguments:
+#> cost = 10
+#> rbf_sigma = 0.1
+#> update(model, cost = 1)#> Radial Basis Function Support Vector Machine Specification (unknown)
+#>
+#> Main Arguments:
+#> cost = 1
+#> rbf_sigma = 0.1
+#> update(model, cost = 1, fresh = TRUE)#> Radial Basis Function Support Vector Machine Specification (unknown)
+#>
+#> Main Arguments:
+#> cost = 1
+#>
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/reference/translate.html b/docs/reference/translate.html
index 3c3abc423..965fc7ff6 100644
--- a/docs/reference/translate.html
+++ b/docs/reference/translate.html
@@ -163,6 +163,9 @@ Details
This function can be useful when you need to understand how
parsnip goes from a generic model specific to a model fitting
function.
+Note: this function is used internally and users should only use it
+to understand what the underlying syntax would be. It should not be used
+to modify the model specification.
Examples
diff --git a/man/linear_reg.Rd b/man/linear_reg.Rd
index f395732d7..5c00e5f60 100644
--- a/man/linear_reg.Rd
+++ b/man/linear_reg.Rd
@@ -14,8 +14,11 @@ linear_reg(mode = "regression", penalty = NULL, mixture = NULL)
\item{mode}{A single character string for the type of model.
The only possible value for this model is "regression".}
-\item{penalty}{An non-negative number representing the
-total amount of regularization (\code{glmnet} and \code{spark} only).}
+\item{penalty}{An non-negative number representing the total
+amount of regularization (\code{glmnet}, \code{keras}, and \code{spark} only).
+For \code{keras} models, this corresponds to purely L2 regularization
+(aka weight decay) while the other models can be a combination
+of L1 and L2 (depending on the value of \code{mixture}).}
\item{mixture}{A number between zero and one (inclusive) that
represents the proportion of regularization that is used for the
@@ -32,11 +35,11 @@ modified in-place of or replaced wholesale.}
\description{
\code{linear_reg} is a way to generate a \emph{specification} of a model
before fitting and allows the model to be created using
-different packages in R, Stan, or via Spark. The main arguments for the
-model are:
+different packages in R, Stan, keras, or via Spark. The main
+arguments for the model are:
\itemize{
\item \code{penalty}: The total amount of regularization
-in the model. Note that this must be zero for some engines .
+in the model. Note that this must be zero for some engines.
\item \code{mixture}: The proportion of L1 regularization in
the model. Note that this will be ignored for some engines.
}
@@ -58,6 +61,7 @@ following \emph{engines}:
\item \pkg{R}: \code{"lm"} or \code{"glmnet"}
\item \pkg{Stan}: \code{"stan"}
\item \pkg{Spark}: \code{"spark"}
+\item \pkg{keras}: \code{"keras"}
}
}
\note{
@@ -97,6 +101,10 @@ model, the template of the fit calls are:
\Sexpr[results=rd]{parsnip:::show_fit(parsnip:::linear_reg(), "spark")}
+\pkg{keras}
+
+\Sexpr[results=rd]{parsnip:::show_fit(parsnip:::linear_reg(), "keras")}
+
When using \code{glmnet} models, there is the option to pass
multiple values (or no values) to the \code{penalty} argument.
This can have an effect on the model object results. When using
diff --git a/man/logistic_reg.Rd b/man/logistic_reg.Rd
index 0b2918a46..0a3416c0c 100644
--- a/man/logistic_reg.Rd
+++ b/man/logistic_reg.Rd
@@ -14,8 +14,11 @@ logistic_reg(mode = "classification", penalty = NULL, mixture = NULL)
\item{mode}{A single character string for the type of model.
The only possible value for this model is "classification".}
-\item{penalty}{An non-negative number representing the
-total amount of regularization (\code{glmnet} and \code{spark} only).}
+\item{penalty}{An non-negative number representing the total
+amount of regularization (\code{glmnet}, \code{keras}, and \code{spark} only).
+For \code{keras} models, this corresponds to purely L2 regularization
+(aka weight decay) while the other models can be a combination
+of L1 and L2 (depending on the value of \code{mixture}).}
\item{mixture}{A number between zero and one (inclusive) that
represents the proportion of regularization that is used for the
@@ -32,8 +35,8 @@ modified in-place of or replaced wholesale.}
\description{
\code{logistic_reg} is a way to generate a \emph{specification} of a model
before fitting and allows the model to be created using
-different packages in R, Stan, or via Spark. The main arguments for the
-model are:
+different packages in R, Stan, keras, or via Spark. The main
+arguments for the model are:
\itemize{
\item \code{penalty}: The total amount of regularization
in the model. Note that this must be zero for some engines.
@@ -56,6 +59,7 @@ following \emph{engines}:
\item \pkg{R}: \code{"glm"} or \code{"glmnet"}
\item \pkg{Stan}: \code{"stan"}
\item \pkg{Spark}: \code{"spark"}
+\item \pkg{keras}: \code{"keras"}
}
}
\note{
@@ -95,6 +99,10 @@ model, the template of the fit calls are:
\Sexpr[results=rd]{parsnip:::show_fit(parsnip:::logistic_reg(), "spark")}
+\pkg{keras}
+
+\Sexpr[results=rd]{parsnip:::show_fit(parsnip:::logistic_reg(), "keras")}
+
When using \code{glmnet} models, there is the option to pass
multiple values (or no values) to the \code{penalty} argument.
This can have an effect on the model object results. When using
diff --git a/man/multinom_reg.Rd b/man/multinom_reg.Rd
index 2bcc20b3e..0de9c5ee1 100644
--- a/man/multinom_reg.Rd
+++ b/man/multinom_reg.Rd
@@ -14,8 +14,11 @@ multinom_reg(mode = "classification", penalty = NULL, mixture = NULL)
\item{mode}{A single character string for the type of model.
The only possible value for this model is "classification".}
-\item{penalty}{An non-negative number representing the
-total amount of regularization.}
+\item{penalty}{An non-negative number representing the total
+amount of regularization (\code{glmnet}, \code{keras}, and \code{spark} only).
+For \code{keras} models, this corresponds to purely L2 regularization
+(aka weight decay) while the other models can be a combination
+of L1 and L2 (depending on the value of \code{mixture}).}
\item{mixture}{A number between zero and one (inclusive) that
represents the proportion of regularization that is used for the
@@ -32,7 +35,7 @@ modified in-place of or replaced wholesale.}
\description{
\code{multinom_reg} is a way to generate a \emph{specification} of a model
before fitting and allows the model to be created using
-different packages in R or Spark. The main arguments for the
+different packages in R, keras, or Spark. The main arguments for the
model are:
\itemize{
\item \code{penalty}: The total amount of regularization
@@ -55,6 +58,7 @@ following \emph{engines}:
\itemize{
\item \pkg{R}: \code{"glmnet"}
\item \pkg{Stan}: \code{"stan"}
+\item \pkg{keras}: \code{"keras"}
}
}
\note{
@@ -86,6 +90,10 @@ model, the template of the fit calls are:
\Sexpr[results=rd]{parsnip:::show_fit(parsnip:::multinom_reg(), "spark")}
+\pkg{keras}
+
+\Sexpr[results=rd]{parsnip:::show_fit(parsnip:::multinom_reg(), "keras")}
+
When using \code{glmnet} models, there is the option to pass
multiple values (or no values) to the \code{penalty} argument.
This can have an effect on the model object results. When using
diff --git a/man/other_predict.Rd b/man/other_predict.Rd
index f462f4d0b..57e3bf3f2 100644
--- a/man/other_predict.Rd
+++ b/man/other_predict.Rd
@@ -1,6 +1,6 @@
% Generated by roxygen2: do not edit by hand
% Please edit documentation in R/predict_class.R, R/predict_classprob.R,
-% R/predict_interval.R, R/predict_num.R, R/predict_quantile.R
+% R/predict_interval.R, R/predict_numeric.R, R/predict_quantile.R
\name{predict_class.model_fit}
\alias{predict_class.model_fit}
\alias{predict_class}
@@ -10,8 +10,8 @@
\alias{predict_confint}
\alias{predict_predint.model_fit}
\alias{predict_predint}
-\alias{predict_num.model_fit}
-\alias{predict_num}
+\alias{predict_numeric.model_fit}
+\alias{predict_numeric}
\alias{predict_quantile.model_fit}
\alias{predict_quantile}
\title{Other predict methods.}
@@ -34,9 +34,9 @@ predict_confint(object, ...)
predict_predint(object, ...)
-\method{predict_num}{model_fit}(object, new_data, ...)
+\method{predict_numeric}{model_fit}(object, new_data, ...)
-predict_num(object, ...)
+predict_numeric(object, ...)
\method{predict_quantile}{model_fit}(object, new_data,
quantile = (1:9)/10, ...)
diff --git a/man/svm_poly.Rd b/man/svm_poly.Rd
new file mode 100644
index 000000000..66a0f361d
--- /dev/null
+++ b/man/svm_poly.Rd
@@ -0,0 +1,90 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/svm_poly.R
+\name{svm_poly}
+\alias{svm_poly}
+\alias{update.svm_poly}
+\title{General interface for polynomial support vector machines}
+\usage{
+svm_poly(mode = "unknown", cost = NULL, degree = NULL,
+ scale_factor = NULL, margin = NULL)
+
+\method{update}{svm_poly}(object, cost = NULL, degree = NULL,
+ scale_factor = NULL, margin = NULL, fresh = FALSE, ...)
+}
+\arguments{
+\item{mode}{A single character string for the type of model.
+Possible values for this model are "unknown", "regression", or
+"classification".}
+
+\item{cost}{A positive number for the cost of predicting a sample within
+or on the wrong side of the margin}
+
+\item{degree}{A positive number for polynomial degree.}
+
+\item{scale_factor}{A positive number for the polynomial scaling factor.}
+
+\item{margin}{A positive number for the epsilon in the SVM insensitive
+loss function (regression only)}
+
+\item{object}{A polynomial SVM model specification.}
+
+\item{fresh}{A logical for whether the arguments should be
+modified in-place of or replaced wholesale.}
+
+\item{...}{Not used for \code{update}.}
+}
+\description{
+\code{svm_poly} is a way to generate a \emph{specification} of a model
+before fitting and allows the model to be created using
+different packages in R or via Spark. The main arguments for the
+model are:
+\itemize{
+\item \code{cost}: The cost of predicting a sample within or on the
+wrong side of the margin.
+\item \code{degree}: The polynomial degree.
+\item \code{scale_factor}: A scaling factor for the kernel.
+\item \code{margin}: The epsilon in the SVM insensitive loss function
+(regression only)
+}
+These arguments are converted to their specific names at the
+time that the model is fit. Other options and argument can be
+set using \code{set_engine}. If left to their defaults
+here (\code{NULL}), the values are taken from the underlying model
+functions. If parameters need to be modified, \code{update} can be used
+in lieu of recreating the object from scratch.
+}
+\details{
+The model can be created using the \code{fit()} function using the
+following \emph{engines}:
+\itemize{
+\item \pkg{R}: \code{"kernlab"}
+}
+}
+\section{Engine Details}{
+
+
+Engines may have pre-set default arguments when executing the
+model fit call. For this type of
+model, the template of the fit calls are::
+
+\pkg{kernlab} classification
+
+\Sexpr[results=rd]{parsnip:::show_fit(parsnip:::svm_poly(mode = "classification"), "kernlab")}
+
+\pkg{kernlab} regression
+
+\Sexpr[results=rd]{parsnip:::show_fit(parsnip:::svm_poly(mode = "regression"), "kernlab")}
+}
+
+\examples{
+svm_poly(mode = "classification", degree = 1.2)
+# Parameters can be represented by a placeholder:
+svm_poly(mode = "regression", cost = varying())
+model <- svm_poly(cost = 10, scale_factor = 0.1)
+model
+update(model, cost = 1)
+update(model, cost = 1, fresh = TRUE)
+}
+\seealso{
+\code{\link[=varying]{varying()}}, \code{\link[=fit]{fit()}}
+}
diff --git a/man/svm_rbf.Rd b/man/svm_rbf.Rd
new file mode 100644
index 000000000..76fa58d61
--- /dev/null
+++ b/man/svm_rbf.Rd
@@ -0,0 +1,88 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/svm_rbf.R
+\name{svm_rbf}
+\alias{svm_rbf}
+\alias{update.svm_rbf}
+\title{General interface for radial basis function support vector machines}
+\usage{
+svm_rbf(mode = "unknown", cost = NULL, rbf_sigma = NULL,
+ margin = NULL)
+
+\method{update}{svm_rbf}(object, cost = NULL, rbf_sigma = NULL,
+ margin = NULL, fresh = FALSE, ...)
+}
+\arguments{
+\item{mode}{A single character string for the type of model.
+Possible values for this model are "unknown", "regression", or
+"classification".}
+
+\item{cost}{A positive number for the cost of predicting a sample within
+or on the wrong side of the margin}
+
+\item{rbf_sigma}{A positive number for radial basis function.}
+
+\item{margin}{A positive number for the epsilon in the SVM insensitive
+loss function (regression only)}
+
+\item{object}{A radial basis function SVM model specification.}
+
+\item{fresh}{A logical for whether the arguments should be
+modified in-place of or replaced wholesale.}
+
+\item{...}{Not used for \code{update}.}
+}
+\description{
+\code{svm_rbf} is a way to generate a \emph{specification} of a model
+before fitting and allows the model to be created using
+different packages in R or via Spark. The main arguments for the
+model are:
+\itemize{
+\item \code{cost}: The cost of predicting a sample within or on the
+wrong side of the margin.
+\item \code{rbf_sigma}: The precision parameter for the radial basis
+function.
+\item \code{margin}: The epsilon in the SVM insensitive loss function
+(regression only)
+}
+These arguments are converted to their specific names at the
+time that the model is fit. Other options and argument can be
+set using \code{set_engine}. If left to their defaults
+here (\code{NULL}), the values are taken from the underlying model
+functions. If parameters need to be modified, \code{update} can be used
+in lieu of recreating the object from scratch.
+}
+\details{
+The model can be created using the \code{fit()} function using the
+following \emph{engines}:
+\itemize{
+\item \pkg{R}: \code{"kernlab"}
+}
+}
+\section{Engine Details}{
+
+
+Engines may have pre-set default arguments when executing the
+model fit call. For this type of
+model, the template of the fit calls are::
+
+\pkg{kernlab} classification
+
+\Sexpr[results=rd]{parsnip:::show_fit(parsnip:::svm_rbf(mode = "classification"), "kernlab")}
+
+\pkg{kernlab} regression
+
+\Sexpr[results=rd]{parsnip:::show_fit(parsnip:::svm_rbf(mode = "regression"), "kernlab")}
+}
+
+\examples{
+svm_rbf(mode = "classification", rbf_sigma = 0.2)
+# Parameters can be represented by a placeholder:
+svm_rbf(mode = "regression", cost = varying())
+model <- svm_rbf(cost = 10, rbf_sigma = 0.1)
+model
+update(model, cost = 1)
+update(model, cost = 1, fresh = TRUE)
+}
+\seealso{
+\code{\link[=varying]{varying()}}, \code{\link[=fit]{fit()}}
+}
diff --git a/man/translate.Rd b/man/translate.Rd
index a0bf27d18..82442df66 100644
--- a/man/translate.Rd
+++ b/man/translate.Rd
@@ -29,6 +29,10 @@ the model fitting function/engine.
This function can be useful when you need to understand how
\code{parsnip} goes from a generic model specific to a model fitting
function.
+
+\strong{Note}: this function is used internally and users should only use it
+to understand what the underlying syntax would be. It should not be used
+to modify the model specification.
}
\examples{
lm_spec <- linear_reg(penalty = 0.01)
diff --git a/tests/testthat/test_boost_tree_C50.R b/tests/testthat/test_boost_tree_C50.R
index 5c3e6096e..c1f189d7c 100644
--- a/tests/testthat/test_boost_tree_C50.R
+++ b/tests/testthat/test_boost_tree_C50.R
@@ -121,5 +121,10 @@ test_that('submodel prediction', {
mp_res <- multi_predict(class_fit, new_data = wa_churn[1:4, vars], trees = 4, type = "prob")
mp_res <- do.call("rbind", mp_res$.pred)
expect_equal(mp_res[[".pred_No"]], unname(pred_class[, "No"]))
+
+ expect_error(
+ multi_predict(class_fit, newdata = wa_churn[1:4, vars], trees = 4, type = "prob"),
+ "Did you mean"
+ )
})
diff --git a/tests/testthat/test_boost_tree_spark.R b/tests/testthat/test_boost_tree_spark.R
index 6c517e3b8..ce148620c 100644
--- a/tests/testthat/test_boost_tree_spark.R
+++ b/tests/testthat/test_boost_tree_spark.R
@@ -58,7 +58,7 @@ test_that('spark execution', {
)
expect_error(
- spark_reg_pred_num <- predict_num(spark_reg_fit, iris_bt_te),
+ spark_reg_pred_num <- predict_numeric(spark_reg_fit, iris_bt_te),
regexp = NA
)
@@ -68,7 +68,7 @@ test_that('spark execution', {
)
expect_error(
- spark_reg_num_dup <- predict_num(spark_reg_fit_dup, iris_bt_te),
+ spark_reg_num_dup <- predict_numeric(spark_reg_fit_dup, iris_bt_te),
regexp = NA
)
diff --git a/tests/testthat/test_boost_tree_xgboost.R b/tests/testthat/test_boost_tree_xgboost.R
index f8a7f7aa1..0c6be9417 100644
--- a/tests/testthat/test_boost_tree_xgboost.R
+++ b/tests/testthat/test_boost_tree_xgboost.R
@@ -141,7 +141,7 @@ test_that('xgboost regression prediction', {
)
xy_pred <- predict(xy_fit$fit, newdata = xgb.DMatrix(data = as.matrix(mtcars[1:8, -1])))
- expect_equal(xy_pred, predict_num(xy_fit, new_data = mtcars[1:8, -1]))
+ expect_equal(xy_pred, predict_numeric(xy_fit, new_data = mtcars[1:8, -1]))
form_fit <- fit(
car_basic,
@@ -151,7 +151,7 @@ test_that('xgboost regression prediction', {
)
form_pred <- predict(form_fit$fit, newdata = xgb.DMatrix(data = as.matrix(mtcars[1:8, -1])))
- expect_equal(form_pred, predict_num(form_fit, new_data = mtcars[1:8, -1]))
+ expect_equal(form_pred, predict_numeric(form_fit, new_data = mtcars[1:8, -1]))
})
@@ -188,5 +188,10 @@ test_that('submodel prediction', {
mp_res <- multi_predict(class_fit, new_data = wa_churn[1:4, vars], trees = 5, type = "prob")
mp_res <- do.call("rbind", mp_res$.pred)
expect_equal(mp_res[[".pred_No"]], pred_class)
+
+ expect_error(
+ multi_predict(class_fit, newdata = wa_churn[1:4, vars], trees = 5, type = "prob"),
+ "Did you mean"
+ )
})
diff --git a/tests/testthat/test_linear_reg.R b/tests/testthat/test_linear_reg.R
index 9df468114..86d2e2bed 100644
--- a/tests/testthat/test_linear_reg.R
+++ b/tests/testthat/test_linear_reg.R
@@ -269,7 +269,7 @@ test_that('lm prediction', {
control = ctrl
)
- expect_equal(uni_pred, predict_num(res_xy, iris[1:5, num_pred]))
+ expect_equal(uni_pred, predict_numeric(res_xy, iris[1:5, num_pred]))
res_form <- fit(
iris_basic,
@@ -277,7 +277,7 @@ test_that('lm prediction', {
data = iris,
control = ctrl
)
- expect_equal(inl_pred, predict_num(res_form, iris[1:5, ]))
+ expect_equal(inl_pred, predict_numeric(res_form, iris[1:5, ]))
res_mv <- fit(
iris_basic,
@@ -285,7 +285,7 @@ test_that('lm prediction', {
data = iris,
control = ctrl
)
- expect_equal(mv_pred, predict_num(res_mv, iris[1:5,]))
+ expect_equal(mv_pred, predict_numeric(res_mv, iris[1:5,]))
})
test_that('lm intervals', {
@@ -322,3 +322,14 @@ test_that('lm intervals', {
expect_equivalent(prediction_parsnip$.pred_upper, prediction_lm[, "upr"])
})
+
+test_that('newdata error trapping', {
+ res_xy <- fit_xy(
+ iris_basic,
+ x = iris[, num_pred],
+ y = iris$Sepal.Length,
+ control = ctrl
+ )
+ expect_error(predict(res_xy, newdata = iris[1:3, num_pred]), "Did you mean")
+})
+
diff --git a/tests/testthat/test_linear_reg_glmnet.R b/tests/testthat/test_linear_reg_glmnet.R
index ba7458038..a22b6e73d 100644
--- a/tests/testthat/test_linear_reg_glmnet.R
+++ b/tests/testthat/test_linear_reg_glmnet.R
@@ -69,7 +69,7 @@ test_that('glmnet prediction, single lambda', {
s = iris_basic$spec$args$penalty)
uni_pred <- unname(uni_pred[,1])
- expect_equal(uni_pred, predict_num(res_xy, iris[1:5, num_pred]))
+ expect_equal(uni_pred, predict_numeric(res_xy, iris[1:5, num_pred]))
res_form <- fit(
iris_basic,
@@ -87,7 +87,7 @@ test_that('glmnet prediction, single lambda', {
s = res_form$spec$spec$args$penalty)
form_pred <- unname(form_pred[,1])
- expect_equal(form_pred, predict_num(res_form, iris[1:5, c("Sepal.Width", "Species")]))
+ expect_equal(form_pred, predict_numeric(res_form, iris[1:5, c("Sepal.Width", "Species")]))
})
@@ -115,7 +115,7 @@ test_that('glmnet prediction, multiple lambda', {
mult_pred$lambda <- rep(lams, each = 5)
mult_pred <- mult_pred[,-2]
- expect_equal(mult_pred, predict_num(res_xy, iris[1:5, num_pred]))
+ expect_equal(mult_pred, predict_numeric(res_xy, iris[1:5, num_pred]))
res_form <- fit(
iris_mult,
@@ -135,7 +135,7 @@ test_that('glmnet prediction, multiple lambda', {
form_pred$lambda <- rep(lams, each = 5)
form_pred <- form_pred[,-2]
- expect_equal(form_pred, predict_num(res_form, iris[1:5, c("Sepal.Width", "Species")]))
+ expect_equal(form_pred, predict_numeric(res_form, iris[1:5, c("Sepal.Width", "Species")]))
})
test_that('glmnet prediction, all lambda', {
@@ -157,7 +157,7 @@ test_that('glmnet prediction, all lambda', {
all_pred$lambda <- rep(res_xy$fit$lambda, each = 5)
all_pred <- all_pred[,-2]
- expect_equal(all_pred, predict_num(res_xy, iris[1:5, num_pred]))
+ expect_equal(all_pred, predict_numeric(res_xy, iris[1:5, num_pred]))
# test that the lambda seq is in the right order (since no docs on this)
tmp_pred <- predict(res_xy$fit, newx = as.matrix(iris[1:5, num_pred]),
@@ -180,7 +180,7 @@ test_that('glmnet prediction, all lambda', {
form_pred$lambda <- rep(res_form$fit$lambda, each = 5)
form_pred <- form_pred[,-2]
- expect_equal(form_pred, predict_num(res_form, iris[1:5, c("Sepal.Width", "Species")]))
+ expect_equal(form_pred, predict_numeric(res_form, iris[1:5, c("Sepal.Width", "Species")]))
})
@@ -198,5 +198,10 @@ test_that('submodel prediction', {
mp_res <- multi_predict(reg_fit, new_data = mtcars[1:4, -1], penalty = .1)
mp_res <- do.call("rbind", mp_res$.pred)
expect_equal(mp_res[[".pred"]], unname(pred_glmn[,1]))
+
+ expect_error(
+ multi_predict(reg_fit, newdata = mtcars[1:4, -1], penalty = .1),
+ "Did you mean"
+ )
})
diff --git a/tests/testthat/test_linear_reg_keras.R b/tests/testthat/test_linear_reg_keras.R
new file mode 100644
index 000000000..c8bcfafb3
--- /dev/null
+++ b/tests/testthat/test_linear_reg_keras.R
@@ -0,0 +1,126 @@
+library(testthat)
+library(parsnip)
+library(rlang)
+library(tibble)
+
+# ------------------------------------------------------------------------------
+
+context("keras linear regression")
+source("helpers.R")
+
+# ------------------------------------------------------------------------------
+
+basic_mod <-
+ linear_reg() %>%
+ set_engine("keras", epochs = 50, verbose = 0)
+
+ridge_mod <-
+ linear_reg(penalty = 0.1) %>%
+ set_engine("keras", epochs = 50, verbose = 0)
+
+ctrl <- fit_control(verbosity = 0, catch = FALSE)
+
+# ------------------------------------------------------------------------------
+
+test_that('model fitting', {
+
+ skip_if_not_installed("keras")
+
+ set.seed(257)
+ expect_error(
+ fit1 <-
+ fit_xy(
+ basic_mod,
+ control = ctrl,
+ x = iris[,2:4],
+ y = iris$Sepal.Length
+ ),
+ regexp = NA
+ )
+
+ set.seed(257)
+ expect_error(
+ fit2 <-
+ fit_xy(
+ basic_mod,
+ control = ctrl,
+ x = iris[,2:4],
+ y = iris$Sepal.Length
+ ),
+ regexp = NA
+ )
+ expect_equal(fit1, fit2)
+
+ expect_error(
+ fit(
+ basic_mod,
+ Sepal.Length ~ .,
+ data = iris[, -5],
+ control = ctrl
+ ),
+ regexp = NA
+ )
+
+ expect_error(
+ fit1 <-
+ fit_xy(
+ ridge_mod,
+ control = ctrl,
+ x = iris[,2:4],
+ y = iris$Sepal.Length
+ ),
+ regexp = NA
+ )
+
+ expect_error(
+ fit(
+ ridge_mod,
+ Sepal.Length ~ .,
+ data = iris[, -5],
+ control = ctrl
+ ),
+ regexp = NA
+ )
+
+})
+
+
+test_that('regression prediction', {
+
+ skip_if_not_installed("keras")
+
+ library(keras)
+
+ set.seed(257)
+ lm_fit <-
+ fit_xy(
+ basic_mod,
+ control = ctrl,
+ x = iris[,2:4],
+ y = iris$Sepal.Length
+ )
+
+ keras_pred <-
+ predict(lm_fit$fit, as.matrix(iris[1:3,2:4])) %>%
+ as_tibble() %>%
+ setNames(".pred")
+ parsnip_pred <- predict(lm_fit, iris[1:3,2:4])
+ expect_equal(as.data.frame(keras_pred), as.data.frame(parsnip_pred))
+
+ set.seed(257)
+ rr_fit <-
+ fit_xy(
+ ridge_mod,
+ control = ctrl,
+ x = iris[,2:4],
+ y = iris$Sepal.Length
+ )
+
+ keras_pred <-
+ predict(rr_fit$fit, as.matrix(iris[1:3,2:4])) %>%
+ as_tibble() %>%
+ setNames(".pred")
+ parsnip_pred <- predict(rr_fit, iris[1:3,2:4])
+ expect_equal(as.data.frame(keras_pred), as.data.frame(parsnip_pred))
+
+})
diff --git a/tests/testthat/test_linear_reg_spark.R b/tests/testthat/test_linear_reg_spark.R
index 2ed55d7d6..f1a033beb 100644
--- a/tests/testthat/test_linear_reg_spark.R
+++ b/tests/testthat/test_linear_reg_spark.R
@@ -42,7 +42,7 @@ test_that('spark execution', {
)
expect_error(
- spark_pred_num <- predict_num(spark_fit, iris_linreg_te),
+ spark_pred_num <- predict_numeric(spark_fit, iris_linreg_te),
regexp = NA
)
diff --git a/tests/testthat/test_linear_reg_stan.R b/tests/testthat/test_linear_reg_stan.R
index 4f7288d90..bf7bd53de 100644
--- a/tests/testthat/test_linear_reg_stan.R
+++ b/tests/testthat/test_linear_reg_stan.R
@@ -70,7 +70,7 @@ test_that('stan prediction', {
control = quiet_ctrl
)
- expect_equal(uni_pred, predict_num(res_xy, iris[1:5, num_pred]), tolerance = 0.001)
+ expect_equal(uni_pred, predict_numeric(res_xy, iris[1:5, num_pred]), tolerance = 0.001)
res_form <- fit(
iris_basic,
@@ -78,7 +78,7 @@ test_that('stan prediction', {
data = iris,
control = quiet_ctrl
)
- expect_equal(inl_pred, predict_num(res_form, iris[1:5, ]), tolerance = 0.001)
+ expect_equal(inl_pred, predict_numeric(res_form, iris[1:5, ]), tolerance = 0.001)
})
diff --git a/tests/testthat/test_logistic_reg_glmnet.R b/tests/testthat/test_logistic_reg_glmnet.R
index 9b751cf46..ed4d0ff77 100644
--- a/tests/testthat/test_logistic_reg_glmnet.R
+++ b/tests/testthat/test_logistic_reg_glmnet.R
@@ -331,6 +331,11 @@ test_that('submodel prediction', {
mp_res <- multi_predict(class_fit, new_data = wa_churn[1:4, vars], penalty = .1, type = "prob")
mp_res <- do.call("rbind", mp_res$.pred)
expect_equal(mp_res[[".pred_No"]], unname(pred_glmn[,1]))
+
+ expect_error(
+ multi_predict(class_fit, newdata = wa_churn[1:4, vars], penalty = .1, type = "prob"),
+ "Did you mean"
+ )
})
diff --git a/tests/testthat/test_logistic_reg_keras.R b/tests/testthat/test_logistic_reg_keras.R
new file mode 100644
index 000000000..8a7c51986
--- /dev/null
+++ b/tests/testthat/test_logistic_reg_keras.R
@@ -0,0 +1,189 @@
+library(testthat)
+library(parsnip)
+library(rlang)
+library(tibble)
+library(dplyr)
+
+# ------------------------------------------------------------------------------
+
+context("keras logistic regression")
+source("helpers.R")
+
+# ------------------------------------------------------------------------------
+
+data("lending_club")
+set.seed(352)
+dat <-
+ lending_club %>%
+ group_by(Class) %>%
+ sample_n(500) %>%
+ ungroup() %>%
+ dplyr::select(Class, funded_amnt, int_rate)
+dat <- dat[order(runif(nrow(dat))),]
+
+tr_dat <- dat[1:995, ]
+te_dat <- dat[996:1000, ]
+
+# ------------------------------------------------------------------------------
+
+basic_mod <-
+ logistic_reg() %>%
+ set_engine("keras", epochs = 50, verbose = 0)
+
+reg_mod <-
+ logistic_reg(penalty = 0.1) %>%
+ set_engine("keras", epochs = 50, verbose = 0)
+
+ctrl <- fit_control(verbosity = 0, catch = FALSE)
+
+# ------------------------------------------------------------------------------
+
+test_that('model fitting', {
+
+ skip_if_not_installed("keras")
+
+ set.seed(257)
+ expect_error(
+ fit1 <-
+ fit_xy(
+ basic_mod,
+ control = ctrl,
+ x = tr_dat[, -1],
+ y = tr_dat$Class
+ ),
+ regexp = NA
+ )
+
+ set.seed(257)
+ expect_error(
+ fit2 <-
+ fit_xy(
+ basic_mod,
+ control = ctrl,
+ x = tr_dat[, -1],
+ y = tr_dat$Class
+ ),
+ regexp = NA
+ )
+ expect_equal(fit1, fit2)
+
+ expect_error(
+ fit(
+ basic_mod,
+ Class ~ .,
+ data = tr_dat,
+ control = ctrl
+ ),
+ regexp = NA
+ )
+
+ expect_error(
+ fit1 <-
+ fit_xy(
+ reg_mod,
+ control = ctrl,
+ x = tr_dat[, -1],
+ y = tr_dat$Class
+ ),
+ regexp = NA
+ )
+
+ expect_error(
+ fit(
+ reg_mod,
+ Class ~ .,
+ data = tr_dat,
+ control = ctrl
+ ),
+ regexp = NA
+ )
+
+})
+
+
+test_that('classification prediction', {
+
+ skip_if_not_installed("keras")
+
+ library(keras)
+
+ set.seed(257)
+ lr_fit <-
+ fit_xy(
+ basic_mod,
+ control = ctrl,
+ x = tr_dat[, -1],
+ y = tr_dat$Class
+ )
+
+ keras_raw <-
+ predict(lr_fit$fit, as.matrix(te_dat[, -1]))
+ keras_pred <-
+ tibble(.pred_class = apply(keras_raw, 1, which.max)) %>%
+ mutate(.pred_class = factor(lr_fit$lvl[.pred_class], levels = lr_fit$lvl))
+
+ parsnip_pred <- predict(lr_fit, te_dat[, -1])
+ expect_equal(as.data.frame(keras_pred), as.data.frame(parsnip_pred))
+
+ set.seed(257)
+ plrfit <-
+ fit_xy(
+ reg_mod,
+ control = ctrl,
+ x = tr_dat[, -1],
+ y = tr_dat$Class
+ )
+
+ keras_raw <-
+ predict(plrfit$fit, as.matrix(te_dat[, -1]))
+ keras_pred <-
+ tibble(.pred_class = apply(keras_raw, 1, which.max)) %>%
+ mutate(.pred_class = factor(plrfit$lvl[.pred_class], levels = plrfit$lvl))
+ parsnip_pred <- predict(plrfit, te_dat[, -1])
+ expect_equal(as.data.frame(keras_pred), as.data.frame(parsnip_pred))
+
+})
+
+
+test_that('classification probabilities', {
+
+ skip_if_not_installed("keras")
+
+ library(keras)
+
+ set.seed(257)
+ lr_fit <-
+ fit_xy(
+ basic_mod,
+ control = ctrl,
+ x = tr_dat[, -1],
+ y = tr_dat$Class
+ )
+
+ keras_pred <-
+ predict_proba(lr_fit$fit, as.matrix(te_dat[, -1])) %>%
+ as_tibble() %>%
+ setNames(paste0(".pred_", lr_fit$lvl))
+
+ parsnip_pred <- predict(lr_fit, te_dat[, -1], type = "prob")
+ expect_equal(as.data.frame(keras_pred), as.data.frame(parsnip_pred))
+
+ set.seed(257)
+ plrfit <-
+ fit_xy(
+ reg_mod,
+ control = ctrl,
+ x = tr_dat[, -1],
+ y = tr_dat$Class
+ )
+
+ keras_pred <-
+ predict_proba(plrfit$fit, as.matrix(te_dat[, -1])) %>%
+ as_tibble() %>%
+ setNames(paste0(".pred_", lr_fit$lvl))
+ parsnip_pred <- predict(plrfit, te_dat[, -1], type = "prob")
+ expect_equal(as.data.frame(keras_pred), as.data.frame(parsnip_pred))
+
+})
+
+
diff --git a/tests/testthat/test_mars.R b/tests/testthat/test_mars.R
index bf3d35c11..ed3505ceb 100644
--- a/tests/testthat/test_mars.R
+++ b/tests/testthat/test_mars.R
@@ -180,7 +180,7 @@ test_that('mars prediction', {
control = ctrl
)
- expect_equal(uni_pred, predict_num(res_xy, iris[1:5, num_pred]))
+ expect_equal(uni_pred, predict_numeric(res_xy, iris[1:5, num_pred]))
res_form <- fit(
iris_basic,
@@ -188,7 +188,7 @@ test_that('mars prediction', {
data = iris,
control = ctrl
)
- expect_equal(inl_pred, predict_num(res_form, iris[1:5, ]))
+ expect_equal(inl_pred, predict_numeric(res_form, iris[1:5, ]))
res_mv <- fit(
iris_basic,
@@ -196,7 +196,7 @@ test_that('mars prediction', {
data = iris,
control = ctrl
)
- expect_equal(mv_pred, predict_num(res_mv, iris[1:5,]))
+ expect_equal(mv_pred, predict_numeric(res_mv, iris[1:5,]))
})
@@ -242,6 +242,11 @@ test_that('submodel prediction', {
mp_res <- multi_predict(class_fit, new_data = wa_churn[1:4, vars], num_terms = 5, type = "prob")
mp_res <- do.call("rbind", mp_res$.pred)
expect_equal(mp_res[[".pred_No"]], pruned_cls_pred)
+
+ expect_error(
+ multi_predict(reg_fit, newdata = mtcars[1:4, -1], num_terms = 5),
+ "Did you mean"
+ )
})
diff --git a/tests/testthat/test_mlp_keras.R b/tests/testthat/test_mlp_keras.R
index 9e1a55448..09ae0cb61 100644
--- a/tests/testthat/test_mlp_keras.R
+++ b/tests/testthat/test_mlp_keras.R
@@ -218,7 +218,7 @@ test_that('multivariate nnet formula', {
data = nn_dat[-(1:5),]
)
expect_equal(length(unlist(keras::get_weights(nnet_form$fit))), 24)
- nnet_form_pred <- predict_num(nnet_form, new_data = nn_dat[1:5, -(1:3)])
+ nnet_form_pred <- predict_numeric(nnet_form, new_data = nn_dat[1:5, -(1:3)])
expect_equal(ncol(nnet_form_pred), 3)
expect_equal(nrow(nnet_form_pred), 5)
expect_equal(names(nnet_form_pred), c("V1", "V2", "V3"))
@@ -233,7 +233,7 @@ test_that('multivariate nnet formula', {
y = nn_dat[-(1:5), 1:3 ]
)
expect_equal(length(unlist(keras::get_weights(nnet_xy$fit))), 24)
- nnet_form_xy <- predict_num(nnet_xy, new_data = nn_dat[1:5, -(1:3)])
+ nnet_form_xy <- predict_numeric(nnet_xy, new_data = nn_dat[1:5, -(1:3)])
expect_equal(ncol(nnet_form_xy), 3)
expect_equal(nrow(nnet_form_xy), 5)
expect_equal(names(nnet_form_xy), c("V1", "V2", "V3"))
diff --git a/tests/testthat/test_mlp_nnet.R b/tests/testthat/test_mlp_nnet.R
index 24dd3fa9e..a112086fe 100644
--- a/tests/testthat/test_mlp_nnet.R
+++ b/tests/testthat/test_mlp_nnet.R
@@ -141,7 +141,7 @@ test_that('nnet regression prediction', {
xy_pred <- predict(xy_fit$fit, newdata = mtcars[1:8, -1])[,1]
xy_pred <- unname(xy_pred)
- expect_equal(xy_pred, predict_num(xy_fit, new_data = mtcars[1:8, -1]))
+ expect_equal(xy_pred, predict_numeric(xy_fit, new_data = mtcars[1:8, -1]))
form_fit <- fit(
car_basic,
@@ -152,7 +152,7 @@ test_that('nnet regression prediction', {
form_pred <- predict(form_fit$fit, newdata = mtcars[1:8, -1])[,1]
form_pred <- unname(form_pred)
- expect_equal(form_pred, predict_num(form_fit, new_data = mtcars[1:8, -1]))
+ expect_equal(form_pred, predict_numeric(form_fit, new_data = mtcars[1:8, -1]))
})
# ------------------------------------------------------------------------------
@@ -175,7 +175,7 @@ test_that('multivariate nnet formula', {
data = nn_dat[-(1:5),]
)
expect_equal(length(nnet_form$fit$wts), 24)
- nnet_form_pred <- predict_num(nnet_form, new_data = nn_dat[1:5, -(1:3)])
+ nnet_form_pred <- predict_numeric(nnet_form, new_data = nn_dat[1:5, -(1:3)])
expect_equal(ncol(nnet_form_pred), 3)
expect_equal(nrow(nnet_form_pred), 5)
expect_equal(names(nnet_form_pred), c("V1", "V2", "V3"))
@@ -192,7 +192,7 @@ test_that('multivariate nnet formula', {
y = nn_dat[-(1:5), 1:3 ]
)
expect_equal(length(nnet_xy$fit$wts), 24)
- nnet_form_xy <- predict_num(nnet_xy, new_data = nn_dat[1:5, -(1:3)])
+ nnet_form_xy <- predict_numeric(nnet_xy, new_data = nn_dat[1:5, -(1:3)])
expect_equal(ncol(nnet_form_xy), 3)
expect_equal(nrow(nnet_form_xy), 5)
expect_equal(names(nnet_form_xy), c("V1", "V2", "V3"))
diff --git a/tests/testthat/test_multinom_reg_glmnet.R b/tests/testthat/test_multinom_reg_glmnet.R
index c658feb6f..517d5f28b 100644
--- a/tests/testthat/test_multinom_reg_glmnet.R
+++ b/tests/testthat/test_multinom_reg_glmnet.R
@@ -134,6 +134,12 @@ test_that('glmnet probabilities, mulitiple lambda', {
mult_class$.pred,
multi_predict(xy_fit, iris[rows, 1:4], penalty = lams)$.pred
)
+
+ expect_error(
+ multi_predict(xy_fit, newdata = iris[rows, 1:4], penalty = lams),
+ "Did you mean"
+ )
+
})
diff --git a/tests/testthat/test_multinom_reg_keras.R b/tests/testthat/test_multinom_reg_keras.R
new file mode 100644
index 000000000..faaa56c0f
--- /dev/null
+++ b/tests/testthat/test_multinom_reg_keras.R
@@ -0,0 +1,182 @@
+library(testthat)
+library(parsnip)
+library(rlang)
+library(tibble)
+library(dplyr)
+
+# ------------------------------------------------------------------------------
+
+context("keras logistic regression")
+source("helpers.R")
+
+# ------------------------------------------------------------------------------
+
+set.seed(352)
+dat <- iris[order(runif(nrow(iris))),]
+
+tr_dat <- dat[1:140, ]
+te_dat <- dat[141:150, ]
+
+# ------------------------------------------------------------------------------
+
+basic_mod <-
+ multinom_reg() %>%
+ set_engine("keras", epochs = 50, verbose = 0)
+
+reg_mod <-
+ multinom_reg(penalty = 0.1) %>%
+ set_engine("keras", epochs = 50, verbose = 0)
+
+ctrl <- fit_control(verbosity = 0, catch = FALSE)
+
+# ------------------------------------------------------------------------------
+
+test_that('model fitting', {
+
+ skip_if_not_installed("keras")
+
+ set.seed(257)
+ expect_error(
+ fit1 <-
+ fit_xy(
+ basic_mod,
+ control = ctrl,
+ x = tr_dat[, -5],
+ y = tr_dat$Species
+ ),
+ regexp = NA
+ )
+
+ set.seed(257)
+ expect_error(
+ fit2 <-
+ fit_xy(
+ basic_mod,
+ control = ctrl,
+ x = tr_dat[, -5],
+ y = tr_dat$Species
+ ),
+ regexp = NA
+ )
+ expect_equal(fit1, fit2)
+
+ expect_error(
+ fit(
+ basic_mod,
+ Species ~ .,
+ data = tr_dat,
+ control = ctrl
+ ),
+ regexp = NA
+ )
+
+ expect_error(
+ fit1 <-
+ fit_xy(
+ reg_mod,
+ control = ctrl,
+ x = tr_dat[, -5],
+ y = tr_dat$Species
+ ),
+ regexp = NA
+ )
+
+ expect_error(
+ fit(
+ reg_mod,
+ Species ~ .,
+ data = tr_dat,
+ control = ctrl
+ ),
+ regexp = NA
+ )
+
+})
+
+
+test_that('classification prediction', {
+
+ skip_if_not_installed("keras")
+
+ library(keras)
+
+ set.seed(257)
+ lr_fit <-
+ fit_xy(
+ basic_mod,
+ control = ctrl,
+ x = tr_dat[, -5],
+ y = tr_dat$Species
+ )
+
+ keras_raw <-
+ predict(lr_fit$fit, as.matrix(te_dat[, -5]))
+ keras_pred <-
+ tibble(.pred_class = apply(keras_raw, 1, which.max)) %>%
+ mutate(.pred_class = factor(lr_fit$lvl[.pred_class], levels = lr_fit$lvl))
+
+ parsnip_pred <- predict(lr_fit, te_dat[, -5])
+ expect_equal(as.data.frame(keras_pred), as.data.frame(parsnip_pred))
+
+ set.seed(257)
+ plrfit <-
+ fit_xy(
+ reg_mod,
+ control = ctrl,
+ x = tr_dat[, -5],
+ y = tr_dat$Species
+ )
+
+ keras_raw <-
+ predict(plrfit$fit, as.matrix(te_dat[, -5]))
+ keras_pred <-
+ tibble(.pred_class = apply(keras_raw, 1, which.max)) %>%
+ mutate(.pred_class = factor(plrfit$lvl[.pred_class], levels = plrfit$lvl))
+ parsnip_pred <- predict(plrfit, te_dat[, -5])
+ expect_equal(as.data.frame(keras_pred), as.data.frame(parsnip_pred))
+
+})
+
+
+test_that('classification probabilities', {
+
+ skip_if_not_installed("keras")
+
+ library(keras)
+
+ set.seed(257)
+ lr_fit <-
+ fit_xy(
+ basic_mod,
+ control = ctrl,
+ x = tr_dat[, -5],
+ y = tr_dat$Species
+ )
+
+ keras_pred <-
+ predict_proba(lr_fit$fit, as.matrix(te_dat[, -5])) %>%
+ as_tibble() %>%
+ setNames(paste0(".pred_", lr_fit$lvl))
+
+ parsnip_pred <- predict(lr_fit, te_dat[, -5], type = "prob")
+ expect_equal(as.data.frame(keras_pred), as.data.frame(parsnip_pred))
+
+ set.seed(257)
+ plrfit <-
+ fit_xy(
+ reg_mod,
+ control = ctrl,
+ x = tr_dat[, -5],
+ y = tr_dat$Species
+ )
+
+ keras_pred <-
+ predict_proba(plrfit$fit, as.matrix(te_dat[, -5])) %>%
+ as_tibble() %>%
+ setNames(paste0(".pred_", lr_fit$lvl))
+ parsnip_pred <- predict(plrfit, te_dat[, -5], type = "prob")
+ expect_equal(as.data.frame(keras_pred), as.data.frame(parsnip_pred))
+
+})
+
+
diff --git a/tests/testthat/test_nearest_neighbor_kknn.R b/tests/testthat/test_nearest_neighbor_kknn.R
index 8cdddd2dc..999c31842 100644
--- a/tests/testthat/test_nearest_neighbor_kknn.R
+++ b/tests/testthat/test_nearest_neighbor_kknn.R
@@ -74,7 +74,7 @@ test_that('kknn prediction', {
newdata = iris[1:5, num_pred]
)
- expect_equal(uni_pred, predict_num(res_xy, iris[1:5, num_pred]))
+ expect_equal(uni_pred, predict_numeric(res_xy, iris[1:5, num_pred]))
# nominal
res_xy_nom <- fit_xy(
@@ -105,5 +105,5 @@ test_that('kknn prediction', {
newdata = iris[1:5,]
)
- expect_equal(form_pred, predict_num(res_form, iris[1:5, c("Sepal.Width", "Species")]))
+ expect_equal(form_pred, predict_numeric(res_form, iris[1:5, c("Sepal.Width", "Species")]))
})
diff --git a/tests/testthat/test_predict_formats.R b/tests/testthat/test_predict_formats.R
index 4b4c24d77..cd10d2add 100644
--- a/tests/testthat/test_predict_formats.R
+++ b/tests/testthat/test_predict_formats.R
@@ -31,7 +31,7 @@ lr_fit_2 <-
test_that('regression predictions', {
expect_true(is_tibble(predict(lm_fit, new_data = iris[1:5,-1])))
- expect_true(is.vector(predict_num(lm_fit, new_data = iris[1:5,-1])))
+ expect_true(is.vector(predict_numeric(lm_fit, new_data = iris[1:5,-1])))
expect_equal(names(predict(lm_fit, new_data = iris[1:5,-1])), ".pred")
})
diff --git a/tests/testthat/test_rand_forest_randomForest.R b/tests/testthat/test_rand_forest_randomForest.R
index 9ae446edc..35937b244 100644
--- a/tests/testthat/test_rand_forest_randomForest.R
+++ b/tests/testthat/test_rand_forest_randomForest.R
@@ -209,6 +209,6 @@ test_that('randomForest regression prediction', {
xy_pred <- predict(xy_fit$fit, newdata = tail(mtcars))
xy_pred <- unname(xy_pred)
- expect_equal(xy_pred, predict_num(xy_fit, new_data = tail(mtcars)))
+ expect_equal(xy_pred, predict_numeric(xy_fit, new_data = tail(mtcars)))
})
diff --git a/tests/testthat/test_rand_forest_ranger.R b/tests/testthat/test_rand_forest_ranger.R
index 7e90bbc43..82d767c4b 100644
--- a/tests/testthat/test_rand_forest_ranger.R
+++ b/tests/testthat/test_rand_forest_ranger.R
@@ -229,7 +229,7 @@ test_that('ranger regression prediction', {
xy_pred <- predict(xy_fit$fit, data = tail(mtcars[, -1]))$prediction
- expect_equal(xy_pred, predict_num(xy_fit, new_data = tail(mtcars[, -1])))
+ expect_equal(xy_pred, predict_numeric(xy_fit, new_data = tail(mtcars[, -1])))
})
diff --git a/tests/testthat/test_rand_forest_spark.R b/tests/testthat/test_rand_forest_spark.R
index bcda93626..4184e6abf 100644
--- a/tests/testthat/test_rand_forest_spark.R
+++ b/tests/testthat/test_rand_forest_spark.R
@@ -58,7 +58,7 @@ test_that('spark execution', {
)
expect_error(
- spark_reg_pred_num <- predict_num(spark_reg_fit, iris_rf_te),
+ spark_reg_pred_num <- predict_numeric(spark_reg_fit, iris_rf_te),
regexp = NA
)
@@ -68,7 +68,7 @@ test_that('spark execution', {
)
expect_error(
- spark_reg_num_dup <- predict_num(spark_reg_fit_dup, iris_rf_te),
+ spark_reg_num_dup <- predict_numeric(spark_reg_fit_dup, iris_rf_te),
regexp = NA
)
diff --git a/tests/testthat/test_svm_poly.R b/tests/testthat/test_svm_poly.R
new file mode 100644
index 000000000..6aea6acbf
--- /dev/null
+++ b/tests/testthat/test_svm_poly.R
@@ -0,0 +1,270 @@
+library(testthat)
+library(parsnip)
+library(rlang)
+library(tibble)
+
+# ------------------------------------------------------------------------------
+
+context("RBF SVM")
+source("helpers.R")
+
+# ------------------------------------------------------------------------------
+
+test_that('primary arguments', {
+ basic <- svm_poly()
+ basic_kernlab <- translate(basic %>% set_engine("kernlab"))
+
+ expect_equal(
+ object = basic_kernlab$method$fit$args,
+ expected = list(
+ x = expr(missing_arg()),
+ y = expr(missing_arg()),
+ kernel = "polydot"
+ )
+ )
+
+ degree <- svm_poly(degree = 2)
+ degree_kernlab <- translate(degree %>% set_engine("kernlab"))
+ degree_obj <- expr(list())
+ degree_obj$degree <- new_empty_quosure(2)
+
+ expect_equal(
+ object = degree_kernlab$method$fit$args,
+ expected = list(
+ x = expr(missing_arg()),
+ y = expr(missing_arg()),
+ kernel = "polydot",
+ kpar = degree_obj
+ )
+ )
+
+ degree_scale <- svm_poly(degree = 2, scale_factor = 1.2)
+ degree_scale_kernlab <- translate(degree_scale %>% set_engine("kernlab"))
+ degree_scale_obj <- expr(list())
+ degree_scale_obj$degree <- new_empty_quosure(2)
+ degree_scale_obj$scale <- new_empty_quosure(1.2)
+
+ expect_equal(
+ object = degree_scale_kernlab$method$fit$args,
+ expected = list(
+ x = expr(missing_arg()),
+ y = expr(missing_arg()),
+ kernel = "polydot",
+ kpar = degree_scale_obj
+ )
+ )
+
+})
+
+test_that('engine arguments', {
+
+ kernlab_cv <- svm_poly() %>% set_engine("kernlab", cross = 10)
+
+ expect_equal(
+ object = translate(kernlab_cv, "kernlab")$method$fit$args,
+ expected = list(
+ x = expr(missing_arg()),
+ y = expr(missing_arg()),
+ cross = new_empty_quosure(10),
+ kernel = "polydot"
+ )
+ )
+
+})
+
+
+test_that('updating', {
+
+ expr1 <- svm_poly() %>% set_engine("kernlab", cross = 10)
+ expr1_exp <- svm_poly(degree = 1) %>% set_engine("kernlab", cross = 10)
+
+ expr2 <- svm_poly(degree = varying()) %>% set_engine("kernlab")
+ expr2_exp <- svm_poly(degree = varying(), scale_factor = 1) %>% set_engine("kernlab")
+
+ expr3 <- svm_poly(degree = 2, scale_factor = varying()) %>% set_engine("kernlab")
+ expr3_exp <- svm_poly(degree = 3) %>% set_engine("kernlab")
+
+ expect_equal(update(expr1, degree = 1), expr1_exp)
+ expect_equal(update(expr2, scale_factor = 1), expr2_exp)
+ expect_equal(update(expr3, degree = 3, fresh = TRUE), expr3_exp)
+})
+
+test_that('bad input', {
+ expect_error(svm_poly(mode = "reallyunknown"))
+ expect_error(translate(svm_poly() %>% set_engine( NULL)))
+})
+
+# ------------------------------------------------------------------------------
+
+reg_mod <-
+ svm_poly(degree = 1, cost = 1/4) %>%
+ set_engine("kernlab") %>%
+ set_mode("regression")
+
+cls_mod <-
+ svm_poly(degree = 2, cost = 1/8) %>%
+ set_engine("kernlab") %>%
+ set_mode("classification")
+
+ctrl <- fit_control(verbosity = 0, catch = FALSE)
+
+# ------------------------------------------------------------------------------
+
+test_that('svm poly regression', {
+
+ skip_if_not_installed("kernlab")
+
+ expect_error(
+ fit_xy(
+ reg_mod,
+ control = ctrl,
+ x = iris[,2:4],
+ y = iris$Sepal.Length
+ ),
+ regexp = NA
+ )
+
+ expect_error(
+ fit(
+ reg_mod,
+ Sepal.Length ~ .,
+ data = iris[, -5],
+ control = ctrl
+ ),
+ regexp = NA
+ )
+
+})
+
+
+test_that('svm poly regression prediction', {
+
+ skip_if_not_installed("kernlab")
+
+ library(kernlab)
+
+ reg_form <-
+ fit(
+ reg_mod,
+ Sepal.Length ~ .,
+ data = iris[, -5],
+ control = ctrl
+ )
+
+ # kern_pred <-
+ # predict(reg_form$fit, iris[1:3, -c(1, 5)]) %>%
+ # as_tibble() %>%
+ # setNames(".pred")
+ kern_pred <-
+ structure(
+ list(
+ .pred = c(5.02154233477783, 4.71496213707127, 4.78370369917621)),
+ row.names = c(NA,-3L),
+ class = c("tbl_df", "tbl", "data.frame")
+ )
+
+ parsnip_pred <- predict(reg_form, iris[1:3, -c(1, 5)])
+ expect_equal(as.data.frame(kern_pred), as.data.frame(parsnip_pred))
+
+
+ reg_xy_form <-
+ fit_xy(
+ reg_mod,
+ x = iris[, 2:4],
+ y = iris$Sepal.Length,
+ control = ctrl
+ )
+ expect_equal(reg_form$fit, reg_xy_form$fit)
+
+ parsnip_xy_pred <- predict(reg_xy_form, iris[1:3, -c(1, 5)])
+ expect_equal(as.data.frame(kern_pred), as.data.frame(parsnip_xy_pred))
+})
+
+# ------------------------------------------------------------------------------
+
+test_that('svm poly classification', {
+
+ skip_if_not_installed("kernlab")
+
+ expect_error(
+ fit_xy(
+ cls_mod,
+ control = ctrl,
+ x = iris[, -5],
+ y = iris$Species
+ ),
+ regexp = NA
+ )
+
+ expect_error(
+ fit(
+ cls_mod,
+ Species ~ .,
+ data = iris,
+ control = ctrl
+ ),
+ regexp = NA
+ )
+
+})
+
+
+test_that('svm poly classification probabilities', {
+
+ skip_if_not_installed("kernlab")
+
+ library(kernlab)
+ ind <- c(1, 51, 101)
+
+ set.seed(34562)
+ cls_form <-
+ fit(
+ cls_mod,
+ Species ~ .,
+ data = iris,
+ control = ctrl
+ )
+
+ # kern_class <-
+ # tibble(.pred_class = predict(cls_form$fit, iris[ind, -5]))
+
+ kern_class <-
+ structure(
+ list(
+ .pred_class =
+ structure(1:3, .Label = c("setosa", "versicolor", "virginica"), class = "factor")),
+ row.names = c(NA, -3L), class = c("tbl_df", "tbl", "data.frame"))
+
+ parsnip_class <- predict(cls_form, iris[ind, -5])
+ expect_equal(kern_class, parsnip_class)
+
+ set.seed(34562)
+ cls_xy_form <-
+ fit_xy(
+ cls_mod,
+ x = iris[, 1:4],
+ y = iris$Species,
+ control = ctrl
+ )
+ expect_equal(cls_form$fit, cls_xy_form$fit)
+
+ # kern_probs <-
+ # predict(cls_form$fit, iris[ind, -5], type = "probabilities") %>%
+ # as_tibble() %>%
+ # setNames(c('.pred_setosa', '.pred_versicolor', '.pred_virginica'))
+
+ kern_probs <-
+ structure(
+ list(
+ .pred_setosa = c(0.982990083267231, 0.0167077303224448, 0.00930879923686657),
+ .pred_versicolor = c(0.00417116710624842, 0.946131931665357, 0.0015524073332013),
+ .pred_virginica = c(0.0128387496265202, 0.0371603380121978, 0.989138793429932)),
+ row.names = c(NA,-3L),
+ class = c("tbl_df", "tbl", "data.frame"))
+
+ parsnip_probs <- predict(cls_form, iris[ind, -5], type = "prob")
+ expect_equal(as.data.frame(kern_probs), as.data.frame(parsnip_probs))
+
+ parsnip_xy_probs <- predict(cls_xy_form, iris[ind, -5], type = "prob")
+ expect_equal(as.data.frame(kern_probs), as.data.frame(parsnip_xy_probs))
+})
diff --git a/tests/testthat/test_svm_rbf.R b/tests/testthat/test_svm_rbf.R
new file mode 100644
index 000000000..61261e0d0
--- /dev/null
+++ b/tests/testthat/test_svm_rbf.R
@@ -0,0 +1,245 @@
+library(testthat)
+library(parsnip)
+library(rlang)
+
+# ------------------------------------------------------------------------------
+
+context("poly SVM")
+source("helpers.R")
+
+# ------------------------------------------------------------------------------
+
+test_that('primary arguments', {
+ basic <- svm_rbf()
+ basic_kernlab <- translate(basic %>% set_engine("kernlab"))
+
+ expect_equal(
+ object = basic_kernlab$method$fit$args,
+ expected = list(
+ x = expr(missing_arg()),
+ y = expr(missing_arg()),
+ kernel = "rbfdot"
+ )
+ )
+
+ rbf_sigma <- svm_rbf(rbf_sigma = .2)
+ rbf_sigma_kernlab <- translate(rbf_sigma %>% set_engine("kernlab"))
+ rbf_sigma_obj <- expr(list())
+ rbf_sigma_obj$sigma <- new_empty_quosure(.2)
+
+ expect_equal(
+ object = rbf_sigma_kernlab$method$fit$args,
+ expected = list(
+ x = expr(missing_arg()),
+ y = expr(missing_arg()),
+ kernel = "rbfdot",
+ kpar = rbf_sigma_obj
+ )
+ )
+
+})
+
+test_that('engine arguments', {
+
+ kernlab_cv <- svm_rbf() %>% set_engine("kernlab", cross = 10)
+
+ expect_equal(
+ object = translate(kernlab_cv, "kernlab")$method$fit$args,
+ expected = list(
+ x = expr(missing_arg()),
+ y = expr(missing_arg()),
+ cross = new_empty_quosure(10),
+ kernel = "rbfdot"
+ )
+ )
+
+})
+
+
+test_that('updating', {
+
+ expr1 <- svm_rbf() %>% set_engine("kernlab", cross = 10)
+ expr1_exp <- svm_rbf(rbf_sigma = .1) %>% set_engine("kernlab", cross = 10)
+
+ expr3 <- svm_rbf(rbf_sigma = .2) %>% set_engine("kernlab")
+ expr3_exp <- svm_rbf(rbf_sigma = .3) %>% set_engine("kernlab")
+
+ expect_equal(update(expr1, rbf_sigma = .1), expr1_exp)
+ expect_equal(update(expr3, rbf_sigma = .3, fresh = TRUE), expr3_exp)
+})
+
+test_that('bad input', {
+ expect_error(svm_rbf(mode = "reallyunknown"))
+ expect_error(translate(svm_rbf() %>% set_engine( NULL)))
+})
+
+# ------------------------------------------------------------------------------
+
+reg_mod <-
+ svm_rbf(rbf_sigma = .1, cost = 1/4) %>%
+ set_engine("kernlab") %>%
+ set_mode("regression")
+
+cls_mod <-
+ svm_rbf(rbf_sigma = .1, cost = 1/8) %>%
+ set_engine("kernlab") %>%
+ set_mode("classification")
+
+ctrl <- fit_control(verbosity = 0, catch = FALSE)
+
+# ------------------------------------------------------------------------------
+
+test_that('svm poly regression', {
+
+ skip_if_not_installed("kernlab")
+
+ expect_error(
+ fit_xy(
+ reg_mod,
+ control = ctrl,
+ x = iris[,2:4],
+ y = iris$Sepal.Length
+ ),
+ regexp = NA
+ )
+
+ expect_error(
+ fit(
+ reg_mod,
+ Sepal.Length ~ .,
+ data = iris[, -5],
+ control = ctrl
+ ),
+ regexp = NA
+ )
+
+})
+
+
+test_that('svm rbf regression prediction', {
+
+ skip_if_not_installed("kernlab")
+
+ library(kernlab)
+
+ reg_form <-
+ fit(
+ reg_mod,
+ Sepal.Length ~ .,
+ data = iris[, -5],
+ control = ctrl
+ )
+
+ # kern_pred <-
+ # predict(reg_form$fit, iris[1:3, -c(1, 5)]) %>%
+ # as_tibble() %>%
+ # setNames(".pred")
+ kern_pred <-
+ structure(
+ list(.pred = c(5.02786147259765, 4.81715220026091, 4.86817852816449)),
+ row.names = c(NA, -3L), class = c("tbl_df", "tbl", "data.frame"))
+
+ parsnip_pred <- predict(reg_form, iris[1:3, -c(1, 5)])
+ expect_equal(as.data.frame(kern_pred), as.data.frame(parsnip_pred))
+
+
+ reg_xy_form <-
+ fit_xy(
+ reg_mod,
+ x = iris[, 2:4],
+ y = iris$Sepal.Length,
+ control = ctrl
+ )
+ expect_equal(reg_form$fit, reg_xy_form$fit)
+
+ parsnip_xy_pred <- predict(reg_xy_form, iris[1:3, -c(1, 5)])
+ expect_equal(as.data.frame(kern_pred), as.data.frame(parsnip_xy_pred))
+})
+
+# ------------------------------------------------------------------------------
+
+test_that('svm rbf classification', {
+
+ skip_if_not_installed("kernlab")
+
+ expect_error(
+ fit_xy(
+ cls_mod,
+ control = ctrl,
+ x = iris[, -5],
+ y = iris$Species
+ ),
+ regexp = NA
+ )
+
+ expect_error(
+ fit(
+ cls_mod,
+ Species ~ .,
+ data = iris,
+ control = ctrl
+ ),
+ regexp = NA
+ )
+
+})
+
+
+test_that('svm rbf classification probabilities', {
+
+ skip_if_not_installed("kernlab")
+
+ library(kernlab)
+ ind <- c(1, 51, 101)
+
+ set.seed(34562)
+ cls_form <-
+ fit(
+ cls_mod,
+ Species ~ .,
+ data = iris,
+ control = ctrl
+ )
+
+ # kern_class <-
+ # tibble(.pred_class = predict(cls_form$fit, iris[ind, -5]))
+
+ kern_class <-
+ structure(list(
+ .pred_class = structure(
+ c(1L, 3L, 3L),
+ .Label = c("setosa", "versicolor", "virginica"), class = "factor")),
+ row.names = c(NA, -3L), class = c("tbl_df", "tbl", "data.frame"))
+
+ parsnip_class <- predict(cls_form, iris[ind, -5])
+ expect_equal(kern_class, parsnip_class)
+
+ set.seed(34562)
+ cls_xy_form <-
+ fit_xy(
+ cls_mod,
+ x = iris[, 1:4],
+ y = iris$Species,
+ control = ctrl
+ )
+ expect_equal(cls_form$fit, cls_xy_form$fit)
+
+ # kern_probs <-
+ # predict(cls_form$fit, iris[ind, -5], type = "probabilities") %>%
+ # as_tibble() %>%
+ # setNames(c('.pred_setosa', '.pred_versicolor', '.pred_virginica'))
+
+ kern_probs <-
+ structure(
+ list(
+ .pred_setosa = c(0.985403715135807, 0.0158818274678279, 0.00633995479908973),
+ .pred_versicolor = c(0.00818691538722139, 0.359005663318986, 0.0173471664171275),
+ .pred_virginica = c(0.00640936947697121, 0.625112509213187, 0.976312878783783)),
+ row.names = c(NA,-3L), class = c("tbl_df", "tbl", "data.frame"))
+
+ parsnip_probs <- predict(cls_form, iris[ind, -5], type = "prob")
+ expect_equal(as.data.frame(kern_probs), as.data.frame(parsnip_probs))
+
+ parsnip_xy_probs <- predict(cls_xy_form, iris[ind, -5], type = "prob")
+ expect_equal(as.data.frame(kern_probs), as.data.frame(parsnip_xy_probs))
+})
diff --git a/vignettes/articles/Models.Rmd b/vignettes/articles/Models.Rmd
index 35ea2f380..8fd627782 100644
--- a/vignettes/articles/Models.Rmd
+++ b/vignettes/articles/Models.Rmd
@@ -62,10 +62,8 @@ _How_ the model is created is related to the _engine_. In many cases, this is an
map2_dfr(engine_info$model, engine_info$engine, mod_names) %>%
dplyr::filter(!(module %in% c("libs", "fit"))) %>%
mutate(
- module = ifelse(module == "pred", "num", module),
module = ifelse(module == "confint", "conf_int", module),
module = ifelse(module == "predint", "pred_int", module),
- module = ifelse(module == "classes", "class", module),
module = paste0("`", module, "`"),
model = paste0("`", model, "()`"),
) %>%
@@ -76,5 +74,5 @@ _How_ the model is created is related to the _engine_. In many cases, this is an
collapse_rows(columns = 1)
```
-Models can be added by the user too. See the "Making a `parsnip` model from scratch" vignette.
+Models can be added by the user too. See the ["Making a `parsnip` model from scratch" vignette](Scratch.html).
diff --git a/vignettes/articles/Scratch.Rmd b/vignettes/articles/Scratch.Rmd
index 22d17a63f..ecccb90d6 100644
--- a/vignettes/articles/Scratch.Rmd
+++ b/vignettes/articles/Scratch.Rmd
@@ -155,27 +155,27 @@ mixture_da_mda_data$fit <-
)
```
-### The `pred` module
+### The `numeric` module
-This is defined only for regression models (so is not added to the list). The convention used here is very similar to the two that are detailed in the next section. For `pred`, the model requires an unnamed numeric vector output (usually).
+This is defined only for regression models (so is not added to the list). The convention used here is very similar to the two that are detailed in the next section. For `numeric`, the model requires an unnamed numeric vector output (usually).
Examples are [here](https://github.com/topepo/parsnip/blob/master/R/linear_reg_data.R) and [here](https://github.com/topepo/parsnip/blob/master/R/rand_forest_data.R).
For multivariate models, the return value should be a matrix or data frame (otherwise a vector should be the results).
-Note that the `pred` module maps to the `predict_num` function in `parsnip`. However, the user-facing `predict` function is used to generate predictions and returns a tibble with a column named `.pred` (see the example below). When creating new models, you don't have to write code for that part.
+Note that the `numeric` module maps to the `predict_numeric` function in `parsnip`. However, the user-facing `predict` function is used to generate predictions and returns a tibble with a column named `.pred` (see the example below). When creating new models, you don't have to write code for that part.
-### The `classes` module
+### The `class` module
-To make hard class predictions, the `classes` object contains the details. The elements of the list are:
+To make hard class predictions, the `class` object contains the details. The elements of the list are:
* `pre` and `post` are optional functions that can preprocess the data being fed to the prediction code and to postprocess the raw output of the predictions. These won't be need for this example, but a section below has examples of how these can be used when the model code is not easy to use. If the data being predicted has a simple type requirement, you can avoid using a `pre` function with the `args` below.
* `func` is the prediction function (in the same format as above). In many cases, packages have a predict method for their model's class but this is typically not exported. In this case (and the example below), it is simple enough to make a generic call to `predict` with no associated package.
* `args` is a list of arguments to pass to the prediction function. These will mostly likely be wrapped in `rlang::expr` so that they are not evaluated when defining the method. For `mda`, the code would be `predict(object, newdata, type = "class")`. What is actually given to the function is the `parsnip` model fit object, which includes a sub-object called `fit` and this houses the `mda` model object. If the data need to be a matrix or data frame, you could also use `new_data = quote(as.data.frame(new_data))` and so on.
-```{r mda-classes}
-mixture_da_mda_data$classes <-
+```{r mda-class}
+mixture_da_mda_data$class <-
list(
pre = NULL,
post = NULL,
@@ -196,14 +196,14 @@ mixture_da_mda_data$classes <-
The `predict_class` function will expect the result to be an unnamed character string or factor. This will be coerced to a factor with the same levels as the original data. As with the `pred` module, the user doesn't call `predict_class` but uses `predict` instead and this produces a tibble with a column named `.pred_class` [per the model guidlines](https://tidymodels.github.io/model-implementation-principles/model-predictions.html#return-values).
-### The `prob` module
+### The `classprob` module
-This defines the class probabilities (if they can be computed). The format is identical to the `classes` module but the output is expected to be a tibble with columns for each factor level.
+This defines the class probabilities (if they can be computed). The format is identical to the `class` module but the output is expected to be a tibble with columns for each factor level.
As an example of the `post` function, the data frame created by `mda:::predict.mda` will be converted to a tibble. The arguments are `x` (the raw results coming from the predict method) and `object` (the `parsnip` model fit object). The latter has a sub-object called `lvl` which is a character string of the outcome's factor levels (if any).
-```{r mda-prob}
-mixture_da_mda_data$prob <-
+```{r mda-classprob}
+mixture_da_mda_data$classprob <-
list(
pre = NULL,
post = function(x, object) {
@@ -263,9 +263,9 @@ There are various things that came to mind while writing this document.
### Do I have to return a simple vector for `predict_num` and `predict_class`?
-Previously, when discussing the `pred` information:
+Previously, when discussing the `numeric` information:
-> For `pred`, the model requires an unnamed numeric vector output **(usually)**.
+> For `numeric`, the model requires an unnamed numeric vector output **(usually)**.
There are some occasions where a prediction for a single new sample may be multidimensional. Examples are enumerated [here](https://tidymodels.github.io/model-implementation-principles/notes.html#list-cols) but some easy examples are: