Changeset 948

Timestamp:

Oct 8, 2007, 4:06:53 PM (16 years ago)

Author:

Markus Ringnér

Message:

Adding support and checks for intended lookups in classifiers

Location:

trunk

Files:

• test/knn_test.cc (modified) (1 diff)
• test/ncc_test.cc (modified) (1 diff)
• yat/classifier/KNN.h (modified) (7 diffs)
• yat/classifier/NBC.cc (modified) (1 diff)
• yat/classifier/NCC.h (modified) (2 diffs)

trunk/test/knn_test.cc

@@ -46 +46 @@
   classifier::MatrixLookupWeighted dataviewweighted(data,weights);
   classifier::KNN<statistics::pearson_vector_distance_tag> knn(dataviewweighted,targets);
-  *error << "Training KNN" << std::endl;
+  *error << "training KNN" << std::endl;
   knn.train();
   
   utility::matrix prediction;
   knn.predict(dataviewweighted,prediction);
+  *error << prediction << std::endl;
   
   if(!ok) {
-    *error << "vector_distance_test failed" << std::endl;
+    *error << "knn_test failed" << std::endl;
+  }
+  else {
+    *error << "OK" << std::endl;
   }
   if (error!=&std::cerr)

trunk/test/ncc_test.cc

@@ -148 +148 @@
     ok=1;
   }
+  try {
+    ok=0; // should catch error here
+    ncc.predict(*dl_kernel,prediction); 
+  }
+  catch (std::runtime_error) {    
+    *error << "caught expected bad cast runtime_error" << std::endl;
+    ok=1;
+  }
   delete dl_kernel;
   

trunk/yat/classifier/KNN.h

@@ -5 +5 @@
 
 #include "DataLookupWeighted1D.h"
+#include "MatrixLookup.h"
 #include "MatrixLookupWeighted.h"
 #include "SupervisedClassifier.h"
@@ -31 +32 @@
   public:
     ///
-    /// Constructor taking the training data with weights, the target
-    /// vector, the distance measure, and a weight matrix for the
-    /// training data as input.
+    /// Constructor taking the training data and the target   
+    /// as input.
+    ///
+    KNN(const MatrixLookup&, const Target&);
+
+
+    ///
+    /// Constructor taking the training data with weights and the
+    /// target as input.
     ///
     KNN(const MatrixLookupWeighted&, const Target&);
@@ -93 +100 @@
     utility::matrix* calculate_distances(const DataLookup2D&) const;
   };
-
-  ///
-  /// The output operator for the KNN class.
-  ///
-  //  std::ostream& operator<< (std::ostream&, const KNN&);
   
   
   // templates
   
+  template <typename Distance>
+  KNN<Distance>::KNN(const MatrixLookup& data, const Target& target) 
+    : SupervisedClassifier(target), data_(data),k_(3)
+  {
+  }
+
+
   template <typename Distance>
   KNN<Distance>::KNN(const MatrixLookupWeighted& data, const Target& target) 
@@ -116 +125 @@
   utility::matrix* KNN<Distance>::calculate_distances(const DataLookup2D& input) const
   {
-    const MatrixLookupWeighted* weighted_data = 
-      dynamic_cast<const MatrixLookupWeighted*>(&data_);
-    const MatrixLookupWeighted* weighted_input = 
-      dynamic_cast<const MatrixLookupWeighted*>(&input);  
-
     // matrix with training samples as rows and test samples as columns
     utility::matrix* distances = 
       new utility::matrix(data_.columns(),input.columns());
-      
-    if(weighted_data && weighted_input) {
+    
+    // if both training and test are unweighted: unweighted
+    // calculations are used.
+    const MatrixLookup* test_unweighted = 
+      dynamic_cast<const MatrixLookup*>(&input);      
+    if(test_unweighted && !data_.weighted()) {
+      const MatrixLookup* data_unweighted = 
+        dynamic_cast<const MatrixLookup*>(&data_);      
       for(size_t i=0; i<data_.columns(); i++) {
-        classifier::DataLookupWeighted1D training(*weighted_data,i,false);
+        classifier::DataLookup1D training(*data_unweighted,i,false);
         for(size_t j=0; j<input.columns(); j++) {
-          classifier::DataLookupWeighted1D test(*weighted_input,j,false);
+          classifier::DataLookup1D test(*test_unweighted,j,false);
           utility::yat_assert<std::runtime_error>(training.size()==test.size());
           (*distances)(i,j) =
@@ -138 +148 @@
       }
     }
+    // if either training or test is weighted: weighted calculations
+    // are used.
     else {
-      std::string str;
-      str = "Error in KNN::calculate_distances: Only MatrixLookupWeighted supported still.";
-      throw std::runtime_error(str);
+      const MatrixLookupWeighted* data_weighted = 
+        dynamic_cast<const MatrixLookupWeighted*>(&data_);
+      const MatrixLookupWeighted* test_weighted = 
+        dynamic_cast<const MatrixLookupWeighted*>(&input);                
+      if(data_weighted && test_weighted) {
+        for(size_t i=0; i<data_.columns(); i++) {
+          classifier::DataLookupWeighted1D training(*data_weighted,i,false);
+          for(size_t j=0; j<input.columns(); j++) {
+            classifier::DataLookupWeighted1D test(*test_weighted,j,false);
+            utility::yat_assert<std::runtime_error>(training.size()==test.size());
+            (*distances)(i,j) =
+              statistics::vector_distance(training.begin(),training.end(),
+                                          test.begin(), typename statistics::vector_distance_traits<Distance>::distance());
+            utility::yat_assert<std::runtime_error>(!std::isnan((*distances)(i,j)));
+          }
+        }
+      }
+      else {
+        std::string str;
+        str = "Error in KNN::calculate_distances: Only support when training and test data both are either MatrixLookup or MatrixLookupWeighted";
+        throw std::runtime_error(str);
+      }
     }
     return distances;
@@ -176 +207 @@
                               target);
       }  
+      else {
+        knn=new KNN<Distance>(dynamic_cast<const MatrixLookup&>(data),
+                              target);
+      }
       knn->k(this->k());
     }
@@ -210 +245 @@
       }
     }
+    prediction*=(1.0/k_);
     delete distances;
   }

trunk/yat/classifier/NBC.cc

@@ -63 +63 @@
   NBC::make_classifier(const DataLookup2D& data, const Target& target) const 
   {     
-    NBC* ncc=0;
-    if(data.weighted()) {
-      ncc=new NBC(dynamic_cast<const MatrixLookupWeighted&>(data),target);
+    NBC* nbc=0;
+    try {
+      if(data.weighted()) {
+        nbc=new NBC(dynamic_cast<const MatrixLookupWeighted&>(data),target);
+      }
+      else {
+        nbc=new NBC(dynamic_cast<const MatrixLookup&>(data),target);
+      }     
     }
-    else {
-      ncc=new NBC(dynamic_cast<const MatrixLookup&>(data),target);
+    catch (std::bad_cast) {
+      std::string str = "Error in NBC::make_classifier: DataLookup2D of unexpected class.";
+      throw std::runtime_error(str);
     }
-    return ncc;
+    return nbc;
   }
 

trunk/yat/classifier/NCC.h

@@ -246 +246 @@
       const MatrixLookupWeighted* test_weighted =
         dynamic_cast<const MatrixLookupWeighted*>(&input);      
-      MatrixLookupWeighted weighted_centroids(*centroids_);
       if(test_weighted) {
+        MatrixLookupWeighted weighted_centroids(*centroids_);
         for(size_t j=0; j<input.columns();j++) {        
           DataLookupWeighted1D in(*test_weighted,j,false);
@@ -260 +260 @@
       }
       else if(data_.weighted() && test_unweighted) {
-        //        MatrixLookupWeighted test2weighted(*test_unweighted);
-        // Need to convert MatrixLookup to MatrixLookupWeighted here
-        // and use it in the code below
-        for(size_t j=0; j<input.columns();j++) {        
-          DataLookupWeighted1D in(*test_weighted,j,false);
-          for(size_t k=0; k<centroids_->columns();k++) {
-            DataLookupWeighted1D centroid(weighted_centroids,k,false);
-            utility::yat_assert<std::runtime_error>(in.size()==centroid.size());
-            prediction(k,j)=statistics::
-              vector_distance(in.begin(),in.end(),centroid.begin(),
-                              typename statistics::vector_distance_traits<Distance>::distance());
-          }
-        }
+        std::string str =  "Error in NCC<Distance>::predict:";
+        str += " predicting unweighted data when NCC";
+        str += " is trained on weighted data is not yet supported";
+        throw std::runtime_error(str);        
       }
       else {
-        std::string str;
-        str = "Error in NCC<Distance>::predict: DataLookup2D of unexpected class.";
+        std::string str = 
+          "Error in NCC<Distance>::predict: DataLookup2D of unexpected class.";
         throw std::runtime_error(str);
       }