source: trunk/yat/classifier/SubsetGenerator.cc @ 704

// $Id$

/*
  Copyright (C) The authors contributing to this file.

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

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

namespace theplu {
namespace yat {
namespace classifier {  

  SubsetGenerator::SubsetGenerator(const Sampler& sampler, 
                                   const DataLookup2D& data)
    : f_selector_(NULL), sampler_(sampler), weighted_(false)
  { 
    assert(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)));
      assert(training_data_.size()==i+1);
      assert(training_target_.size()==i+1);
      assert(validation_data_.size()==i+1);
      assert(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);

    assert(training_data_.size()==size());
    assert(training_target_.size()==size());
    assert(validation_data_.size()==size());
    assert(validation_target_.size()==size());
  }


  SubsetGenerator::SubsetGenerator(const Sampler& sampler, 
                                   const DataLookup2D& data, 
                                   FeatureSelector& fs)
    : f_selector_(&fs), sampler_(sampler), weighted_(false)
  { 
    assert(target().size()==data.columns());

    features_.reserve(size());
    training_data_.reserve(size());
    validation_data_.reserve(size());

    // Taking care of three different case.
    // We start with the case of MatrixLookup
    const MatrixLookup* ml = dynamic_cast<const MatrixLookup*>(&data);
    if (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
        assert(train_data_all_feat);
        f_selector_->update(*train_data_all_feat, training_target(k));
        // get features
        features_.push_back(f_selector_->features());
        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)));      
      }
    }
    else {
      // Second the case of MatrixLookupWeighted
      const MatrixLookupWeighted* ml = 
        dynamic_cast<const MatrixLookupWeighted*>(&data);
      if (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)
                                                              ));     
        }
      }
      else {
        // Third the case of MatrixLookupWeighted
        const KernelLookup* kernel = dynamic_cast<const KernelLookup*>(&data);
        if (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());
            assert(kernel);
            const KernelLookup* kl = kernel->selected(features_.back());
            assert(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)));
            assert(kl);
            delete kl;
          }
        }
        else {
        std::cerr << "Sorry, your type of DataLookup2D (" 
                  << typeid(data).name() << ")\nis not supported in " 
                  << "SubsetGenerator with\nFeatureSelection\n";
        exit(-1);
        }
      }
    }
    assert(training_data_.size()==size());
    assert(training_target_.size()==size());
    assert(validation_data_.size()==size());
    assert(validation_target_.size()==size());
  }


  SubsetGenerator::~SubsetGenerator()
  {
    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];
  }

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