Changeset 1160

Timestamp:

Feb 26, 2008, 4:29:50 PM (16 years ago)

Author:

Markus Ringnér

Message:

Fixes #333

Location:

trunk/yat/classifier

Files:

• KNN.h (modified) (12 diffs)
• NBC.cc (modified) (3 diffs)
• NBC.h (modified) (2 diffs)
• NCC.h (modified) (4 diffs)
• SupervisedClassifier.h (modified) (2 diffs)

trunk/yat/classifier/KNN.h

@@ -107 +107 @@
     /// class.
     ///
-    ///
-    void predict(const DataLookup2D&, utility::Matrix&) const;
+    void predict(const MatrixLookup&, utility::Matrix&) const;
+
+    ///
+    /// For each sample, calculate the number of neighbors for each
+    /// class.
+    ///
+    void predict(const MatrixLookupWeighted&, utility::Matrix&) const;
 
 
   private:
 
-    // data_ has to be of type DataLookup2D to accomodate both
-    // MatrixLookup and MatrixLookupWeighted
-    const DataLookup2D* data_;
+    const MatrixLookup* data_ml_;
+    const MatrixLookupWeighted* data_mlw_;
     const Target* target_;
 
@@ -124 +128 @@
 
     NeighborWeighting weighting_;
-
-    ///
-    /// Calculates the distances between a data set and the training
-    /// data. The rows are training and the columns test samples,
-    /// respectively. The returned distance matrix is dynamically
-    /// generated and needs to be deleted by the caller.
-    ///
-    utility::Matrix* calculate_distances(const DataLookup2D&) const;
 
     void calculate_unweighted(const MatrixLookup&,
@@ -139 +135 @@
                             const MatrixLookupWeighted&,
                             utility::Matrix*) const;
+
+    void predict_common(const utility::Matrix& distances, 
+                        utility::Matrix& prediction) const;
+
   };
   
@@ -146 +146 @@
   template <typename Distance, typename NeighborWeighting>
   KNN<Distance, NeighborWeighting>::KNN() 
-    : SupervisedClassifier(),data_(0),target_(0),k_(3)
+    : SupervisedClassifier(),data_ml_(0),data_mlw_(0),target_(0),k_(3)
   {
   }
@@ -152 +152 @@
   template <typename Distance, typename NeighborWeighting>
   KNN<Distance, NeighborWeighting>::KNN(const Distance& dist) 
-    : SupervisedClassifier(),data_(0),target_(0),k_(3), distance_(dist)
+    : SupervisedClassifier(),data_ml_(0),data_mlw_(0),target_(0),k_(3), distance_(dist)
   {
   }
@@ -162 +162 @@
   }
   
-  template <typename Distance, typename NeighborWeighting>
-  utility::Matrix* KNN<Distance, NeighborWeighting>::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(),test.columns());
-    
-    
-    // unweighted test data
-    if(const MatrixLookup* test_unweighted = 
-       dynamic_cast<const MatrixLookup*>(&test)) {      
-      // 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 {
-      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, typename NeighborWeighting>
@@ -214 +169 @@
   {
     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());
+        (*distances)(i,j) = distance_(training.begin_column(i), training.end_column(i), 
+                                      test.begin_column(j));
         utility::yat_assert<std::runtime_error>(!std::isnan((*distances)(i,j)));
       }
     }
   }
+
   
   template <typename Distance, typename NeighborWeighting>
@@ -229 +184 @@
    utility::Matrix* distances) const
   {
-    for(size_t i=0; i<training.columns(); i++) {
-      classifier::DataLookupWeighted1D training1(training,i,false);
+    for(size_t i=0; i<training.columns(); i++) { 
       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());
+        (*distances)(i,j) = distance_(training.begin_column(i), training.end_column(i), 
+                                      test.begin_column(j));
         // If the distance is NaN (no common variables with non-zero weights),
         // the distance is set to infinity to be sorted as a neighbor at the end
@@ -277 +230 @@
     if(data.columns()<k_) 
       k_=data.columns();
-    data_=&data;
+    data_ml_=&data;
+    data_mlw_=0;
     target_=&target;
     trained_=true;
@@ -292 +246 @@
     if(data.columns()<k_) 
       k_=data.columns();
-    data_=&data;
+    data_ml_=0;
+    data_mlw_=&data;
     target_=&target;
     trained_=true;
@@ -299 +254 @@
 
   template <typename Distance, typename NeighborWeighting>
-  void KNN<Distance, NeighborWeighting>::predict(const DataLookup2D& test,
+  void KNN<Distance, NeighborWeighting>::predict(const MatrixLookup& test,
                                                  utility::Matrix& prediction) const
   {   
-    utility::yat_assert<std::runtime_error>(data_->rows()==test.rows(),"KNN::predict different number of rows in training and test data");
-
-    utility::Matrix* distances=calculate_distances(test);
-    
+    // matrix with training samples as rows and test samples as columns
+    utility::Matrix* distances = 0;
+    // unweighted training data
+    if(data_ml_ && !data_mlw_) {
+      utility::yat_assert<std::runtime_error>
+        (data_ml_->rows()==test.rows(),
+         "KNN::predict different number of rows in training and test data");      
+      distances=new utility::Matrix(data_ml_->columns(),test.columns());
+      calculate_unweighted(*data_ml_,test,distances);
+    }
+    else if (data_mlw_ && !data_ml_) {
+      // weighted training data
+      utility::yat_assert<std::runtime_error>
+        (data_mlw_->rows()==test.rows(),
+         "KNN::predict different number of rows in training and test data");            
+      distances=new utility::Matrix(data_mlw_->columns(),test.columns());
+      calculate_weighted(*data_mlw_,MatrixLookupWeighted(test),
+                         distances);              
+    }
+    else {
+      std::runtime_error("KNN::predict no training data");
+    }
+
     prediction.resize(target_->nof_classes(),test.columns(),0.0);
-    for(size_t sample=0;sample<distances->columns();sample++) {
+    predict_common(*distances,prediction);
+    if(distances)
+      delete distances;
+  }
+
+  template <typename Distance, typename NeighborWeighting>
+  void KNN<Distance, NeighborWeighting>::predict(const MatrixLookupWeighted& test,
+                                                 utility::Matrix& prediction) const
+  {   
+    // matrix with training samples as rows and test samples as columns
+    utility::Matrix* distances=0; 
+    // unweighted training data
+    if(data_ml_ && !data_mlw_) { 
+      utility::yat_assert<std::runtime_error>
+        (data_ml_->rows()==test.rows(),
+         "KNN::predict different number of rows in training and test data");    
+      distances=new utility::Matrix(data_ml_->columns(),test.columns());
+      calculate_weighted(MatrixLookupWeighted(*data_ml_),test,distances);   
+    }
+    // weighted training data
+    else if (data_mlw_ && !data_ml_) {
+      utility::yat_assert<std::runtime_error>
+        (data_mlw_->rows()==test.rows(),
+         "KNN::predict different number of rows in training and test data");    
+      distances=new utility::Matrix(data_mlw_->columns(),test.columns());
+      calculate_weighted(*data_mlw_,test,distances);              
+    }
+    else {
+      std::runtime_error("KNN::predict no training data");
+    }
+
+    prediction.resize(target_->nof_classes(),test.columns(),0.0);
+    predict_common(*distances,prediction);
+    
+    if(distances)
+      delete distances;
+  }
+  
+  template <typename Distance, typename NeighborWeighting>
+  void KNN<Distance, NeighborWeighting>::predict_common
+  (const utility::Matrix& distances, utility::Matrix& prediction) const
+  {   
+    for(size_t sample=0;sample<distances.columns();sample++) {
       std::vector<size_t> k_index;
-      utility::VectorConstView dist=distances->column_const_view(sample);
+      utility::VectorConstView dist=distances.column_const_view(sample);
       utility::sort_smallest_index(k_index,k_,dist);
       utility::VectorView pred=prediction.column_view(sample);
       weighting_(dist,k_index,*target_,pred);
     }
-    delete distances;
-
+    
     // classes for which there are no training samples should be set
     // to nan in the predictions
@@ -324 +339 @@
   }
 
+
 }}} // of namespace classifier, yat, and theplu
 

trunk/yat/classifier/NBC.cc

@@ -24 +24 @@
 
 #include "NBC.h"
-#include "DataLookup2D.h"
 #include "MatrixLookup.h"
 #include "MatrixLookupWeighted.h"
 #include "Target.h"
+#include "yat/statistics/Averager.h"
 #include "yat/statistics/AveragerWeighted.h"
 #include "yat/utility/Matrix.h"
@@ -120 +120 @@
 
 
-  void NBC::predict(const DataLookup2D& x,                    
+  void NBC::predict(const MatrixLookup& ml,                     
                     utility::Matrix& prediction) const
   {   
-    assert(x.rows()==sigma2_.rows());
-    assert(x.rows()==centroids_.rows());
-    
-    
+    assert(ml.rows()==sigma2_.rows());
+    assert(ml.rows()==centroids_.rows());
     // each row in prediction corresponds to a sample label (class)
-    prediction.resize(centroids_.columns(), x.columns(), 0);
-    // weighted calculation
-    if (const MatrixLookupWeighted* mlw = 
-        dynamic_cast<const MatrixLookupWeighted*>(&x)) {
-      // first calculate -lnP = sum ln_sigma_i + (x_i-m_i)^2/2sigma_i^2
-      for (size_t label=0; label<centroids_.columns(); ++label) {
-        double sum_log_sigma = sum_logsigma(label);
-        for (size_t sample=0; sample<prediction.rows(); ++sample) {
-          prediction(label,sample) = sum_log_sigma;
-          for (size_t i=0; i<x.rows(); ++i) 
-            // taking care of NaN and missing training features
-            if (mlw->weight(i, label) && !std::isnan(sigma2_(i, label))) {
-              prediction(label, sample) += mlw->weight(i, label)*
-                std::pow(mlw->data(i, label)-centroids_(i, label),2)/
-                sigma2_(i, label);
-            }
+    prediction.resize(centroids_.columns(), ml.columns(), 0);
+
+    // first calculate -lnP = sum sigma_i + (x_i-m_i)^2/2sigma_i^2
+    for (size_t label=0; label<centroids_.columns(); ++label) {
+      double sum_log_sigma = sum_logsigma(label);
+      for (size_t sample=0; sample<prediction.rows(); ++sample) {
+        prediction(label,sample) = sum_log_sigma;
+        for (size_t i=0; i<ml.rows(); ++i) 
+          // Ignoring missing features
+          if (!std::isnan(sigma2_(i, label)))
+            prediction(label, sample) += 
+              std::pow(ml(i, label)-centroids_(i, label),2)/
+              sigma2_(i, label);
+      }
+    }
+    standardize_lnP(prediction);
+  }
+
       
-        }
-      }
-    }
-      // no weights
-    else if (const MatrixLookup* ml = dynamic_cast<const MatrixLookup*>(&x)) {
-      // first calculate -lnP = sum sigma_i + (x_i-m_i)^2/2sigma_i^2
-      for (size_t label=0; label<centroids_.columns(); ++label) {
-        double sum_log_sigma = sum_logsigma(label);
-        for (size_t sample=0; sample<prediction.rows(); ++sample) {
-          prediction(label,sample) = sum_log_sigma;
-          for (size_t i=0; i<ml->rows(); ++i) 
-            // Ignoring missing features
-            if (!std::isnan(sigma2_(i, label)))
-              prediction(label, sample) += 
-                std::pow((*ml)(i, label)-centroids_(i, label),2)/
-                sigma2_(i, label);
-        }
-      }
-    }
-    else {
-      std::string str = 
-        "Error in NBC::predict: DataLookup2D of unexpected class.";
-      throw std::runtime_error(str);
-    }
-
-
+  void NBC::predict(const MatrixLookupWeighted& mlw,                    
+                    utility::Matrix& prediction) const
+  {   
+    assert(mlw.rows()==sigma2_.rows());
+    assert(mlw.rows()==centroids_.rows());
+    
+    // each row in prediction corresponds to a sample label (class)
+    prediction.resize(centroids_.columns(), mlw.columns(), 0);
+
+    // first calculate -lnP = sum sigma_i + (x_i-m_i)^2/2sigma_i^2
+    for (size_t label=0; label<centroids_.columns(); ++label) {
+      double sum_log_sigma = sum_logsigma(label);
+      for (size_t sample=0; sample<prediction.rows(); ++sample) {
+        prediction(label,sample) = sum_log_sigma;
+        for (size_t i=0; i<mlw.rows(); ++i) 
+          // taking care of NaN and missing training features
+          if (mlw.weight(i, label) && !std::isnan(sigma2_(i, label))) {
+            prediction(label, sample) += mlw.weight(i, label)*
+              std::pow(mlw.data(i, label)-centroids_(i, label),2)/
+              sigma2_(i, label);
+          }
+        
+      }
+    }
+    standardize_lnP(prediction);
+  }
+
+  void NBC::standardize_lnP(utility::Matrix& prediction) const
+  {
     // -lnP might be a large number, in order to avoid out of bound
     // problems when calculating P = exp(- -lnP), we centralize matrix
@@ -177 +180 @@
     add(a, prediction.begin(), prediction.end());
     prediction -= a.mean();
-
+    
     // exponentiate
     for (size_t i=0; i<prediction.rows(); ++i)
       for (size_t j=0; j<prediction.columns(); ++j)
         prediction(i,j) = std::exp(prediction(i,j));
-
+    
     // normalize each row (label) to sum up to unity (probability)
     for (size_t i=0; i<prediction.rows(); ++i){

trunk/yat/classifier/NBC.h

@@ -33 +33 @@
 namespace classifier {  
 
-  class DataLookup1D;
-  class DataLookup2D;
   class MatrixLookup;
   class MatrixLookupWeighted;
@@ -100 +98 @@
        equivalent to using all weight equal to unity.
     */
-    void predict(const DataLookup2D& data, utility::Matrix& res) const;
+    void predict(const MatrixLookup& data, utility::Matrix& res) const;
+
+    /**
+       @see above
+     */
+    void predict(const MatrixLookupWeighted& data, utility::Matrix& res) const;
 
 
   private:
+    void standardize_lnP(utility::Matrix& prediction) const;
+
     utility::Matrix centroids_;
     utility::Matrix sigma2_;

trunk/yat/classifier/NCC.h

@@ -27 +27 @@
 */
 
-#include "DataLookup1D.h"
-#include "DataLookup2D.h"
-#include "DataLookupWeighted1D.h"
 #include "MatrixLookup.h"
 #include "MatrixLookupWeighted.h"
@@ -104 +101 @@
     /// Calculate the distance to each centroid for test samples
     ///
-    void predict(const DataLookup2D&, utility::Matrix&) const;
-    
+    void predict(const MatrixLookup&, utility::Matrix&) const;
+    
+    ///
+    /// Calculate the distance to each centroid for weighted test samples
+    ///
+    void predict(const MatrixLookupWeighted&, utility::Matrix&) const;
+
     
   private:
@@ -203 +205 @@
 
   template <typename Distance>
-  void NCC<Distance>::predict(const DataLookup2D& test,                     
+  void NCC<Distance>::predict(const MatrixLookup& test,                     
                               utility::Matrix& prediction) const
   {   
@@ -214 +216 @@
     prediction.resize(centroids_->columns(), test.columns());
 
-    // unweighted test data
-    if (const MatrixLookup* test_unweighted =
-        dynamic_cast<const MatrixLookup*>(&test)) {
-      // If weighted training data has resulted in NaN in centroids: weighted calculations
-      if(centroids_nan_) { 
-        predict_weighted(MatrixLookupWeighted(*test_unweighted),prediction);
-      }
-      // If unweighted training data: unweighted calculations
-      else {
-        predict_unweighted(*test_unweighted,prediction);
-      }
-    }
-    // weighted test data: weighted calculations
-    else if (const MatrixLookupWeighted* test_weighted =
-             dynamic_cast<const MatrixLookupWeighted*>(&test)) { 
-      predict_weighted(*test_weighted,prediction);
-    }
+    // If weighted training data has resulted in NaN in centroids: weighted calculations
+    if(centroids_nan_) { 
+      predict_weighted(MatrixLookupWeighted(test),prediction);
+    }
+    // If unweighted training data: unweighted calculations
     else {
-      std::string str = 
-        "Error in NCC<Distance>::predict: DataLookup2D of unexpected class.";
-      throw std::runtime_error(str);
-    }
-  }
+      predict_unweighted(test,prediction);
+    }
+  }
+
+  template <typename Distance>
+  void NCC<Distance>::predict(const MatrixLookupWeighted& test,                     
+                              utility::Matrix& prediction) const
+  {   
+    utility::yat_assert<std::runtime_error>
+      (centroids_,"NCC::predict called for untrained classifier");
+    utility::yat_assert<std::runtime_error>
+      (centroids_->rows()==test.rows(),
+       "NCC::predict test data with incorrect number of rows");
+    
+    prediction.resize(centroids_->columns(), test.columns());
+    predict_weighted(test,prediction);
+  }
+
   
   template <typename Distance>

trunk/yat/classifier/SupervisedClassifier.h

@@ -38 +38 @@
 namespace classifier {  
 
-  class DataLookup2D;
   class MatrixLookup;
   class MatrixLookupWeighted;
@@ -79 +78 @@
     /// Generate output values for a data set
     ///
-    virtual void predict(const DataLookup2D&, utility::Matrix&) const =0;   
+    virtual void predict(const MatrixLookup&, utility::Matrix&) const =0;   
+
+    ///
+    /// Generate output values for a weighted data set
+    ///
+    virtual void predict(const MatrixLookupWeighted&, utility::Matrix&) const =0;