Changeset 1031 for trunk/yat/classifier

Timestamp:

Feb 4, 2008, 4:44:44 PM (16 years ago)

Author:

Markus Ringnér

Message:

Fixes #272

Location:

trunk/yat/classifier

Files:

• IGP.h (modified) (2 diffs)
• KNN.h (modified) (3 diffs)
• NCC.h (modified) (9 diffs)

trunk/yat/classifier/IGP.h

@@ -30 +30 @@
 #include "yat/utility/vector.h"
 #include "yat/utility/yat_assert.h"
-#include "yat/statistics/vector_distance.h"
+#include "yat/statistics/distance.h"
 
 #include <cmath>
@@ -95 +95 @@
         DataLookup1D b(matrix_,j,false);
         double dist=statistics::
-          vector_distance(a.begin,a.end(),b.begin(),
-                          statistics::vector_distance_traits<Distance>::distace());
+          distance(a.begin,a.end(),b.begin(),
+                          statistics::distance_traits<Distance>::distace());
         if(j!=i && dist<mindist) {
           mindist=dist;

trunk/yat/classifier/KNN.h

@@ -30 +30 @@
 #include "SupervisedClassifier.h"
 #include "Target.h"
-#include "yat/statistics/vector_distance.h"
+#include "yat/statistics/distance.h"
 #include "yat/utility/matrix.h"
 #include "yat/utility/yat_assert.h"
@@ -144 +144 @@
   
   template <typename Distance>
-  utility::matrix* KNN<Distance>::calculate_distances(const DataLookup2D& input) const
+  utility::matrix* KNN<Distance>::calculate_distances(const DataLookup2D& test) const
   {
     // matrix with training samples as rows and test samples as columns
     utility::matrix* distances = 
-      new utility::matrix(data_.columns(),input.columns());
-    
-    // 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_);      
+      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++) {
-        classifier::DataLookup1D training(*data_unweighted,i,false);
-        for(size_t j=0; j<input.columns(); j++) {
+        for(size_t j=0; j<test.columns(); j++) {
           classifier::DataLookup1D test(*test_unweighted,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());
+            statistics::distance(classifier::DataLookup1D(data_,
+                                                          i,false).begin(),
+                                 classifier::DataLookup1D(data_,
+                                                          i,false).end(),
+                                 test.begin(), 
+                                 typename statistics::
+                                 distance_traits<Distance>::distance());
           utility::yat_assert<std::runtime_error>(!std::isnan((*distances)(i,j)));
         }
       }
     }
-    // if either training or test is weighted: weighted calculations
-    // are used.
+    // weighted test data
     else {
       const MatrixLookupWeighted* data_weighted = 
         dynamic_cast<const MatrixLookupWeighted*>(&data_);
       const MatrixLookupWeighted* test_weighted = 
-        dynamic_cast<const MatrixLookupWeighted*>(&input);                
+        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<input.columns(); j++) {
+          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) =
-              statistics::vector_distance(training.begin(),training.end(),
-                                          test.begin(), typename statistics::vector_distance_traits<Distance>::distance());
+              statistics::distance(training.begin(),training.end(),
+                                   test.begin(), typename statistics::distance_traits<Distance>::distance());
             utility::yat_assert<std::runtime_error>(!std::isnan((*distances)(i,j)));
           }
@@ -251 +249 @@
 
   template <typename Distance>
-  void KNN<Distance>::predict(const DataLookup2D& input,                    
+  void KNN<Distance>::predict(const DataLookup2D& test,                     
                               utility::matrix& prediction) const
   {   
-    utility::matrix* distances=calculate_distances(input);
+    utility::yat_assert<std::runtime_error>(data_.rows()==test.rows());
+
+    utility::matrix* distances=calculate_distances(test);
     
     // for each test sample (column in distances) find the closest
     // training samples
-    prediction.clone(utility::matrix(target_.nof_classes(),input.columns(),0.0));
+    prediction.clone(utility::matrix(target_.nof_classes(),test.columns(),0.0));
     for(size_t sample=0;sample<distances->columns();sample++) {
       std::vector<size_t> k_index;

trunk/yat/classifier/NCC.h

@@ -37 +37 @@
 #include "yat/statistics/Averager.h"
 #include "yat/statistics/AveragerWeighted.h"
-#include "yat/statistics/vector_distance.h"
+#include "yat/statistics/distance.h"
 
 #include "yat/utility/Iterator.h"
@@ -112 +112 @@
     // MatrixLookup and MatrixLookupWeighted
     const DataLookup2D& data_;
-
+    bool centroids_nan_;
   };
 
@@ -125 +125 @@
   template <typename Distance>
   NCC<Distance>::NCC(const MatrixLookup& data, const Target& target) 
-    : SupervisedClassifier(target), centroids_(0), data_(data) 
+    : SupervisedClassifier(target), centroids_(0), data_(data), centroids_nan_(false) 
   {
   }
@@ -131 +131 @@
   template <typename Distance>
   NCC<Distance>::NCC(const MatrixLookupWeighted& data, const Target& target)
-    : SupervisedClassifier(target), centroids_(0), data_(data) 
+    : SupervisedClassifier(target), centroids_(0), data_(data), centroids_nan_(false)  
   {
   }
@@ -169 +169 @@
                               target);
       }
-      ncc->centroids_=0;
     }
     catch (std::bad_cast) {
@@ -198 +197 @@
         for(size_t c=0;c<target_.nof_classes();c++) {
           (*centroids_)(i,c) = class_averager[c].mean();
+          if(class_averager[c].sum_w()==0)
+            centroids_nan_=true;
         }
       }
@@ -230 +231 @@
     prediction.clone(utility::matrix(centroids_->columns(), test.columns()));       
 
-    // unweighted test data
+    // unweighted test data and no nan's in centroids
+    // Markus: Should test centroid_nan_ here!!!
     if (const MatrixLookup* test_unweighted =
         dynamic_cast<const MatrixLookup*>(&test)) {
@@ -240 +242 @@
           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());
+            distance(in.begin(),in.end(),centroid.begin(),
+                            typename statistics::distance_traits<Distance>::distance());
         }
       }
@@ -255 +257 @@
           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());
+            distance(in.begin(),in.end(),centroid.begin(),
+                            typename statistics::distance_traits<Distance>::distance());
         }
       }