Changeset 551 for trunk/test/crossvalidation_test.cc

Timestamp:

Mar 7, 2006, 2:39:51 PM (17 years ago)

Author:

Markus Ringnér

Message:

Added tests of two nested CrossSplitters? to crossvalidation_test

File:

• trunk/test/crossvalidation_test.cc (modified) (2 diffs)

trunk/test/crossvalidation_test.cc

@@ -12 +12 @@
 #include <vector>
 
+// forward declaration
+void class_count_test(const std::vector<size_t>&, std::ostream*, bool&);
+void sample_count_test(const std::vector<size_t>&, std::ostream*, bool&);
+
+
 int main(const int argc,const char* argv[])
 {  
   using namespace theplu;
-
+  
   std::ostream* error;
   if (argc>1 && argv[1]==std::string("-v"))
@@ -58 +63 @@
       class_count[target(cv.training_index()[i])]++;
     }
-    for (size_t i=0; i<class_count.size(); i++)
-      if (class_count[i]==0){
-        ok = false;
-        *error << "ERROR: class " << i << " was not in training set." 
-                  << " Expected at least one sample from each class." 
-                  << std::endl;
+    class_count_test(class_count,error,ok);
+  }
+  sample_count_test(sample_count,error,ok);
+  
+  //
+  // Test two nested CrossSplitters 
+  //
+
+  *error << "\ntesting two nested crossplitters" << std::endl;
+  label.resize(9);
+  label[0]=label[1]=label[2]="0";
+  label[3]=label[4]=label[5]="1";
+  label[6]=label[7]=label[8]="2";
+                 
+  target=classifier::Target(label);
+  gslapi::matrix raw_data2(2,9);
+  for(size_t i=0;i<raw_data2.rows();i++)
+    for(size_t j=0;j<raw_data2.columns();j++)
+      raw_data2(i,j)=i*10+10+j+1;
+    
+  classifier::MatrixLookup data2(raw_data2);
+  classifier::CrossSplitter cv_test(target,data2,3,3);
+
+  std::vector<size_t> test_sample_count(9,0);
+  std::vector<size_t> test_class_count(3,0);
+  std::vector<double> test_value1(4,0);
+  std::vector<double> test_value2(4,0);
+  std::vector<double> t_value(4,0);
+  std::vector<double> v_value(4,0); 
+  while(cv_test.more()) {
+    
+    const classifier::DataLookup2D& tv_view=cv_test.training_data();
+    const classifier::Target& tv_target=cv_test.training_target();
+    const std::vector<size_t>& tv_index=cv_test.training_index();
+    const classifier::DataLookup2D& test_view=cv_test.validation_data();
+    const classifier::Target& test_target=cv_test.validation_target();
+    const std::vector<size_t>& test_index=cv_test.validation_index();
+
+    for (size_t i=0; i<test_index.size(); i++) {
+      assert(test_index[i]<sample_count.size());
+      test_sample_count[test_index[i]]++;
+      test_class_count[target(test_index[i])]++;
+      test_value1[0]+=test_view(0,i);
+      test_value2[0]+=test_view(1,i);
+      test_value1[test_target(i)+1]+=test_view(0,i);
+      test_value2[test_target(i)+1]+=test_view(1,i);
+      if(test_target(i)!=target(test_index[i])) {
+        ok=false;
+        *error << "ERROR: incorrect mapping of test indices" << std:: endl;
+      }        
+    }
+    
+    classifier::CrossSplitter cv_training(tv_target,tv_view,2,2);
+    std::vector<size_t> v_sample_count(6,0);
+    std::vector<size_t> t_sample_count(6,0);
+    std::vector<size_t> v_class_count(3,0);
+    std::vector<size_t> t_class_count(3,0);
+    std::vector<size_t> t_class_count2(3,0);
+    while(cv_training.more()) {
+      const classifier::DataLookup2D& t_view=cv_training.training_data();
+      const classifier::Target& t_target=cv_training.training_target();
+      const std::vector<size_t>& t_index=cv_training.training_index();
+      const classifier::DataLookup2D& v_view=cv_training.validation_data();
+      const classifier::Target& v_target=cv_training.validation_target();
+      const std::vector<size_t>& v_index=cv_training.validation_index();
+      
+      if (test_index.size()+tv_index.size()!=target.size() 
+          || t_index.size()+v_index.size() != tv_target.size() 
+          || test_index.size()+v_index.size()+t_index.size() !=  target.size()){
+        ok = false;
+        *error << "ERROR: size of training samples, validation samples " 
+               << "and test samples in is invalid." 
+               << std::endl;
+      }
+      if (test_index.size()!=3 || tv_index.size()!=6 || t_index.size()!=3 ||
+          v_index.size()!=3){
+        ok = false;
+        *error << "ERROR: size of training, validation, and test samples"
+               << " is invalid." 
+               << " Expected sizes to be 3" << std::endl;
+      }     
+
+      for (size_t i=0; i<t_index.size(); i++) {
+        assert(t_index[i]<t_sample_count.size());
+        t_sample_count[t_index[i]]++;
+        t_class_count[t_target(i)]++;
+        t_class_count2[tv_target(t_index[i])]++;
+        t_value[0]+=t_view(0,i);
+        t_value[t_target(i)+1]+=t_view(0,i);
       }
-  }
-  for (size_t i=0; i<sample_count.size(); i++){
-    if (sample_count[i]!=1){
-      ok = false;
-      *error << "ERROR: sample " << i << " was validated " << sample_count[i] 
-                << " times." << " Expected to be 1 time" << std::endl;
-    }
-  }
-  
+      for (size_t i=0; i<v_index.size(); i++) {
+        assert(v_index[i]<v_sample_count.size());
+        v_sample_count[v_index[i]]++;
+        v_class_count[v_target(i)]++;
+        v_value[0]+=v_view(0,i);
+        v_value[v_target(i)+1]+=v_view(0,i);
+      }
+
+      cv_training.next();     
+    }
+    sample_count_test(v_sample_count,error,ok);
+    sample_count_test(t_sample_count,error,ok);
+    
+    class_count_test(t_class_count,error,ok);
+    class_count_test(t_class_count2,error,ok);
+    class_count_test(v_class_count,error,ok);
+
+
+    cv_test.next();
+  }
+  sample_count_test(test_sample_count,error,ok);
+  class_count_test(test_class_count,error,ok);
+  
+  if(test_value1[0]!=135 || test_value1[1]!=36 || test_value1[2]!=45 ||
+     test_value1[3]!=54) {
+    ok=false;
+    *error << "ERROR: incorrect sums of test values in row 1" 
+           << " found: " << test_value1[0] << ", "  << test_value1[1] 
+           << ", "  << test_value1[2] << " and "  << test_value1[3] 
+           << std::endl;
+  }
+
+  
+  if(test_value2[0]!=225 || test_value2[1]!=66 || test_value2[2]!=75 ||
+     test_value2[3]!=84) {
+    ok=false;
+    *error << "ERROR: incorrect sums of test values in row 2" 
+           << " found: " << test_value2[0] << ", "  << test_value2[1] 
+           << ", "  << test_value2[2] << " and "  << test_value2[3] 
+           << std::endl;
+  }
+
+  if(t_value[0]!=270 || t_value[1]!=72 || t_value[2]!=90 || t_value[3]!=108)  {
+    ok=false;
+    *error << "ERROR: incorrect sums of training values in row 1" 
+           << " found: " << t_value[0] << ", "  << t_value[1] 
+           << ", "  << t_value[2] << " and "  << t_value[3] 
+           << std::endl;    
+  }
+
+  if(v_value[0]!=270 || v_value[1]!=72 || v_value[2]!=90 || v_value[3]!=108)  {
+    ok=false;
+    *error << "ERROR: incorrect sums of validation values in row 1" 
+           << " found: " << v_value[0] << ", "  << v_value[1] 
+           << ", "  << v_value[2] << " and "  << v_value[3] 
+           << std::endl;    
+  }
+
+
+
   if (error!=&std::cerr)
     delete error;
-
+  
   if (ok)
     return 0;
   return -1;
 }
+
+
+void class_count_test(const std::vector<size_t>& class_count, 
+                      std::ostream* error, bool& ok)  
+{
+  for (size_t i=0; i<class_count.size(); i++)
+    if (class_count[i]==0){
+      ok = false;
+      *error << "ERROR: class " << i << " was not in set." 
+             << " Expected at least one sample from each class." 
+             << std::endl;
+    }
+}
+
+void sample_count_test(const std::vector<size_t>& sample_count, 
+                       std::ostream* error, bool& ok)  
+{
+  for (size_t i=0; i<sample_count.size(); i++){
+    if (sample_count[i]!=1){
+      ok = false;
+      *error << "ERROR: sample " << i << " was validated " << sample_count[i] 
+             << " times." << " Expected to be 1 time" << std::endl;
+    }
+  }
+}