Changeset 1142 for trunk/test

Timestamp:

Feb 25, 2008, 3:32:35 PM (15 years ago)

Author:

Markus Ringnér

Message:

Refs #335, fixed for NCC, working on KNN

Location:

trunk/test

Files:

• knn_test.cc (modified) (4 diffs)
• ncc_test.cc (modified) (1 diff)

trunk/test/knn_test.cc

@@ -124 +124 @@
   ////////////////////////////////////////////////////////////////
   *error << "test of predictions using weighted training and test data\n";
+  *error << "... uniform neighbor weighting" << std::endl;
   weights1(0,1)=0;
   utility::Matrix weights2(3,4,1.0);
@@ -146 +147 @@
   // A test of reciprocal ranks weighting with training and test both weighted 
   ////////////////////////////////////////////////////////////////
+  *error << "... reciprokal rank neighbor weighting" << std::endl;
   utility::Matrix data2(data1);
   data2(1,3)=7;
@@ -166 +168 @@
   }
 
-
+  
   ////////////////////////////////////////////////////////////////
   // A test of reciprocal distance weighting with training and test both weighted 
   ////////////////////////////////////////////////////////////////
+  *error << "... reciprokal distance neighbor weighting" << std::endl;
   classifier::KNN<statistics::EuclideanDistance,classifier::KNN_ReciprocalDistance> 
     knn4(mlw2,target1);
@@ -175 +178 @@
   knn4.train();
   knn4.predict(mlw3,prediction1); 
-  slack = deviation(prediction1,result1); 
-  if (!std::isinf(prediction1(0,0)) && !std::isinf(prediction1(0,1)) && 
-      !std::isinf(prediction1(1,2)) && 
-      fabs(prediction1(1,3)-(1.0/3.67423461417))>slack_bound &&
-      fabs(prediction1(1,0)-(1.0/2.82842712475+1.0/2.44948974278))>slack_bound){
-    *error << "Difference to expected prediction too large\n";
-    ok = false;
-  }
+  if (!(std::isinf(prediction1(0,0)) && std::isinf(prediction1(0,1)) && 
+        std::isinf(prediction1(1,2)) && 
+        fabs(prediction1(1,3)-(1.0/3.67423461417))<slack_bound &&
+        fabs(prediction1(1,0)-(1.0/2.82842712475+1.0/2.44948974278))<slack_bound)){
+    *error << "Difference to expected prediction too large\n";
+    ok = false;
+  }
+
+
+  ////////////////////////////////////////////////////////////////
+  // A test of when a class has no training samples, should give nan
+  // in predictions. Also tests that k is reduced if not enough
+  // training samples.
+  ////////////////////////////////////////////////////////////////
+  //Keep only the second class in the training samples
+  std::vector<size_t> ind(2,2);
+  ind[1]=3;
+  classifier::Target target2(target1,utility::Index(ind));
+  classifier::MatrixLookupWeighted mlw4(data1,weights2,utility::Index(ind),false);
+  classifier::KNN<statistics::EuclideanDistance> knn5(mlw4,target2);
+  knn5.k(3);
+  knn5.train();
+  knn5.predict(mlw3,prediction1); 
+  if (!(std::isnan(prediction1(0,0)) && std::isnan(prediction1(0,1)) && 
+        std::isnan(prediction1(0,2)) && std::isnan(prediction1(0,3)) &&
+        fabs(prediction1(1,0)-2.0)<slack_bound &&
+        fabs(prediction1(1,1)-2.0)<slack_bound &&
+        fabs(prediction1(1,2)-2.0)<slack_bound &&
+        fabs(prediction1(1,3)-2.0)<slack_bound)) {
+    *error << "Difference to expected prediction too large\n";
+    ok = false;
+  }
+
+  ////////////////////////////////////////////////////////////////
+  // A test of when a test sample has no variables with non-zero
+  // weights in common with training samples: should give nan distance
+  ////////////////////////////////////////////////////////////////
+  *error << "test of predictions with nan distances\n";
+  weights1.all(1);
+  weights1(1,0)=weights1(1,1)=weights1(2,0)=weights1(2,1)=0.0;
+  weights2.all(1);
+  weights2(0,0)=0.0;
+  classifier::KNN<statistics::EuclideanDistance> knn6(mlw1,target1);
+  knn6.k(3);
+  knn6.train();
+  knn6.predict(mlw3,prediction1); 
+  // std::cout << "train:\n" << mlw1 << std::endl;
+  // std::cout << "test:\n" << mlw3 << std::endl;
+  // std::cout << "pred:\n" << prediction1 << std::endl;
+
 
   if(!ok) {

trunk/test/ncc_test.cc

@@ -159 +159 @@
 
   //////////////////////////////////////////////////////////////////////////
+  // A test of predictions when a centroid has nan for all variables that a
+  // test sample has non-zero weights for.
+  //////////////////////////////////////////////////////////////////////////
+  *error << "test of predictions using nan centroids and weighted test data\n";
+  *error << "... using EuclideanDistance" << std::endl;
+  weights1(0,0)=weights1(2,0)=0;
+  classifier::NCC<statistics::EuclideanDistance> ncc3(mlw2,target1);
+  ncc3.train();
+  ncc3.predict(mlw1,prediction1); 
+  if(!std::isnan(ncc3.centroids()(1,0))) {
+    ok=false;
+    *error << "Training failed: expected nan in centroid" << std::endl;
+  }
+  if(!(std::isnan(prediction1(0,0)) &&
+       fabs(prediction1(1,0)-sqrt(3.0))<slack_bound &&
+       fabs(prediction1(0,1)-sqrt(3.0))<slack_bound &&
+       fabs(prediction1(1,1)-sqrt(15.0))<slack_bound &&
+       fabs(prediction1(0,2)-sqrt(27.0))<slack_bound)) {  
+    ok=false; 
+    *error << "Test failed: predictions incorrect" << std::endl;
+  }
+  *error << "... using PearsonDistance" << std::endl;;
+  classifier::NCC<statistics::PearsonDistance> ncc4(mlw2,target1);
+  ncc4.train();
+  ncc4.predict(mlw1,prediction1); 
+  if(!std::isnan(ncc4.centroids()(1,0))) {
+    ok=false;
+    *error << "Training failed: expected nan in centroid" << std::endl;
+  }
+  if(!(std::isnan(prediction1(0,0)) &&
+       std::isnan(prediction1(0,2)) &&
+       std::isnan(prediction1(1,0)) &&
+       fabs(prediction1(0,1))<slack_bound &&
+       fabs(prediction1(1,2))<slack_bound &&
+       fabs(prediction1(1,3))<slack_bound &&  
+       fabs(prediction1(0,3)-2.0)<slack_bound &&
+       fabs(prediction1(1,1)-2.0)<slack_bound)) {
+    ok=false; 
+    *error << "Test failed: predictions incorrect" << std::endl;
+  }
+
+
+  //////////////////////////////////////////////////////////////////////////
   // A test of predictions using Sorlie data
   //////////////////////////////////////////////////////////////////////////