make create_learner.Rmd precommit compatible (#2824)

Author: pat-s

vignettes/tutorial/create_learner.Rmd

@@ -170,7 +170,7 @@ In addition to the data of the task, we also need the formula that describes wha
 We use the function `getTaskFormula()` to extract this from the task.
 
 ```{r, code=showFunctionDef(mlr:::trainLearner.classif.lda), eval=FALSE, tidy=TRUE}
-trainLearner.classif.lda = function(.learner, .task, .subset, .weights = NULL,  ...) {
+trainLearner.classif.lda = function(.learner, .task, .subset, .weights = NULL, ...) {
   f = getTaskFormula(.task)
   MASS::lda(f, data = getTaskData(.task, .subset), ...)
 }
@@ -198,10 +198,11 @@ It is pretty much just a straight pass-through of the arguments to the `base::pr
 ```{r, code=showFunctionDef(mlr:::predictLearner.classif.lda), eval=FALSE, tidy=TRUE, tidy.opts=list(indent=2, width.cutoff=100)}
 predictLearner.classif.lda = function(.learner, .model, .newdata, predict.method = "plug-in", ...) {
   p = predict(.model$learner.model, newdata = .newdata, method = predict.method, ...)
-  if(.learner$predict.type == "response")
+  if (.learner$predict.type == "response") {
     return(p$class)
-  else
+  } else {
     return(p$posterior)
+  }
 }
 ```
 
@@ -243,7 +244,7 @@ makeRLearner.regr.earth = function() {
 ```
 
 ```{r, code=showFunctionDef(mlr:::trainLearner.regr.earth), eval=FALSE, tidy=TRUE}
-trainLearner.regr.earth = function(.learner, .task, .subset, .weights = NULL,  ...) {
+trainLearner.regr.earth = function(.learner, .task, .subset, .weights = NULL, ...) {
   f = getTaskFormula(.task)
   earth::earth(f, data = getTaskData(.task, .subset), ...)
 }
@@ -297,29 +298,30 @@ makeRLearner.surv.coxph = function() {
 ```
 
 ```{r, code=showFunctionDef(mlr:::trainLearner.surv.coxph), eval=FALSE, tidy=TRUE, tidy.opts=list(indent=2, width.cutoff=100)}
-trainLearner.surv.coxph = function(.learner, .task, .subset, .weights = NULL,  ...) {
+trainLearner.surv.coxph = function(.learner, .task, .subset, .weights = NULL, ...) {
   f = getTaskFormula(.task)
   data = getTaskData(.task, subset = .subset)
   if (is.null(.weights)) {
     mod = survival::coxph(formula = f, data = data, ...)
-  } else  {
+  } else {
     mod = survival::coxph(formula = f, data = data, weights = .weights, ...)
   }
-  if (.learner$predict.type == "prob")
+  if (.learner$predict.type == "prob") {
     mod = attachTrainingInfo(mod, list(surv.range = range(getTaskTargets(.task)[, 1L])))
+  }
   mod
 }
 ```
 
 ```{r, code=showFunctionDef(mlr:::predictLearner.surv.coxph), eval=FALSE, tidy=TRUE, tidy.opts=list(indent=2, width.cutoff=100)}
 predictLearner.surv.coxph = function(.learner, .model, .newdata, ...) {
-  if(.learner$predict.type == "response") {
+  if (.learner$predict.type == "response") {
     predict(.model$learner.model, newdata = .newdata, type = "lp", ...)
   } else if (.learner$predict.type == "prob") {
     surv.range = getTrainingInfo(.model$learner.model)$surv.range
     times = seq(from = surv.range[1L], to = surv.range[2L], length.out = 1000)
     t(summary(survival::survfit(.model$learner.model, newdata = .newdata,
-                se.fit = FALSE, conf.int = FALSE), times = times)$surv)
+      se.fit = FALSE, conf.int = FALSE), times = times)$surv)
   } else {
     stop("Unknown predict type")
   }
@@ -355,7 +357,7 @@ makeRLearner.cluster.FarthestFirst = function() {
 ```
 
 ```{r, code=showFunctionDef(mlr:::trainLearner.cluster.FarthestFirst), eval=FALSE, tidy=TRUE, tidy.opts=list(indent=2, width.cutoff=100)}
-trainLearner.cluster.FarthestFirst = function(.learner, .task, .subset, .weights = NULL,  ...) {
+trainLearner.cluster.FarthestFirst = function(.learner, .task, .subset, .weights = NULL, ...) {
   ctrl = RWeka::Weka_control(...)
   RWeka::FarthestFirst(getTaskData(.task, .subset), control = ctrl)
 }
@@ -459,14 +461,15 @@ This method takes the Learner (`makeLearner()`) `.learner` and the WrappedModel
 It must return the predictions in the same format as the `predictLearner()` function.
 
 ```{r, code=showFunctionDef(mlr:::getOOBPredsLearner.classif.randomForest), eval=FALSE, tidy=TRUE, tidy.opts=list(indent=2, width.cutoff=100)}
+
 ```
 
 # Registering your learner
 
 If your interface code to a new learning algorithm exists only locally, i.e., it is not (yet) merged into `mlr` or does not live in an extra package with a proper namespace you might want to register the new S3 methods to make sure that these are found by, e.g., `listLearners()`.
 You can do this as follows:
 
-```{r, eval=FALSE}
+```r
 registerS3method("makeRLearner", "<awesome_new_learner_class>",
   makeRLearner.<awesome_new_learner_class>)
 registerS3method("trainLearner", "<awesome_new_learner_class>",
@@ -477,14 +480,14 @@ registerS3method("predictLearner", "<awesome_new_learner_class>",
 
 If you have written more methods, for example in order to extract feature importance values or out-of-bag predictions these also need to be registered in the same manner, for example:
 
-```{r, eval=FALSE}
+```r
 registerS3method("getFeatureImportanceLearner", "<awesome_new_learner_class>",
   getFeatureImportanceLearner.<awesome_new_learner_class>)
 ```
 
 For the new learner to work with parallelization, you may have to export the new methods explicitly:
 
-```{r, eval=FALSE}
+```r
 parallelExport("trainLearner.<awesome_new_learner_class>",
   "predictLearner.<awesome_new_learner_class>")
 ```