@@ -3,8 +3,8 @@ Type: Package

 Title: A framework for cross-validated classification problems, with

        applications to differential variability and differential

        distribution testing

-Version: 3.1.20

-Date: 2022-10-07

+Version: 3.1.21

+Date: 2022-10-14

 Author: Dario Strbenac, Ellis Patrick, John Ormerod, Graham Mann, Jean Yang

 Maintainer: Dario Strbenac <dario.strbenac@sydney.edu.au>

 VignetteBuilder: knitr

@@ -912,18 +912,32 @@ train.data.frame <- function(x, outcomeTrain, ...)

 #' @rdname crossValidate

 #' @param assayIDs A character vector for assays to train with. Special value \code{"all"}

 #' uses all assays in the input object.

+#' @param performanceType Performance metric to optimise if classifier has any tuning parameters.

 #' @method train DataFrame

 #' @export

-train.DataFrame <- function(x, outcomeTrain, classifier = "randomForest", multiViewMethod = "none", assayIDs = "all", ...) # ... for prepareData.

+train.DataFrame <- function(x, outcomeTrain, classifier = "randomForest", performanceType = "auto",

+                            multiViewMethod = "none", assayIDs = "all", ...) # ... for prepareData.

                    {

               prepArgs <- list(x, outcomeTrain)

               extraInputs <- list(...)

               prepExtras <- numeric()

               if(length(extraInputs) > 0)

-                prepExtras <- which(names(extrasInputs) %in% .ClassifyRenvir[["prepareDataFormals"]])

+                prepExtras <- which(names(extraInputs) %in% .ClassifyRenvir[["prepareDataFormals"]])

               if(length(prepExtras) > 0)

                 prepArgs <- append(prepArgs, extraInputs[prepExtras])

               measurementsAndOutcome <- do.call(prepareData, prepArgs)

+              

+              # Ensure performance type is one of the ones that can be calculated by the package.

+              if(!performanceType %in% c("auto", .ClassifyRenvir[["performanceTypes"]]))

+                stop(paste("performanceType must be one of", paste(c("auto", .ClassifyRenvir[["performanceTypes"]]), collapse = ", "), "but is", performanceType))

+              

+              if(performanceType == "auto")

+              {

+                if(is.character(outcomeTrain) && (length(outcomeTrain) == 1 || length(outcomeTrain) == nrow(x)) || is.factor(outcomeTrain))

+                  performanceType <- "Balanced Accuracy"

+                else performanceType <- "C-index"

+              }

+              

               measurements <- measurementsAndOutcome[["measurements"]]

               outcomeTrain <- measurementsAndOutcome[["outcome"]]

@@ -939,11 +953,13 @@ train.DataFrame <- function(x, outcomeTrain, classifier = "randomForest", multiV

                           # Loop over assays

                           sapply(classifier[[assayIndex]], function(classifierForAssay) {

                               # Loop over classifiers

+                              

                                   measurementsUse <- measurements

                                   if(assayIndex != 1) measurementsUse <- measurements[, mcols(measurements)[, "assay"] == assayIndex, drop = FALSE]

                                   classifierParams <- .classifierKeywordToParams(classifierForAssay)

-                                  classifierParams$trainParams@tuneParams <- c(classifierParams$trainParams@tuneParams, performanceType = performanceType)

+                                  if(!is.null(classifierParams$trainParams@tuneParams))

+                                    classifierParams$trainParams@tuneParams <- c(classifierParams$trainParams@tuneParams, performanceType = performanceType)

                                   modellingParams <- ModellingParams(balancing = "none", selectParams = NULL,

                                                                trainParams = classifierParams$trainParams, predictParams = classifierParams$predictParams)

@@ -1019,7 +1035,6 @@ train.DataFrame <- function(x, outcomeTrain, classifier = "randomForest", multiV

 #' @rdname crossValidate

 #' @method train list

 #' @export

-# Each of the first four variables are named lists with names of assays.

 train.list <- function(x, outcomeTrain, ...)

               {

                 # Check data type is valid

@@ -1062,13 +1077,13 @@ train.MultiAssayExperiment <- function(x, outcomeColumns, ...)

               extraInputs <- list(...)

               prepExtras <- trainExtras <- numeric()

               if(length(extraInputs) > 0)

-                prepExtras <- which(names(extrasInputs) %in% .ClassifyRenvir[["prepareDataFormals"]])

+                prepExtras <- which(names(extraInputs) %in% .ClassifyRenvir[["prepareDataFormals"]])

               if(length(prepExtras) > 0)

                 prepArgs <- append(prepArgs, extraInputs[prepExtras])

               measurementsAndOutcome <- do.call(prepareData, prepArgs)

               trainArgs <- list(measurementsAndOutcome[["measurements"]], measurementsAndOutcome[["outcome"]])

               if(length(extraInputs) > 0)

-                trainExtras <- which(!names(extrasInputs) %in% .ClassifyRenvir[["prepareDataFormals"]])

+                trainExtras <- which(!names(extraInputs) %in% .ClassifyRenvir[["prepareDataFormals"]])

               if(length(trainExtras) > 0)

                 trainArgs <- append(trainArgs, extraInputs[trainExtras])

               do.call(train, trainArgs)

@@ -1101,10 +1116,8 @@ predict.trainedByClassifyR <- function(object, newData, ...)

               # Some classifiers dangerously use positional matching rather than column name matching.

               # newData columns are sorted so that the right column ordering is guaranteed.

             } else {stop("'newData' is not one of the valid data types. It is of type ", class(newData), '.')}

-  if(is(object, "ClassifyResult"))

-  {

-    object@modellingParams@predictParams@predictor(object@finalModel[[1]], newData)

-  } else if (is(object, "listOfModels")) { # Object is itself a trained model and it is assumed that a predict method is defined for it.

-    mapply(function(model, assay) predict(model, assay), object, newData, SIMPLIFY = FALSE)

-  } else predict(object, newData)

+

+    if (is(object, "listOfModels")) 

+         mapply(function(model, assay) predict(model, assay), object, newData, SIMPLIFY = FALSE)

+    else predict(object, newData) # Object is itself a trained model and it is assumed that a predict method is defined for it.

 }

@@ -29,7 +29,7 @@ DLDApredictInterface <- function(model, measurementsTest, returnType = c("both",

     message("Predicting classes using trained DLDA classifier.")

   #predict(model, as.matrix(test))

-  predictions <- .predict(model, as.matrix(measurementsTest)) # Copy located in utilities.R.

+  predictions <- predict(model, as.matrix(measurementsTest)) # Copy located in utilities.R.

   switch(returnType, class = predictions[["class"]], # Factor vector.

          score = predictions[["posterior"]][, model[["groups"]]], # Numeric matrix.

@@ -1,27 +1,28 @@

-# An Interface for randomForest Package's randomForest Function

-randomForestTrainInterface <- function(measurementsTrain, classesTrain, mTryProportion = 0.5, ..., verbose = 3)

+# An Interface for ranger Package's randomForest Function

+randomForestTrainInterface <- function(measurementsTrain, outcomeTrain, mTryProportion = 0.5, ..., verbose = 3)

 {

-  if(!requireNamespace("randomForest", quietly = TRUE))

-    stop("The package 'randomForest' could not be found. Please install it.")

+  if(!requireNamespace("ranger", quietly = TRUE))

+    stop("The package 'ranger' could not be found. Please install it.")

   if(verbose == 3)

-    message("Fitting random forest classifier to training data and making predictions on test

-            data.")

+    message("Fitting random forest classifier to training data.")

   mtry <- round(mTryProportion * ncol(measurementsTrain)) # Number of features to try.

   # Convert to base data.frame as randomForest doesn't understand DataFrame.

-  randomForest::randomForest(as(measurementsTrain, "data.frame"), classesTrain, mtry = mtry, keep.forest = TRUE, ...)

+  ranger::ranger(x = as(measurementsTrain, "data.frame"), y = outcomeTrain, mtry = mtry, importance = "impurity_corrected", ...)

 }

 attr(randomForestTrainInterface, "name") <- "randomForestTrainInterface"

-# forest is of class randomForest

+# forest is of class ranger

 randomForestPredictInterface <- function(forest, measurementsTest, ..., returnType = c("both", "class", "score"), verbose = 3)

 {

   returnType <- match.arg(returnType)

+  classes <- forest$forest$levels

   if(verbose == 3)

     message("Predicting using random forest.")  

   measurementsTest <- as.data.frame(measurementsTest)

-  classPredictions <- predict(forest, measurementsTest)

-  classScores <- predict(forest, measurementsTest, type = "vote")[, forest[["classes"]], drop = FALSE]

+  classPredictions <- predict(forest, measurementsTest)$predictions

+  classScores <- predict(forest, measurementsTest, predict.all = TRUE)[[1]]

+  classScores <- t(apply(classScores, 1, function(sampleRow) table(factor(classes[sampleRow], levels = classes)) / forest$forest$num.trees))

   switch(returnType, class = classPredictions,

          score = classScores,

          both = data.frame(class = classPredictions, classScores, check.names = FALSE))

@@ -35,7 +36,7 @@ randomForestPredictInterface <- function(forest, measurementsTest, ..., returnTy

 forestFeatures <- function(forest)

                   {

-                    rankedFeaturesIndices <- order(randomForest::importance(forest), decreasing = TRUE)

-                    selectedFeaturesIndices <- randomForest::varUsed(forest, count = FALSE)

+                    rankedFeaturesIndices <- order(ranger::importance(forest), decreasing = TRUE)

+                    selectedFeaturesIndices <- which(ranger::importance(forest) > 0)

                     list(rankedFeaturesIndices, selectedFeaturesIndices)

                   }

\ No newline at end of file

@@ -1,5 +1,5 @@

 # An Interface for xgboost Package's xgboost Function

-extremeGradientBoostingTrainInterface <- function(measurementsTrain, outcomesTrain, mTryProportion = 0.5, nrounds = 10, ..., verbose = 3)

+extremeGradientBoostingTrainInterface <- function(measurementsTrain, outcomeTrain, mTryProportion = 0.5, nrounds = 10, ..., verbose = 3)

 {

   if(!requireNamespace("xgboost", quietly = TRUE))

     stop("The package 'xgboost' could not be found. Please install it.")

@@ -12,22 +12,22 @@ extremeGradientBoostingTrainInterface <- function(measurementsTrain, outcomesTra

   isClassification <- FALSE

   numClasses <- NULL

-  if(is(outcomesTrain, "Surv")) # xgboost only knows about numeric vectors.

+  if(is(outcomeTrain, "Surv")) # xgboost only knows about numeric vectors.

   {

-    time <- outcomesTrain[, "time"]

-    event <- as.numeric(outcomesTrain[, "status"])

+    time <- outcomeTrain[, "time"]

+    event <- as.numeric(outcomeTrain[, "status"])

     if(max(event) == 2) event <- event - 1

-    outcomesTrain <- time * ifelse(event == 1, 1, -1) # Negative for censoring.

+    outcomeTrain <- time * ifelse(event == 1, 1, -1) # Negative for censoring.

     objective <- "survival:cox"

   } else { # Classification task.

     isClassification <- TRUE

-    classes <- levels(outcomesTrain)

+    classes <- levels(outcomeTrain)

     numClasses <- length(classes)

     objective <- "multi:softprob"

-    outcomesTrain <- as.numeric(outcomesTrain) - 1 # Classes are represented as 0, 1, 2, ...

+    outcomeTrain <- as.numeric(outcomeTrain) - 1 # Classes are represented as 0, 1, 2, ...

   }

-  trained <- xgboost::xgboost(measurementsTrain, outcomesTrain, objective = objective, nrounds = nrounds,

+  trained <- xgboost::xgboost(measurementsTrain, outcomeTrain, objective = objective, nrounds = nrounds,

                               num_class = numClasses, colsample_bynode = mTryProportion, verbose = 0, ...)

   if(isClassification)

   {

@@ -79,4 +79,4 @@ XGBfeatures <- function(booster)

                     rankedFeaturesIndices <- order(gains, decreasing = TRUE)

                     selectedFeaturesIndices <- indicesUsed

                     list(rankedFeaturesIndices, selectedFeaturesIndices)

-                  }

\ No newline at end of file

+                  }

@@ -1,6 +1,6 @@

 # Random Forest

 RFparams <- function() {

-    trainParams <- TrainParams(randomForestTrainInterface, tuneParams = list(mTryProportion = c(0.25, 0.33, 0.50, 0.66, 0.75, 1.00), ntree = seq(100, 500, 100)),

+    trainParams <- TrainParams(randomForestTrainInterface, tuneParams = list(mTryProportion = c(0.25, 0.33, 0.50, 0.66, 0.75, 1.00)),

                                getFeatures = forestFeatures)

     predictParams <- PredictParams(randomForestPredictInterface)

@@ -167,7 +167,7 @@

           result <- runTest(measurementsTrain, outcomeTrain, measurementsTrain, outcomeTrain,

                             crossValParams = NULL, modellingParams = modellingParams,

                             verbose = verbose, .iteration = "internal")

-          

+

           predictions <- result[["predictions"]]

           # Classifiers will use a column "class" and survival models will use a column "risk".

           if(class(predictions) == "data.frame")

@@ -222,6 +222,7 @@

                             measurementsTrain, outcomeTrain,

                             crossValParams = NULL, modellingParams,

                             verbose = verbose, .iteration = "internal")

+

           predictions <- result[["predictions"]]

           if(class(predictions) == "data.frame")

             predictedOutcome <- predictions[, "class"]

@@ -275,7 +276,7 @@

         result <- runTest(measurementsTrain, outcomeTrain, measurementsTrain, outcomeTrain,

                           crossValParams = NULL, modellingParams,

                           verbose = verbose, .iteration = "internal")

-        

+

         predictions <- result[["predictions"]]

         if(class(predictions) == "data.frame")

           predictedOutcome <- predictions[, colnames(predictions) %in% c("class", "risk")]

@@ -580,7 +581,8 @@

   obj

 }

-.predict <- function(object, newdata, ...) { # Remove once sparsediscrim is reinstated to CRAN.

+#' @method predict dlda

+predict.dlda <- function(object, newdata, ...) { # Remove once sparsediscrim is reinstated to CRAN.

   if (!inherits(object, "dlda"))  {

     stop("object not of class 'dlda'")

   }

@@ -111,6 +111,7 @@ crossValidate(measurements, outcome, ...)

   x,

   outcomeTrain,

   classifier = "randomForest",

+  performanceType = "auto",

   multiViewMethod = "none",

   assayIDs = "all",

   ...

@@ -143,8 +144,7 @@ and performing multiview classification, the respective classification methods w

 \item{selectionOptimisation}{A character of "Resubstitution", "Nested CV" or "none" specifying the approach used to optimise \code{nFeatures}.}

-\item{performanceType}{Default: \code{"auto"}. If \code{"auto"}, then balanced accuracy for classification or C-index for survival. Any one of the

-options described in \code{\link{calcPerformance}} may otherwise be specified.}

+\item{performanceType}{Performance metric to optimise if classifier has any tuning parameters.}

 \item{classifier}{A character vector of classification methods to compare. If a named character vector with names corresponding to different assays, 

 and performing multiview classification, the respective classification methods will be used on each assay.}

@@ -31,8 +31,7 @@ and performing multiview classification, the respective classification methods w

 \item{selectionOptimisation}{A character of "Resubstitution", "Nested CV" or "none" specifying the approach used to optimise \code{nFeatures}.}

-\item{performanceType}{Default: \code{"auto"}. If \code{"auto"}, then balanced accuracy for classification or C-index for survival. Any one of the

-options described in \code{\link{calcPerformance}} may otherwise be specified.}

+\item{performanceType}{Performance metric to optimise if classifier has any tuning parameters.}

 \item{classifier}{A character vector of classification methods to compare. If a named character vector with names corresponding to different assays, 

 and performing multiview classification, the respective classification methods will be used on each assay.}