EnsembleBuilder.h

#ifndef _theplu_yat_classifier_ensemblebuilder_ 
#define _theplu_yat_classifier_ensemblebuilder_ 

// $Id: EnsembleBuilder.h 2226 2010-03-24 14:40:02Z peter $

/*
  Copyright (C) 2005 Markus Ringnér
  Copyright (C) 2006 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2007 Jari Häkkinen, Peter Johansson
  Copyright (C) 2008 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2009 Jari Häkkinen, Peter Johansson
  Copyright (C) 2010 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 3 of the
  License, or (at your option) any later version.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "FeatureSelector.h"
#include "Sampler.h"
#include "SubsetGenerator.h"
#include "yat/statistics/Averager.h"
#include "yat/utility/Matrix.h"
#include "yat/utility/yat_assert.h"

#include <vector>

namespace theplu {
namespace yat {
namespace classifier {  

  template <class Classifier, class Data>
  class EnsembleBuilder
  {
  public:
    typedef Classifier classifier_type;

    typedef Data data_type;

    EnsembleBuilder(const Classifier&, const Data&, const Sampler&);

    EnsembleBuilder(const Classifier&, const Data&, const Sampler&, 
                    FeatureSelector&);

    virtual ~EnsembleBuilder(void);

    void build(void);

    const Classifier& classifier(size_t i) const;
      
    unsigned long size(void) const;

    const std::vector<std::vector<statistics::Averager> >& validate(void);
    
    void predict(const Data& data, 
                 std::vector<std::vector<statistics::Averager> > &);

  private:
    // no copying
    EnsembleBuilder(const EnsembleBuilder&);
    const EnsembleBuilder& operator=(const EnsembleBuilder&);
    

    const Classifier& mother_;
    SubsetGenerator<Data>* subset_;
    std::vector<Classifier*> classifier_;
    KernelLookup test_data(const KernelLookup&, size_t k);
    MatrixLookup test_data(const MatrixLookup&, size_t k);
    MatrixLookupWeighted test_data(const MatrixLookupWeighted&, size_t k);
    std::vector<std::vector<statistics::Averager> > validation_result_;

  };
  

  // implementation

  template <class Classifier, class Data>
  EnsembleBuilder<Classifier, Data>::EnsembleBuilder(const Classifier& sc,
                                                     const Data& data,
                                                     const Sampler& sampler)
    : mother_(sc),subset_(new SubsetGenerator<Data>(sampler,data))
  {
  }


  template <class Classifier, class Data>
  EnsembleBuilder<Classifier, Data>::EnsembleBuilder(const Classifier& sc,
                                                     const Data& data,
                                                     const Sampler& sampler,
                                                     FeatureSelector& fs)
    : mother_(sc),
      subset_(new SubsetGenerator<Data>(sampler,data,fs))
  {
  }


  template <class Classifier, class Data>
  EnsembleBuilder<Classifier, Data>::~EnsembleBuilder(void)
  {
    for(size_t i=0; i<classifier_.size(); i++)
      delete classifier_[i];
    delete subset_;
  }


  template <class Classifier, class Data>
  void EnsembleBuilder<Classifier, Data>::build(void)
  {
    if (classifier_.empty()){
      for(unsigned long i=0; i<subset_->size();++i) {
        Classifier* classifier = mother_.make_classifier();
        classifier->train(subset_->training_data(i), 
                          subset_->training_target(i));
        classifier_.push_back(classifier);
      }   
    }
  }


  template <class Classifier, class Data>
  const Classifier& EnsembleBuilder<Classifier, Data>::classifier(size_t i) const
  {
    return *(classifier_[i]);
  }


  template <class Classifier, class Data>
  void EnsembleBuilder<Classifier, Data>::predict
  (const Data& data, std::vector<std::vector<statistics::Averager> >& result)
  {
    result = std::vector<std::vector<statistics::Averager> >
      (subset_->target().nof_classes(), 
       std::vector<statistics::Averager>(data.columns()));
    
    utility::Matrix prediction;  

    for(unsigned long k=0;k<size();++k) {       
      Data sub_data = test_data(data, k);
      classifier(k).predict(sub_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));    
    }
  }

  
  template <class Classifier, class Data>
  unsigned long EnsembleBuilder<Classifier, Data>::size(void) const
  {
    return classifier_.size();
  }


  template <class Classifier, class Data>
  MatrixLookup EnsembleBuilder<Classifier,
                               Data>::test_data(const MatrixLookup& data,
                                                size_t k)
  {
    return MatrixLookup(data, subset_->training_features(k), true);
  }
  

  template <class Classifier, class Data>
  MatrixLookupWeighted 
  EnsembleBuilder<Classifier, Data>::test_data(const MatrixLookupWeighted& data,
                                               size_t k)
  {
    return MatrixLookupWeighted(data, subset_->training_features(k), 
                                utility::Index(data.columns()));
  }
  

  template <class Classifier, class Data>
  KernelLookup
  EnsembleBuilder<Classifier, Data>::test_data(const KernelLookup& kernel,
                                               size_t k)
  {
    // weighted case
    if (kernel.weighted()){
      // no feature selection
      if (kernel.data_weighted().rows()==subset_->training_features(k).size())
        return KernelLookup(kernel, subset_->training_index(k), true);
      MatrixLookupWeighted mlw = test_data(kernel.data_weighted(), k);
      return subset_->training_data(k).test_kernel(mlw);

    }
    // unweighted case

    // no feature selection
    if (kernel.data().rows()==subset_->training_features(k).size())
      return KernelLookup(kernel, subset_->training_index(k), true);
    
    // feature selection
    MatrixLookup ml = test_data(kernel.data(),k);
    return subset_->training_data(k).test_kernel(ml);
  }
  

  template <class Classifier, class Data>
  const std::vector<std::vector<statistics::Averager> >& 
  EnsembleBuilder<Classifier, Data>::validate(void)
  {
    // Don't recalculate validation_result_
    if (!validation_result_.empty())
      return validation_result_;

    validation_result_ = std::vector<std::vector<statistics::Averager> >
      (subset_->target().nof_classes(), 
       std::vector<statistics::Averager>(subset_->target().size()));

    utility::Matrix prediction;  
    for(unsigned long k=0;k<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

#endif