Changeset 1072


Ignore:
Timestamp:
Feb 12, 2008, 1:22:27 AM (13 years ago)
Author:
Peter
Message:

fixes #309

Location:
trunk
Files:
1 deleted
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/test/ensemble_test.cc

    r1000 r1072  
    8383  *error << "create Subsets" << std::endl;
    8484  classifier::CrossValidationSampler sampler(target,3,3);
    85   classifier::SubsetGenerator cv(sampler,kernel_lookup);
     85  classifier::SubsetGenerator<classifier::DataLookup2D> cv(sampler,
     86                                                           kernel_lookup);
    8687  *error << "create ensemble" << std::endl;
    8788  classifier::EnsembleBuilder ensemble(svm,sampler);
  • trunk/test/subset_generator_test.cc

    r1000 r1072  
    102102  classifier::FeatureSelectorIR fs(score, 96, 0);
    103103  *error << "building SubsetGenerator" << std::endl;
    104   classifier::SubsetGenerator subset_data(sampler, data, fs);
    105   classifier::SubsetGenerator subset_kernel(sampler, kernel, fs);
     104  classifier::SubsetGenerator<classifier::DataLookup2D> subset_data(sampler,
     105                                                                    data, fs);
     106  classifier::SubsetGenerator<classifier::DataLookup2D> subset_kernel(sampler,
     107                                                                      kernel,fs);
    106108  return ok;
    107109}
     
    128130  classifier::MatrixLookup data2(raw_data2);
    129131  classifier::CrossValidationSampler cv2(target,3,3);
    130   classifier::SubsetGenerator cv_test(cv2,data2);
     132  classifier::SubsetGenerator<classifier::DataLookup2D> cv_test(cv2,data2);
    131133
    132134  std::vector<size_t> sample_count(10,0);
     
    161163   
    162164    classifier::CrossValidationSampler sampler_training(tv_target,2,2);
    163     classifier::SubsetGenerator cv_training(sampler_training,tv_view);
     165    classifier::SubsetGenerator<classifier::DataLookup2D>
     166      cv_training(sampler_training,tv_view);
    164167    std::vector<size_t> v_sample_count(6,0);
    165168    std::vector<size_t> t_sample_count(6,0);
  • trunk/yat/classifier/EnsembleBuilder.cc

    r1000 r1072  
    4444  EnsembleBuilder::EnsembleBuilder(const SupervisedClassifier& sc,
    4545                                   const Sampler& sampler)
    46     : mother_(sc),subset_(new SubsetGenerator(sampler,sc.data()))
     46    : mother_(sc),subset_(new SubsetGenerator<DataLookup2D>(sampler,sc.data()))
    4747  {
    4848  }
     
    5151                                   const Sampler& sampler,
    5252                                   FeatureSelector& fs)
    53     : mother_(sc),subset_(new SubsetGenerator(sampler,sc.data(),fs))
     53    : mother_(sc),
     54      subset_(new SubsetGenerator<DataLookup2D>(sampler,sc.data(),fs))
    5455  {
    5556  }
  • trunk/yat/classifier/EnsembleBuilder.h

    r1000 r1072  
    2727*/
    2828
     29#include "DataLookup2D.h"
     30#include "SubsetGenerator.h"
    2931#include "yat/statistics/Averager.h"
    3032
     
    3537namespace classifier { 
    3638
    37   class DataLookup2D;
    3839  class FeatureSelector;
    3940  class Sampler;
    4041  class SupervisedClassifier;
    41   class SubsetGenerator;
    4242
    4343  ///
     
    105105
    106106    const SupervisedClassifier& mother_;
    107     SubsetGenerator* subset_;
     107    SubsetGenerator<DataLookup2D>* subset_;
    108108    std::vector<SupervisedClassifier*> classifier_;
    109109    std::vector<std::vector<statistics::Averager> > validation_result_;
  • trunk/yat/classifier/Makefile.am

    r1000 r1072  
    4848  PolynomialKernelFunction.cc \
    4949  Sampler.cc \
    50   SubsetGenerator.cc \
    5150  SupervisedClassifier.cc \
    5251  SVindex.cc \
  • trunk/yat/classifier/SubsetGenerator.h

    r1000 r1072  
    2626*/
    2727
     28#include "DataLookup2D.h"
     29#include "FeatureSelector.h"
     30#include "KernelLookup.h"
     31#include "MatrixLookup.h"
     32#include "MatrixLookupWeighted.h"
    2833#include "Target.h"
    2934#include "Sampler.h"
    3035
     36
     37#include <algorithm>
     38#include <cassert>
     39#include <utility>
     40#include <typeinfo>
    3141#include <vector>
    3242
     
    3444namespace yat {
    3545namespace classifier { 
    36   class DataLookup2D;
    37   class FeatureSelector;
    38   class MatrixLookup;
    3946
    4047  ///
    4148  /// @brief Class splitting a set into training set and validation set.
    4249  ///
    43   class SubsetGenerator
     50  template <typename T>
     51  class SubsetGenerator
    4452  {
    45  
     53
    4654  public:
    4755    ///
     
    5159    /// @param data data to split up in validation and training.
    5260    ///
    53     SubsetGenerator(const Sampler& sampler, const DataLookup2D& data);
     61    SubsetGenerator(const Sampler& sampler, const T& data);
    5462
    5563
     
    6169    /// @param fs Object selecting features for each subset
    6270    ///
    63     SubsetGenerator(const Sampler& sampler, const DataLookup2D& data,
     71    SubsetGenerator(const Sampler& sampler, const T& data,
    6472                    FeatureSelector& fs);
    6573
     
    8795    /// @return training data
    8896    ///
    89     const DataLookup2D&
    90     training_data(std::vector<DataLookup2D*>::size_type i) const;
     97    const T& training_data(size_t i) const;
    9198
    9299    ///
     
    110117    /// @return validation data
    111118    ///
    112     const DataLookup2D&
    113     validation_data(std::vector<DataLookup2D*>::size_type i) const;
     119    const T& validation_data(size_t i) const;
    114120
    115121    ///
     
    136142    std::vector<std::vector<size_t> > features_;
    137143    const Sampler& sampler_;
    138     std::vector<const DataLookup2D*> training_data_;
     144    std::vector<const T*> training_data_;
    139145    std::vector<Target> training_target_;
    140     std::vector<const DataLookup2D*> validation_data_;
     146    std::vector<const T*> validation_data_;
    141147    std::vector<Target> validation_target_;
    142148    const bool weighted_;
     
    144150  };
    145151
     152
     153  // templates
     154
     155  template<typename T>
     156  SubsetGenerator<T>::SubsetGenerator(const Sampler& sampler,
     157                                   const T& data)
     158    : f_selector_(NULL), sampler_(sampler), weighted_(false)
     159  {
     160    assert(target().size()==data.columns());
     161
     162    training_data_.reserve(sampler_.size());
     163    validation_data_.reserve(sampler_.size());
     164    for (size_t i=0; i<sampler_.size(); ++i){
     165      // Dynamically allocated. Must be deleted in destructor.
     166      training_data_.push_back(data.training_data(sampler.training_index(i)));
     167      validation_data_.push_back(data.validation_data(sampler.training_index(i),
     168                                                      sampler.validation_index(i)));
     169
     170      training_target_.push_back(Target(target(),sampler.training_index(i)));
     171      validation_target_.push_back(Target(target(),
     172                                          sampler.validation_index(i)));
     173      assert(training_data_.size()==i+1);
     174      assert(training_target_.size()==i+1);
     175      assert(validation_data_.size()==i+1);
     176      assert(validation_target_.size()==i+1);
     177    }
     178
     179    // No feature selection, hence features same for all partitions
     180    // and can be stored in features_[0]
     181    features_.resize(1);
     182    features_[0].reserve(data.rows());
     183    for (size_t i=0; i<data.rows(); ++i)
     184      features_[0].push_back(i);
     185
     186    assert(training_data_.size()==size());
     187    assert(training_target_.size()==size());
     188    assert(validation_data_.size()==size());
     189    assert(validation_target_.size()==size());
     190  }
     191
     192
     193  template<typename T>
     194  SubsetGenerator<T>::SubsetGenerator(const Sampler& sampler,
     195                                   const T& data,
     196                                   FeatureSelector& fs)
     197    : f_selector_(&fs), sampler_(sampler), weighted_(false)
     198  {
     199    assert(target().size()==data.columns());
     200
     201    features_.reserve(size());
     202    training_data_.reserve(size());
     203    validation_data_.reserve(size());
     204
     205    // Taking care of three different case.
     206    // We start with the case of MatrixLookup
     207    const MatrixLookup* ml = dynamic_cast<const MatrixLookup*>(&data);
     208    if (ml){
     209      for (size_t k=0; k<size(); k++){
     210     
     211        training_target_.push_back(Target(target(),training_index(k)));
     212        validation_target_.push_back(Target(target(),validation_index(k)));
     213        // training data with no feature selection
     214        const MatrixLookup* train_data_all_feat =
     215          ml->training_data(training_index(k));
     216        // use these data to create feature selection
     217        assert(train_data_all_feat);
     218        f_selector_->update(*train_data_all_feat, training_target(k));
     219        // get features
     220        features_.push_back(f_selector_->features());
     221        assert(train_data_all_feat);
     222        delete train_data_all_feat;
     223       
     224        // Dynamically allocated. Must be deleted in destructor.
     225        training_data_.push_back(new MatrixLookup(*ml,features_.back(),
     226                                                  training_index(k)));
     227        validation_data_.push_back(new MatrixLookup(*ml,features_.back(),
     228                                                    validation_index(k)));     
     229      }
     230    }
     231    else {
     232      // Second the case of MatrixLookupWeighted
     233      const MatrixLookupWeighted* ml =
     234        dynamic_cast<const MatrixLookupWeighted*>(&data);
     235      if (ml){       
     236        for (u_long k=0; k<size(); k++){
     237          training_target_.push_back(Target(target(),training_index(k)));
     238          validation_target_.push_back(Target(target(),validation_index(k)));
     239          // training data with no feature selection
     240          const MatrixLookupWeighted* train_data_all_feat =
     241            ml->training_data(training_index(k));
     242          // use these data to create feature selection
     243          f_selector_->update(*train_data_all_feat, training_target(k));
     244          // get features
     245          features_.push_back(f_selector_->features());
     246          delete train_data_all_feat;
     247         
     248          // Dynamically allocated. Must be deleted in destructor.
     249          training_data_.push_back(new MatrixLookupWeighted(*ml,
     250                                                            features_.back(),
     251                                                            training_index(k)
     252                                                            ));
     253          validation_data_.push_back(new MatrixLookupWeighted(*ml,
     254                                                              features_.back(),
     255                                                              validation_index(k)
     256                                                              ));     
     257        }
     258      }
     259      else {
     260        // Third the case of MatrixLookupWeighted
     261        const KernelLookup* kernel = dynamic_cast<const KernelLookup*>(&data);
     262        if (kernel){
     263          for (u_long k=0; k<size(); k++){
     264            training_target_.push_back(Target(target(),training_index(k)));
     265            validation_target_.push_back(Target(target(),validation_index(k)));
     266            const T* matrix = kernel->data();
     267            // dynamically allocated must be deleted
     268            const T* training_matrix =
     269              matrix->training_data(training_index(k));
     270            if (matrix->weighted()){
     271              const MatrixLookupWeighted& ml =
     272                dynamic_cast<const MatrixLookupWeighted&>(*matrix);
     273              f_selector_->update(MatrixLookupWeighted(ml,training_index(k),false),
     274                                  training_target(k));
     275            }
     276            else {
     277              const MatrixLookup& ml =
     278                dynamic_cast<const MatrixLookup&>(*matrix);
     279              f_selector_->update(MatrixLookup(ml,training_index(k), false),
     280                                  training_target(k));
     281            }
     282            std::vector<size_t> dummie=f_selector_->features();
     283            features_.push_back(dummie);
     284            //features_.push_back(f_selector_->features());
     285            assert(kernel);
     286            const KernelLookup* kl = kernel->selected(features_.back());
     287            assert(training_matrix);
     288            delete training_matrix;
     289                     
     290            // Dynamically allocated. Must be deleted in destructor.
     291            training_data_.push_back(kl->training_data(training_index(k)));
     292            validation_data_.push_back(kl->validation_data(training_index(k),
     293                                                           validation_index(k)));
     294            assert(kl);
     295            delete kl;
     296          }
     297        }
     298        else {
     299        std::cerr << "Sorry, your type of T ("
     300                  << typeid(data).name() << ")\nis not supported in "
     301                  << "SubsetGenerator with\nFeatureSelection\n";
     302        exit(-1);
     303        }
     304      }
     305    }
     306    assert(training_data_.size()==size());
     307    assert(training_target_.size()==size());
     308    assert(validation_data_.size()==size());
     309    assert(validation_target_.size()==size());
     310  }
     311
     312
     313  template<typename T>
     314  SubsetGenerator<T>::~SubsetGenerator()
     315  {
     316    assert(training_data_.size()==validation_data_.size());
     317    for (size_t i=0; i<training_data_.size(); i++)
     318      delete training_data_[i];
     319    for (size_t i=0; i<validation_data_.size(); i++)
     320      delete validation_data_[i];
     321  }
     322
     323
     324  template<typename T>
     325  u_long SubsetGenerator<T>::size(void) const
     326  {
     327    return sampler_.size();
     328  }
     329
     330
     331  template<typename T>
     332  const Target& SubsetGenerator<T>::target(void) const
     333  {
     334    return sampler_.target();
     335  }
     336
     337
     338  template<typename T>
     339  const T&
     340  SubsetGenerator<T>::training_data(size_t i) const
     341  {
     342    return *(training_data_[i]);
     343  }
     344
     345
     346  template<typename T>
     347  const std::vector<size_t>&
     348  SubsetGenerator<T>::training_features(typename std::vector<size_t>::size_type i) const
     349  {
     350    return f_selector_ ? features_[i] : features_[0];
     351  }
     352
     353
     354  template<typename T>
     355  const std::vector<size_t>&
     356  SubsetGenerator<T>::training_index(std::vector<size_t>::size_type i) const
     357  {
     358    return sampler_.training_index(i);
     359  }
     360
     361
     362  template<typename T>
     363  const Target&
     364  SubsetGenerator<T>::training_target(std::vector<Target>::size_type i) const
     365  {
     366    return training_target_[i];
     367  }
     368
     369
     370  template<typename T>
     371  const T&
     372  SubsetGenerator<T>::validation_data(size_t i) const
     373  {
     374    return *(validation_data_[i]);
     375  }
     376
     377
     378  template<typename T>
     379  const std::vector<size_t>&
     380  SubsetGenerator<T>::validation_index(std::vector<size_t>::size_type i) const
     381  {
     382    return sampler_.validation_index(i);
     383  }
     384
     385
     386  template<typename T>
     387  const Target&
     388  SubsetGenerator<T>::validation_target(std::vector<Target>::size_type i) const
     389  {
     390    return validation_target_[i];
     391  }
     392
    146393}}} // of namespace classifier, yat, and theplu
    147394
Note: See TracChangeset for help on using the changeset viewer.