source: trunk/yat/classifier/SubsetGenerator.h @ 1090

#ifndef _theplu_yat_classifier_subset_generator_ 
#define _theplu_yat_classifier_subset_generator_ 

// $Id: SubsetGenerator.h 1086 2008-02-14 05:43:10Z peter $

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

  This file is part of the yat library, http://trac.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 "DataLookup2D.h"
#include "FeatureSelector.h"
#include "KernelLookup.h"
#include "MatrixLookup.h"
#include "MatrixLookupWeighted.h"
#include "Target.h"
#include "Sampler.h"
#include "yat/utility/yat_assert.h"

#include <algorithm>
#include <cassert>
#include <utility>
#include <typeinfo>
#include <vector>

namespace theplu {
namespace yat {
namespace classifier {  

  ///
  /// @brief Class splitting a set into training set and validation set. 
  ///
  template <typename T> 
  class SubsetGenerator
  {
  public:
    typedef T value_type;

    ///
    /// @brief Constructor 
    ///  
    /// @param sampler sampler
    /// @param data data to split up in validation and training.
    ///
    SubsetGenerator(const Sampler& sampler, const T& data);

    ///
    /// @brief Constructor 
    ///  
    /// @param sampler taking care of partioning dataset
    /// @param data data to be split up in validation and training.
    /// @param fs Object selecting features for each subset
    ///
    SubsetGenerator(const Sampler& sampler, const T& data, 
                    FeatureSelector& fs);

    ///
    /// Destructor
    ///
    ~SubsetGenerator();
  
    ///
    /// @return number of subsets
    ///
    u_long size(void) const;

    ///
    /// @return the target for the total set
    ///
    const Target& target(void) const;

    ///
    /// @return the sampler for the total set
    ///
    //    const Sampler& sampler(void) const;

    ///
    /// @return training data
    ///
    const T& training_data(size_t i) const;

    ///
    /// @return training features
    ///
    const std::vector<size_t>&
    training_features(std::vector<size_t>::size_type i) const;

    ///
    /// @return training index
    ///
    const std::vector<size_t>&
    training_index(std::vector<size_t>::size_type i) const;

    ///
    /// @return training target
    ///
    const Target& training_target(std::vector<Target>::size_type i) const;

    ///
    /// @return validation data
    ///
    const T& validation_data(size_t i) const;

    ///
    /// @return validation index
    ///
    const std::vector<size_t>&
    validation_index(std::vector<size_t>::size_type i) const;

    ///
    /// @return validation target
    ///
    const Target& validation_target(std::vector<Target>::size_type i) const;

    ///
    /// @return true if weighted 
    /// @todo remove this function
    //bool weighted(void) const;

  private:
    void build(const MatrixLookup&);
    void build(const MatrixLookupWeighted&);
    void build(const KernelLookup&);

    SubsetGenerator(const SubsetGenerator&);
    const SubsetGenerator& operator=(const SubsetGenerator&) const;

    FeatureSelector* f_selector_;
    std::vector<std::vector<size_t> > features_;
    const Sampler& sampler_;
    std::vector<const T*> training_data_;
    std::vector<Target> training_target_;
    std::vector<const T*> validation_data_;
    std::vector<Target> validation_target_;

  };


  // templates

  template<typename T>
  SubsetGenerator<T>::SubsetGenerator(const Sampler& sampler, 
                                      const T& data)
    : f_selector_(NULL), sampler_(sampler)
  { 
    utility::yat_assert<std::runtime_error>(target().size()==data.columns());

    training_data_.reserve(sampler_.size());
    validation_data_.reserve(sampler_.size());
    for (size_t i=0; i<sampler_.size(); ++i){
      // Dynamically allocated. Must be deleted in destructor.
      training_data_.push_back(data.training_data(sampler.training_index(i)));
      validation_data_.push_back(data.validation_data(sampler.training_index(i),
                                                      sampler.validation_index(i)));

      training_target_.push_back(Target(target(),sampler.training_index(i)));
      validation_target_.push_back(Target(target(),
                                          sampler.validation_index(i)));
      utility::yat_assert<std::runtime_error>(training_data_.size()==i+1);
      utility::yat_assert<std::runtime_error>(training_target_.size()==i+1);
      utility::yat_assert<std::runtime_error>(validation_data_.size()==i+1);
      utility::yat_assert<std::runtime_error>(validation_target_.size()==i+1);
    }

    // No feature selection, hence features same for all partitions
    // and can be stored in features_[0]
    features_.resize(1);
    features_[0].reserve(data.rows());
    for (size_t i=0; i<data.rows(); ++i)
      features_[0].push_back(i);

    utility::yat_assert<std::runtime_error>(training_data_.size()==size());
    utility::yat_assert<std::runtime_error>(training_target_.size()==size());
    utility::yat_assert<std::runtime_error>(validation_data_.size()==size());
    utility::yat_assert<std::runtime_error>(validation_target_.size()==size());
  }


  template<typename T>
  SubsetGenerator<T>::SubsetGenerator(const Sampler& sampler, 
                                   const T& data, 
                                   FeatureSelector& fs)
    : f_selector_(&fs), sampler_(sampler)
  { 
    utility::yat_assert<std::runtime_error>(target().size()==data.columns());
    features_.reserve(size());
    training_data_.reserve(size());
    validation_data_.reserve(size());
    build(data);
    utility::yat_assert<std::runtime_error>(training_data_.size()==size());
    utility::yat_assert<std::runtime_error>(training_target_.size()==size());
    utility::yat_assert<std::runtime_error>(validation_data_.size()==size());
    utility::yat_assert<std::runtime_error>(validation_target_.size()==size());
  }


  template<typename T>
  SubsetGenerator<T>::~SubsetGenerator()
  {
    utility::yat_assert<std::runtime_error>(training_data_.size()==validation_data_.size());
    for (size_t i=0; i<training_data_.size(); i++) 
      delete training_data_[i];
    for (size_t i=0; i<validation_data_.size(); i++) 
      delete validation_data_[i];
  }


  template<typename T>
  void SubsetGenerator<T>::build(const MatrixLookup& ml)
  {
    for (size_t k=0; k<size(); k++){
      training_target_.push_back(Target(target(),training_index(k)));
      validation_target_.push_back(Target(target(),validation_index(k)));
      // training data with no feature selection
      const MatrixLookup* train_data_all_feat = 
        ml.training_data(training_index(k));
      // use these data to create feature selection
      utility::yat_assert<std::runtime_error>(train_data_all_feat);
      f_selector_->update(*train_data_all_feat, training_target(k));
        // get features
      features_.push_back(f_selector_->features());
      utility::yat_assert<std::runtime_error>(train_data_all_feat);
      delete train_data_all_feat;
      
      // Dynamically allocated. Must be deleted in destructor.
      training_data_.push_back(new MatrixLookup(ml,features_.back(), 
                                                training_index(k)));
      validation_data_.push_back(new MatrixLookup(ml,features_.back(), 
                                                  validation_index(k)));      
    }

  }


  template<typename T>
  void SubsetGenerator<T>::build(const MatrixLookupWeighted& ml)
  {
    for (u_long k=0; k<size(); k++){
      training_target_.push_back(Target(target(),training_index(k)));
      validation_target_.push_back(Target(target(),validation_index(k)));
      // training data with no feature selection
      const MatrixLookupWeighted* train_data_all_feat = 
        ml.training_data(training_index(k));
      // use these data to create feature selection
      f_selector_->update(*train_data_all_feat, training_target(k));
      // get features
      features_.push_back(f_selector_->features());
      delete train_data_all_feat;
      
      // Dynamically allocated. Must be deleted in destructor.
      training_data_.push_back(new MatrixLookupWeighted(ml, features_.back(), 
                                                        training_index(k)));
      validation_data_.push_back(new MatrixLookupWeighted(ml, features_.back(), 
                                                          validation_index(k)));
    }
  }

  template<typename T>
  void SubsetGenerator<T>::build(const KernelLookup& kernel)
  {
    for (u_long k=0; k<size(); k++){
      training_target_.push_back(Target(target(),training_index(k)));
      validation_target_.push_back(Target(target(),validation_index(k)));
      const DataLookup2D* matrix = kernel.data();
      // dynamically allocated must be deleted
      const DataLookup2D* training_matrix = 
        matrix->training_data(training_index(k));
      if (matrix->weighted()){
        const MatrixLookupWeighted& ml = 
          dynamic_cast<const MatrixLookupWeighted&>(*matrix);
        f_selector_->update(MatrixLookupWeighted(ml,training_index(k),false), 
                            training_target(k));
      }
      else {
        const MatrixLookup& ml = 
          dynamic_cast<const MatrixLookup&>(*matrix);
        f_selector_->update(MatrixLookup(ml,training_index(k), false), 
                            training_target(k));
      } 
      std::vector<size_t> dummie=f_selector_->features();
      features_.push_back(dummie);
      //features_.push_back(f_selector_->features());
      const KernelLookup* kl = kernel.selected(features_.back());
      utility::yat_assert<std::runtime_error>(training_matrix);
      delete training_matrix;
      
      // Dynamically allocated. Must be deleted in destructor.
      training_data_.push_back(kl->training_data(training_index(k)));
      validation_data_.push_back(kl->validation_data(training_index(k), 
                                                     validation_index(k)));
      utility::yat_assert<std::runtime_error>(kl);
      delete kl;
    }
  }


  template<typename T>
  u_long SubsetGenerator<T>::size(void) const
  {
    return sampler_.size();
  }


  template<typename T>
  const Target& SubsetGenerator<T>::target(void) const
  {
    return sampler_.target();
  }


  template<typename T>
  const T&
  SubsetGenerator<T>::training_data(size_t i) const 
  {
    return *(training_data_[i]);
  }


  template<typename T>
  const std::vector<size_t>&
  SubsetGenerator<T>::training_features(typename std::vector<size_t>::size_type i) const
  {
    return f_selector_ ? features_[i] : features_[0];
  }


  template<typename T>
  const std::vector<size_t>&
  SubsetGenerator<T>::training_index(std::vector<size_t>::size_type i) const
  {
    return sampler_.training_index(i);
  }


  template<typename T>
  const Target&
  SubsetGenerator<T>::training_target(std::vector<Target>::size_type i) const
  {
    return training_target_[i];
  }


  template<typename T>
  const T&
  SubsetGenerator<T>::validation_data(size_t i) const
  {
    return *(validation_data_[i]);
  }


  template<typename T>
  const std::vector<size_t>&
  SubsetGenerator<T>::validation_index(std::vector<size_t>::size_type i) const
  {
    return sampler_.validation_index(i);
  }


  template<typename T>
  const Target&
  SubsetGenerator<T>::validation_target(std::vector<Target>::size_type i) const
  {
    return validation_target_[i];
  }

}}} // of namespace classifier, yat, and theplu

#endif