Changeset 1107 for trunk/yat/classifier

Timestamp:

Feb 19, 2008, 4:23:52 PM (16 years ago)

Author:

Markus Ringnér

Message:

Ticket #259 fixed for KNN

File:

• trunk/yat/classifier/KNN.h (modified) (4 diffs)

trunk/yat/classifier/KNN.h

@@ -90 +90 @@
     
     ///
-    /// Train the classifier using the training data. Centroids are
-    /// calculated for each class.
+    /// Train the classifier using the training data. 
+    /// This function does nothing but is required by the interface.
     ///
     /// @return true if training succedeed.
@@ -99 +99 @@
     
     ///
-    /// Calculate the distance to each centroid for test samples
+    /// For each sample, calculate the number of neighbours for each
+    /// class.
+    ///
     ///
     void predict(const DataLookup2D&, utility::matrix&) const;
@@ -121 +123 @@
     ///
     utility::matrix* calculate_distances(const DataLookup2D&) const;
+    void calculate_unweighted(const MatrixLookup&,
+                              const MatrixLookup&,
+                              utility::matrix*) const;
+    void calculate_weighted(const MatrixLookupWeighted&,
+                            const MatrixLookupWeighted&,
+                            utility::matrix*) const;
   };
   
@@ -151 +159 @@
       new utility::matrix(data_.columns(),test.columns());
     
+    
     // unweighted test data
     if(const MatrixLookup* test_unweighted = 
        dynamic_cast<const MatrixLookup*>(&test)) {      
-      for(size_t i=0; i<data_.columns(); i++) {
-        for(size_t j=0; j<test.columns(); j++) {
-          classifier::DataLookup1D test(*test_unweighted,j,false);
-          classifier::DataLookup1D tmp(data_,i,false);
-          (*distances)(i,j) = distance_(tmp.begin(), tmp.end(), test.begin());
-          utility::yat_assert<std::runtime_error>(!std::isnan((*distances)(i,j)));
-        }
-      }
+      // unweighted training data
+      if(const MatrixLookup* training_unweighted = 
+         dynamic_cast<const MatrixLookup*>(&data_)) 
+        calculate_unweighted(*training_unweighted,*test_unweighted,distances);
+      // weighted training data
+      else if(const MatrixLookupWeighted* training_weighted = 
+              dynamic_cast<const MatrixLookupWeighted*>(&data_)) 
+        calculate_weighted(*training_weighted,MatrixLookupWeighted(*test_unweighted),
+                           distances);              
+      // Training data can not be of incorrect type
     }
     // weighted test data
+    else if (const MatrixLookupWeighted* test_weighted = 
+             dynamic_cast<const MatrixLookupWeighted*>(&test)) {      
+      // unweighted training data
+      if(const MatrixLookup* training_unweighted = 
+         dynamic_cast<const MatrixLookup*>(&data_)) {
+        calculate_weighted(MatrixLookupWeighted(*training_unweighted),
+                           *test_weighted,distances);
+      }
+      // weighted training data
+      else if(const MatrixLookupWeighted* training_weighted = 
+              dynamic_cast<const MatrixLookupWeighted*>(&data_)) 
+        calculate_weighted(*training_weighted,*test_weighted,distances);              
+      // Training data can not be of incorrect type
+    } 
     else {
-      const MatrixLookupWeighted* data_weighted = 
-        dynamic_cast<const MatrixLookupWeighted*>(&data_);
-      const MatrixLookupWeighted* test_weighted = 
-        dynamic_cast<const MatrixLookupWeighted*>(&test);               
-      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<test.columns(); j++) {
-            classifier::DataLookupWeighted1D test(*test_weighted,j,false);
-            utility::yat_assert<std::runtime_error>(training.size()==test.size());
-            (*distances)(i,j) = distance_(training.begin(), training.end(),
-                                          test.begin());
-            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);
-      }
+      std::string str;
+      str = "Error in KNN::calculate_distances: test data has to be either MatrixLookup or MatrixLookupWeighted";
+      throw std::runtime_error(str);
     }
     return distances;
   }
+
+  template <typename Distance>
+  void  KNN<Distance>:: calculate_unweighted(const MatrixLookup& training,
+                                             const MatrixLookup& test,
+                                             utility::matrix* distances) const
+  {
+    for(size_t i=0; i<training.columns(); i++) {
+      classifier::DataLookup1D training1(training,i,false);
+      for(size_t j=0; j<test.columns(); j++) {
+        classifier::DataLookup1D test1(test,j,false);
+        (*distances)(i,j) = distance_(training1.begin(), training1.end(), test1.begin());
+        utility::yat_assert<std::runtime_error>(!std::isnan((*distances)(i,j)));
+      }
+    }
+  }
+  
+  template <typename Distance>
+  void  KNN<Distance>:: calculate_weighted(const MatrixLookupWeighted& training,
+                                           const MatrixLookupWeighted& test,
+                                           utility::matrix* distances) const
+  {
+    for(size_t i=0; i<training.columns(); i++) {
+      classifier::DataLookupWeighted1D training1(training,i,false);
+      for(size_t j=0; j<test.columns(); j++) {
+        classifier::DataLookupWeighted1D test1(test,j,false);
+        (*distances)(i,j) = distance_(training1.begin(), training1.end(), test1.begin());
+        utility::yat_assert<std::runtime_error>(!std::isnan((*distances)(i,j)));
+      }
+    }
+  }
+
   
   template <typename Distance>