Changeset 898

Timestamp:

Sep 26, 2007, 3:44:19 PM (16 years ago)

Author:

Markus Ringnér

Message:

A first suggestion for how to adress #250. Also removed contamination of namespace std (see #251).

Location:

trunk

Files:

• test/iterator_test.cc (modified) (2 diffs)
• test/ncc_test.cc (modified) (3 diffs)
• test/vector_distance_test.cc (modified) (4 diffs)
• yat/classifier/NCC.cc (modified) (5 diffs)
• yat/classifier/NCC.h (modified) (4 diffs)
• yat/statistics/euclidean_vector_distance.h (modified) (1 diff)
• yat/statistics/pearson_vector_distance.h (modified) (2 diffs)
• yat/statistics/vector_distance.h (modified) (2 diffs)
• yat/statistics/vector_distance_ptr.h (added)
• yat/utility/IteratorWeighted.h (modified) (3 diffs)

trunk/test/iterator_test.cc

@@ -24 +24 @@
 #include "yat/classifier/DataLookup1D.h"
 
+#include "yat/classifier/DataLookupWeighted1D.h"
+#include "yat/classifier/MatrixLookupWeighted.h"
 #include "yat/utility/Iterator.h"
+#include "yat/utility/IteratorWeighted.h"
+#include "yat/utility/matrix.h"
 #include "yat/utility/vector.h"
 
@@ -63 +67 @@
   std::sort(begin, end);
 
+  // test std algorithm on IteratorWeighted
+  utility::matrix m(1,3,1);
+  m(0,1)=2.0;
+  utility::matrix w(1,3,1);
+  classifier::MatrixLookupWeighted mw(m,w);
+  classifier::DataLookupWeighted1D aw(mw,0,true);
+  size_t nof1=std::count(aw.begin(),aw.end(),1.0);
+  if(nof1!=2) {
+    *message << "std algoritm with IteratorWeighted failed" << std::endl;
+    ok=false;
+  }
+
   if (!ok)
     *message << "iterator test failed" << std::endl;

trunk/test/ncc_test.cc

@@ -28 +28 @@
 #include "yat/classifier/Target.h"
 #include "yat/utility/matrix.h"
-#include "yat/statistics/PearsonDistance.h"
+#include "yat/statistics/vector_distance_ptr.h"
+#include "yat/statistics/pearson_vector_distance.h"
 #include "yat/utility/utility.h"
 
@@ -71 +72 @@
       
   classifier::MatrixLookupWeighted dataviewweighted(data,weights);
-  statistics::PearsonDistance pearson;  
-  classifier::NCC ncc(dataviewweighted,targets,pearson);
+  statistics::vector_distance_lookup_weighted_ptr distance=
+    statistics::vector_distance<statistics::pearson_vector_distance_tag>;
+  classifier::NCC ncc(dataviewweighted,targets,distance);
   ncc.train();
 
@@ -127 +129 @@
   
 
-  // Testing IGP  
-  classifier:: MatrixLookup dataview(data);
-  *error << "testing igp" << std::endl;
-  classifier::IGP igp(dataview,targets,pearson);
-  *error << igp.score() << std::endl;
-
   if(ok)
     *error << "OK" << std::endl;

trunk/test/vector_distance_test.cc

@@ -5 +5 @@
 #include "yat/statistics/euclidean_vector_distance.h"
 #include "yat/statistics/pearson_vector_distance.h"
+#include "yat/statistics/vector_distance_ptr.h"
 #include "yat/utility/matrix.h"
 #include "yat/utility/vector.h"
@@ -14 +15 @@
 
 using namespace theplu::yat;
+
+
+// Function to test pointers to distance specialized for DataLookup1D::iterator
+double f(statistics::vector_distance_lookup_weighted_ptr distance) {
+  utility::matrix m(2,3,1);
+  m(0,1)=2;
+  m(1,0)=0;
+  m(1,1)=0;
+  utility::matrix w(2,3,1);
+  w(0,0)=0;
+  classifier::MatrixLookupWeighted mw(m,w);
+  classifier::DataLookupWeighted1D aw(mw,0,true);
+  classifier::DataLookupWeighted1D bw(mw,1,true);
+  
+  double dist=(*distance)(aw.begin(),aw.end(),bw.begin());
+  return dist;  
+}
 
 int main(const int argc,const char* argv[])
@@ -63 +81 @@
   
   dist=statistics::vector_distance(aw.begin(),aw.end(),bw.begin(),
-                                          statistics::euclidean_vector_distance_tag());
+                                   statistics::euclidean_vector_distance_tag());
   
   if(fabs(dist-2)>tolerance) {
@@ -79 +97 @@
 
 
-  // Test with reference to a vector_distance_tag
-  statistics::euclidean_vector_distance_tag tag;
-  statistics::vector_distance_tag& tagref=tag;
-  dist=statistics::vector_distance(aw.begin(),aw.end(),bw.begin(),tagref);
-  *error << "Dist: " << dist << std::endl;
+  // Test with std::vectors
+  std::vector<double> sa(3,1);
+  sa[1] = 2;
+  std::vector<double> sb(3,0);
+  sb[2] = 1;
 
+  dist=statistics::vector_distance(sa.begin(),sa.end(),sb.begin(),
+                                   statistics::euclidean_vector_distance_tag());  if(fabs(dist-2.23607)>tolerance) {
+    *error << "Error in vector_distance for std::vector: " << std::endl;
+    ok=false;
+  }
+
+
+  // Test with pointer to a vector_distance
+  statistics::vector_distance_lookup_weighted_ptr test_ptr=
+    statistics::vector_distance<statistics::euclidean_vector_distance_tag>;
+  dist=(*test_ptr)(aw.begin(),aw.end(),bw.begin());
+  if(fabs(dist-2)>tolerance) {
+    *error << "Error when using pointer to vector_distance" << std::endl;
+    ok=false;
+  }
+
+  if(!ok) {
+    *error << "vector_distance_test failed" << std::endl;
+  }
   if (error!=&std::cerr)
     delete error;
-
   if (ok=true)  
     return 0;

trunk/yat/classifier/NCC.cc

@@ -27 +27 @@
 #include "DataLookup1D.h"
 #include "DataLookup2D.h"
+#include "DataLookupWeighted1D.h"
 #include "MatrixLookup.h"
 #include "MatrixLookupWeighted.h"
 #include "Target.h"
+#include "yat/statistics/vector_distance.h"
+#include "yat/statistics/euclidean_vector_distance.h"
+#include "yat/utility/Iterator.h"
+#include "yat/utility/IteratorWeighted.h"
 #include "yat/utility/matrix.h"
 #include "yat/utility/vector.h"
-#include "yat/statistics/Distance.h"
 #include "yat/utility/stl_utility.h"
 
@@ -45 +49 @@
 
   NCC::NCC(const MatrixLookup& data, const Target& target, 
-           const statistics::Distance& distance) 
+           const statistics::vector_distance_lookup_weighted_ptr distance) 
     : SupervisedClassifier(target), distance_(distance), data_(data)
   {
@@ -51 +55 @@
 
   NCC::NCC(const MatrixLookupWeighted& data, const Target& target, 
-           const statistics::Distance& distance) 
+           const statistics::vector_distance_lookup_weighted_ptr distance) 
     : SupervisedClassifier(target), distance_(distance), data_(data)
   {
@@ -65 +69 @@
     return centroids_;
   }
+  
 
-    const DataLookup2D& NCC::data(void) const
-    {
+  const DataLookup2D& NCC::data(void) const
+  {
     return data_;
-    }
-
+  }
+  
   SupervisedClassifier* 
   NCC::make_classifier(const DataLookup2D& data, const Target& target) const 
@@ -109 +114 @@
   }
 
-
-  void NCC::predict(const utility::vector& input, const utility::vector& weights,
-                    utility::vector& prediction) const
-  {
-    prediction.clone(utility::vector(centroids_.columns()));
-    
-    // take care of nan's in centroids
-    for(size_t j=0; j<centroids_.columns(); j++) {
-      const utility::vector centroid(utility::vector(centroids_,j,false));
-      utility::vector wc(centroid.size(),0);
-      for(size_t i=0; i<centroid.size(); i++)  { 
-        if(!std::isnan(centroid(i)))
-          wc(i)=1.0;
-      }
-      prediction(j)=distance_(input,centroid,weights,wc);   
-    }
-  }
-
-
   void NCC::predict(const DataLookup2D& input,                    
                     utility::matrix& prediction) const
   {   
-    prediction.clone(utility::matrix(centroids_.columns(), input.columns()));
-    // weighted case
-    const MatrixLookupWeighted* data =
-      dynamic_cast<const MatrixLookupWeighted*>(&input);  
-    if (data) {
-      for(size_t j=0; j<input.columns();j++) {     
-        utility::vector in(input.rows(),0);
-        for(size_t i=0; i<in.size();i++) 
-          in(i)=data->data(i,j);
-        utility::vector weights(in.size(),0);
-        for(size_t i=0; i<in.size();i++) 
-          weights(i)=data->weight(i,j);
-        utility::vector out;
-        predict(in,weights,out);
-        prediction.column(j,out);
+    prediction.clone(utility::matrix(centroids_.columns(), input.columns()));   
+
+    // Weighted case
+    const MatrixLookupWeighted* testdata =
+      dynamic_cast<const MatrixLookupWeighted*>(&input);      
+    if (testdata) {
+      utility::matrix centroid_weights;
+      utility::nan(centroids_,centroid_weights);
+      MatrixLookupWeighted weighted_centroids(centroids_,centroid_weights);
+      for(size_t j=0; j<input.columns();j++) {        
+        DataLookupWeighted1D in(*testdata,j,false);
+        for(size_t k=0; k<centroids_.columns();k++) {
+          DataLookupWeighted1D centroid(weighted_centroids,k,false);
+          prediction(k,j)=(*distance_)(in.begin(),in.end(),centroid.begin());
+        }
       }
-      return;
     }
-    // non-weighted case
-    const MatrixLookup* x = dynamic_cast<const MatrixLookup*>(&input);
-    if (!x){
+    else {
       std::string str;
       str = "Error in NCC::predict: DataLookup2D of unexpected class.";
       throw std::runtime_error(str);
     }
-    for(size_t j=0; j<input.columns();j++) {     
-      utility::vector in(input.rows(),0);
-      for(size_t i=0; i<in.size();i++) 
-        in(i)=(*data)(i,j);
-      utility::vector weights(in.size(),1.0);
-      utility::vector out;
-      predict(in,weights,out);
-      prediction.column(j,out);
-    }
   }
-
-  
-  // additional operators
-
-//  std::ostream& operator<< (std::ostream& s, const NCC& ncc) {
-//    std::copy(ncc.classes().begin(), ncc.classes().end(), 
-//              std::ostream_iterator<std::map<double, u_int>::value_type>
-//              (s, "\n"));
-//    s << "\n" << ncc.centroids() << "\n";
-//    return s;
-//  }
-
+    
 }}} // of namespace classifier, yat, and theplu

trunk/yat/classifier/NCC.h

@@ -28 +28 @@
 
 #include "yat/utility/matrix.h"
+#include "yat/statistics/vector_distance_ptr.h"
 #include "SupervisedClassifier.h"
 
@@ -37 +38 @@
   namespace utlitity {
     class vector;
-  }
-
-  namespace statistics {
-    class Distance;
   }
 
@@ -61 +58 @@
     ///
     /// Constructor taking the training data, the target vector, and
-    /// the distance measure as input.
+    /// the distance measure tag as input.
     ///
-    NCC(const MatrixLookup&, const Target&, const statistics::Distance&);
+    NCC(const MatrixLookup&, const Target&, 
+        const statistics::vector_distance_lookup_weighted_ptr);
     
     ///
     /// Constructor taking the training data with weights, the target
-    /// vector, the distance measure, and a weight matrix for the
-    /// training data as input.
+    /// vector, the distance measure tag.
     ///
-    NCC(const MatrixLookupWeighted&, const Target&, const statistics::Distance&);
+    NCC(const MatrixLookupWeighted&, const Target&, 
+        const statistics::vector_distance_lookup_weighted_ptr);
 
     virtual ~NCC();
@@ -97 +95 @@
     ///
     void predict(const DataLookup2D&, utility::matrix&) const;
-
-
+    
+    
   private:
     utility::matrix centroids_;
-    const statistics::Distance& distance_;                 
+    const statistics::vector_distance_lookup_weighted_ptr distance_;                 
 
     // data_ has to be of type DataLookup2D to accomodate both
     // MatrixLookup and MatrixLookupWeighted
     const DataLookup2D& data_;
-
-    ///
-    /// Calculate the distance to each centroid for a test sample
-    ///
-    void predict(const utility::vector&, const utility::vector&,
-                 utility::vector&) const;
 
   };

trunk/yat/statistics/euclidean_vector_distance.h

@@ -50 +50 @@
   double vector_distance(Iter1 beg1, Iter1 end1, Iter2 beg2,
                          const euclidean_vector_distance_tag& disttype,
-                         std::weighted_random_access_iterator_tag)
+                         utility::weighted_random_access_iterator_tag)
   {
     AveragerPairWeighted ap;

trunk/yat/statistics/pearson_vector_distance.h

@@ -7 +7 @@
 
 #include "AveragerPair.h"
+#include "AveragerPairWeighted.h"
 
 namespace theplu {
@@ -47 +48 @@
   double vector_distance(Iter beg1,Iter end1, Iter beg2,
                          const pearson_vector_distance_tag& disttype,
-                         std::weighted_random_access_iterator_tag)
+                         utility::weighted_random_access_iterator_tag)
   {
     AveragerPairWeighted ap;

trunk/yat/statistics/vector_distance.h

@@ -6 +6 @@
 #include <iterator>
 
+#include "yat/classifier/DataLookup1D.h"
+#include "yat/classifier/DataLookupWeighted1D.h"
+
 namespace theplu {
 namespace yat {
 
 namespace statistics {
-
+  
   ///
   /// For each measure to calculate distances between containers
@@ -52 +55 @@
                            typename std::iterator_traits<Iter1>::iterator_category());
   }       
+
+  /// A partial specialization for DataLookupWeighted1D
+  template<typename Dist>
+  double vector_distance(const classifier::DataLookupWeighted1D::const_iterator& beg1,const classifier::DataLookupWeighted1D::const_iterator& end1,const classifier::DataLookupWeighted1D::const_iterator& beg2) 
+  {
+    return vector_distance(beg1,end1,beg2, typename statistics::vector_distance_traits<Dist>::distance());
+  }
   
-  // Temporary function of where I end up when calling with a reference to distance_tag
-  template <typename Iter1, typename Iter2>
-  double vector_distance(Iter1 beg1, Iter1 end1, Iter2 beg2, 
-                         const vector_distance_tag& disttag)
+  /// A partial specialization for DataLookup1D
+  template<typename Dist>
+  double vector_distance(const classifier::DataLookup1D::const_iterator& beg1,const classifier::DataLookup1D::const_iterator& end1,const classifier::DataLookup1D::const_iterator& beg2) 
   {
-    return 0;
-  }       
+    return vector_distance(beg1,end1,beg2, typename statistics::vector_distance_traits<Dist>::distance());
+  }
 
   

trunk/yat/utility/IteratorWeighted.h

@@ -7 +7 @@
 #include <stddef.h>
 
-namespace std {
-  struct weighted_random_access_iterator_tag 
-    : public random_access_iterator_tag {
-  };
-}
+// namespace std {
+//  struct weighted_random_access_iterator_tag 
+//    : public random_access_iterator_tag {
+//  };
+// }
 
 
@@ -17 +17 @@
 namespace yat {
 namespace utility {
+
+  struct weighted_random_access_iterator_tag 
+    : public std::random_access_iterator_tag {
+  };
 
   /**
@@ -25 +29 @@
   {
   public:
-    typedef std::weighted_random_access_iterator_tag iterator_category;
+    typedef weighted_random_access_iterator_tag iterator_category;
     typedef double value_type;
     typedef size_t difference_type;