Changeset 526

Timestamp:

Mar 1, 2006, 9:49:48 AM (16 years ago)

Author:

Markus Ringnér

Message:

Fixed bug in tScore and in MatrixLookup?. Added support for scoring inputs in SupervisedClassifier? and for using this in training and prediction in NCC.

Location:

trunk/lib

Files:

• classifier/MatrixLookup.cc (modified) (1 diff)
• classifier/NCC.cc (modified) (8 diffs)
• classifier/NCC.h (modified) (5 diffs)
• classifier/SupervisedClassifier.cc (modified) (2 diffs)
• classifier/SupervisedClassifier.h (modified) (1 diff)
• statistics/tScore.cc (modified) (1 diff)

trunk/lib/classifier/MatrixLookup.cc

@@ -84 +84 @@
                                 const std::vector<size_t>& val) const
   { 
-    return new MatrixLookup(*this,train); 
+    return new MatrixLookup(*this,val); 
   }
 

trunk/lib/classifier/NCC.cc

@@ -5 +5 @@
 #include <c++_tools/classifier/DataLookup1D.h>
 #include <c++_tools/classifier/DataLookup2D.h>
+#include <c++_tools/classifier/MatrixLookup.h>
 #include <c++_tools/classifier/InputRanker.h>
 #include <c++_tools/classifier/Target.h>
@@ -19 +20 @@
 namespace classifier {
 
-  NCC::NCC(const DataLookup2D& data, const Target& target, 
+  NCC::NCC(const MatrixLookup& data, const Target& target, 
            const statistics::Distance& distance) 
     : SupervisedClassifier(target), distance_(distance), matrix_(data)
@@ -25 +26 @@
   }
 
-  NCC::NCC(const DataLookup2D& data, const Target& target, 
+  NCC::NCC(const MatrixLookup& data, const Target& target, 
            const statistics::Distance& distance, 
            statistics::Score& score, size_t nof_inputs) 
@@ -44 +45 @@
                        const Target& target) const 
   {     
-    NCC* ncc= new NCC(data,target,this->distance_);
+    const MatrixLookup& tmp = dynamic_cast<const MatrixLookup&>(data);
+
+    NCC* ncc= new NCC(tmp,target,this->distance_);
     ncc->score_=this->score_;
     ncc->nof_inputs_=this->nof_inputs_;
@@ -53 +56 @@
   bool NCC::train()
   {
+    // If score is set calculate centroids only for nof_inputs_ number
+    // of top ranked inputs. Otherwise calculate centroids based on
+    // all inputs ( = all rows in data matrix).
     if(ranker_)
       delete ranker_;
-    if(score_)
-      ranker_=new InputRanker(matrix_, target_, *score_);
-    // Markus : ranker_ should be taken into account if used!!!
-
-    // Calculate the centroids for each class
-    centroids_=gslapi::matrix(matrix_.rows(),target_.nof_classes());
-    gslapi::matrix nof_in_class(matrix_.rows(),target_.nof_classes());
-    for(size_t i=0; i<matrix_.rows(); i++) {
+    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);
+      rows=nof_inputs_;
+    }
+    centroids_=gslapi::matrix(rows, target_.nof_classes());
+    gslapi::matrix nof_in_class(rows, target_.nof_classes());
+    for(size_t i=0; i<rows; i++) {
       for(size_t j=0; j<matrix_.columns(); j++) {
-        if(!std::isnan(matrix_(i,j))) {
-          centroids_(i,target_(j)) += matrix_(i,j);
+        double value=matrix_(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))++;
         }
@@ -75 +92 @@
   }
 
+
   void NCC::predict(const DataLookup1D& input, 
                     gslapi::vector& prediction) const
   {
-    // Markus : ranker_ should be taken into account if used!!!
-
     prediction=gslapi::vector(centroids_.columns());    
-    gslapi::vector w(input.size(),0);
-    for(size_t i=0; i<input.size(); i++)  // take care of missing values
-      if(!std::isnan(input(i)))
+    size_t size=input.size();
+    if(ranker_)
+      size=nof_inputs_;
+    gslapi::vector w(size,0);
+    gslapi::vector value(size,0);
+    for(size_t i=0; i<size; i++)  { // take care of missing values
+      value(i)=input(i);
+      if(ranker_)
+        value(i)=input(ranker_->id(i));
+      if(!std::isnan(value(i)))
         w(i)=1.0;
+    }
     for(size_t j=0; j<centroids_.columns(); j++) 
-      prediction(j)=distance_(gslapi::vector(input),
-                             gslapi::vector(centroids_,j,false),w, w);    
+      prediction(j)=distance_(value,gslapi::vector(centroids_,j,false),w, w);   
   }
 
@@ -94 +117 @@
                     gslapi::matrix& prediction) const
   {
-    // Markus : ranker_ should be taken into account if used!!!
-    
     prediction=gslapi::matrix(centroids_.columns(), input.columns());   
     for(size_t j=0; j<input.columns();j++) {     
@@ -108 +129 @@
   // additional operators
 
-  std::ostream& operator<< (std::ostream& s, const NCC& ncc) {
+//  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;
-  }
+//    s << "\n" << ncc.centroids() << "\n";
+//    return s;
+//  }
 
 }} // of namespace classifier and namespace theplu

trunk/lib/classifier/NCC.h

@@ -22 +22 @@
   class DataLookup1D;
   class DataLookup2D;
+  class MatrixLookup;
 
   ///
-  /// Class for Nearest Centroid Classification
+  /// Class for Nearest Centroid Classification.
   ///
 
@@ -35 +36 @@
     /// the distance measure as input. 
     ///
-    NCC(const DataLookup2D&, const Target&, const statistics::Distance&);
+    NCC(const MatrixLookup&, const Target&, const statistics::Distance&);
 
-    NCC(const DataLookup2D&, const Target&, const statistics::Distance&, 
+
+    ///
+    /// 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.
+    ///
+    NCC(const MatrixLookup&, const Target&, const statistics::Distance&, 
         statistics::Score&, const size_t);
 
     virtual ~NCC();
 
+    ///
+    /// @return the centroids for each class as columns in a matrix.
+    ///
     const gslapi::matrix& centroids(void) const {return centroids_;}
 
@@ -47 +57 @@
     make_classifier(const DataLookup2D&, const Target&) const;
     
+    ///
+    /// Train the classifier using the training data. Centroids are
+    /// calculated for each class.
+    ///
+    /// @return true if training succedeed.
+    ///
     bool train();
 
 
     ///
-    /// Calculate the scores to each centroid for a test sample
+    /// Calculate the distance to each centroid for a test sample
     ///
     void predict(const DataLookup1D&, gslapi::vector&) const;
     
     ///
-    /// Calculate the scores to each centroid for test samples
+    /// Calculate the distance to each centroid for test samples
     ///
     void predict(const DataLookup2D&, gslapi::matrix&) const;
@@ -64 +80 @@
     gslapi::matrix centroids_;
     const statistics::Distance& distance_;                 
-    const DataLookup2D& matrix_;
+    const MatrixLookup& matrix_;
 
   };
@@ -71 +87 @@
   /// The output operator for the NCC class.
   ///
-  std::ostream& operator<< (std::ostream&, const NCC&);
+  //  std::ostream& operator<< (std::ostream&, const NCC&);
   
   

trunk/lib/classifier/SupervisedClassifier.cc

@@ -6 +6 @@
 namespace classifier {
 
-  SupervisedClassifier::SupervisedClassifier(const Target& target,
+  SupervisedClassifier::SupervisedClassifier(const Target& target)
+    : target_(target), score_(0), ranker_(0), nof_inputs_(0),
+      trained_(false)
+  {
+  }
+
+    SupervisedClassifier::SupervisedClassifier(const Target& target,
                                              statistics::Score* score,
                                              const size_t nof_inputs)
@@ -14 +20 @@
   }
 
+
 }}

trunk/lib/classifier/SupervisedClassifier.h

@@ -35 +35 @@
     /// Constructor. Taking a vector of target values.
     ///
-    SupervisedClassifier(const Target&, statistics::Score* =0, 
-                         const size_t=0);
+    SupervisedClassifier(const Target&);
     
+
+    ///
+    /// Constructor. Taking a vector of target values, a score used to
+    /// rank data inputs, and the number of top ranked inputs to use
+    /// in classification.
+    ///
+    SupervisedClassifier(const Target&, statistics::Score*, const size_t);
+
     ///
     /// Destructor

trunk/lib/statistics/tScore.cc

@@ -61 +61 @@
       (positive.n()+negative.n()-2);
     t_=diff/sqrt(s2*(1.0/positive.sum_w()+1.0/negative.sum_w()));
-    assert(0);
     if (t_<0 && absolute_)
       t_=-t_;