source: trunk/lib/classifier/CrossSplitter.h @ 558

// $Id: CrossSplitter.h 558 2006-03-10 15:58:16Z peter $

#ifndef _theplu_classifier_cross_splitter_ 
#define _theplu_classifier_cross_splitter_ 

#include <c++_tools/classifier/Target.h>
#include <c++_tools/classifier/MatrixLookup.h>


#include <cassert>
#include <vector>

namespace theplu {
namespace classifier {  
  class DataLookup2D;


  ///
  /// Class splitting a set into training set and validation set in a
  /// crossvalidation manner. This is done in a balanced way, meaning
  /// the proportions between the classes in the trainingset is close
  /// to the proportions in the whole dataset. In the first \a k
  /// rounds each sample is returned k-1 times, for next round the
  /// samples are shuffled and... In total there are N partitions, in
  /// other words, each sample is in validation roughly N/k
  ///   

  class CrossSplitter
  {
  
  public:
    ///
    /// @brief Constructor 
    ///  
    /// @parameter Target targets
    /// @parameter data data to split up in validation and training.
    /// @parameter N total number of partitions
    /// @parameter k for k-fold crossvalidation
    ///
    CrossSplitter(const Target& target, const DataLookup2D& data, 
                  const size_t N, const size_t k);

    ///
    /// @brief Constructor with weights
    ///  
    /// @parameter Target targets
    /// @parameter data data to split up in validation and training.
    /// @parameter weights accompanying data.
    /// @parameter N total number of partitions
    /// @parameter k for k-fold crossvalidation
    ///
    CrossSplitter(const Target& target, const DataLookup2D& data, 
                  const MatrixLookup& weight,
                  const size_t N, const size_t k);

    ///
    /// Destructor
    ///
    ~CrossSplitter();

    ///
    /// @return true if in a valid state
    ///
    inline bool more(void) const { return state_<size(); }

    ///
    /// Function turning the object to the next state.
    ///
    inline void next(void) { state_++; }

    ///
    /// rewind the sampler to initial state
    ///
    inline void reset(void) { state_=0; }


    ///
    /// @return number of partitions
    ///
    inline u_long size(void) const { return training_data_.size(); }

    ///
    /// @return the target for the total set
    ///
    inline const Target& target(void) const { return target_; }


    ///
    /// @return training data
    ///
    /// @note if state is invalid the result is undefined
    ///
    inline const DataLookup2D& training_data(void) const 
    { assert(more()); return *(training_data_[state_]); } 

    /// @return training index
    ///
    /// @note if state is invalid the result is undefined
    ///
    inline const std::vector<size_t>& training_index(void) const
    { assert(more()); return training_index_[state_]; }


    ///
    /// @return training target
    ///
    /// @note if state is invalid the result is undefined
    ///
    inline const Target& training_target(void) const 
    { assert(more()); return training_target_[state_]; }

    ///
    /// @return training data weight
    ///
    /// @note if state is invalid the result is undefined
    ///
    inline const DataLookup2D& training_weight(void) const 
    { assert(more()); return *(training_weight_[state_]); } 

    ///
    /// @return validation data
    ///
    /// @note if state is invalid the result is undefined
    ///
    inline const DataLookup2D& validation_data(void) const
    { assert(more()); return *(validation_data_[state_]); }


    /// @return validation index
    ///
    /// @note if state is invalid the result is undefined
    ///
    inline const std::vector<size_t>& validation_index(void) const
    { assert(more()); return validation_index_[state_]; }

    ///
    /// @return validation target
    ///
    /// @note if state is invalid the result is undefined
    ///
    inline const Target& validation_target(void) const 
    { assert(more()); return validation_target_[state_]; }

    ///
    /// @return validation data weights
    ///
    /// @note if state is invalid the result is undefined
    ///
    inline const DataLookup2D& validation_weight(void) const 
    { assert(more()); return *(validation_weight_[state_]); } 

    ///
    /// @return true if weighted 
    ///
    inline bool weighted(void) const { return weighted_; }

  private:
    void build(const Target& target, size_t N, size_t k); 

    const size_t k_;
    u_long state_;
    Target target_;
    const bool weighted_;
    
    std::vector<const DataLookup2D*> training_data_;
    std::vector<const MatrixLookup*> training_weight_;
    std::vector<std::vector<size_t> > training_index_;
    std::vector<Target> training_target_;

    std::vector<const DataLookup2D*> validation_data_;
    std::vector<const MatrixLookup*> validation_weight_;
    std::vector<std::vector<size_t> > validation_index_;
    std::vector<Target> validation_target_;
  };

}} // of namespace classifier and namespace theplu

#endif