## Split the data
nfold<-10;
pos_cases <- data[data$label==1,];
pos_cases<-sample(pos_cases);
neg_cases <- data[data$label==0,];
neg_cases<-sample(neg_cases);
num_pos_cases <- nrow(pos_cases);
num_pos_portion<-ceiling(num_pos_cases/nfold);
num_neg_cases <- nrow(neg_cases);
num_neg_portion<-ceiling(num_neg_cases/nfold);
for (i in 1:nfold){
  if (i==1) {
      testX<-rbind(pos_cases[1:num_pos_portion,],neg_cases[1:num_neg_portion,]);
      testY<-factor(testX$label);
      testX<-subset(testX, select=-label)
      trainX<-rbind(pos_cases[-(1:num_pos_portion),],neg_cases[-(1:num_neg_portion),]);
      trainY<-factor(trainX$label);
      trainX<-subset(trainX, select=-label)
   }
  if (i>1 & i<nfold) {
     testX<-rbind(pos_cases[(num_pos_portion*(i-1)+1):(num_pos_portion*i),], neg_cases[(num_neg_portion*(i-1)+1):(num_neg_portion*i),]);
     testY<-factor(testX$label);
     testX<-subset(testX, select=-label)
     trainX<-rbind(pos_cases[-((num_pos_portion*(i-1)+1):(num_pos_portion*i)),], neg_cases[-((num_neg_portion*(i-1)+1):(num_neg_portion*i)),]);
     trainY<-factor(trainX$label);
     trainX<-subset(trainX, select=-label)
  }
  if (i==nfold) {
     testX<-rbind(pos_cases[(num_pos_portion*(i-1)+1):num_pos_cases,], neg_cases[(num_neg_portion*(i-1)+1):num_neg_cases,]);
     testY<-factor(testX$label);
     testX<-subset(testX, select=-label)
     trainX<-rbind(pos_cases[-((num_pos_portion*(i-1)+1):num_pos_cases),], neg_cases[-((num_neg_portion*(i-1)+1):num_neg_cases),]);
     trainY<-factor(trainX$label);
     trainX<-subset(trainX, select=-label)
   }
  filename<-paste("fold_",i,".RData",sep="")
  save(trainX, trainY, testX, testY, file = filename)
}

## Performance function
getperf<-function(result_matrix){
    testY<-result_matrix[,1]
    t1<-result_matrix[,2]
    TP=FN=FP=TN=0
    for(i in 1:dim(result_matrix)[1]){
          if(testY[i]==1) {
              if(t1[i]==1) TP=TP+1;
              if(t1[i]==0) FN=FN+1;
           }
          if(testY[i]==0){
              if(t1[i]==1) FP=FP+1;
              if(t1[i]==0) TN=TN+1;
           }
     }
     sen<-TP/(TP+FN);
     spe<-TN/(TN+FP);
     ACC<-(TP+TN)/(TP+FN+TN+FP);
     mcc<-(TN*TP-FN*FP)/((TP+FN)*(TN+FN)*(TN+FP)*(TP+FP))^(1/2);
     perf<-c(TP,FN,FP,TN,sen,spe,ACC,mcc);
    return(perf);
}


## Cross-validation
## test dataset 
library(caret)
nfold<-10;
cvControl <- trainControl(method="cv", number=nfold)

svmresult_matrix<-NULL;
rfresult_matrix<-NULL;
gbmresult_matrix<-NULL;
rpartresult_matrix<-NULL;
nnetresult_matrix<-NULL;
plsresult_matrix<-NULL;
knnresult_matrix<-NULL;
nbresult_matrix<-NULL;
adaresult_matrix<-NULL;

for (i in 1:nfold){
   filename<-paste("fold_",i,".RData",sep="")
   load(filename)
   
   ### Support Vector Machine- svmLinear (SVM)
   svmGrid <- expand.grid(.C=10**(-2:3))
   svmFit <- train(trainX, trainY, method = "svmLinear", trControl = cvControl, tuneGrid=svmGrid, scaled=F)
   svmPred <- predict(svmFit, newdata = testX)
   svmPred <- cbind(as.data.frame(testY),as.data.frame(svmPred));
   svmresult_matrix <- rbind(svmresult_matrix,svmPred);

   ### Random Forest (RF)
   rfFit <- train(trainX, trainY, method="rf", tuneLength=5, trControl=cvControl, scaled=F)
   rfPred <- predict(rfFit, newdata = testX)
   rfPred <- cbind(as.data.frame(testY),as.data.frame(rfPred));
   rfresult_matrix <- rbind(rfresult_matrix,rfPred);

   ### Boosting Trees (GBM)
   gbmGrid <- expand.grid(.interaction.depth=(1:5)*2, .n.trees=(1:10)*25, .shrinkage=.1)
   gbmFit <- train(trainX, trainY, method="gbm", trControl=cvControl, verbose=FALSE, bag.fraction=0.5,tuneGrid=gbmGrid)
   gbmPred <- predict(gbmFit, newdata = testX)
   gbmPred <- cbind(as.data.frame(testY),as.data.frame(gbmPred));
   gbmresult_matrix <- rbind(gbmresult_matrix,gbmPred);

   ### Recursive Partitioning (RPART)
   rpart.grid <- expand.grid(.cp=0.2)
   train.rpart <- train(trainX, trainY, method="rpart",trControl=tc,tuneGrid=rpart.grid)
   rpartPred <- predict(train.rpart, newdata = testX)
   rpartPred <- cbind(as.data.frame(testY),as.data.frame(rpartPred));
   rpartresult_matrix <- rbind(rpartresult_matrix,rpartPred);

   ### Neural Networks (NNet)
   nnetGrid <- expand.grid(.decay=(1:5), .size=(1:5))
   nnetFit <- train(trainX, trainY, method="nnet",trControl=cvControl,tuneGrid=nnetGrid)
   nnetPred <- predict(nnetFit, newdata = testX)
   nnetPred <- cbind(as.data.frame(testY),as.data.frame(nnetPred));
   nnetresult_matrix <- rbind(nnetresult_matrix,nnetPred);

   ### Partial Least Squares (PLS)
   plsGrid <- expand.grid(.ncomp=2*(1:(dim(trainX)[2]/2)))
   plsFit <- train(trainX, trainY, method="pls",trControl=cvControl,tuneGrid=plsGrid)
   plsPred <- predict(plsFit, newdata = testX)
   plsPred <- cbind(as.data.frame(testY),as.data.frame(plsPred));
   plsresult_matrix <- rbind(plsresult_matrix,plsPred);

   ### K Nearest Neighbors (KNN)
   knnGrid <- expand.grid(.k=2*(1:10))
   knnFit <- train(trainX, trainY, method="knn",trControl=cvControl,tuneGrid=knnGrid)
   knnPred <- predict(knnFit, newdata = testX)
   knnPred <- cbind(as.data.frame(testY),as.data.frame(knnPred));
   knnresult_matrix <- rbind(knnresult_matrix,knnPred);

   ### Naive Bayes (NB)
   nbFit <- train(trainX, trainY, method="nb",trControl=cvControl)
   nbPred <- predict(nbFit, newdata = testX)
   nbPred <- cbind(as.data.frame(testY),as.data.frame(nbPred));
   nbresult_matrix <- rbind(nbresult_matrix,nbPred);

   ### Ada Boost (Ada)
   adaGrid <- expand.grid(.maxdepth=(1:5), .iter=50*(1:5),.nu=0.1*(1:5))
   adaFit <- train(trainX, trainY, method="ada",trControl=cvControl, tuneGrid=adaGrid)
   adaPred <- predict(adaFit, newdata = testX)
   adaPred <- cbind(as.data.frame(testY),as.data.frame(adaPred));
   adaresult_matrix <- rbind(adaresult_matrix,adaPred);
}

svmperf<-getperf(svmresult_matrix)
rfperf<-getperf(rfresult_matrix)
gbmperf<-getperf(gbmresult_matrix)
rpartperf<-getperf(rpartresult_matrix)
nnetperf<-getperf(nnetresult_matrix)
plsperf<-getperf(plsresult_matrix)
knnperf<-getperf(knnresult_matrix)
nbperf<-getperf(nbresult_matrix)
adaperf<-getperf(adaresult_matrix)