@@ -32,7 +32,7 @@

 #' Set to NULL or "all" if all features should be used.

 #' @param selectionMethod Default: \code{"auto"}. A character vector of feature selection methods to compare. If a named character vector with names corresponding to different assays, 

 #' and performing multiview classification, the respective selection methods will be used on each assay. If \code{"auto"}, t-test (two categories) / F-test (three or more categories) ranking

-#' and top \code{nFeatures} optimisation is done. Otherwise, the ranking method is per-feature Cox proportional hazards p-value. \code{NULL} is also a valid value, meaning that no

+#' and top \code{nFeatures} optimisation is done. Otherwise, the ranking method is per-feature Cox proportional hazards p-value. \code{"none"} is also a valid value, meaning that no

 #' indepedent feature selection will be performed (but implicit selection might still happen with the classifier).

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

 #' @param performanceType Default: \code{"auto"}. If \code{"auto"}, then balanced accuracy for classification or C-index for survival. Otherwise, any one of the

@@ -114,7 +114,7 @@ setMethod("crossValidate", "DataFrame",

           {

               # Check that data is in the right format, if not already done for MultiAssayExperiment input.

-              if(!"assay" %in% S4Vectors::mcols(measurements)) # Assay is put there by prepareData for MultiAssayExperiment, skip if present. 

+              if(!"assay" %in% colnames(S4Vectors::mcols(measurements))) # Assay is put there by prepareData for MultiAssayExperiment, skip if present. 

               {

                 prepParams <- list(measurements, outcome, clinicalPredictors)

                 if("prepare" %in% names(extraParams))

@@ -594,7 +594,6 @@ generateModellingParams <- function(assayIDs,

     }    

     selectionMethod <- unlist(selectionMethod)

-    if(is.null(selectionMethod)) selectionMethod <- "none"

     if(selectionMethod != "none")

     {

@@ -6,20 +6,26 @@ elasticNetGLMtrainInterface <- function(measurementsTrain, classesTrain, lambda

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

   if(verbose == 3)

     message("Fitting elastic net regularised GLM classifier to data.")

-    

-  measurementsMatrix <- glmnet::makeX(as(measurementsTrain, "data.frame"))

-  fitted <- glmnet::glmnet(measurementsMatrix, classesTrain, family = "multinomial", ...)

+  # One-hot encoding needed.    

+  measurementsTrain <- MatrixModels::model.Matrix(~ 0 + ., data = measurementsTrain)

+  fitted <- glmnet::glmnet(measurementsTrain, classesTrain, family = "multinomial", ...)

+  

   if(is.null(lambda)) # fitted has numerous models for automatically chosen lambda values.

-  { # Pick one lambda based on resubstitution performance.

-    bestLambda <- fitted[["lambda"]][which.min(sapply(fitted[["lambda"]], function(lambda) # Largest Lambda with minimum balanced error rate.

+  { # Pick one lambda based on resubstitution performance. But not the one that makes all variables excluded from model.

+      lambdaConsider <- colSums(as.matrix(fitted[["beta"]][[1]])) != 0

+    bestLambda <- fitted[["lambda"]][lambdaConsider][which.min(sapply(fitted[["lambda"]][lambdaConsider], function(lambda) # Largest Lambda with minimum balanced error rate.

     {

-      classPredictions <- factor(as.character(predict(fitted, measurementsMatrix, s = lambda, type = "class")), levels = fitted[["classnames"]])

+      classPredictions <- factor(as.character(predict(fitted, measurementsTrain, s = lambda, type = "class")), levels = fitted[["classnames"]])

       calcExternalPerformance(classesTrain, classPredictions, "Balanced Error")

     }))[1]]

     attr(fitted, "tune") <- list(lambda = bestLambda)

   }

+  

+  attr(fitted, "featureNames") <- colnames(measurementsTrain)

+  attr(fitted, "featureGroups") <- measurementsTrain@assign

+  

   fitted

 }

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

@@ -28,6 +34,8 @@ attr(elasticNetGLMtrainInterface, "name") <- "elasticNetGLMtrainInterface"

 elasticNetGLMpredictInterface <- function(model, measurementsTest, lambda, ..., returnType = c("both", "class", "score"), verbose = 3)

 { # ... just consumes emitted tuning variables from .doTrain which are unused.

   returnType <- match.arg(returnType)

+  # One-hot encoding needed.    

+  measurementsTest <- MatrixModels::model.Matrix(~ 0 + ., data = measurementsTest)

   # Ensure that testing data has same columns names in same order as training data.

   # Remove those annoying backquotes which glmnet adds if variables have spaces in names.

@@ -41,11 +49,11 @@ elasticNetGLMpredictInterface <- function(model, measurementsTest, lambda, ...,

   if(missing(lambda)) # Tuning parameters are not passed to prediction functions.

     lambda <- attr(model, "tune")[["lambda"]] # Sneak it in as an attribute on the model.

-  testMatrix <- glmnet::makeX(as(measurementsTest, "data.frame"))

-  testMatrix <- testMatrix[, rownames(model[["beta"]][[1]])]

-  classPredictions <- factor(as.character(predict(model, testMatrix, s = lambda, type = "class")), levels = model[["classnames"]])

-  classScores <- predict(model, testMatrix, s = lambda, type = "response")[, , 1]

+  measurementsTest <- measurementsTest[, rownames(model[["beta"]][[1]])]

+  

+  classPredictions <- factor(as.character(predict(model, measurementsTest, s = lambda, type = "class")), levels = model[["classnames"]])

+  classScores <- predict(model, measurementsTest, s = lambda, type = "response")[, , 1]

   if(is.matrix(classScores))

     classScores <- classScores[, model[["classnames"]]]

@@ -61,16 +69,20 @@ elasticNetGLMpredictInterface <- function(model, measurementsTest, lambda, ...,

 #

 # Get selected features (i.e. non-zero model coefficients)

 #

+# Note: Need to convert back to actual features when factors were expanded into

+# multiple columns using indicator variables.

+#

 ################################################################################

 elasticNetFeatures <- function(model)

                       {

-                        inputFeatures <- rownames(model[["beta"]][[1]])            

                         # Floating point numbers test for equality.

                         whichCoefficientColumn <- which(abs(model[["lambda"]] - attr(model, "tune")[["lambda"]]) < 0.00001)[1]

                         coefficientsUsed <- sapply(model[["beta"]], function(classCoefficients) classCoefficients[, whichCoefficientColumn])

                         featureScores <- rowSums(abs(coefficientsUsed))

-                        rankedFeaturesIndices <- order(featureScores, decreasing = TRUE)

-                        selectedFeaturesIndices <- which(featureScores != 0)

+                        featureGroups <- attr(model, "featureGroups")[match(names(featureScores), attr(model, "featureNames"))]

+                        groupScores <- unname(by(featureScores, featureGroups, max))

+                        rankedFeaturesIndices <- order(groupScores, decreasing = TRUE)

+                        selectedFeaturesIndices <- which(groupScores != 0)

                         list(rankedFeaturesIndices, selectedFeaturesIndices)

                       }

\ No newline at end of file

@@ -5,43 +5,28 @@ setGeneric("precisionPathwayTrain", function(measurements, class, ...)

 #' @rdname precisionPathwayTrain

 #' @export

-setMethod("precisionPathwayTrain", "MultiAssayExperiment", 

-          function(measurements, class, clinicalPredictors = NULL, ..., fixedAssays = "clinical",

-                   confidenceCutoff = 0.8, minAssaySamples = 10,

-                   nFeatures = 20, selectionMethod = setNames(c(NULL, rep("t-test", length(measurements))), c("clinical", names(measurements))),

+setMethod("precisionPathwayTrain", "MultiAssayExperimentOrList", 

+          function(measurements, class, clinicalPredictors = NULL, maxMissingProp = 0.0, topNvariance = NULL,

+                   fixedAssays = "clinical", confidenceCutoff = 0.8, minAssaySamples = 10,

+                   nFeatures = 20, selectionMethod = setNames(c("none", rep("t-test", length(measurements))), c("clinical", names(measurements))),

                    classifier = setNames(c("elasticNetGLM", rep("randomForest", length(measurements))), c("clinical", names(measurements))),

                    nFolds = 5, nRepeats = 20, nCores = 1)

           {

-              prepArgs <- list(measurements, class, clinicalPredictors)              

-              extraInputs <- list(...)

-              prepExtras <- numeric()

-              if(length(extraInputs) > 0)

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

-              if(length(prepExtras) > 0)

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

-              measurementsAndClass <- do.call(prepareData, prepArgs)

-              

-             .precisionPathwayTrain(measurementsAndClass[["measurements"]], measurementsAndClass[["outcome"]],

-                                    fixedAssays = fixedAssays, confidenceCutoff = confidenceCutoff,

-                                    minAssaySamples = minAssaySamples, nFeatures = nFeatures,

-                                    selectionMethod = selectionMethod, classifier = classifier,

-                                    nFolds = nFolds, nRepeats = nRepeats, nCores = nCores)

-          })

-

-#' @rdname precisionPathwayTrain

-#' @export

-setMethod("precisionPathwayTrain", "list", 

-          function(measurements, class, clinicalPredictors = NULL, fixedAssays = "clinical",

-                   confidenceCutoff = 0.8, minAssaySamples = 10,

-                   nFeatures = 20, selectionMethod = setNames(c(NULL, rep("t-test", length(measurements))), c("clinical", names(measurements))),

-                   classifier = setNames(c("elasticNetGLM", rep("randomForest", length(measurements))), c("clinical", names(measurements))),

-                   nFolds = 5, nRepeats = 20, nCores = 1, ...)

-          {

-            # One of the tables must be named "clinical".

-            if (!any(names(measurements) == "clinical"))

-              stop("One of the tables must be named \"clinical\".")

+            if(is.list(measurements)) # Ensure plain list has clinical data.

+            {

+              # One of the tables must be named "clinical".

+              if (!any(names(measurements) == "clinical"))

+                stop("One of the tables must be named \"clinical\".")

+            }

+            prepArgs <- list(measurements, outcomeColumns = class, clinicalPredictors = clinicalPredictors,

+                             maxMissingProp = maxMissingProp, topNvariance = topNvariance)

+            measurementsAndClass <- do.call(prepareData, prepArgs)

-            .precisionPathwayTrain(measurements = combined_df, class = class)

+            .precisionPathwayTrain(measurementsAndClass[["measurements"]], measurementsAndClass[["outcome"]],

+                                   fixedAssays = fixedAssays, confidenceCutoff = confidenceCutoff,

+                                   minAssaySamples = minAssaySamples, nFeatures = nFeatures,

+                                   selectionMethod = selectionMethod, classifier = classifier,

+                                   nFolds = nFolds, nRepeats = nRepeats, nCores = nCores)

           })

 # Internal method which carries out all of the processing, obtaining reformatted data from the

@@ -52,25 +37,13 @@ setMethod("precisionPathwayTrain", "list",

                    classifier = setNames(c("elasticNetGLM", rep("randomForest", length(measurements))), c("clinical", names(measurements))),

                    nFolds = 5, nRepeats = 20, nCores = 1, ...)

           {

-            # Step 1: Separate the vector classes from the table of measurements, if not already separate.

-            prepArgs <- list(measurements, class, clinicalPredictors)              

-            extraInputs <- list(...)

-            prepExtras <- numeric()

-            if(length(extraInputs) > 0)

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

-            if(length(prepExtras) > 0)

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

-            

-            measurementsAndClass <- do.call(prepareData, prepArgs)

-            measurements <- measurementsAndClass[["measurements"]]

-            class <- measurementsAndClass[["outcome"]]

-            # Step 2: Determine all valid permutations of assays, taking into account the

+            # Step 1: Determine all valid permutations of assays, taking into account the

             # assays to be used and which assays, if any, must be included.

             assayIDs <- unique(S4Vectors::mcols(measurements)[["assay"]])

             assaysPermutations <- .permutations(assayIDs, fixed = data.frame(seq_along(fixedAssays), fixedAssays))

-            # Step 3: Build a classifier for each assay using all of the samples.

+            # Step 2: Build a classifier for each assay using all of the samples.

             modelsList <- crossValidate(measurements, class, nFeatures, selectionMethod,

                                         classifier = classifier, nFolds = nFolds,

                                         nRepeats = nRepeats, nCores = nCores)

@@ -180,10 +180,10 @@ setMethod("prepareData", "MultiAssayExperiment",

   if(is.null(clinicalPredictors))

     stop("'clinicalPredictors' must be a vector of informative clinical features (i.e. not sample IDs, sampling dates, etc.) to consider for classification.")      

-  if(any(anyReplicated(measurements[, , omicsTargets])))

+  if(any(anyReplicated(measurements)))

     stop("Data set contains replicates. Please remove or average replicate observations and try again.")

-  if(is.null(outcomeColums))

+  if(is.null(outcomeColumns))

     stop("'outcomeColumns' is a mandatory parameter but was not specified.")

   if(!all(outcomeColumns %in% colnames(MultiAssayExperiment::colData(measurements))))

@@ -195,6 +195,7 @@ setMethod("prepareData", "MultiAssayExperiment",

   dataTable <- MultiAssayExperiment::wideFormat(measurements, colDataCols = union(clinicalPredictors, outcomeColumns))

   rownames(dataTable) <- dataTable[, "primary"]

   S4Vectors::mcols(dataTable)[, "sourceName"] <- gsub("colDataCols", "clinical", S4Vectors::mcols(dataTable)[, "sourceName"])

+  dataTable <- dataTable[, -match("primary", colnames(dataTable))]

   colnames(S4Vectors::mcols(dataTable))[1] <- "assay"

   # Sample information variable names not included in column metadata of wide table but only as row names of it.

@@ -129,7 +129,7 @@ Set to NULL or "all" if all features should be used.}

 \item{selectionMethod}{Default: \code{"auto"}. A character vector of feature selection methods to compare. If a named character vector with names corresponding to different assays, 

 and performing multiview classification, the respective selection methods will be used on each assay. If \code{"auto"}, t-test (two categories) / F-test (three or more categories) ranking

-and top \code{nFeatures} optimisation is done. Otherwise, the ranking method is per-feature Cox proportional hazards p-value. \code{NULL} is also a valid value, meaning that no

+and top \code{nFeatures} optimisation is done. Otherwise, the ranking method is per-feature Cox proportional hazards p-value. \code{"none"} is also a valid value, meaning that no

 indepedent feature selection will be performed (but implicit selection might still happen with the classifier).}

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