SubsetGenerator.h

#ifndef _theplu_yat_classifier_subset_generator_ 
#define _theplu_yat_classifier_subset_generator_ 

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

/*
  Copyright (C) 2006 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009, 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 "KernelLookup.h"
#include "MatrixLookup.h"
#include "MatrixLookupWeighted.h"
#include "Target.h"
#include "Sampler.h"
#include "yat/utility/Index.h"
#include "yat/utility/yat_assert.h"

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

namespace theplu {
namespace yat {
namespace classifier {  
  template <typename Data> 
  class SubsetGenerator
  {
  public:
    typedef Data value_type;

    SubsetGenerator(const Sampler& sampler, const Data& data);

    SubsetGenerator(const Sampler& sampler, const Data& data, 
                    FeatureSelector& fs);

    ~SubsetGenerator();
  
    size_t size(void) const;

    const Target& target(void) const;

    const Data& training_data(size_t i) const;

    const utility::Index& training_features(size_t i) const;

    const utility::Index& training_index(size_t i) const;

    const Target& training_target(size_t i) const;

    const Data& validation_data(size_t i) const;

    const utility::Index& validation_index(size_t i) const;

    const Target& validation_target(size_t i) 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<utility::Index > features_;
    const Sampler& sampler_;
    std::vector<const Data*> training_data_;
    std::vector<Target> training_target_;
    std::vector<const Data*> validation_data_;
    std::vector<Target> validation_target_;

  };


  // templates

  template<typename Data>
  SubsetGenerator<Data>::SubsetGenerator(const Sampler& sampler, 
                                         const Data& data)
    : f_selector_(NULL), sampler_(sampler)
  { 
    YAT_ASSERT(target().size()==data.columns());

    training_data_.reserve(sampler_.size());
    validation_data_.reserve(sampler_.size());
    build(data);
    YAT_ASSERT(training_data_.size()==size());
    YAT_ASSERT(training_target_.size()==size());
    YAT_ASSERT(validation_data_.size()==size());
    YAT_ASSERT(validation_target_.size()==size());
  }


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


  template<typename Data>
  SubsetGenerator<Data>::~SubsetGenerator()
  {
    YAT_ASSERT(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 Data>
  void SubsetGenerator<Data>::build(const MatrixLookup& ml)
  {
    if (!f_selector_)// no feature selection
      features_.push_back(utility::Index(ml.rows()));

    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)));
      if (f_selector_){
        // training data with no feature selection
        const MatrixLookup* train_data_all_feat = 
          new MatrixLookup(ml, training_index(k), false);
        // use these data to create feature selection
        YAT_ASSERT(train_data_all_feat);
        f_selector_->update(*train_data_all_feat, training_target(k));
        // get features
        features_.push_back(f_selector_->features());
        YAT_ASSERT(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 Data>
  void SubsetGenerator<Data>::build(const MatrixLookupWeighted& ml)
  {
    if (!f_selector_)// no feature selection
      features_.push_back(utility::Index(ml.rows()));

    for (unsigned long k=0; k<size(); k++){
      training_target_.push_back(Target(target(),training_index(k)));
      validation_target_.push_back(Target(target(),validation_index(k)));
      if (f_selector_){
        // training data with no feature selection
        const MatrixLookupWeighted* train_data_all_feat = 
          new MatrixLookupWeighted(ml, utility::Index(ml.rows()), 
                                   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 Data>
  void SubsetGenerator<Data>::build(const KernelLookup& kernel)
  {
    for (unsigned long k=0; k<size(); k++){
      training_target_.push_back(Target(target(),training_index(k)));
      validation_target_.push_back(Target(target(),validation_index(k)));

      if (f_selector_){
        if (kernel.weighted()){
          MatrixLookupWeighted ml = kernel.data_weighted();
          f_selector_->update(MatrixLookupWeighted(ml, 
                                                   utility::Index(ml.rows()),
                                                   training_index(k)), 
                              training_target(k));
        }
        else {
          MatrixLookup ml=kernel.data();
          f_selector_->update(MatrixLookup(ml,training_index(k), false), 
                              training_target(k));
        } 
        features_.push_back(f_selector_->features());
        KernelLookup kl = kernel.selected(features_.back());
        // Dynamically allocated. Must be deleted in destructor.
        training_data_.push_back(new KernelLookup(kl,training_index(k),
                                                  training_index(k)));
        validation_data_.push_back(new KernelLookup(kl, training_index(k), 
                                                    validation_index(k)));
      }
      else {// no feature selection
        training_data_.push_back(new KernelLookup(kernel, training_index(k),
                                                  training_index(k)));
        validation_data_.push_back(new KernelLookup(kernel, 
                                                    training_index(k), 
                                                    validation_index(k)));
      }
      
    }
    if (!f_selector_){
      if (kernel.weighted())
        features_.push_back(utility::Index(kernel.data_weighted().rows()));
      else
        features_.push_back(utility::Index(kernel.data().rows()));
    }
  }


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


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


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


  template<typename Data>
  const utility::Index&
  SubsetGenerator<Data>::training_features(size_t i) const
  {
    YAT_ASSERT(features_.size());
    return f_selector_ ? features_[i] : features_[0];
  }


  template<typename Data>
  const utility::Index&
  SubsetGenerator<Data>::training_index(size_t i) const
  {
    return sampler_.training_index(i);
  }


  template<typename Data>
  const Target&
  SubsetGenerator<Data>::training_target(size_t i) const
  {
    return training_target_[i];
  }


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


  template<typename Data>
  const utility::Index&
  SubsetGenerator<Data>::validation_index(size_t i) const
  {
    return sampler_.validation_index(i);
  }


  template<typename Data>
  const Target&
  SubsetGenerator<Data>::validation_target(size_t i) const
  {
    return validation_target_[i];
  }

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

#endif