source: branches/0.4-stable/yat/classifier/EnsembleBuilder.h @ 1392

#ifndef _theplu_yat_classifier_ensemblebuilder_ 
#define _theplu_yat_classifier_ensemblebuilder_ 

// $Id$

/*
  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

  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 2 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 this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

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

#include <vector>

namespace theplu {
namespace yat {
namespace classifier {  

  ///
  /// @brief Class for ensembles of supervised classifiers
  ///
  template <class Classifier, class Data>
  class EnsembleBuilder
  {
  public:
    /**
       \brief Type of classifier that ensemble is built on.
     */
    typedef Classifier classifier_type;

    /**
       Type of container used for storing data. Must be MatrixLookup,
       MatrixLookupWeighted, or KernelLookup
     */
    typedef Data data_type;

    ///
    /// Constructor.
    ///
    EnsembleBuilder(const Classifier&, const Data&, const Sampler&);

    ///
    /// Constructor.
    ///
    EnsembleBuilder(const Classifier&, const Data&, const Sampler&, 
                    FeatureSelector&);

    ///
    /// Destructor.
    ///
    virtual ~EnsembleBuilder(void);

    /**
       \brief Generate ensemble. 
       
       Function trains each member of the Ensemble.
    */
    void build(void);

    ///
    /// @return ith classifier
    ///
    const Classifier& classifier(size_t i) const;
      
    ///
    /// @return Number of classifiers in ensemble. Prior build(void)
    /// is issued size is zero.
    ///
    unsigned long size(void) const;

    ///
    /// @brief Generate validation data for ensemble
    ///
    /// validate()[i][j] return averager for class @a i for sample @a j
    ///
    const std::vector<std::vector<statistics::Averager> >& validate(void);
    
    /**
       Predict a dataset using the ensemble.
       
       If @a data is a KernelLookup each column should correspond to a
       test sample and each row should correspond to a training
       sample. More exactly row \f$ i \f$ in @a data should correspond
       to the same sample as row/column \f$ i \f$ in the training
       kernel corresponds to.
    */
    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 C, class D> 
  EnsembleBuilder<C,D>::EnsembleBuilder(const C& sc, const D& data,
                                        const Sampler& sampler) 
    : mother_(sc),subset_(new SubsetGenerator<D>(sampler,data))
  {
  }


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


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


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


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


  template <class C, class D> 
  void EnsembleBuilder<C, D>::predict
  (const D& 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) {       
      D 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 C, class D> 
  unsigned long EnsembleBuilder<C, D>::size(void) const
  {
    return classifier_.size();
  }


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

  template <class C, class D> 
  MatrixLookupWeighted 
  EnsembleBuilder<C, D>::test_data(const MatrixLookupWeighted& data, size_t k)
  {
    return MatrixLookupWeighted(data, subset_->training_features(k), true);
  }
  

  template <class C, class D> 
  KernelLookup
  EnsembleBuilder<C, D>::test_data(const KernelLookup& kernel, size_t k)
  {
    // weighted case
    if (kernel.weighted()){
      assert(false);
      // 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
    return subset_->training_data(k).test_kernel(test_data(kernel.data(),k));
  }
  

  template <class C, class D> 
  const std::vector<std::vector<statistics::Averager> >& 
  EnsembleBuilder<C, D>::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