Changeset 1072 for trunk/yat/classifier

Timestamp:

Feb 12, 2008, 1:22:27 AM (16 years ago)

Author:

Peter

Message:

fixes #309

Location:

trunk/yat/classifier

Files:

• EnsembleBuilder.cc (modified) (2 diffs)
• EnsembleBuilder.h (modified) (3 diffs)
• Makefile.am (modified) (1 diff)
• SubsetGenerator.cc (deleted)
• SubsetGenerator.h (modified) (8 diffs)

trunk/yat/classifier/EnsembleBuilder.cc

@@ -44 +44 @@
   EnsembleBuilder::EnsembleBuilder(const SupervisedClassifier& sc, 
                                    const Sampler& sampler) 
-    : mother_(sc),subset_(new SubsetGenerator(sampler,sc.data()))
+    : mother_(sc),subset_(new SubsetGenerator<DataLookup2D>(sampler,sc.data()))
   {
   }
@@ -51 +51 @@
                                    const Sampler& sampler,
                                    FeatureSelector& fs) 
-    : mother_(sc),subset_(new SubsetGenerator(sampler,sc.data(),fs))
+    : mother_(sc),
+      subset_(new SubsetGenerator<DataLookup2D>(sampler,sc.data(),fs))
   {
   }

trunk/yat/classifier/EnsembleBuilder.h

@@ -27 +27 @@
 */
 
+#include "DataLookup2D.h"
+#include "SubsetGenerator.h"
 #include "yat/statistics/Averager.h"
 
@@ -35 +37 @@
 namespace classifier {  
 
-  class DataLookup2D;
   class FeatureSelector;
   class Sampler;
   class SupervisedClassifier;
-  class SubsetGenerator;
 
   ///
@@ -105 +105 @@
 
     const SupervisedClassifier& mother_;
-    SubsetGenerator* subset_;
+    SubsetGenerator<DataLookup2D>* subset_;
     std::vector<SupervisedClassifier*> classifier_;
     std::vector<std::vector<statistics::Averager> > validation_result_;

trunk/yat/classifier/Makefile.am

@@ -48 +48 @@
   PolynomialKernelFunction.cc \
   Sampler.cc \
-  SubsetGenerator.cc \
   SupervisedClassifier.cc \
   SVindex.cc \

trunk/yat/classifier/SubsetGenerator.h

@@ -26 +26 @@
 */
 
+#include "DataLookup2D.h"
+#include "FeatureSelector.h"
+#include "KernelLookup.h"
+#include "MatrixLookup.h"
+#include "MatrixLookupWeighted.h"
 #include "Target.h"
 #include "Sampler.h"
 
+
+#include <algorithm>
+#include <cassert>
+#include <utility>
+#include <typeinfo>
 #include <vector>
 
@@ -34 +44 @@
 namespace yat {
 namespace classifier {  
-  class DataLookup2D;
-  class FeatureSelector;
-  class MatrixLookup;
 
   ///
   /// @brief Class splitting a set into training set and validation set. 
   ///
-  class SubsetGenerator
+  template <typename T> 
+  class SubsetGenerator
   {
-  
+
   public:
     ///
@@ -51 +59 @@
     /// @param data data to split up in validation and training.
     ///
-    SubsetGenerator(const Sampler& sampler, const DataLookup2D& data);
+    SubsetGenerator(const Sampler& sampler, const T& data);
 
 
@@ -61 +69 @@
     /// @param fs Object selecting features for each subset
     ///
-    SubsetGenerator(const Sampler& sampler, const DataLookup2D& data, 
+    SubsetGenerator(const Sampler& sampler, const T& data, 
                     FeatureSelector& fs);
 
@@ -87 +95 @@
     /// @return training data
     ///
-    const DataLookup2D&
-    training_data(std::vector<DataLookup2D*>::size_type i) const;
+    const T& training_data(size_t i) const;
 
     ///
@@ -110 +117 @@
     /// @return validation data
     ///
-    const DataLookup2D&
-    validation_data(std::vector<DataLookup2D*>::size_type i) const;
+    const T& validation_data(size_t i) const;
 
     ///
@@ -136 +142 @@
     std::vector<std::vector<size_t> > features_;
     const Sampler& sampler_;
-    std::vector<const DataLookup2D*> training_data_;
+    std::vector<const T*> training_data_;
     std::vector<Target> training_target_;
-    std::vector<const DataLookup2D*> validation_data_;
+    std::vector<const T*> validation_data_;
     std::vector<Target> validation_target_;
     const bool weighted_;
@@ -144 +150 @@
   };
 
+
+  // templates
+
+  template<typename T>
+  SubsetGenerator<T>::SubsetGenerator(const Sampler& sampler, 
+                                   const T& data)
+    : f_selector_(NULL), sampler_(sampler), weighted_(false)
+  { 
+    assert(target().size()==data.columns());
+
+    training_data_.reserve(sampler_.size());
+    validation_data_.reserve(sampler_.size());
+    for (size_t i=0; i<sampler_.size(); ++i){
+      // Dynamically allocated. Must be deleted in destructor.
+      training_data_.push_back(data.training_data(sampler.training_index(i)));
+      validation_data_.push_back(data.validation_data(sampler.training_index(i),
+                                                      sampler.validation_index(i)));
+
+      training_target_.push_back(Target(target(),sampler.training_index(i)));
+      validation_target_.push_back(Target(target(),
+                                          sampler.validation_index(i)));
+      assert(training_data_.size()==i+1);
+      assert(training_target_.size()==i+1);
+      assert(validation_data_.size()==i+1);
+      assert(validation_target_.size()==i+1);
+    }
+
+    // No feature selection, hence features same for all partitions
+    // and can be stored in features_[0]
+    features_.resize(1);
+    features_[0].reserve(data.rows());
+    for (size_t i=0; i<data.rows(); ++i)
+      features_[0].push_back(i);
+
+    assert(training_data_.size()==size());
+    assert(training_target_.size()==size());
+    assert(validation_data_.size()==size());
+    assert(validation_target_.size()==size());
+  }
+
+
+  template<typename T>
+  SubsetGenerator<T>::SubsetGenerator(const Sampler& sampler, 
+                                   const T& data, 
+                                   FeatureSelector& fs)
+    : f_selector_(&fs), sampler_(sampler), weighted_(false)
+  { 
+    assert(target().size()==data.columns());
+
+    features_.reserve(size());
+    training_data_.reserve(size());
+    validation_data_.reserve(size());
+
+    // Taking care of three different case.
+    // We start with the case of MatrixLookup
+    const MatrixLookup* ml = dynamic_cast<const MatrixLookup*>(&data);
+    if (ml){
+      for (size_t k=0; k<size(); k++){
+      
+        training_target_.push_back(Target(target(),training_index(k)));
+        validation_target_.push_back(Target(target(),validation_index(k)));
+        // training data with no feature selection
+        const MatrixLookup* train_data_all_feat = 
+          ml->training_data(training_index(k));
+        // use these data to create feature selection
+        assert(train_data_all_feat);
+        f_selector_->update(*train_data_all_feat, training_target(k));
+        // get features
+        features_.push_back(f_selector_->features());
+        assert(train_data_all_feat);
+        delete train_data_all_feat;
+        
+        // Dynamically allocated. Must be deleted in destructor.
+        training_data_.push_back(new MatrixLookup(*ml,features_.back(), 
+                                                  training_index(k)));
+        validation_data_.push_back(new MatrixLookup(*ml,features_.back(), 
+                                                    validation_index(k)));      
+      }
+    }
+    else {
+      // Second the case of MatrixLookupWeighted
+      const MatrixLookupWeighted* ml = 
+        dynamic_cast<const MatrixLookupWeighted*>(&data);
+      if (ml){        
+        for (u_long k=0; k<size(); k++){
+          training_target_.push_back(Target(target(),training_index(k)));
+          validation_target_.push_back(Target(target(),validation_index(k)));
+          // training data with no feature selection
+          const MatrixLookupWeighted* train_data_all_feat = 
+            ml->training_data(training_index(k));
+          // use these data to create feature selection
+          f_selector_->update(*train_data_all_feat, training_target(k));
+          // get features
+          features_.push_back(f_selector_->features());
+          delete train_data_all_feat;
+          
+          // Dynamically allocated. Must be deleted in destructor.
+          training_data_.push_back(new MatrixLookupWeighted(*ml,
+                                                            features_.back(), 
+                                                            training_index(k)
+                                                            ));
+          validation_data_.push_back(new MatrixLookupWeighted(*ml,
+                                                              features_.back(), 
+                                                              validation_index(k)
+                                                              ));     
+        }
+      }
+      else {
+        // Third the case of MatrixLookupWeighted
+        const KernelLookup* kernel = dynamic_cast<const KernelLookup*>(&data);
+        if (kernel){
+          for (u_long k=0; k<size(); k++){
+            training_target_.push_back(Target(target(),training_index(k)));
+            validation_target_.push_back(Target(target(),validation_index(k)));
+            const T* matrix = kernel->data();
+            // dynamically allocated must be deleted
+            const T* training_matrix = 
+              matrix->training_data(training_index(k));
+            if (matrix->weighted()){
+              const MatrixLookupWeighted& ml = 
+                dynamic_cast<const MatrixLookupWeighted&>(*matrix);
+              f_selector_->update(MatrixLookupWeighted(ml,training_index(k),false), 
+                                  training_target(k));
+            }
+            else {
+              const MatrixLookup& ml = 
+                dynamic_cast<const MatrixLookup&>(*matrix);
+              f_selector_->update(MatrixLookup(ml,training_index(k), false), 
+                                  training_target(k));
+            } 
+            std::vector<size_t> dummie=f_selector_->features();
+            features_.push_back(dummie);
+            //features_.push_back(f_selector_->features());
+            assert(kernel);
+            const KernelLookup* kl = kernel->selected(features_.back());
+            assert(training_matrix);
+            delete training_matrix;
+                      
+            // Dynamically allocated. Must be deleted in destructor.
+            training_data_.push_back(kl->training_data(training_index(k)));
+            validation_data_.push_back(kl->validation_data(training_index(k), 
+                                                           validation_index(k)));
+            assert(kl);
+            delete kl;
+          }
+        }
+        else {
+        std::cerr << "Sorry, your type of T (" 
+                  << typeid(data).name() << ")\nis not supported in " 
+                  << "SubsetGenerator with\nFeatureSelection\n";
+        exit(-1);
+        }
+      }
+    }
+    assert(training_data_.size()==size());
+    assert(training_target_.size()==size());
+    assert(validation_data_.size()==size());
+    assert(validation_target_.size()==size());
+  }
+
+
+  template<typename T>
+  SubsetGenerator<T>::~SubsetGenerator()
+  {
+    assert(training_data_.size()==validation_data_.size());
+    for (size_t i=0; i<training_data_.size(); i++) 
+      delete training_data_[i];
+    for (size_t i=0; i<validation_data_.size(); i++) 
+      delete validation_data_[i];
+  }
+
+
+  template<typename T>
+  u_long SubsetGenerator<T>::size(void) const
+  {
+    return sampler_.size();
+  }
+
+
+  template<typename T>
+  const Target& SubsetGenerator<T>::target(void) const
+  {
+    return sampler_.target();
+  }
+
+
+  template<typename T>
+  const T&
+  SubsetGenerator<T>::training_data(size_t i) const 
+  {
+    return *(training_data_[i]);
+  }
+
+
+  template<typename T>
+  const std::vector<size_t>&
+  SubsetGenerator<T>::training_features(typename std::vector<size_t>::size_type i) const
+  {
+    return f_selector_ ? features_[i] : features_[0];
+  }
+
+
+  template<typename T>
+  const std::vector<size_t>&
+  SubsetGenerator<T>::training_index(std::vector<size_t>::size_type i) const
+  {
+    return sampler_.training_index(i);
+  }
+
+
+  template<typename T>
+  const Target&
+  SubsetGenerator<T>::training_target(std::vector<Target>::size_type i) const
+  {
+    return training_target_[i];
+  }
+
+
+  template<typename T>
+  const T&
+  SubsetGenerator<T>::validation_data(size_t i) const
+  {
+    return *(validation_data_[i]);
+  }
+
+
+  template<typename T>
+  const std::vector<size_t>&
+  SubsetGenerator<T>::validation_index(std::vector<size_t>::size_type i) const
+  {
+    return sampler_.validation_index(i);
+  }
+
+
+  template<typename T>
+  const Target&
+  SubsetGenerator<T>::validation_target(std::vector<Target>::size_type i) const
+  {
+    return validation_target_[i];
+  }
+
 }}} // of namespace classifier, yat, and theplu