Changeset 593

Timestamp:

Aug 25, 2006, 2:59:21 PM (15 years ago)

Author:

Markus Ringnér

Message:

Fixed std includes to compile with g++ 4.1.

Location:

trunk

Files:

• c++_tools/classifier/DataLookup1D.cc (modified) (3 diffs)
• c++_tools/classifier/DataLookup1D.h (modified) (1 diff)
• c++_tools/classifier/EnsembleBuilder.cc (modified) (1 diff)
• c++_tools/classifier/MatrixLookup.cc (modified) (1 diff)
• c++_tools/classifier/NCC.cc (modified) (5 diffs)
• c++_tools/classifier/NCC.h (modified) (4 diffs)
• c++_tools/classifier/SVM.cc (modified) (2 diffs)
• c++_tools/classifier/SVM.h (modified) (2 diffs)
• c++_tools/classifier/SupervisedClassifier.h (modified) (2 diffs)
• c++_tools/gslapi/matrix.cc (modified) (1 diff)
• c++_tools/gslapi/vector.cc (modified) (1 diff)
• c++_tools/statistics/AveragerPair.h (modified) (1 diff)
• test/data_lookup_1d_test.cc (modified) (3 diffs)
• test/ncc_test.cc (modified) (3 diffs)

trunk/c++_tools/classifier/DataLookup1D.cc

@@ -6 +6 @@
 #include <cassert>
 #include <iostream>
+#include <iomanip>
 
 namespace theplu {
@@ -36 +37 @@
   }
 
+
   double DataLookup1D::operator*(const DataLookup1D& other) const
   {
@@ -45 +47 @@
   }
 
-  std::ostream& operator<< (std::ostream& os, const DataLookup1D& x)
+
+  std::ostream& operator<<(std::ostream& os, const DataLookup1D& x)
   {
     os.setf(std::ios::dec);
     os.precision(12);
-    for (size_t i = 0; i < x.size(); ++i) {
+    
+    for (size_t i=0; i<x.size(); ++i) {
       os << x(i);
-      if ( (i+1)<x.size() )
-        os << " ";
+      if ((i+1)<x.size())
+        os << os.fill();
     }
     return os;
   }
+
 }} // of namespace classifier and namespace theplu

trunk/c++_tools/classifier/DataLookup1D.h

@@ -87 +87 @@
     const bool owner_;
     
-  };  
+  };
+
   ///
-  /// The output operator DataLook1D
+  /// @brief The output operator for DataLookup1D.
   ///
-  /// @todo test that output can be used from gslapi::vector istream constructor
-  std::ostream& operator<< (std::ostream& s, const DataLookup1D&);
+  /**
+   * Elements are separated by the character from the omanip fill.
+   * The following example will write the elements separated by tab.
+   * 
+   @verbatim 
+   char prev=s.fill('\t'); 
+   s << v;
+   s.fill(prev); 
+   @endverbatim
+  */
+  std::ostream& operator<<(std::ostream& s, const DataLookup1D& v);
   
 }} // of namespace classifier and namespace theplu

trunk/c++_tools/classifier/EnsembleBuilder.cc

@@ -30 +30 @@
     cross_splitter_.reset();
     while(cross_splitter_.more()) {
-      const DataLookup2D& training=cross_splitter_.training_data();
-      const Target& targets=cross_splitter_.training_target();
-
       SupervisedClassifier* classifier=
-        mother_.make_classifier(training,targets);
+        mother_.make_classifier(cross_splitter_);
       classifier->train();
       classifier_.push_back(classifier);

trunk/c++_tools/classifier/MatrixLookup.cc

@@ -162 +162 @@
         s << m(i,j);
         if (j<m.columns()-1)
-          s << "\t";
+          s << s.fill();
         else if (i<m.rows()-1)
           s << "\n";

trunk/c++_tools/classifier/NCC.cc

@@ -3 +3 @@
 #include <c++_tools/classifier/NCC.h>
 
+#include <c++_tools/classifier/CrossSplitter.h>
 #include <c++_tools/classifier/DataLookup1D.h>
 #include <c++_tools/classifier/DataLookup2D.h>
@@ -22 +23 @@
   NCC::NCC(const MatrixLookup& data, const Target& target, 
            const statistics::Distance& distance) 
-    : SupervisedClassifier(target), distance_(distance), matrix_(data)
-  {   
+    : SupervisedClassifier(target), distance_(distance), matrix_(data),
+      weighted_(false),
+      weights_(new MatrixLookup(data.rows(),data.columns(),1.0))
+  {
   }
+
+  NCC::NCC(const MatrixLookup& data, const Target& target, 
+           const statistics::Distance& distance, const MatrixLookup& weights) 
+    : SupervisedClassifier(target), distance_(distance), matrix_(data),
+      weighted_(true),weights_(&weights)
+  {
+  }
+
 
   NCC::NCC(const MatrixLookup& data, const Target& target, 
@@ -30 +41 @@
            statistics::Score& score, size_t nof_inputs) 
     : SupervisedClassifier(target, &score, nof_inputs), 
-      distance_(distance), matrix_(data)
+      distance_(distance), matrix_(data),weighted_(false),
+      weights_(new MatrixLookup(data.rows(),data.columns(),1.0))
   {
   }
 
-  NCC::~NCC()   
+  NCC::NCC(const MatrixLookup& data, const Target& target, 
+           const statistics::Distance& distance,
+           const MatrixLookup& weights,
+           statistics::Score& score, size_t nof_inputs) 
+    : SupervisedClassifier(target, &score, nof_inputs), 
+      distance_(distance), matrix_(data),weighted_(true),
+      weights_(&weights)
   {
   }
 
 
+  NCC::~NCC()   
+  {
+    if(!weighted_) 
+      if(weights_)
+        delete weights_;
+      else 
+        std::cerr << "Error in NCC implementation: probably a constructor"
+                  << " should be debugged to make sure a unity weight matrix is"
+                  << " dynamically allocated for all unweighted cases" 
+                  << std::endl;
+  }
+
+
   SupervisedClassifier* 
-  NCC::make_classifier(const DataLookup2D& data, 
-                       const Target& target) const 
+  NCC::make_classifier(const CrossSplitter& cs) const 
   {     
-    const MatrixLookup& tmp = dynamic_cast<const MatrixLookup&>(data);
-
-    NCC* ncc= new NCC(tmp,target,this->distance_);
+    const MatrixLookup& training_data = 
+      dynamic_cast<const MatrixLookup&>(cs.training_data());
+    NCC* ncc=0;
+    if(cs.weighted()) {
+      ncc= new NCC(training_data,cs.training_target(),this->distance_,
+                        cs.training_weight());
+    }
+    else {
+      ncc= new NCC(training_data,cs.training_target(),this->distance_);
+    }
     ncc->score_=this->score_;
     ncc->nof_inputs_=this->nof_inputs_;
@@ -61 +98 @@
     size_t rows=matrix_.rows();
     if(score_) {
-      // Markus: missing values should not be handled here, but a weight matrix
-      // should be supported throughout the classifier class structure.
-      gslapi::matrix weight(matrix_.rows(),matrix_.columns(),0.0);
-      for(size_t i=0; i<matrix_.rows(); i++) 
-        for(size_t j=0; j<matrix_.columns(); j++) 
-          if(!std::isnan(matrix_(i,j))) 
-            weight(i,j)=1.0;
-      MatrixLookup weightview(weight);
-      ranker_=new InputRanker(matrix_, target_, *score_, weightview);
+      ranker_=new InputRanker(matrix_, target_, *score_, *weights_);
       rows=nof_inputs_;
     }
@@ -77 +106 @@
       for(size_t j=0; j<matrix_.columns(); j++) {
         double value=matrix_(i,j);
-        if(score_)
+        double weight=(*weights_)(i,j);
+        if(score_) {
           value=matrix_(ranker_->id(i),j);
-        if(!std::isnan(value)) {
-          centroids_(i,target_(j)) += value;
-          nof_in_class(i,target_(j))++;
+          weight=(*weights_)(ranker_->id(i),j);
+        }
+        if(weight) {
+          centroids_(i,target_(j)) += value*weight;
+          nof_in_class(i,target_(j))+=weight;
         }
       }

trunk/c++_tools/classifier/NCC.h

@@ -19 +19 @@
 namespace classifier {  
 
-  class Target;
+  class CrossSplitter;
   class DataLookup1D;
   class DataLookup2D;
   class MatrixLookup;
+  class Target;
 
   ///
@@ -33 +34 @@
   public:
     ///
-    /// Constructor taking the training data, the target vector and
-    /// the distance measure as input. 
+    /// Constructor taking the training data, the target vector, and
+    /// the distance measure as input.
     ///
     NCC(const MatrixLookup&, const Target&, const statistics::Distance&);
+    
+    ///
+    /// Constructor taking the training data, the target vector, the
+    /// distance measure, and a weight matrix for the training data as
+    /// input.
+    ///
+    NCC(const MatrixLookup&, const Target&, const statistics::Distance&,
+        const MatrixLookup&);
 
+    
 
     ///
     /// Constructor taking the training data, the target vector, the
     /// distance measure, the score used to rank data inputs, and the
-    /// number of top ranked data inputs to use in the classification.
+    /// number of top ranked data inputs to use in the classification
+    /// as input
     ///
     NCC(const MatrixLookup&, const Target&, const statistics::Distance&, 
         statistics::Score&, const size_t);
+
+    ///
+    /// Constructor taking the training data, the target vector, the
+    /// distance measure, a weight matrix for the training data, the
+    /// score used to rank data inputs, and the number of top ranked
+    /// data inputs to use in the classification as input
+    ///
+    NCC(const MatrixLookup&, const Target&, const statistics::Distance&, 
+        const MatrixLookup&, statistics::Score&, const size_t);
+
 
     virtual ~NCC();
@@ -55 +76 @@
 
     inline SupervisedClassifier* 
-    make_classifier(const DataLookup2D&, const Target&) const;
+    make_classifier(const CrossSplitter&) const;
     
     ///
@@ -81 +102 @@
     const statistics::Distance& distance_;                 
     const MatrixLookup& matrix_;
-
+    bool weighted_;
+    const MatrixLookup* weights_;
   };
 

trunk/c++_tools/classifier/SVM.cc

@@ -3 +3 @@
 #include <c++_tools/classifier/SVM.h>
 
+#include <c++_tools/classifier/CrossSplitter.h>
 #include <c++_tools/classifier/DataLookup2D.h>
 #include <c++_tools/classifier/InputRanker.h>
@@ -111 +112 @@
 
 
-  SupervisedClassifier* SVM::make_classifier(const DataLookup2D& data, 
-                                             const Target& target) const
-  {
+  SupervisedClassifier* SVM::make_classifier(const CrossSplitter& cs) const
+  {
+    // Peter, should check success of dynamic_cast
+    const KernelLookup& data = 
+      dynamic_cast<const KernelLookup&>(cs.training_data());
+    const Target& target=cs.training_target();
+
     assert(data.rows()==data.columns());
     assert(data.columns()==target.size());
-    // Peter, should check success of dynamic_cast
-    const KernelLookup& tmp = dynamic_cast<const KernelLookup&>(data);
     SVM* sc;
     if (ranker_)
-      sc = new SVM(tmp,target,*score_,nof_inputs_);
+      sc = new SVM(data,target,*score_,nof_inputs_);
     else
-      sc = new SVM(tmp,target);
+      sc = new SVM(data,target);
 
 

trunk/c++_tools/classifier/SVM.h

@@ -17 +17 @@
 namespace theplu {
 namespace classifier {  
+
+  // forward declarations
+  class CrossSplitter;
 
   // @internal Class keeping track of which samples are support vectors and
@@ -136 +139 @@
     ///
     SupervisedClassifier* 
-    make_classifier(const DataLookup2D&, const Target&) const;
+    make_classifier(const CrossSplitter&) const;
 
     ///

trunk/c++_tools/classifier/SupervisedClassifier.h

@@ -20 +20 @@
 namespace classifier {  
 
+  class CrossSplitter;
   class DataLookup2D;
-  class InputRanker;  class Target;
-
+  class InputRanker;
+  class Target;
 
   ///
@@ -59 +60 @@
     ///
     virtual SupervisedClassifier* 
-    make_classifier(const DataLookup2D&, const Target&) const =0;
+    make_classifier(const CrossSplitter&) const =0;
     
 

trunk/c++_tools/gslapi/matrix.cc

@@ -231 +231 @@
         s << m(i,j);
         if (j<m.columns()-1)
-          s << "\t";
+          s << s.fill();
         else if (i<m.rows()-1)
           s << "\n";

trunk/c++_tools/gslapi/vector.cc

@@ -258 +258 @@
       s << a[j];
       if ( (j+1)<a.size() )
-        s << " ";
+        s << s.fill();
     }
 

trunk/c++_tools/statistics/AveragerPair.h

@@ -6 +6 @@
 #include <c++_tools/statistics/Averager.h>
 
+#include <cassert>
 #include <cmath>
 #include <utility>

trunk/test/data_lookup_1d_test.cc

@@ -8 +8 @@
 #include <iostream>
 #include <vector>
+#include <cmath>
 
 using namespace theplu;
@@ -39 +40 @@
   index_even.push_back(4);
   classifier::MatrixLookup m1(gsl_m1,index_odd,index_even);
+  *error << gsl_m1 << std::endl << '\n';
+  *error << m1 << std::endl;
   *error << "DataLookup1D::DataLookup1D(const MatrixLookup&\n"
          << "                           const size_t, const bool)...";
@@ -93 +96 @@
     *error << "Ok" << std::endl;
 
+  *error << "Testing that output from ostream operator for DataLookup1D"
+         << " can be used by the gslapi::vector istream constructor...";
+
+  // First with a vector with no missing values separated by ' '.
+  std::ofstream my_out("data/tmp_test_datalookup1D.txt");
+  my_out << v1;
+  my_out.close();
+  std::ifstream is("data/tmp_test_datalookup1D.txt");
+  gslapi::vector v5(is);
+  is.close();
+  if (v5.size()!=v1.size() || v5(0)!=v1(0) || v5(1)!=v1(1) ||
+      v5(2)!=v1(2)) {
+    ok=false;
+    *error << "\nERROR\n" << std::endl;
+  }
+  unlink("data/tmp_test_datalookup1D.txt");
+  
+  // Second with a vector with a missing value separated by '\t'.
+  gsl_m1(3,0)=std::numeric_limits<double>::quiet_NaN();
+  classifier::DataLookup1D v6(m1,1, true);  
+  my_out.open("data/tmp_test_datalookup1D.txt");
+  char prev=my_out.fill('\t');
+  my_out << v1;
+  my_out.fill(prev);
+  my_out.close();
+  is.open("data/tmp_test_datalookup1D.txt");
+  gslapi::vector v7(is,'\t');
+  is.close();
+  if (v7.size()!=v6.size() || !std::isnan(v7(1))) {
+    ok=false;
+    *error << "\nERROR\n"
+           << "size: " << v7.size() << " expected " << v6.size() << "\n" 
+           << "v7(1): " << v7(1) << " expected nan\n" 
+           << std::endl;
+  }
+  unlink("data/tmp_test_datalookup1D.txt");
+   
+
   if (ok)
     *error << "Ok." << std::endl;

trunk/test/ncc_test.cc

@@ -34 +34 @@
   bool ok = true;
 
-
   std::ifstream is("data/sorlie_centroids.txt");
   gslapi::matrix data(is,'\t');
@@ -43 +42 @@
   is.close();
 
-    
+  // Generate weight matrix with 0 for missing values and 1 for others.
+  gslapi::matrix weights(data.rows(),data.columns(),0.0);
+  for(size_t i=0;i<data.rows();++i)
+    for(size_t j=0;j<data.columns();++j)
+      if(!std::isnan(data(i,j)))
+        weights(i,j)=1.0;
+      
   classifier::MatrixLookup dataview(data);
+  classifier::MatrixLookup weightview(weights);
   statistics::PearsonDistance pearson;  
-  classifier::NCC ncc(dataview,targets,pearson);
+  classifier::NCC ncc(dataview,targets,pearson,weightview);
   ncc.train();
 
@@ -78 +84 @@
   *error << igp.score() << std::endl;
 
+  if(ok)
+    *error << "OK" << std::endl;
+
 
   if (error!=&std::cerr)
     delete error;
 
-  if(ok)
+  if(ok) 
     return 0;
   return -1;