Changeset 1079 for trunk/yat/classifier

Timestamp:

Feb 13, 2008, 12:44:28 PM (15 years ago)

Author:

Peter

Message:

fixes #311

Location:

trunk/yat/classifier

Files:

• EnsembleBuilder.cc (deleted)
• EnsembleBuilder.h (modified) (5 diffs)
• Makefile.am (modified) (1 diff)
• SubsetGenerator.h (modified) (1 diff)

trunk/yat/classifier/EnsembleBuilder.h

@@ -7 +7 @@
   Copyright (C) 2005 Markus Ringnér
   Copyright (C) 2006 Jari Häkkinen, Markus Ringnér, Peter Johansson
-  Copyright (C) 2007 Peter Johansson
+  Copyright (C) 2007, 2008 Peter Johansson
 
   This file is part of the yat library, http://trac.thep.lu.se/yat
@@ -27 +27 @@
 */
 
-#include "DataLookup2D.h"
+#include "FeatureSelector.h";
+#include "Sampler.h"
 #include "SubsetGenerator.h"
 #include "yat/statistics/Averager.h"
@@ -37 +38 @@
 namespace classifier {  
 
-  class FeatureSelector;
-  class Sampler;
-  class SupervisedClassifier;
-
   ///
   /// @brief Class for ensembles of supervised classifiers
   ///
-
+  template <class Classifier, class Data>
   class EnsembleBuilder
   {
   
   public:
+    typedef Classifier classifier_type;
+    typedef Data data_type;
+
     ///
     /// Constructor.
     ///
-    EnsembleBuilder(const SupervisedClassifier&, const Sampler&);
+    EnsembleBuilder(const Classifier&, const Sampler&);
 
     ///
     /// Constructor.
     ///
-    EnsembleBuilder(const SupervisedClassifier&, const Sampler&, 
+    EnsembleBuilder(const Classifier&, const Sampler&, 
                     FeatureSelector&);
 
@@ -73 +73 @@
     /// @Return classifier
     ///
-    const SupervisedClassifier& classifier(size_t i) const;
+    const Classifier& classifier(size_t i) const;
       
     ///
@@ -96 +96 @@
        kernel corresponds to.
     */
-    void predict(const DataLookup2D& data, 
+    void predict(const Data& data, 
                  std::vector<std::vector<statistics::Averager> > &);
 
   private:
+    // no copying
     EnsembleBuilder(const EnsembleBuilder&);
     const EnsembleBuilder& operator=(const EnsembleBuilder&);
     
 
-    const SupervisedClassifier& mother_;
-    SubsetGenerator<DataLookup2D>* subset_;
-    std::vector<SupervisedClassifier*> classifier_;
+    const Classifier& mother_;
+    SubsetGenerator<Data>* subset_;
+    std::vector<Classifier*> classifier_;
     std::vector<std::vector<statistics::Averager> > validation_result_;
 
   };
   
+
+  // implementation
+
+  template <class C, class D> 
+  EnsembleBuilder<C,D>::EnsembleBuilder(const C& sc, 
+                                        const Sampler& sampler) 
+    : mother_(sc),subset_(new SubsetGenerator<D>(sampler,sc.data()))
+  {
+  }
+
+
+  template <class C, class D> 
+  EnsembleBuilder<C, D>::EnsembleBuilder(const C& sc, const Sampler& sampler,
+                                         FeatureSelector& fs) 
+    : mother_(sc),
+      subset_(new SubsetGenerator<D>(sampler,sc.data(),fs))
+  {
+  }
+
+
+  template <class C, class D> 
+  EnsembleBuilder<C, D>::~EnsembleBuilder(void) 
+  {
+    for(size_t i=0; i<classifier_.size(); i++)
+      delete classifier_[i];
+    delete subset_;
+  }
+
+
+  template <class C, class D> 
+  void EnsembleBuilder<C, D>::build(void) 
+  {
+    for(u_long i=0; i<subset_->size();++i) {
+      C* classifier = mother_.make_classifier(subset_->training_data(i), 
+                                              subset_->training_target(i));
+      classifier->train();
+      classifier_.push_back(classifier);
+    }   
+  }
+
+
+  template <class C, class D> 
+  const C& EnsembleBuilder<C, D>::classifier(size_t i) const
+  {
+    return *(classifier_[i]);
+  }
+
+
+  template <class C, class D> 
+  u_long EnsembleBuilder<C, D>::size(void) const
+  {
+    return classifier_.size();
+  }
+
+
+  template <class C, class D> 
+  void EnsembleBuilder<C, D>::predict
+  (const D& data, std::vector<std::vector<statistics::Averager> >& result)
+  {
+    result.clear();
+    result.reserve(subset_->target().nof_classes());    
+    for(size_t i=0; i<subset_->target().nof_classes();i++)
+      result.push_back(std::vector<statistics::Averager>(data.columns()));
+    
+    utility::matrix prediction;  
+
+    for(u_long k=0;k<subset_->size();++k) {       
+      const D* sub_data =
+        data.selected(subset_->training_features(k));
+      assert(sub_data);
+      classifier(k).predict(*sub_data,prediction);
+      delete sub_data;
+    }
+
+    for(size_t i=0; i<prediction.rows();i++) 
+      for(size_t j=0; j<prediction.columns();j++) 
+        result[i][j].add(prediction(i,j));    
+  }
+
+  
+  template <class C, class D> 
+  const std::vector<std::vector<statistics::Averager> >& 
+  EnsembleBuilder<C, D>::validate(void)
+  {
+    validation_result_.clear();
+
+    validation_result_.reserve(subset_->target().nof_classes());    
+    for(size_t i=0; i<subset_->target().nof_classes();i++)
+      validation_result_.push_back(std::vector<statistics::Averager>(subset_->target().size()));
+    
+    utility::matrix prediction;  
+    for(u_long k=0;k<subset_->size();k++) {
+      classifier(k).predict(subset_->validation_data(k),prediction);
+      
+      // map results to indices of samples in training + validation data set
+      for(size_t i=0; i<prediction.rows();i++) 
+        for(size_t j=0; j<prediction.columns();j++) {
+          validation_result_[i][subset_->validation_index(k)[j]].
+            add(prediction(i,j));
+        }           
+    }
+    return validation_result_;
+  }
+
 }}} // of namespace classifier, yat, and theplu
 

trunk/yat/classifier/Makefile.am

@@ -33 +33 @@
   DataLookupWeighted1D.cc \
   DataLookup2D.cc \
-  EnsembleBuilder.cc \
   FeatureSelector.cc \
   FeatureSelectorIR.cc \

trunk/yat/classifier/SubsetGenerator.h

@@ -51 +51 @@
   class SubsetGenerator
   {
-
   public:
+    typedef T value_type;
+
     ///
     /// @brief Constructor