Changeset 463

Timestamp:

Dec 16, 2005, 6:59:15 PM (17 years ago)

Author:

Peter

Message:

fixed bug in KernelView? constructor and updated tests

Location:

trunk

Files:

• lib/classifier/KernelView.cc (modified) (1 diff)
• lib/classifier/KernelView.h (modified) (1 diff)
• lib/classifier/SVM.cc (modified) (1 diff)
• test/crossvalidation_test.cc (modified) (2 diffs)
• test/kernel_test.cc (modified) (6 diffs)
• test/score_test.cc (modified) (2 diffs)
• test/svm_test.cc (modified) (6 diffs)

trunk/lib/classifier/KernelView.cc

@@ -8 +8 @@
 namespace classifier {  
 
+  KernelView::KernelView(const Kernel& kernel)
+    : MatrixView(), kernel_(&kernel)
+  {
+    for(size_t i=0;i<(*kernel_).size();i++)
+      column_index_.push_back(i);
+    row_index_=column_index_;
+  }
+  
+  KernelView::KernelView(const Kernel& kernel, 
+                         const std::vector<size_t>& index)
+    : MatrixView(index,index), kernel_(&kernel)
+  {
+  }
+  
   KernelView::KernelView(const Kernel& kernel, 
                          const std::vector<size_t>& row, 

trunk/lib/classifier/KernelView.h

@@ -21 +21 @@
   public:
     
+    ///
+    /// Constructor
+    ///
+    KernelView(const Kernel&);
+
+    /// 
+    /// Contructor taking the Kernel to view into, index
+    /// vector. Equivalent to KernelView(kernel, index, index).
+    ///
+    /// @note For training usage row index shall always be equal to
+    /// column index.
+    ///
+    KernelView(const Kernel& kernel, const std::vector<size_t>& index); 
+    
     /// 
     /// Contructor taking the Kernel to view into, row index vector,
-    /// and column vector. 
+    /// and column index vector. 
     ///
     /// @note For training usage row index shall always be equal to

trunk/lib/classifier/SVM.cc

@@ -10 +10 @@
 #include <c++_tools/random/random.h>
 
-#include <iostream>
 #include <algorithm>
+#include <cassert>
 #include <cmath>
 #include <limits>

trunk/test/crossvalidation_test.cc

@@ -1 +1 @@
 // $Id$
 
-#include <c++_tools/classifier/CrossValidation.h>
+#include <c++_tools/classifier/CrossSplitting.h>
 #include <c++_tools/gslapi/vector.h>
 
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
 #include <vector>
-#include <cstdlib>
-#include <iostream>
 
-using namespace theplu;
-
-int main()
+int main(const int argc,const char* argv[])
 {  
 
+  using namespace theplu;
+
+  std::ostream* error;
+  if (argc>1 && argv[1]==std::string("-v"))
+    error = &std::cerr;
+  else {
+    error = new std::ofstream("/dev/null");
+    if (argc>1)
+      std::cout << "crossvalidation_test -v : for printing extra information\n";
+  }
+  *error << "testing crosssplitting" << std::endl;
+  bool ok = true;
   gslapi::vector target(10,1);
   for (size_t i=0; i<5; i++) 
     target(i)=-1;
 
-  classifier::CrossValidation cv(target,3);
+  classifier::CrossSplitting cv(target,3);
 
 
@@ -36 +47 @@
 
   for (unsigned int i=0; i<10 ; i++) 
-    if (count[i]!=2)
-      return -1;
+    ok = ok && (count[i]==2);
 
+  if (!ok)
+    *error << "crossvalidation failed" << std::endl;
+
+  if (error!=&std::cerr)
+    delete error;
   return 0;
 }

trunk/test/kernel_test.cc

@@ -22 +22 @@
 
 bool test_MEV(const gslapi::matrix& data, const classifier::KernelFunction* kf, 
-              const gslapi::matrix& control, const double error_bound)
+              const gslapi::matrix& control, const double error_bound,
+              std::ostream* error)
 {
   classifier::Kernel_MEV kernel(data,*kf);
@@ -35 +36 @@
   index[1]=2;
   index[2]=3;
-  classifier::KernelView(kernel,index);
+  classifier::KernelView kv(kernel,index);
+  if (kv.rows()!=index.size()){
+    *error << "Error: KernelView(kernel, index)\n" << std::endl
+           << "Size of KernelView is " << kv.rows() << std::endl
+           << "expected " << index.size() << std::endl;
+    
+    return false;
+  }
+  classifier::KernelView kv2(kernel);
+  if (kv2.rows()!=kernel.size()){
+    *error << "Error: KernelView(kernel)\n" << std::endl
+           << "Size of KernelView is " << kv.rows() << std::endl
+           << "expected " << kernel.size() << std::endl;
+    
+    return false;
+  }
 
   return true;
@@ -41 +57 @@
 
 bool test_SEV(const gslapi::matrix& data, const classifier::KernelFunction* kf, 
-              const gslapi::matrix& control, const double error_bound)
+              const gslapi::matrix& control, const double error_bound,
+              std::ostream* error)
 {
   classifier::Kernel_SEV kernel(data,*kf);
@@ -54 +71 @@
   index[1]=2;
   index[2]=3;
-  classifier::KernelView(kernel,index);
+  classifier::KernelView kv(kernel,index);
+  if (kv.rows()!=index.size()){
+    *error << "Error: KernelView(kernel, index)\n" << std::endl
+           << "Size of KernelView is " << kv.rows() << std::endl
+           << "expected " << index.size() << std::endl;
+    
+    return false;
+  }
+  classifier::KernelView kv2(kernel);
+  if (kv2.rows()!=kernel.size()){
+    *error << "Error: KernelView(kernel)\n" << std::endl
+           << "Size of KernelView is " << kv.rows() << std::endl
+           << "expected " << kernel.size() << std::endl;
+    
+    return false;
+  }
   return true;
 }
@@ -85 +117 @@
   is.close();
   classifier::KernelFunction* kf = new classifier::PolynomialKernelFunction(); 
-  ok = (ok && test_MEV(data,kf,kernel_matlab,error_bound)
-        & test_SEV(data,kf,kernel_matlab,error_bound));
+  ok = (ok && test_MEV(data,kf,kernel_matlab,error_bound, error)
+        & test_SEV(data,kf,kernel_matlab,error_bound, error));
   delete kf;
   
@@ -93 +125 @@
   is.close();
   kf = new classifier::PolynomialKernelFunction(2); 
-  ok = (ok && test_MEV(data,kf,kernel_matlab2,error_bound)
-        & test_SEV(data,kf,kernel_matlab2,error_bound));
+  ok = (ok && test_MEV(data,kf,kernel_matlab2,error_bound, error)
+        & test_SEV(data,kf,kernel_matlab2,error_bound, error));
   delete kf;
 

trunk/test/score_test.cc

@@ -7 +7 @@
 #include <c++_tools/statistics/FoldChange.h>
 #include <c++_tools/gslapi/vector.h>
+#include <c++_tools/statistics/WilcoxonFoldChange.h>
 
 #include <gsl/gsl_cdf.h>
@@ -108 +109 @@
   statistics::Pearson pearson(true);
 
+  *error << "testing WilcoxonFoldChange" << std::endl;
+  statistics::WilcoxonFoldChange wfc(true);
+
 
   if (ok)

trunk/test/svm_test.cc

@@ -20 +20 @@
 {  
 
-  bool print = (argc>1 && argv[1]==std::string("-p"));
+  std::ostream* error;
+  if (argc>1 && argv[1]==std::string("-v"))
+    error = &std::cerr;
+  else {
+    error = new std::ofstream("/dev/null");
+    if (argc>1)
+      std::cout << "svm_test -v : for printing extra information\n";
+  }
+  *error << "testing svm" << std::endl;
   bool ok = true;
 
@@ -37 +45 @@
   classifier::Kernel_MEV kernel2(data2,*kf2);
   assert(kernel2.size()==3);
-  classifier::SVM classifier2(kernel2, target2);
+  assert(target2.size()==3);
+  classifier::KernelView kv2(kernel2);
+  *error << "testing with linear kernel" << std::endl;
+  assert(kv2.rows()==target2.size());
+  classifier::SVM classifier2(kv2, target2);
+  *error << "training...";
   classifier2.train();
+  *error << " done." << std::endl;
 
   if (classifier2.alpha()*target2){
-    std::cerr << "condition not fullfilled" << std::endl;
+    *error << "condition not fullfilled" << std::endl;
     return -1;
   }
 
   if (classifier2.alpha()(1)!=2 || classifier2.alpha()(2)!=2){
-    std::cerr << "wrong alpha" << std::endl;
-    std::cerr << "alpha: " << classifier2.alpha() <<  std::endl;
-    std::cerr << "expected: 4 2 2" <<  std::endl;
+    *error << "wrong alpha" << std::endl;
+    *error << "alpha: " << classifier2.alpha() <<  std::endl;
+    *error << "expected: 4 2 2" <<  std::endl;
 
     return -1;
@@ -73 +87 @@
   is.close();
 
-  theplu::classifier::SVM classifier(kernel, target);
-  if (!classifier.train()){
+  classifier::KernelView kv(kernel);
+  theplu::classifier::SVM svm(kv, target);
+  if (!svm.train()){
     ok=false;
-    if (print)
-      std::cerr << "Training failured" << std::endl;
+    *error << "Training failured" << std::endl;
   }
 
-  theplu::gslapi::vector alpha = classifier.alpha();
+  theplu::gslapi::vector alpha = svm.alpha();
       
   // Comparing alpha to alpha_matlab
@@ -86 +100 @@
   diff_alpha-=alpha_matlab;
   if (diff_alpha*diff_alpha> 1e-10 ){
-    if (print) 
-      std::cerr << "Difference to matlab alphas too large\n";
+    *error << "Difference to matlab alphas too large\n";
     ok=false;
   }
 
   // Comparing output to target
-  theplu::gslapi::vector output(classifier.output());
+  theplu::gslapi::vector output(svm.output());
   double slack = 0;
   for (unsigned int i=0; i<target.size(); i++){
@@ -101 +114 @@
   double slack_bound=2e-7;
   if (slack > slack_bound){
-    if (print){
-      std::cerr << "Slack too large. Is the bias correct?\n";
-      std::cerr << "slack: " << slack << std::endl;
-      std::cerr << "expected less than " << slack_bound << std::endl;
-    }
+    *error << "Slack too large. Is the bias correct?\n";
+    *error << "slack: " << slack << std::endl;
+    *error << "expected less than " << slack_bound << std::endl;
     ok = false;
   }
@@ -112 +123 @@
   delete kf2;
 
+  if (error!=&std::cerr)
+    delete error;
+
   if(ok)
     return 0;