source: trunk/yat/classifier/SubsetGenerator.h

#ifndef _theplu_yat_classifier_subset_generator_
#define _theplu_yat_classifier_subset_generator_

// $Id: SubsetGenerator.h 4359 2023-08-23 01:28:46Z peter $

/*
  Copyright (C) 2006 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2007 Peter Johansson
  Copyright (C) 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 {
  ///
  /// @brief Class splitting Data into training and validation set.
  ///
  /// A SubsetGenerator splits a Data into several training and
  /// validation data. A Sampler is used to select samples for a
  /// training Data set and a validation Data set, respectively. In
  /// addition a FeatureSelector can be used to select Features. For
  /// more details see constructors.
  ///
  /// \note Data must be one of MatrixLookup, MatrixLookupWeighted, or
  /// KernelLookup.
  ///
  template <typename Data>
  class SubsetGenerator
  {
  public:
    /**
       type of Data that is stored in SubsetGenerator
     */
    typedef Data value_type;

    ///
    /// @brief Create SubDataSets
    ///
    /// Creates N training data sets and N validation data sets, where
    /// N equals the size of \a sampler. Data must be one of
    /// MatrixLookup, MatrixLookupWeighted, or KernelLookup.
    ///
    /// In case of MatrixLookup or MatrixLookupWeighted, each column
    /// corresponds to a sample and the \a sampler is used to select
    /// columns. Sampler::training_index(size_t) is used to select
    /// columns for the corresponding traing_data, and
    /// Sampler::validation_index(size_t) is used to select columns
    /// for the corresponding validation_data.
    ///
    /// In case of a KernelLookup it is a bit different. A symmetric
    /// training kernel is created using
    /// Sampler::training_index(size_t) to select rows and
    /// columns. The validation kernel is typically not symmetric, but
    /// the columns correspond to a validation sample and each row
    /// corresponds to a training sample. Consequently
    /// Sampler::training_index(size_t) is used to select rows, and
    /// Sampler::validation_index(size_t) is used to select columns.
    ///
    /// @param sampler Sampler that is used to select samples.
    /// @param data Data to split up in validation and training.
    ///
    SubsetGenerator(const Sampler& sampler, const Data& data);

    ///
    /// @brief Create SubDataSets with feature selection
    ///
    /// Creates N training data sets and N validation data sets, where
    /// N equals the size of \a sampler. The Sampler defines which
    /// samples are included in a subset. Likewise a FeatureSelector,
    /// \a fs, is used to select features. The selection is based on
    /// not based on the entire dataset but solely on the training
    /// dataset. Data must be one of MatrixLookup,
    /// MatrixLookupWeighted, or KernelLookup.
    ///
    /// In case of MatrixLookup or MatrixLookupWeighted, each column
    /// corresponds to a sample and the \a sampler is used to select
    /// columns. Sampler::training_index(size_t) is used to select
    /// columns for the corresponding traing_data, and
    /// Sampler::validation_index(size_t) is used to select columns
    /// for the corresponding validation_data. The FeatureSelector is
    /// used to select features, i.e., to select rows to be included
    /// in the subsets.
    ///
    /// In case of a KernelLookup it is a bit different. A symmetric
    /// training kernel is created using
    /// Sampler::training_index(size_t) to select rows and
    /// columns. However, the created KernelLookup is not simply the
    /// subkernel of \a data, but each element is recalculated using
    /// the features selected by FeatureSelector \a fs. In the
    /// validation kernel each column corresponds to a validation
    /// sample and each row corresponds to a training
    /// sample. Consequently Sampler::training_index(size_t) is used
    /// to select rows, and Sampler::validation_index(size_t) is used
    /// to select columns. The same set of features are used to
    /// caclulate the elements as for the training kernel, i.e.,
    /// feature selection is based on training data.
    ///
    /// @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 Data& data,
                    FeatureSelector& fs);

    ///
    /// Destructor
    ///
    ~SubsetGenerator();

    ///
    /// @return number of subsets
    ///
    size_t size(void) const;

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

    ///
    /// See constructors for details on how training data are
    /// generated.
    ///
    /// @return ith training data
    ///
    const Data& training_data(size_t i) const;

    ///
    /// Features that are used to create ith training data and
    /// validation data.
    ///
    /// @return training features
    ///
    const utility::Index& training_features(size_t i) const;

    ///
    /// @return Index of samples included in ith training data.
    ///
    const utility::Index& training_index(size_t i) const;

    ///
    /// @return Targets of ith set of training samples
    ///
    const Target& training_target(size_t i) const;

    ///
    /// See constructors for details on how validation data are
    /// generated.
    ///
    /// @return ith validation data
    ///
    const Data& validation_data(size_t i) const;

    ///
    /// @return Index of samples included in ith validation data.
    ///
    const utility::Index& validation_index(size_t i) const;

    ///
    /// @return Targets of ith set validation samples
    ///
    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