BruteForce test: enable/disable each method

progs/ImagenetBinary.conf

@@ -26,7 +26,15 @@ noiseGPVarApproxFile = /home/luetz/code/nice/vislearning/progs/gpvarNoise.txt
 
 indexOfFirstClass = 0
 indexOfLastClass = 0
-runsPerClassToAverageTraining = 100000
-runsPerClassToAverageTraining = 100000
+runsPerClassToAverageTraining = 100
+runsPerClassToAverageTraining = 100
 
 nrOfExamplesPerClass = 100
+
+GPSRMean = true
+GPSRVar = true
+GPMean = true
+GPVar = true
+
+[GPSR]
+nrOfRegressors = 50

progs/testImageNetBinaryBruteForce.cpp

@@ -652,6 +652,15 @@ int main (int argc, char **argv)
   
   // share parameters among methods and classes?
   bool shareParameters = conf.gB("main" , "shareParameters", true);
+  
+  bool GPMeanApprox = conf.gB( "main", "GPMeanApprox", false);
+  bool GPVarApprox = conf.gB( "main", "GPVarApprox", false);  
+  bool GPMean = conf.gB( "main", "GPMean", false);
+  bool GPVar = conf.gB( "main", "GPVar", false);
+  bool GPSRMean = conf.gB( "main", "GPSRMean", false);
+  bool GPSRVar = conf.gB( "main", "GPSRVar", false);  
+  bool Parzen = conf.gB( "main", "Parzen", false);
+  bool SVDD = conf.gB( "main", "SVDD", false);  
 
   
   // GP variance approximation  
@@ -851,37 +860,45 @@ int main (int argc, char **argv)
     
     //train GP Var Approx    
     NICE::Vector matrixDInv;
-    trainGPVarApprox(matrixDInv, noiseGPVarApproxParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining );
+    if (GPVarApprox)
+      trainGPVarApprox(matrixDInv, noiseGPVarApproxParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining );
     
     //train GP Var
     NICE::Matrix GPVarCholesky;
-    trainGPVar(GPVarCholesky, noiseGPVarParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining );    
+    if (GPVar)
+      trainGPVar(GPVarCholesky, noiseGPVarParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining );    
     
     //train GP Mean Approx
     NICE::Vector GPMeanApproxRightPart;
-    trainGPMeanApprox(GPMeanApproxRightPart, noiseGPMeanApproxParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining );
+    if (GPMeanApprox)
+      trainGPMeanApprox(GPMeanApproxRightPart, noiseGPMeanApproxParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining );
     
     //train GP Mean
     NICE::Vector GPMeanRightPart;
-    trainGPMean(GPMeanRightPart, noiseGPMeanParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining );    
+    if (GPMean)
+      trainGPMean(GPMeanRightPart, noiseGPMeanParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining );    
     
     //train GP SR Mean
     NICE::Vector GPSRMeanRightPart;
     std::vector<int> indicesOfChosenExamplesGPSRMean;
     int nrOfRegressors = conf.gI( "GPSR", "nrOfRegressors", nrOfExamplesPerClass/2);
     nrOfRegressors = std::min( nrOfRegressors, nrOfExamplesPerClass );
-    trainGPSRMean(GPSRMeanRightPart, noiseGPSRMeanParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining, nrOfRegressors, indicesOfChosenExamplesGPSRMean );        
+    if (GPSRMean)
+      trainGPSRMean(GPSRMeanRightPart, noiseGPSRMeanParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining, nrOfRegressors, indicesOfChosenExamplesGPSRMean );        
     
     //train GP SR Var
     NICE::Matrix GPSRVarCholesky;   
     std::vector<int> indicesOfChosenExamplesGPSRVar;
-    trainGPSRVar(GPSRVarCholesky, noiseGPSRVarParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining, nrOfRegressors, indicesOfChosenExamplesGPSRVar );      
+    if (GPSRVar)
+      trainGPSRVar(GPSRVarCholesky, noiseGPSRVarParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining, nrOfRegressors, indicesOfChosenExamplesGPSRVar );      
     
     //train Parzen 
     //nothing to do :)
     
     //train SVDD
-    KCMinimumEnclosingBall *svdd = trainSVDD(noiseSVDDParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining );
+    KCMinimumEnclosingBall *svdd;
+    if (SVDD)
+      svdd = trainSVDD(noiseSVDDParas[cl], kernelMatrix, nrOfExamplesPerClass, cl, runsPerClassToAverageTraining );
   
     tTrain.stop();
     std::cerr << "Time used for training class " << cl << ": " << tTrain.getLast() << std::endl;      
@@ -937,36 +954,44 @@ int main (int argc, char **argv)
       
       //evaluate GP Var Approx
       ClassificationResult rGPVarApprox;      
-      evaluateGPVarApprox( kernelVector, kernelSelf, matrixDInv, rGPVarApprox, timeForSingleExamplesGPVarApprox, runsPerClassToAverageTesting );
+      if (GPVarApprox)
+        evaluateGPVarApprox( kernelVector, kernelSelf, matrixDInv, rGPVarApprox, timeForSingleExamplesGPVarApprox, runsPerClassToAverageTesting );
       
       //evaluate GP Var
       ClassificationResult rGPVar;
-      evaluateGPVar( kernelVector, kernelSelf, GPVarCholesky, rGPVar, timeForSingleExamplesGPVar, runsPerClassToAverageTesting );      
+      if (GPVar)
+        evaluateGPVar( kernelVector, kernelSelf, GPVarCholesky, rGPVar, timeForSingleExamplesGPVar, runsPerClassToAverageTesting );      
       
       //evaluate GP Mean Approx
       ClassificationResult rGPMeanApprox;      
-      evaluateGPMeanApprox( kernelVector, matrixDInv, rGPMeanApprox, timeForSingleExamplesGPMeanApprox, runsPerClassToAverageTesting );
+      if (GPMeanApprox)
+        evaluateGPMeanApprox( kernelVector, matrixDInv, rGPMeanApprox, timeForSingleExamplesGPMeanApprox, runsPerClassToAverageTesting );
       
       //evaluate GP Mean
       ClassificationResult rGPMean;
-      evaluateGPMean( kernelVector, GPMeanRightPart, rGPMean, timeForSingleExamplesGPMean, runsPerClassToAverageTesting );       
+      if (GPMean)
+        evaluateGPMean( kernelVector, GPMeanRightPart, rGPMean, timeForSingleExamplesGPMean, runsPerClassToAverageTesting );       
        
       //evaluate GP SR Mean
       ClassificationResult rGPSRMean;
-      evaluateGPSRMean( kernelVector, GPSRMeanRightPart, rGPSRMean, timeForSingleExamplesGPSRMean, runsPerClassToAverageTesting, nrOfRegressors, indicesOfChosenExamplesGPSRMean );       
+      if (GPSRMean)
+        evaluateGPSRMean( kernelVector, GPSRMeanRightPart, rGPSRMean, timeForSingleExamplesGPSRMean, runsPerClassToAverageTesting, nrOfRegressors, indicesOfChosenExamplesGPSRMean );       
       
       //evaluate GP SR Var
       ClassificationResult rGPSRVar;
-      evaluateGPSRVar( kernelVector, GPSRVarCholesky, rGPSRVar, timeForSingleExamplesGPSRVar, runsPerClassToAverageTesting, nrOfRegressors, indicesOfChosenExamplesGPSRVar, noiseGPSRVarParas[cl] );       
+      if (GPSRVar)
+        evaluateGPSRVar( kernelVector, GPSRVarCholesky, rGPSRVar, timeForSingleExamplesGPSRVar, runsPerClassToAverageTesting, nrOfRegressors, indicesOfChosenExamplesGPSRVar, noiseGPSRVarParas[cl] );       
 
       
       //evaluate Parzen
       ClassificationResult rParzen;
-      evaluateParzen( kernelVector, rParzen, timeForSingleExamplesParzen, runsPerClassToAverageTesting ); 
+      if (Parzen)
+        evaluateParzen( kernelVector, rParzen, timeForSingleExamplesParzen, runsPerClassToAverageTesting ); 
       
       //evaluate SVDD
       ClassificationResult rSVDD;
-      evaluateSVDD( svdd, kernelVector, rSVDD, timeForSingleExamplesSVDD, runsPerClassToAverageTesting );       
+      if (SVDD)
+        evaluateSVDD( svdd, kernelVector, rSVDD, timeForSingleExamplesSVDD, runsPerClassToAverageTesting );       
 
       
       // set ground truth label
@@ -1012,14 +1037,32 @@ int main (int argc, char **argv)
     std::cerr << "SVDD -- time used for evaluation single elements of class " << cl << " : " << timeForSingleExamplesSVDD << std::endl;    
 
     // run the AUC-evaluation
-    double perfvalueGPVarApprox = resultsGPVarApprox.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
-    double perfvalueGPVar = resultsGPVar.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
-    double perfvalueGPMeanApprox = resultsGPMeanApprox.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
-    double perfvalueGPMean = resultsGPMean.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
-    double perfvalueGPSRMean = resultsGPSRMean.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
-    double perfvalueGPSRVar = resultsGPSRVar.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
-    double perfvalueParzen = resultsParzen.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
-    double perfvalueSVDD = resultsSVDD.getBinaryClassPerformance( ClassificationResults::PERF_AUC );    
+    double perfvalueGPVarApprox( 0.0 );
+    double perfvalueGPVar( 0.0 );
+    double perfvalueGPMeanApprox( 0.0 );
+    double perfvalueGPMean( 0.0 );
+    double perfvalueGPSRMean( 0.0 );
+    double perfvalueGPSRVar( 0.0 );
+    double perfvalueParzen( 0.0 );
+    double perfvalueSVDD( 0.0 );     
+
+    if (GPVarApprox)
+      perfvalueGPVarApprox = resultsGPVarApprox.getBinaryClassPerformance( ClassificationResults::PERF_AUC );    
+    if (GPVar)
+      perfvalueGPVar = resultsGPVar.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
+    if (GPMeanApprox)
+      perfvalueGPMeanApprox = resultsGPMeanApprox.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
+    if (GPMean)
+      perfvalueGPMean = resultsGPMean.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
+    if (GPSRMean)
+      perfvalueGPSRMean = resultsGPSRMean.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
+    if (GPSRVar)
+      perfvalueGPSRVar = resultsGPSRVar.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
+    if (Parzen)
+      perfvalueParzen = resultsParzen.getBinaryClassPerformance( ClassificationResults::PERF_AUC );
+    if (SVDD)
+      perfvalueSVDD = resultsSVDD.getBinaryClassPerformance( ClassificationResults::PERF_AUC );  
+
 
     std::cerr << "Performance GPVarApprox: " << perfvalueGPVarApprox << std::endl;
     std::cerr << "Performance GPVar: " << perfvalueGPVar << std::endl;