Changeset 1031

Timestamp:

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

Author:

Markus Ringnér

Message:

Fixes #272

Location:

trunk

Files:

• test/knn_test.cc (modified) (2 diffs)
• test/ncc_test.cc (modified) (4 diffs)
• test/vector_distance_test.cc (modified) (6 diffs)
• yat/classifier/IGP.h (modified) (2 diffs)
• yat/classifier/KNN.h (modified) (3 diffs)
• yat/classifier/NCC.h (modified) (9 diffs)
• yat/statistics/Makefile.am (modified) (1 diff)
• yat/statistics/distance.h (moved) (moved from trunk/yat/statistics/vector_distance.h) (4 diffs)
• yat/statistics/euclidean_distance.h (moved) (moved from trunk/yat/statistics/euclidean_vector_distance.h) (5 diffs)
• yat/statistics/pearson_distance.h (moved) (moved from trunk/yat/statistics/pearson_vector_distance.h) (5 diffs)

trunk/test/knn_test.cc

@@ -24 +24 @@
 #include "yat/classifier/KNN.h"
 #include "yat/classifier/MatrixLookupWeighted.h"
-#include "yat/statistics/euclidean_vector_distance.h"
-#include "yat/statistics/pearson_vector_distance.h"
+#include "yat/statistics/euclidean_distance.h"
+#include "yat/statistics/pearson_distance.h"
 #include "yat/utility/matrix.h"
 
@@ -66 +66 @@
 
   classifier::MatrixLookupWeighted dataviewweighted(data,weights);
-  classifier::KNN<statistics::pearson_vector_distance_tag> knn(dataviewweighted,targets);
+  classifier::KNN<statistics::pearson_distance_tag> knn(dataviewweighted,targets);
   *error << "training KNN" << std::endl;
   knn.train();

trunk/test/ncc_test.cc

@@ -31 +31 @@
 #include "yat/classifier/Target.h"
 #include "yat/utility/matrix.h"
-#include "yat/statistics/euclidean_vector_distance.h"
-#include "yat/statistics/pearson_vector_distance.h"
+#include "yat/statistics/euclidean_distance.h"
+#include "yat/statistics/pearson_distance.h"
 #include "yat/utility/utility.h"
 
@@ -78 +78 @@
   vec[3]="bjds";
   classifier::Target target(vec);
-  classifier::NCC<statistics::pearson_vector_distance_tag> ncctmp(ml,target);
+  classifier::NCC<statistics::pearson_distance_tag> ncctmp(ml,target);
   *error << "training...\n";
   ncctmp.train();
@@ -100 +100 @@
   classifier::Target target1(vec1);
 
-  classifier::NCC<statistics::euclidean_vector_distance_tag> ncc1(ml1,target1);
+  classifier::NCC<statistics::euclidean_distance_tag> ncc1(ml1,target1);
   ncc1.train();
   utility::matrix prediction1;
@@ -150 +150 @@
       
   classifier::MatrixLookupWeighted dataviewweighted(data,weights);
-  classifier::NCC<statistics::pearson_vector_distance_tag> ncc(dataviewweighted,targets);
+  classifier::NCC<statistics::pearson_distance_tag> ncc(dataviewweighted,targets);
   *error << "training...\n";
   ncc.train();

trunk/test/vector_distance_test.cc

@@ -24 +24 @@
 #include "yat/classifier/DataLookupWeighted1D.h"
 #include "yat/classifier/MatrixLookupWeighted.h"
-#include "yat/statistics/euclidean_vector_distance.h"
-#include "yat/statistics/pearson_vector_distance.h"
+#include "yat/statistics/euclidean_distance.h"
+#include "yat/statistics/pearson_distance.h"
 #include "yat/utility/matrix.h"
 #include "yat/utility/vector.h"
@@ -47 +47 @@
     error = new std::ofstream("/dev/null");
     if (argc>1)
-      std::cout << "vector_distance_test -v : for printing extra information\n";
+      std::cout << "distance_test -v : for printing extra information\n";
   }
-  *error << "testing vector_distance" << std::endl;
+  *error << "testing distance" << std::endl;
   bool ok = true;
   
@@ -59 +59 @@
   double tolerance=1e-4;
   
-  double dist=statistics::vector_distance(a.begin(),a.end(),b.begin(),
-                                          statistics::euclidean_vector_distance_tag());
+  double dist=statistics::distance(a.begin(),a.end(),b.begin(),
+                                          statistics::euclidean_distance_tag());
   if(fabs(dist-2.23607)>tolerance) {
-    *error << "Error in unweighted Euclidean vector_distance " << std::endl;
+    *error << "Error in unweighted Euclidean distance " << std::endl;
     ok=false;
   }
   
-  dist=statistics::vector_distance(a.begin(),a.end(),b.begin(),
-                                   statistics::pearson_vector_distance_tag());  
+  dist=statistics::distance(a.begin(),a.end(),b.begin(),
+                                   statistics::pearson_distance_tag()); 
   if(fabs(dist-1.5)>tolerance) {
-    *error << "Error in unweighted Pearson vector_distance " << std::endl;
+    *error << "Error in unweighted Pearson distance " << std::endl;
     ok=false;
   }
@@ -85 +85 @@
   classifier::DataLookupWeighted1D bw(mw,1,true);
   
-  dist=statistics::vector_distance(aw.begin(),aw.end(),bw.begin(),
-                                   statistics::euclidean_vector_distance_tag());
+  dist=statistics::distance(aw.begin(),aw.end(),bw.begin(),
+                                   statistics::euclidean_distance_tag());
   
   if(fabs(dist-sqrt(6))>tolerance) {
-    *error << "Error in weighted Euclidean vector_distance " << std::endl;
+    *error << "Error in weighted Euclidean distance " << std::endl;
     ok=false;
   }
   
-  dist=statistics::vector_distance(aw.begin(),aw.end(),bw.begin(),
-                                   statistics::pearson_vector_distance_tag());
+  dist=statistics::distance(aw.begin(),aw.end(),bw.begin(),
+                                   statistics::pearson_distance_tag());
   
   if(fabs(dist-2)>tolerance) {
-    *error << "Error in weighted Pearson vector_distance " << std::endl;
+    *error << "Error in weighted Pearson distance " << std::endl;
     ok=false;
   }
@@ -108 +108 @@
   sb[2] = 1;
   
-  dist=statistics::vector_distance(sa.begin(),sa.end(),sb.begin(),
-                                   statistics::euclidean_vector_distance_tag());  
+  dist=statistics::distance(sa.begin(),sa.end(),sb.begin(),
+                                   statistics::euclidean_distance_tag()); 
   if(fabs(dist-2.23607)>tolerance) {
-    *error << "Error in vector_distance for std::vector " << std::endl;
+    *error << "Error in distance for std::vector " << std::endl;
     ok=false;
   }
@@ -118 +118 @@
   std::list<double> la;
   std::copy(sa.begin(),sa.end(),std::back_inserter<std::list<double> >(la));
-  dist=statistics::vector_distance(la.begin(),la.end(),sb.begin(),
-                                   statistics::euclidean_vector_distance_tag());  
+  dist=statistics::distance(la.begin(),la.end(),sb.begin(),
+                                   statistics::euclidean_distance_tag()); 
   if(fabs(dist-2.23607)>tolerance) {
-    *error << "Error in vector_distance for std::list " << std::endl;
+    *error << "Error in distance for std::list " << std::endl;
     ok=false;
   }
   
   if(!ok) {
-    *error << "vector_distance_test failed" << std::endl;
+    *error << "distance_test failed" << std::endl;
   }
   if (error!=&std::cerr)

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());
         }
       }

trunk/yat/statistics/Makefile.am

@@ -40 +40 @@
 include_statistics_HEADERS = AUC.h Averager.h AveragerPair.h \
   AveragerWeighted.h AveragerPairWeighted.h \
-  euclidean_vector_distance.h Fisher.h \
+  distance.h euclidean_distance.h Fisher.h \
   FoldChange.h Histogram.h \
   KolmogorovSmirnov.h \
   Pearson.h PearsonCorrelation.h \
-  pearson_vector_distance.h ROC.h \
+  pearson_distance.h ROC.h \
   SAMScore.h Score.h SNRScore.h tScore.h tTest.h \
-  utility.h vector_distance.h VectorFunction.h WilcoxonFoldChange.h
+  utility.h VectorFunction.h WilcoxonFoldChange.h

trunk/yat/statistics/distance.h

@@ -1 @@
-#ifndef theplu_yat_statistics_vector_distance_h
-#define theplu_yat_statistics_vector_distance_h
+#ifndef theplu_yat_statistics_distance_h
+#define theplu_yat_statistics_distance_h
 
 // $Id$
@@ -39 +39 @@
   /// For each measure to calculate distances between containers
   /// with random access iterators one should provide a struct
-  /// that inherits from vector_distance_tag and provides a "label" for
+  /// that inherits from distance_tag and provides a "label" for
   /// the distance measure.
   ///
-  struct vector_distance_tag {
+  struct distance_tag {
     /// tag defining distance measure
-    typedef vector_distance_tag distance;
+    typedef distance_tag distance;
   };
 
@@ -54 +54 @@
   /// distance measures.  Instead it can access the "label" of each
   /// distance measure through the special template structure
-  /// vector_distance_traits.
+  /// distance_traits.
   ///
   template <class T>
-  struct vector_distance_traits {
+  struct distance_traits {
     /// \return distance type
     typedef typename T::distance distance;
@@ -73 +73 @@
   ///
   template <typename Iter1, typename Iter2, typename Dist>
-  double vector_distance(Iter1 beg1, Iter1 end1, Iter2 beg2, const Dist disttag)
+  double distance(Iter1 beg1, Iter1 end1, Iter2 beg2, const Dist disttag)
   {
     return 
-      vector_distance(beg1,end1,beg2,
-                      typename vector_distance_traits<Dist>::distance(),
+      distance(beg1,end1,beg2,
+                      typename distance_traits<Dist>::distance(),
                       typename utility::weighted_if_any2<Iter1, Iter2>::type());
   }       

trunk/yat/statistics/euclidean_distance.h

@@ -1 @@
-#ifndef theplu_yat_statistics_euclidean_vector_distance_h
-#define theplu_yat_statistics_euclidean_vector_distance_h
+#ifndef theplu_yat_statistics_euclidean_distance_h
+#define theplu_yat_statistics_euclidean_distance_h
 
 // $Id$
@@ -27 +27 @@
 #include "AveragerPair.h"
 #include "AveragerPairWeighted.h"
-#include "vector_distance.h"
+#include "distance.h"
 #include "yat/utility/iterator_traits.h"
 
@@ -41 +41 @@
   /// the Euclidean distance measure.
   ///
-  struct euclidean_vector_distance_tag 
-    : public vector_distance_tag
+  struct euclidean_distance_tag 
+    : public distance_tag
   {
     /// \brief tag for euclidean distance
-    typedef euclidean_vector_distance_tag distance;
+    typedef euclidean_distance_tag distance;
   };
 
@@ -55 +55 @@
   /// 
   template <typename Iter1, typename Iter2>
-  double vector_distance(Iter1 beg1,Iter1 end1, Iter2 beg2,
-                         const euclidean_vector_distance_tag& disttype,
+  double distance(Iter1 beg1,Iter1 end1, Iter2 beg2,
+                         const euclidean_distance_tag& disttype,
                          utility::unweighted_type)
   {
@@ -71 +71 @@
   /// 
   template <typename Iter1, typename Iter2>
-  double vector_distance(Iter1 beg1, Iter1 end1, Iter2 beg2,
-                         const euclidean_vector_distance_tag& disttype,
+  double distance(Iter1 beg1, Iter1 end1, Iter2 beg2,
+                         const euclidean_distance_tag& disttype,
                          utility::weighted_type)
   {

trunk/yat/statistics/pearson_distance.h

@@ -1 @@
-#ifndef theplu_yat_statistics_pearson_vector_distance_h
-#define theplu_yat_statistics_pearson_vector_distance_h
+#ifndef theplu_yat_statistics_pearson_distance_h
+#define theplu_yat_statistics_pearson_distance_h
 
 // $Id$
@@ -25 +25 @@
 */
 
-#include "vector_distance.h"
+#include "distance.h"
 
 #include "AveragerPair.h"
@@ -40 +40 @@
   /// the Pearson distance measure.
   ///
-  struct pearson_vector_distance_tag 
-    : public vector_distance_tag
+  struct pearson_distance_tag 
+    : public distance_tag
   {
     /// \brief tag for pearson distance
-    typedef pearson_vector_distance_tag distance;
+    typedef pearson_distance_tag distance;
   };
 
@@ -54 +54 @@
   /// 
   template <class Iter>
-  double vector_distance(Iter beg1,Iter end1, Iter beg2,
-                         const pearson_vector_distance_tag& disttype,
+  double distance(Iter beg1,Iter end1, Iter beg2,
+                         const pearson_distance_tag& disttype,
                          utility::unweighted_type)
   {
@@ -69 +69 @@
   /// 
   template <class Iter>
-  double vector_distance(Iter beg1,Iter end1, Iter beg2,
-                         const pearson_vector_distance_tag& disttype,
+  double distance(Iter beg1,Iter end1, Iter beg2,
+                         const pearson_distance_tag& disttype,
                          utility::weighted_type)
   {