source: trunk/lib/classifier/EnsembleBuilder.cc @ 531

// $Id: EnsembleBuilder.cc 531 2006-03-02 17:35:12Z markus $

#include <c++_tools/classifier/EnsembleBuilder.h>

#include <c++_tools/classifier/CrossSplitter.h>
#include <c++_tools/classifier/DataLookup2D.h>
#include <c++_tools/classifier/SupervisedClassifier.h>
#include <c++_tools/classifier/Target.h>

#include <c++_tools/gslapi/matrix.h>

namespace theplu {
namespace classifier {

  EnsembleBuilder::EnsembleBuilder(const SupervisedClassifier& sc, 
                                   CrossSplitter& cs) 
    : mother_(sc), cross_splitter_(cs)
  {
  }

  EnsembleBuilder::~EnsembleBuilder(void) 
  {
    for(size_t i=0; i<classifier_.size(); i++)
      delete classifier_[i];
  }

  void EnsembleBuilder::build(void) 
  {
    cross_splitter_.reset();
    while(cross_splitter_.more()) {
      const DataLookup2D& training=cross_splitter_.training_data();
      const Target& targets=cross_splitter_.training_target();
      SupervisedClassifier* classifier=
        mother_.make_classifier(training,targets);
      classifier->train();
      classifier_.push_back(classifier);
      cross_splitter_.next();
    }   
  }

  void  EnsembleBuilder::predict
  (const DataLookup2D& data, 
   std::vector<std::vector<statistics::Averager> >& result)
  {
    cross_splitter_.reset();

    result.clear();
    result.reserve(cross_splitter_.target().nof_classes());   
    for(size_t i=0; i<cross_splitter_.target().nof_classes();i++)
      result.push_back(std::vector<statistics::Averager>(data.columns()));
    
    size_t k=0;
    gslapi::matrix prediction;   
    while(cross_splitter_.more()) {
      classifier(k++).predict(data,prediction);

      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));

      cross_splitter_.next();
    }

  }



  const std::vector<std::vector<statistics::Averager> >& 
  EnsembleBuilder::validate(void)
  {
    cross_splitter_.reset();
    validation_result_.clear();

    validation_result_.reserve(cross_splitter_.target().nof_classes());   
    for(size_t i=0; i<cross_splitter_.target().nof_classes();i++)
      validation_result_.push_back(std::vector<statistics::Averager>(cross_splitter_.target().size()));
    
    size_t k=0;
    gslapi::matrix prediction;   
    while(cross_splitter_.more()) {
      classifier(k++).predict(cross_splitter_.validation_data(),prediction);

      for(size_t i=0; i<prediction.rows();i++) 
        for(size_t j=0; j<prediction.columns();j++) {
          validation_result_[i][cross_splitter_.validation_index()[j]].
            add(prediction(i,j));
        } 
          
      cross_splitter_.next();
    }
    return validation_result_;
  }

}} // of namespace classifier and namespace theplu