1 FRESA.CAD Classifiers

1.1 GBSG2

op <- par(no.readonly = TRUE,pty="m")

data("GBSG2", package = "TH.data")

GBSG2  <- GBSG2[complete.cases(GBSG2),]
GBSG2$tgrade <- as.character(GBSG2$tgrade)
GBSG2$tgrade <- as.factor(GBSG2$tgrade)
summary(GBSG2)

GBSG2 <- subset(GBSG2,cens == 1 | GBSG2$time > 730) #Only subjects with more than three year observations
GBSG2$time <- NULL
summary(GBSG2)

GBSG2.mat <- as.data.frame(model.matrix(cens ~ .*.*.,GBSG2))
#GBSG2.mat <- as.data.frame(model.matrix(cens ~ .,GBSG2))
GBSG2.mat$`(Intercept)` <- NULL
GBSG2.mat$cens <- GBSG2$cens
GBSG2.mat[,1:ncol(GBSG2.mat)] <- sapply(GBSG2.mat,as.numeric)
fnames <- colnames(GBSG2.mat)
fnames <- str_replace_all(fnames," ","_")
fnames <- str_replace_all(fnames,"/","_")
fnames <- str_replace_all(fnames,":","_x_")
colnames(GBSG2.mat) <- fnames
table(GBSG2.mat$cens)

1.2 Training and Testing sets

par(op)
trainSamples <- sample(nrow(GBSG2.mat),0.70*nrow(GBSG2.mat))
traningSet <- GBSG2.mat[trainSamples,];
testingSet <- GBSG2.mat[-trainSamples,];

traningSetc <- traningSet
traningSetc$cens <- as.factor(traningSetc$cens)


vartoAdjust <- !(colnames(testingSet) %in% c("cens"))
cmrmat <- abs(cor(testingSet[,vartoAdjust] ,method="spearman"))
diag(cmrmat) <- 0;
gplots::heatmap.2(cmrmat,trace = "none",mar = c(10,10),col=rev(heat.colors(5)),main = "Raw Correlation",cexRow = 0.5,cexCol = 0.5,key.xlab="Spearman Correlation",xlab="Feature", ylab="Feature")



dataTrainDecorrelated <- featureDecorrelation(traningSet,outcome="cens",method="LOESS",thr=0.75,degre=2,span=1.0,family="symmetric")
dataTestDecorrelated <- featureDecorrelation(testingSet,outcome="cens",refdata=traningSet,method="LOESS",thr=0.75,degre=2,span=1.0,family="symmetric")

dataTrainDecorrelatedc <- dataTrainDecorrelated
dataTrainDecorrelatedc$cens <- as.factor(dataTrainDecorrelatedc$cens)


cmrmat2 <- abs(cor(dataTestDecorrelated[,vartoAdjust] ,method="spearman"))
diag(cmrmat2) <- 0;
gplots::heatmap.2(cmrmat2,trace = "none",mar = c(10,10),col=rev(heat.colors(5)),main = "Decorrelation",cexRow = 0.5,cexCol = 0.5,key.xlab="Spearman Correlation",xlab="Feature", ylab="Feature")

1.3 ML-Methods in FRESA.CAD


par(mfrow = c(2,2),cex = 0.5);

BSWiMS_ml <- BSWiMS.model(cens~.,traningSet,NumberofRepeats = 5)
bsBSWiMS <- predictionStats_binary(cbind(testingSet$cens,predict(BSWiMS_ml,testingSet)),"BSWiMS",cex = 0.7)

sm <- summary(BSWiMS_ml)
cf <- sm$coefficients

eBSWiMS_ml <- BSWiMS.model(cens~.,traningSet,NumberofRepeats = -5)
bseBSWiMS <- predictionStats_binary(cbind(testingSet$cens,predict(eBSWiMS_ml,testingSet)),"eBSWiMS",cex = 0.7)

KNN_method_ml <- KNN_method(cens~.,traningSet)
bsKNN_method <- predictionStats_binary(cbind(testingSet$cens,predict(KNN_method_ml,testingSet)),"KNN",cex = 0.7)


RAWNB_ml <- try(NAIVE_BAYES(cens~.,traningSet,pca=FALSE))
print(class(RAWNB_ml))
if (inherits(RAWNB_ml, "try-error")) 
{
  cat("Error I'll use without Kernel\n")
  RAWNB_ml <- try(NAIVE_BAYES(cens~.,traningSet,pca=FALSE,usekernel=FALSE))
  bsRAWNB <- predictionStats_binary(cbind(testingSet$cens,predict(RAWNB_ml,testingSet)),"NB:RAW",cex = 0.7)
} else
{
  bsRAWNB <- predictionStats_binary(cbind(testingSet$cens,predict(RAWNB_ml,testingSet)),"NB:RAW",cex = 0.7)
}


PCANB_ml <- NAIVE_BAYES(cens~.,traningSet,pca=TRUE)
bsPCANB <- predictionStats_binary(cbind(testingSet$cens,predict(PCANB_ml,testingSet)),"NB:PCA",cex = 0.7)

FilteredPCANB_ml <- filteredFit(cens~.,traningSet,fitmethod=NAIVE_BAYES)
bsFilteredPCANB <- predictionStats_binary(cbind(testingSet$cens,predict(FilteredPCANB_ml,testingSet)),"Filtered:NB:PCA",cex = 0.7)

BESS_ml <- try(BESS(cens~.,traningSet))
bsBESS <- predictionStats_binary(cbind(testingSet$cens,predict(BESS_ml,testingSet)),"BESS",cex = 0.7)

BESS_GOLD_ml <- BESS(cens~.,traningSet,method="gsection")
bsBESS_GOLD <- predictionStats_binary(cbind(testingSet$cens,predict(BESS_GOLD_ml,testingSet)),"BESS: Golden",cex = 0.7)


SignatureRSS_ml <- CVsignature(cens~.,traningSet,method = "RSS")
bsSignatureRSS <- predictionStats_binary(cbind(testingSet$cens,predict(SignatureRSS_ml,testingSet)),"Signature: RSS",cex = 0.7)

SignatureNB_ml <- CVsignature(cens~.,traningSet,method = "NB")
bsSignatureNB <- predictionStats_binary(cbind(testingSet$cens,predict(SignatureNB_ml,testingSet)),"Signature: NB",cex = 0.7)
#pr <- predict(SignatureRSS_ml,testingSet)
#barplot(SignatureRSS_ml$wts)

SignatureSpearman_ml <- CVsignature(cens~.,traningSet,method = "spearman")
bsSignatureSpearman <- predictionStats_binary(cbind(testingSet$cens,predict(SignatureSpearman_ml,testingSet)),"Signature: spearman",cex = 0.7)

SignatureMAN_ml <- CVsignature(cens~.,traningSet,method = "MAN")
bsSignatureMAN <- predictionStats_binary(cbind(testingSet$cens,predict(SignatureMAN_ml,testingSet)),"Signature: MAN",cex = 0.7)


SignaturePearson_ml <- CVsignature(cens~.,traningSet,method = "pearson")
bsSignaturePearson <- predictionStats_binary(cbind(testingSet$cens,predict(SignaturePearson_ml,testingSet)),"Signature: Pearson",cex = 0.7)

Signaturekendall_ml <- CVsignature(cens~.,traningSet,method = "kendall")
bsSignaturekendall <- predictionStats_binary(cbind(testingSet$cens,predict(Signaturekendall_ml,testingSet)),"Signature: Kendall",cex = 0.7)

LASSO1SE_ml <- LASSO_1SE(cens~.,traningSet,family = "binomial")
bsLASSO1SE <- predictionStats_binary(cbind(testingSet$cens,predict(LASSO1SE_ml,testingSet)),"LASSO: 1SE",cex = 0.7)

LASSOMIN_ml <- LASSO_MIN(cens~.,traningSet,family = "binomial")
bsLASSOMIN <- predictionStats_binary(cbind(testingSet$cens,predict(LASSOMIN_ml,testingSet)),"LASSO: MIN",cex = 0.7)


GLMNETRIDGE_MIN_ml <- GLMNET_RIDGE_MIN(cens~.,traningSet,family = "binomial")
bsRIDGE_MIN <- predictionStats_binary(cbind(testingSet$cens,predict(GLMNETRIDGE_MIN_ml,testingSet)),"GLMNET RIDGE",cex = 0.7)

ELASTICNET_ml <- GLMNET_ELASTICNET_MIN(cens~.,traningSet,family = "binomial")
bsELASTICNET <- predictionStats_binary(cbind(testingSet$cens,predict(ELASTICNET_ml,testingSet)),"ELASTICNET",cex = 0.7)


FilteredSVM_ml <- filteredFit(cens~.,traningSetc,fitmethod=e1071::svm,probability = TRUE)
bsFilteredSVM <- predictionStats_binary(cbind(testingSet$cens,predict(FilteredSVM_ml,testingSet)),"Filtered:SVM",cex = 0.7)

TUNED_SVM_ml <- TUNED_SVM(cens~.,traningSetc,probability = TRUE,gamma = 10^(-5:-1), cost = 10^(-3:1))
bsTUNED_SVM <- predictionStats_binary(cbind(testingSet$cens,predict(TUNED_SVM_ml,testingSet)),"TUNED_SVM",cex = 0.7)


HLCM_ml <- HLCM(cens~.,traningSet,NumberofRepeats = 5)
bsHLCM <- predictionStats_binary(cbind(testingSet$cens,predict(HLCM_ml,testingSet)),"Lattent class: BSWiMS",cex = 0.7)

HLCMNB_ml <- HLCM(cens~.,traningSet,classMethod=NAIVE_BAYES,NumberofRepeats = 5)
bsHLCMNB <- predictionStats_binary(cbind(testingSet$cens,predict(HLCMNB_ml,testingSet)),"Latent class: NB:BSWiMS",cex = 0.7)

HLCM_EM_ml <- HLCM_EM(cens~.,traningSet)
bsHLCM_EM <- predictionStats_binary(cbind(testingSet$cens,predict(HLCM_EM_ml,testingSet)),"Lattent class EM: BSWiMS",cex = 0.7)

HLCM_LASSO_ml <- HLCM_EM(cens~.,traningSet,method=LASSO_1SE,family = "binomial")
bsHLCM_LASSO <- predictionStats_binary(cbind(testingSet$cens,predict(HLCM_LASSO_ml,testingSet)),"Lattent class: LASSO",cex = 0.7)


GMVEBSWiMS_ml <- GMVEBSWiMS(cens~.,traningSet,pvalue=0.01)
bsGMVEBSWiMS <- predictionStats_binary(cbind(testingSet$cens,predict(GMVEBSWiMS_ml,testingSet)),"GMVE Cluster: BSWiMS",cex = 0.7)

ClustClassGMVE_ml <- ClustClass(cens~.,traningSet)
bsClustClassGMVE <- predictionStats_binary(cbind(testingSet$cens,predict(ClustClassGMVE_ml,testingSet)),
                                       "ClustClass: GMVE",cex = 0.7)

ClustClass_ml <- ClustClass(cens~.,traningSet,clustermethod=Mclust,
                         clustermethod.control=list(G = 2))

bsClustClass <- predictionStats_binary(cbind(testingSet$cens,predict(ClustClass_ml,testingSet)),
                                       "ClustClass: Mclust K =2",cex = 0.7)

par(mfrow = c(1,1),cex = 0.5);

1.3.1 Plotting the Holdout Performance Statistics

berror <- bsBSWiMS$berror
berror <- rbind(berror,bseBSWiMS$berror)
berror <- rbind(berror,bsKNN_method$berror)
berror <- rbind(berror,bsRAWNB$berror)
berror <- rbind(berror,bsPCANB$berror)
berror <- rbind(berror,bsFilteredPCANB$berror)
berror <- rbind(berror,bsBESS$berror)
berror <- rbind(berror,bsBESS_GOLD$berror)
berror <- rbind(berror,bsSignatureRSS$berror)
berror <- rbind(berror,bsSignatureNB$berror)
berror <- rbind(berror,bsSignatureSpearman$berror)
berror <- rbind(berror,bsSignatureMAN$berror)
berror <- rbind(berror,bsSignaturePearson$berror)
berror <- rbind(berror,bsSignaturekendall$berror)
berror <- rbind(berror,bsLASSO1SE$berror)
berror <- rbind(berror,bsLASSOMIN$berror)
berror <- rbind(berror,bsRIDGE_MIN$berror)
berror <- rbind(berror,bsELASTICNET$berror)
berror <- rbind(berror,bsFilteredSVM$berror)
berror <- rbind(berror,bsTUNED_SVM$berror)
berror <- rbind(berror,bsHLCM$berror)
berror <- rbind(berror,bsHLCMNB$berror)
berror <- rbind(berror,bsHLCM_EM$berror)
berror <- rbind(berror,bsHLCM_LASSO$berror)
berror <- rbind(berror,bsGMVEBSWiMS$berror)
berror <- rbind(berror,bsClustClass$berror)
berror <- rbind(berror,bsClustClassGMVE$berror)



rownames(berror) <- c("BSWiMS","eBSWiMS","KNN_method","RAWNB","PCANB","FilteredPCANB","BESS","BESS_GOLD","SignatureRSS","SignatureNB","SignatureSpearman","SignatureMAN","SignaturePearson","Signaturekendall","LASSO1SE","LASSOMIN","RIDGE_MIN","ELASTICNET","FilteredSVM","TUNED_SVM","HLCM","HLCMNB","HLCM_EM","HLCM_LASSO","GMVEBSWiMS","ClustClass","ClustClassGMVE")

bpBER <- barPlotCiError(as.matrix(berror),
                        metricname = "Balanced Error",
                        thesets = "Hold-Out Error",
                        themethod = rownames(berror),
                        main = "Balanced Error",
                        offsets = c(0.5,1),
                        scoreDirection = "<",
                        ho=0.5,
                        args.legend = list(bg = "white",x="bottomright",inset=c(0.0,0),cex=0.5),
                        col = terrain.colors(nrow(berror))
                        )


aucs <- bsBSWiMS$aucs
aucs <- rbind(aucs,bseBSWiMS$aucs)
aucs <- rbind(aucs,bsKNN_method$aucs)
aucs <- rbind(aucs,bsRAWNB$aucs)
aucs <- rbind(aucs,bsPCANB$aucs)
aucs <- rbind(aucs,bsFilteredPCANB$aucs)
aucs <- rbind(aucs,bsBESS$aucs)
aucs <- rbind(aucs,bsBESS_GOLD$aucs)
aucs <- rbind(aucs,bsSignatureRSS$aucs)
aucs <- rbind(aucs,bsSignatureNB$aucs)
aucs <- rbind(aucs,bsSignatureSpearman$aucs)
aucs <- rbind(aucs,bsSignatureMAN$aucs)
aucs <- rbind(aucs,bsSignaturePearson$aucs)
aucs <- rbind(aucs,bsSignaturekendall$aucs)
aucs <- rbind(aucs,bsLASSO1SE$aucs)
aucs <- rbind(aucs,bsLASSOMIN$aucs)
aucs <- rbind(aucs,bsRIDGE_MIN$aucs)
aucs <- rbind(aucs,bsELASTICNET$aucs)
aucs <- rbind(aucs,bsFilteredSVM$aucs)
aucs <- rbind(aucs,bsTUNED_SVM$aucs)
aucs <- rbind(aucs,bsHLCM$aucs)
aucs <- rbind(aucs,bsHLCMNB$aucs)
aucs <- rbind(aucs,bsHLCM_EM$aucs)
aucs <- rbind(aucs,bsHLCM_LASSO$aucs)
aucs <- rbind(aucs,bsGMVEBSWiMS$aucs)
aucs <- rbind(aucs,bsClustClass$aucs)
aucs <- rbind(aucs,bsClustClassGMVE$aucs)


rownames(aucs) <- rownames(berror)

bpAUC <- barPlotCiError(as.matrix(aucs),
                        metricname = "ROC AUC",
                        thesets = "Hold-Out AUC",
                        themethod = rownames(aucs),
                        main = "AUC",
                        offsets = c(-0.5,1),
                        scoreDirection = ">",
                        ho=0.5,
                        args.legend = list(bg = "white",x="bottomleft",inset=c(0.0,0),cex=0.5),
                        col = terrain.colors(nrow(aucs))
                        )


accc <- bsBSWiMS$accc
accc <- rbind(accc,bseBSWiMS$accc)
accc <- rbind(accc,bsKNN_method$accc)
accc <- rbind(accc,bsRAWNB$accc)
accc <- rbind(accc,bsPCANB$accc)
accc <- rbind(accc,bsFilteredPCANB$accc)
accc <- rbind(accc,bsBESS$accc)
accc <- rbind(accc,bsBESS_GOLD$accc)
accc <- rbind(accc,bsSignatureRSS$accc)
accc <- rbind(accc,bsSignatureNB$accc)
accc <- rbind(accc,bsSignatureSpearman$accc)
accc <- rbind(accc,bsSignatureMAN$accc)
accc <- rbind(accc,bsSignaturePearson$accc)
accc <- rbind(accc,bsSignaturekendall$accc)
accc <- rbind(accc,bsLASSO1SE$accc)
accc <- rbind(accc,bsLASSOMIN$accc)
accc <- rbind(accc,bsRIDGE_MIN$accc)
accc <- rbind(accc,bsELASTICNET$accc)
accc <- rbind(accc,bsFilteredSVM$accc)
accc <- rbind(accc,bsTUNED_SVM$accc)
accc <- rbind(accc,bsHLCM$accc)
accc <- rbind(accc,bsHLCMNB$accc)
accc <- rbind(accc,bsHLCM_EM$accc)
accc <- rbind(accc,bsHLCM_LASSO$accc)
accc <- rbind(accc,bsGMVEBSWiMS$accc)
accc <- rbind(accc,bsClustClass$accc)
accc <- rbind(accc,bsClustClassGMVE$accc)


rownames(accc) <- rownames(berror)

bpaccc <- barPlotCiError(as.matrix(accc),
                        metricname = "Accuracy",
                        thesets = "Hold-Out Accuracy",
                        themethod = rownames(accc),
                        main = "Accuracy",
                        offsets = c(-0.5,1),
                        scoreDirection = ">",
                        ho=0.5,
                        args.legend = list(bg = "white",x="bottomleft",inset=c(0.0,0),cex=0.45),
                        col = terrain.colors(nrow(accc))
                        )

1.4 Filters

par(mfrow = c(2,2),cex = 0.5);

FilteredEnsemble_ml <- filteredFit(cens~.,
                              traningSet,
                              fitmethod=glm,
                              filtermethod=univariate_BinEnsemble,
                              filtermethod.control=list(pvalue=0.05,limit=as.integer(0.05*nrow(traningSet)+0.5)),
                              family = "binomial")
bsFilteredEnsemble <- predictionStats_binary(cbind(testingSet$cens,predict(FilteredEnsemble_ml,testingSet))
                                           ,"Ensemble:logit",cex = 0.7)



FilteredWilcox_ml <- filteredFit(cens~.,
                              traningSetc,
                              fitmethod=glm,
                              filtermethod=univariate_Wilcoxon,
                              filtermethod.control=list(pvalue=0.05,limit=0.05),
                              family = "binomial")
bsFilteredWilcox <- predictionStats_binary(cbind(testingSet$cens,predict(FilteredWilcox_ml,testingSet))
                                           ,"Wilcox:logit",cex = 0.7)



Filteredttest_ml <- filteredFit(cens~.,traningSetc,
                              fitmethod=glm,
                              filtermethod=univariate_tstudent,
                              filtermethod.control=list(pvalue=0.05,limit=0.05),
                              family = "binomial")
bsFilteredttest <- predictionStats_binary(cbind(testingSet$cens,predict(Filteredttest_ml,testingSet))
                                          ,"t-test:logit",cex = 0.7)

Filteredkendall_ml <- filteredFit(cens~.,traningSet,
                              fitmethod=glm,
                              filtermethod=univariate_correlation,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,method = "kendall"),
                              family = "binomial")
bsFilteredkendall <- predictionStats_binary(cbind(testingSet$cens,predict(Filteredkendall_ml,testingSet))
                                          ,"Kendall:logit",cex = 0.7)



Filteredspearman_ml <- filteredFit(cens~.,traningSet,
                              fitmethod=glm,
                              filtermethod=univariate_correlation,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,method = "spearman"),
                              family = "binomial")

bsFilteredspearman <- predictionStats_binary(cbind(testingSet$cens,predict(Filteredspearman_ml,testingSet))
                                          ,"Spearman:logit",cex = 0.7)
Filteredpearson_ml <- filteredFit(cens~.,traningSet,
                              fitmethod=glm,
                              filtermethod=univariate_correlation,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,method = "pearson"),
                              family = "binomial")

bsFilteredpearson <- predictionStats_binary(cbind(testingSet$cens,predict(Filteredpearson_ml,testingSet))
                                          ,"Pearson:logit",cex = 0.7)


FilteredFtest_ml <- filteredFit(cens~.,traningSet,
                              fitmethod=glm,
                              filtermethod=univariate_residual,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,uniTest = "Ftest",type="LOGIT"),
                              family = "binomial")

bsFilteredFtest <- predictionStats_binary(cbind(testingSet$cens,predict(FilteredFtest_ml,testingSet))
                                          ,"Fit_F:logit",cex = 0.7)

FilteredBinomial_ml <- filteredFit(cens~.,traningSet,
                              fitmethod=glm,
                              filtermethod=univariate_residual,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,uniTest = "Binomial",type="LOGIT"),
                              family = "binomial")

bsFilteredBinomial <- predictionStats_binary(cbind(testingSet$cens,predict(FilteredBinomial_ml,testingSet))
                                          ,"Fit_Bin:logit",cex = 0.7)



FilteredWilcox2_ml <- filteredFit(cens~.,traningSet,
                              fitmethod=glm,
                              filtermethod=univariate_residual,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,uniTest = "Wilcox",type="LOGIT"),
                              family = "binomial")

bsFilteredWilcox2 <- predictionStats_binary(cbind(testingSet$cens,predict(FilteredWilcox2_ml,testingSet))
                                          ,"Fit_Wil:logit",cex = 0.7)


FilteredtStudent_ml <- filteredFit(cens~.,traningSet,
                              fitmethod=glm,
                              filtermethod=univariate_residual,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,uniTest = "tStudent",type="LOGIT"),
                              family = "binomial")

bsFilteredtStudent <- predictionStats_binary(cbind(testingSet$cens,predict(FilteredtStudent_ml,testingSet))
                                          ,"Fit_tt:logit",cex = 0.7)




FilteredzIDI_ml <- filteredFit(cens~.,traningSet,
                              fitmethod=glm,
                              filtermethod=univariate_Logit,
                              filtermethod.control=list(pvalue=0.1,limit=0.05,uniTest = "zIDI"),
                              family = "binomial")

bsFilteredzIDI <- predictionStats_binary(cbind(testingSet$cens,predict(FilteredzIDI_ml,testingSet))
                                          ,"Fit_IDI:logit",cex = 0.7)



FilteredzNRI_ml <- filteredFit(cens~.,traningSet,
                              fitmethod=glm,
                              filtermethod=univariate_Logit,
                              filtermethod.control=list(pvalue=0.1,limit=0.05,uniTest = "zNRI"),
                              family = "binomial")



bsFilteredzNRI <- predictionStats_binary(cbind(testingSet$cens,predict(FilteredzNRI_ml,testingSet))
                                          ,"Fit_NRI:logit",cex = 0.7)



FilteredmRMR_ml <- filteredFit(cens~.,traningSet,
                              fitmethod=glm,
                              filtermethod=mRMR.classic_FRESA,
                              filtermethod.control=list(feature_count=as.integer(0.05*nrow(traningSet)+0.5)),
                              family = "binomial")


bsFilteredmRMR <- predictionStats_binary(cbind(testingSet$cens,predict(FilteredmRMR_ml,testingSet))
                                          ,"Fit_mRMR:logit",cex = 0.7)



par(mfrow = c(1,1),cex = 0.5)

1.5 Filters Decorrlated

par(mfrow = c(2,2),cex = 0.5);

FilteredEnsemble_ml <- filteredFit(cens~.,
                              dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=univariate_BinEnsemble,
                              filtermethod.control=list(pvalue=0.05,limit=0.05),
                              family = "binomial")

deBsFilteredEnsemble <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(FilteredEnsemble_ml,dataTestDecorrelated)),"De: Ensemble:logit",cex = 0.7)



FilteredWilcox_ml <- filteredFit(cens~.,
                              dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=univariate_Wilcoxon,
                              filtermethod.control=list(pvalue=0.05,limit=0.05),
                              family = "binomial")
deBsFilteredWilcox <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(FilteredWilcox_ml,dataTestDecorrelated)),"De:Wilcox:logit",cex = 0.7)



Filteredttest_ml <- filteredFit(cens~.,dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=univariate_tstudent,
                              filtermethod.control=list(pvalue=0.05,limit=0.05),
                              family = "binomial")
deBsFilteredttest <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(Filteredttest_ml,dataTestDecorrelated)),"De:t-test:logit",cex = 0.7)

Filteredkendall_ml <- filteredFit(cens~.,dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=univariate_correlation,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,method = "kendall"),
                              family = "binomial")
deBsFilteredkendall <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(Filteredkendall_ml,dataTestDecorrelated)),"Kendall:logit",cex = 0.7)



Filteredspearman_ml <- filteredFit(cens~.,dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=univariate_correlation,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,method = "spearman"),
                              family = "binomial")

deBsFilteredspearman <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(Filteredspearman_ml,dataTestDecorrelated)),"De:Spearman:logit",cex = 0.7)

Filteredpearson_ml <- filteredFit(cens~.,dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=univariate_correlation,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,method = "pearson"),
                              family = "binomial")

deBsFilteredpearson <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(Filteredpearson_ml,dataTestDecorrelated)),"De: Pearson:logit",cex = 0.7)


FilteredFtest_ml <- filteredFit(cens~.,dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=univariate_residual,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,uniTest = "Ftest",type="LOGIT"),
                              family = "binomial")

deBsFilteredFtest <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(FilteredFtest_ml,dataTestDecorrelated)),"De:Fit_F:logit",cex = 0.7)

FilteredBinomial_ml <- filteredFit(cens~.,dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=univariate_residual,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,uniTest = "Binomial",type="LOGIT"),
                              family = "binomial")

deBsFilteredBinomial <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(FilteredBinomial_ml,dataTestDecorrelated)),"De:Fit_Bin:logit",cex = 0.7)



FilteredWilcox2_ml <- filteredFit(cens~.,dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=univariate_residual,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,uniTest = "Wilcox",type="LOGIT"),
                              family = "binomial")

deBsFilteredWilcox2 <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(FilteredWilcox2_ml,dataTestDecorrelated)),"De:Fit_Wil:logit",cex = 0.7)


FilteredtStudent_ml <- filteredFit(cens~.,dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=univariate_residual,
                              filtermethod.control=list(pvalue=0.05,limit=0.05,uniTest = "tStudent",type="LOGIT"),
                              family = "binomial")

deBsFilteredtStudent <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(FilteredtStudent_ml,dataTestDecorrelated)),"De:Fit_tt:logit",cex = 0.7)



FilteredzIDI_ml <- filteredFit(cens~.,dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=univariate_Logit,
                              filtermethod.control=list(pvalue=0.1,limit=0.05,uniTest = "zIDI"),
                              family = "binomial")

deBsFilteredzIDI <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(FilteredzIDI_ml,dataTestDecorrelated)),"De:Fit_IDI:logit",cex = 0.7)



FilteredzNRI_ml <- filteredFit(cens~.,dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=univariate_Logit,
                              filtermethod.control=list(pvalue=0.1,limit=0.05,uniTest = "zNRI"),
                              family = "binomial")



deBsFilteredzNRI <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(FilteredzNRI_ml,dataTestDecorrelated)),"De:Fit_NRI:logit",cex = 0.7)



FilteredmRMR_ml <- filteredFit(cens~.,dataTrainDecorrelated,
                              fitmethod=glm,
                              filtermethod=mRMR.classic_FRESA,
                              filtermethod.control=list(feature_count=as.integer(0.05*nrow(dataTrainDecorrelated)+0.5)),
                              family = "binomial")


deBsFilteredmRMR <- predictionStats_binary(cbind(dataTestDecorrelated$cens,predict(FilteredmRMR_ml,dataTestDecorrelated)),"De:Fit_mRMR:logit",cex = 0.7)



par(mfrow = c(1,1),cex = 0.5)

1.5.1 Plotting the Filters Performance Statistics


berror <- deBsFilteredWilcox$berror
berror <- rbind(berror,deBsFilteredttest$berror)
berror <- rbind(berror,deBsFilteredspearman$berror)
berror <- rbind(berror,deBsFilteredkendall$berror)
berror <- rbind(berror,deBsFilteredpearson$berror)
berror <- rbind(berror,deBsFilteredFtest$berror)
berror <- rbind(berror,deBsFilteredBinomial$berror)
berror <- rbind(berror,deBsFilteredWilcox2$berror)
berror <- rbind(berror,deBsFilteredtStudent$berror)
berror <- rbind(berror,deBsFilteredzIDI$berror)
berror <- rbind(berror,deBsFilteredzNRI$berror)
berror <- rbind(berror,deBsFilteredmRMR$berror)
berror <- rbind(berror,deBsFilteredEnsemble$berror)

berror <- rbind(berror,bsFilteredWilcox$berror)
berror <- rbind(berror,bsFilteredttest$berror)
berror <- rbind(berror,bsFilteredspearman$berror)
berror <- rbind(berror,bsFilteredkendall$berror)
berror <- rbind(berror,bsFilteredpearson$berror)
berror <- rbind(berror,bsFilteredFtest$berror)
berror <- rbind(berror,bsFilteredBinomial$berror)
berror <- rbind(berror,bsFilteredWilcox2$berror)
berror <- rbind(berror,bsFilteredtStudent$berror)
berror <- rbind(berror,bsFilteredzIDI$berror)
berror <- rbind(berror,bsFilteredzNRI$berror)
berror <- rbind(berror,bsFilteredmRMR$berror)
berror <- rbind(berror,bsFilteredEnsemble$berror)


rownames(berror) <- c("De_Wilcox","De_ttest","De_spearman","De_kendall","De_Pearson","De_Ftest","De_Binomial","De_Wilcox2","De_tStudent","De_zIDI","De_zNRI","De_mRMR","De_Ensemble","Wilcox","ttest","spearman","kendall","Pearson","Ftest","Binomial","Wilcox2","tStudent","zIDI","zNRI","mRMR","Ensemble")


bpBER <- barPlotCiError(as.matrix(berror),
                        metricname = "Balanced Error",
                        thesets = "Hold-Out Error",
                        themethod = rownames(berror),
                        main = "Balanced Error",
                        offsets = c(0.5,1),
                        scoreDirection = "<",
                        ho=0.5,
                        args.legend = list(bg = "white",x="bottomright",inset=c(0.0,0),cex=0.5),
                        col = terrain.colors(nrow(berror))
                        )


aucs <- deBsFilteredWilcox$aucs
aucs <- rbind(aucs,deBsFilteredttest$aucs)
aucs <- rbind(aucs,deBsFilteredspearman$aucs)
aucs <- rbind(aucs,deBsFilteredkendall$aucs)
aucs <- rbind(aucs,deBsFilteredpearson$aucs)
aucs <- rbind(aucs,deBsFilteredFtest$aucs)
aucs <- rbind(aucs,deBsFilteredBinomial$aucs)
aucs <- rbind(aucs,deBsFilteredWilcox2$aucs)
aucs <- rbind(aucs,deBsFilteredtStudent$aucs)
aucs <- rbind(aucs,deBsFilteredzIDI$aucs)
aucs <- rbind(aucs,deBsFilteredzNRI$aucs)
aucs <- rbind(aucs,deBsFilteredmRMR$aucs)
aucs <- rbind(aucs,deBsFilteredEnsemble$aucs)

aucs <- rbind(aucs,bsFilteredWilcox$aucs)
aucs <- rbind(aucs,bsFilteredttest$aucs)
aucs <- rbind(aucs,bsFilteredspearman$aucs)
aucs <- rbind(aucs,bsFilteredkendall$aucs)
aucs <- rbind(aucs,bsFilteredpearson$aucs)
aucs <- rbind(aucs,bsFilteredFtest$aucs)
aucs <- rbind(aucs,bsFilteredBinomial$aucs)
aucs <- rbind(aucs,bsFilteredWilcox2$aucs)
aucs <- rbind(aucs,bsFilteredtStudent$aucs)
aucs <- rbind(aucs,bsFilteredzIDI$aucs)
aucs <- rbind(aucs,bsFilteredzNRI$aucs)
aucs <- rbind(aucs,bsFilteredmRMR$aucs)
aucs <- rbind(aucs,bsFilteredEnsemble$aucs)

rownames(aucs) <- rownames(berror)

bpAUC <- barPlotCiError(as.matrix(aucs),
                        metricname = "ROC AUC",
                        thesets = "Hold-Out AUC",
                        themethod = rownames(aucs),
                        main = "AUC",
                        offsets = c(-0.5,1),
                        scoreDirection = ">",
                        ho=0.5,
                        args.legend = list(bg = "white",x="bottomleft",inset=c(0.0,0),cex=0.5),
                        col = terrain.colors(nrow(aucs))
                        )

1.5.2 Extracted Features

par(mfrow = c(1,1),cex = 0.5,pty="m")

rownamesFeat <- c("Wilcox","ttest","spearman","kendall","Pearson","Ftest","Binomial","Wilcox2","tStudent","zIDI","zNRI","mRMR","Ensemble")


featursMatrix <- as.data.frame(matrix(0,ncol=19,nrow=ncol(traningSet)))
rownames(featursMatrix) <- colnames(traningSet)
colnames(featursMatrix) <- c(rownamesFeat,"BSWiMS","eBSWiMS","LASSO:MIN","LASSO:1SE","BESS","BESS:GOLDEN");

featursMatrix[FilteredWilcox_ml$selectedfeatures,1] <- 1
featursMatrix[Filteredttest_ml$selectedfeatures,2] <- 1
featursMatrix[Filteredspearman_ml$selectedfeatures,3] <- 1
featursMatrix[Filteredkendall_ml$selectedfeatures,4] <- 1
featursMatrix[Filteredpearson_ml$selectedfeatures,5] <- 1
featursMatrix[FilteredFtest_ml$selectedfeatures,6] <- 1
featursMatrix[FilteredBinomial_ml$selectedfeatures,7] <- 1
featursMatrix[FilteredWilcox2_ml$selectedfeatures,8] <- 1
featursMatrix[FilteredtStudent_ml$selectedfeatures,9] <- 1
featursMatrix[FilteredzIDI_ml$selectedfeatures,10] <- 1
featursMatrix[FilteredzNRI_ml$selectedfeatures,11] <- 1
featursMatrix[FilteredmRMR_ml$selectedfeatures,12] <- 1
featursMatrix[names(BSWiMS_ml$bagging$bagged.model$coefficients)[-1],13] <- 1
featursMatrix[names(eBSWiMS_ml$bagging$bagged.model$coefficients)[-1],14] <- 1
featursMatrix[LASSOMIN_ml$selectedfeatures,15] <- 1
featursMatrix[LASSO1SE_ml$selectedfeatures,16] <- 1
featursMatrix[BESS_ml$selectedfeatures,17] <- 1
featursMatrix[BESS_GOLD_ml$selectedfeatures,18] <- 1
featursMatrix[FilteredEnsemble_ml$selectedfeatures,19] <- 1
sumselected <- apply(featursMatrix,1,sum)
featursMatrix <- featursMatrix[sumselected>0,]

gplots::heatmap.2(as.matrix(featursMatrix),trace = "none",mar = c(7,13),main = "Selected Features", cexRow = 0.5,cexCol = 0.75)