Changeset 1013 for trunk/test

Timestamp:

Feb 1, 2008, 4:34:30 PM (15 years ago)

Author:

Markus Ringnér

Message:

Adding functionality tests for NCC

File:

• trunk/test/ncc_test.cc (modified) (9 diffs)

trunk/test/ncc_test.cc

@@ -31 +31 @@
 #include "yat/classifier/Target.h"
 #include "yat/utility/matrix.h"
+#include "yat/statistics/euclidean_vector_distance.h"
 #include "yat/statistics/pearson_vector_distance.h"
 #include "yat/utility/utility.h"
@@ -45 +46 @@
 using namespace theplu::yat;
 
+double deviation(const utility::matrix& a, const utility::matrix& b) {
+  double sl=0;
+  for (size_t i=0; i<a.rows(); i++){
+    for (size_t j=0; j<a.columns(); j++){
+      sl += fabs(a(i,j)-b(i,j));
+    }
+  }
+  sl /= (a.columns()*a.rows());
+  return sl;
+}
+
 int main(const int argc,const char* argv[])
 {  
@@ -59 +71 @@
   bool ok = true;
 
+  /////////////////////////////////////////////
+  // First test of constructor and training  
+  /////////////////////////////////////////////
   classifier::MatrixLookup ml(4,4);
   std::vector<std::string> vec(4, "pos");
@@ -66 +81 @@
   *error << "training...\n";
   ncctmp.train();
+  *error << "done\n";
+
+  /////////////////////////////////////////////
+  // A test of predictions using unweighted data
+  /////////////////////////////////////////////
+  utility::matrix data1(3,4);
+  for(size_t i=0;i<3;i++) {
+    data1(i,0)=3-i;
+    data1(i,1)=5-i;
+    data1(i,2)=i+1;
+    data1(i,3)=i+3;
+  }
+  std::vector<std::string> vec1(4, "pos");
+  vec1[0]="neg";
+  vec1[1]="neg";
+
+  classifier::MatrixLookup ml1(data1);
+  classifier::Target target1(vec1);
+
+  classifier::NCC<statistics::euclidean_vector_distance_tag> ncc1(ml1,target1);
+  ncc1.train();
+  utility::matrix prediction1;
+  ncc1.predict(ml1,prediction1);
+  double slack_bound=2e-7;
+  utility::matrix result1(2,4);
+  result1(0,0)=result1(0,1)=result1(1,2)=result1(1,3)=sqrt(3.0);
+  result1(0,2)=result1(0,3)=result1(1,0)=result1(1,1)=sqrt(11.0);
+  double slack = deviation(prediction1,result1); 
+  if (slack > slack_bound || std::isnan(slack)){
+    *error << "Difference to expected prediction too large\n";
+    *error << "slack: " << slack << std::endl;
+    *error << "expected less than " << slack_bound << std::endl;
+    ok = false;
+  }
+
+  //////////////////////////////////////////////////////////////////////////
+  // A test of predictions using unweighted training and weighted test data
+  //////////////////////////////////////////////////////////////////////////
+  utility::matrix weights1(3,4,1.0);
+  weights1(0,0)=weights1(1,1)=weights1(2,2)=weights1(1,3)=0.0;
+  classifier::MatrixLookupWeighted mlw1(data1,weights1);
+  ncc1.predict(mlw1,prediction1); 
+  result1(0,2)=result1(0,3)=result1(1,0)=result1(1,1)=sqrt(15.0);
+  slack = deviation(prediction1,result1);
+  if (slack > slack_bound || std::isnan(slack)){
+    *error << "Difference to expected prediction too large\n";
+    *error << "slack: " << slack << std::endl;
+    *error << "expected less than " << slack_bound << std::endl;
+    ok = false;
+  }
+
   
+
+  //////////////////////////////////////////////////////////////////////////
+  // A test of predictions using Sorlie data
+  //////////////////////////////////////////////////////////////////////////
   std::ifstream is("data/sorlie_centroid_data.txt");
   utility::matrix data(is,'\t');
@@ -98 +168 @@
   }
 
-  double slack = 0;
-  for (size_t i=0; i<centroids.rows(); i++){
-    for (size_t j=0; j<centroids.columns(); j++){
-      slack += fabs(centroids(i,j)-ncc.centroids()(i,j));
-    }
-  }
-  slack /= (centroids.columns()*centroids.rows());
-  double slack_bound=2e-7;
+  slack = deviation(centroids,ncc.centroids());
   if (slack > slack_bound || std::isnan(slack)){
     *error << "Difference to stored centroids too large\n";
@@ -113 +176 @@
   }
 
-  *error << "prediction...\n";
+  *error << "...predicting...\n";
   utility::matrix prediction;
   ncc.predict(dataviewweighted,prediction);
@@ -122 +185 @@
   is.close();
 
-  slack = 0;
-  for (size_t i=0; i<result.rows(); i++){
-    for (size_t j=0; j<result.columns(); j++){
-        slack += fabs(result(i,j)-prediction(i,j));
-    }
-  }
-  slack /= (result.columns()*result.rows());
+  slack = deviation(result,prediction);
   if (slack > slack_bound || std::isnan(slack)){
     *error << "Difference to stored prediction too large\n";
@@ -135 +192 @@
     ok = false;
   }
-
-  // testing rejection of KernelLookups
+  *error << "done\n";
+
+  //////////////////////////////////////////////////////////////////////////
+  // Testing rejection of KernelLookups
+  //////////////////////////////////////////////////////////////////////////
   classifier::PolynomialKernelFunction kf;
   classifier::Kernel_MEV kernel(ml,kf);
@@ -161 +221 @@
     *error << "OK" << std::endl;
 
-
   if (error!=&std::cerr)
     delete error;