Changeset 1079


Ignore:
Timestamp:
Feb 13, 2008, 12:44:28 PM (13 years ago)
Author:
Peter
Message:

fixes #311

Location:
trunk
Files:
1 deleted
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/test/ensemble_test.cc

    r1072 r1079  
    8686                                                           kernel_lookup);
    8787  *error << "create ensemble" << std::endl;
    88   classifier::EnsembleBuilder ensemble(svm,sampler);
     88  classifier::EnsembleBuilder<classifier::SupervisedClassifier, classifier::DataLookup2D>
     89    ensemble(svm,sampler);
    8990  *error << "build ensemble" << std::endl;
    9091  ensemble.build();
  • trunk/yat/classifier/EnsembleBuilder.h

    r1072 r1079  
    77  Copyright (C) 2005 Markus Ringnér
    88  Copyright (C) 2006 Jari Häkkinen, Markus Ringnér, Peter Johansson
    9   Copyright (C) 2007 Peter Johansson
     9  Copyright (C) 2007, 2008 Peter Johansson
    1010
    1111  This file is part of the yat library, http://trac.thep.lu.se/yat
     
    2727*/
    2828
    29 #include "DataLookup2D.h"
     29#include "FeatureSelector.h";
     30#include "Sampler.h"
    3031#include "SubsetGenerator.h"
    3132#include "yat/statistics/Averager.h"
     
    3738namespace classifier { 
    3839
    39   class FeatureSelector;
    40   class Sampler;
    41   class SupervisedClassifier;
    42 
    4340  ///
    4441  /// @brief Class for ensembles of supervised classifiers
    4542  ///
    46 
     43  template <class Classifier, class Data>
    4744  class EnsembleBuilder
    4845  {
    4946 
    5047  public:
     48    typedef Classifier classifier_type;
     49    typedef Data data_type;
     50
    5151    ///
    5252    /// Constructor.
    5353    ///
    54     EnsembleBuilder(const SupervisedClassifier&, const Sampler&);
     54    EnsembleBuilder(const Classifier&, const Sampler&);
    5555
    5656    ///
    5757    /// Constructor.
    5858    ///
    59     EnsembleBuilder(const SupervisedClassifier&, const Sampler&,
     59    EnsembleBuilder(const Classifier&, const Sampler&,
    6060                    FeatureSelector&);
    6161
     
    7373    /// @Return classifier
    7474    ///
    75     const SupervisedClassifier& classifier(size_t i) const;
     75    const Classifier& classifier(size_t i) const;
    7676     
    7777    ///
     
    9696       kernel corresponds to.
    9797    */
    98     void predict(const DataLookup2D& data,
     98    void predict(const Data& data,
    9999                 std::vector<std::vector<statistics::Averager> > &);
    100100
    101101  private:
     102    // no copying
    102103    EnsembleBuilder(const EnsembleBuilder&);
    103104    const EnsembleBuilder& operator=(const EnsembleBuilder&);
    104105   
    105106
    106     const SupervisedClassifier& mother_;
    107     SubsetGenerator<DataLookup2D>* subset_;
    108     std::vector<SupervisedClassifier*> classifier_;
     107    const Classifier& mother_;
     108    SubsetGenerator<Data>* subset_;
     109    std::vector<Classifier*> classifier_;
    109110    std::vector<std::vector<statistics::Averager> > validation_result_;
    110111
    111112  };
    112113 
     114
     115  // implementation
     116
     117  template <class C, class D>
     118  EnsembleBuilder<C,D>::EnsembleBuilder(const C& sc,
     119                                        const Sampler& sampler)
     120    : mother_(sc),subset_(new SubsetGenerator<D>(sampler,sc.data()))
     121  {
     122  }
     123
     124
     125  template <class C, class D>
     126  EnsembleBuilder<C, D>::EnsembleBuilder(const C& sc, const Sampler& sampler,
     127                                         FeatureSelector& fs)
     128    : mother_(sc),
     129      subset_(new SubsetGenerator<D>(sampler,sc.data(),fs))
     130  {
     131  }
     132
     133
     134  template <class C, class D>
     135  EnsembleBuilder<C, D>::~EnsembleBuilder(void)
     136  {
     137    for(size_t i=0; i<classifier_.size(); i++)
     138      delete classifier_[i];
     139    delete subset_;
     140  }
     141
     142
     143  template <class C, class D>
     144  void EnsembleBuilder<C, D>::build(void)
     145  {
     146    for(u_long i=0; i<subset_->size();++i) {
     147      C* classifier = mother_.make_classifier(subset_->training_data(i),
     148                                              subset_->training_target(i));
     149      classifier->train();
     150      classifier_.push_back(classifier);
     151    }   
     152  }
     153
     154
     155  template <class C, class D>
     156  const C& EnsembleBuilder<C, D>::classifier(size_t i) const
     157  {
     158    return *(classifier_[i]);
     159  }
     160
     161
     162  template <class C, class D>
     163  u_long EnsembleBuilder<C, D>::size(void) const
     164  {
     165    return classifier_.size();
     166  }
     167
     168
     169  template <class C, class D>
     170  void EnsembleBuilder<C, D>::predict
     171  (const D& data, std::vector<std::vector<statistics::Averager> >& result)
     172  {
     173    result.clear();
     174    result.reserve(subset_->target().nof_classes());   
     175    for(size_t i=0; i<subset_->target().nof_classes();i++)
     176      result.push_back(std::vector<statistics::Averager>(data.columns()));
     177   
     178    utility::matrix prediction; 
     179
     180    for(u_long k=0;k<subset_->size();++k) {       
     181      const D* sub_data =
     182        data.selected(subset_->training_features(k));
     183      assert(sub_data);
     184      classifier(k).predict(*sub_data,prediction);
     185      delete sub_data;
     186    }
     187
     188    for(size_t i=0; i<prediction.rows();i++)
     189      for(size_t j=0; j<prediction.columns();j++)
     190        result[i][j].add(prediction(i,j));   
     191  }
     192
     193 
     194  template <class C, class D>
     195  const std::vector<std::vector<statistics::Averager> >&
     196  EnsembleBuilder<C, D>::validate(void)
     197  {
     198    validation_result_.clear();
     199
     200    validation_result_.reserve(subset_->target().nof_classes());   
     201    for(size_t i=0; i<subset_->target().nof_classes();i++)
     202      validation_result_.push_back(std::vector<statistics::Averager>(subset_->target().size()));
     203   
     204    utility::matrix prediction; 
     205    for(u_long k=0;k<subset_->size();k++) {
     206      classifier(k).predict(subset_->validation_data(k),prediction);
     207     
     208      // map results to indices of samples in training + validation data set
     209      for(size_t i=0; i<prediction.rows();i++)
     210        for(size_t j=0; j<prediction.columns();j++) {
     211          validation_result_[i][subset_->validation_index(k)[j]].
     212            add(prediction(i,j));
     213        }           
     214    }
     215    return validation_result_;
     216  }
     217
    113218}}} // of namespace classifier, yat, and theplu
    114219
  • trunk/yat/classifier/Makefile.am

    r1072 r1079  
    3333  DataLookupWeighted1D.cc \
    3434  DataLookup2D.cc \
    35   EnsembleBuilder.cc \
    3635  FeatureSelector.cc \
    3736  FeatureSelectorIR.cc \
  • trunk/yat/classifier/SubsetGenerator.h

    r1072 r1079  
    5151  class SubsetGenerator
    5252  {
    53 
    5453  public:
     54    typedef T value_type;
     55
    5556    ///
    5657    /// @brief Constructor
Note: See TracChangeset for help on using the changeset viewer.