CvHanler is an utility function for building the submatrix/subvectors needed when creating learning and test data sets. More...

#include <STK_PartitionHandler.h>

Inheritance diagram for STK::PartitionHandler:

Public Member Functions
	PartitionHandler (Range const &rangeData, Real prop)
	Default constructor.

virtual	~PartitionHandler ()
	destructor

Real const &	proportion () const

Range const &	rangeData () const

CVectorXi const &	partitions () const

virtual bool	run ()
	run the computations.

void	setData (Range const &rangeData, Real prop)

template<class Data >
bool	getPartitions (Data const &x, Data &xLearn, Data &xTest)
	get the data set when setting out fold k and test data set

template<class xData , class yData >
bool	getPartitions (xData const &x, xData &xLearn, xData &xTest, yData const &y, yData &yLearn, yData &yTest)
	get the data set when setting out fold k and test data set

Public Member Functions inherited from STK::IRunnerBase
String const &	error () const
	get the last error message.

Protected Member Functions
void	partition ()
	create a random partition

Protected Member Functions inherited from STK::IRunnerBase
	IRunnerBase ()
	default constructor

	IRunnerBase (IRunnerBase const &runner)
	copy constructor

virtual	~IRunnerBase ()
	destructor

virtual void	update ()
	update the runner.

Private Attributes
Range	rangeData_
	Range of the data set (number of rows)

Real	prop_
	proportion

int	sizeTest_
	size of the test (should

CVectorXi	partitions_
	repartition of the sample into k-folds

Additional Inherited Members
Protected Attributes inherited from STK::IRunnerBase
String	msg_error_
	String with the last error message.

bool	hasRun_
	`true` if run has been used, `false` otherwise

Detailed Description

CvHanler is an utility function for building the submatrix/subvectors needed when creating learning and test data sets.

Definition at line 18 of file STK_PartitionHandler.h.

Constructor & Destructor Documentation

◆ PartitionHandler()

STK::PartitionHandler::PartitionHandler	(	Range const &	rangeData,
		Real	prop
	)

inline

Default constructor.

Parameters

rangeData	prop range of the data to partition
prop	to set in test data

Definition at line 74 of file STK_PartitionHandler.h.

                                         : IRunnerBase()
                                         , rangeData_(rangeData), prop_(prop)
                                         , sizeTest_(int(rangeData_.size()*prop_))
                                         , partitions_()
{
  // check proportion
  if (prop_>1)
  { STKRUNTIME_ERROR_1ARG(PartitionHandler::PartitionHandler,prop,prop>1);}
  if (prop_<0)
  { STKRUNTIME_ERROR_1ARG(PartitionHandler::PartitionHandler,prop,prop<0);}
}

References PartitionHandler(), prop_, and STKRUNTIME_ERROR_1ARG.

Referenced by PartitionHandler().

◆ ~PartitionHandler()

virtual STK::PartitionHandler::~PartitionHandler ( )

inlinevirtual

destructor

Definition at line 27 of file STK_PartitionHandler.h.

27{}

Member Function Documentation

◆ getPartitions() [1/2]

template<class Data >

bool STK::PartitionHandler::getPartitions	(	Data const &	x,
		Data &	xLearn,
		Data &	xTest
	)

get the data set when setting out fold k and test data set

Definition at line 88 of file STK_PartitionHandler.h.

{
  // check if partitions are determined
  if (!hasRun_)
  { msg_error_ = STKERROR_NO_ARG(PartitionHandler::getPartitions,PartitionHandler has to run);
    return false;
  }
  // check dimensions
  if (x.rows() != rangeData_)
  { msg_error_ = STKERROR_NO_ARG(PartitionHandler::getKLearn,x.rows()!=rangeData_);
    return false;
  }
  // prepare containers
  Range xLearnRows = x.rows();
  xLearnRows.decLast(sizeTest_);
  xLearn.resize(xLearnRows, x.cols());
  xTest.resize(sizeTest_, x.cols());
  // copy data
  int iLearnRow = xLearn.beginRows(), iTestRow = xTest.beginRows();
  for (int i = partitions_.begin(); i < partitions_.end(); ++i)
  {
    if (partitions_[i] == 1)
    {
      xTest.row(iTestRow) = x.row(i);
      ++iTestRow;
    }
    else
    {
      xLearn.row(iLearnRow) = x.row(i);
      ++iLearnRow;
    }
  }
  return true;
}

References getPartitions(), STK::IRunnerBase::hasRun_, STK::IRunnerBase::msg_error_, partitions_, rangeData_, run(), sizeTest_, and STKERROR_NO_ARG.

Referenced by getPartitions().

◆ getPartitions() [2/2]

template<class xData , class yData >

bool STK::PartitionHandler::getPartitions	(	xData const &	x,
		xData &	xLearn,
		xData &	xTest,
		yData const &	y,
		yData &	yLearn,
		yData &	yTest
	)

get the data set when setting out fold k and test data set

Definition at line 124 of file STK_PartitionHandler.h.

{
  // check if partitions are determined
  if (!hasRun_)
  { msg_error_ = STKERROR_NO_ARG(PartitionHandler::getKLearn,PartitionHandler has to run);
    return false;
  }
  // check dimensions
  if (x.rows() != rangeData_)
  { msg_error_ = STKERROR_NO_ARG(PartitionHandler::getKLearn,x.rows()!=rangeData_);
    return false;
  }
  if (y.rows() != rangeData_)
  { msg_error_ = STKERROR_NO_ARG(PartitionHandler::getKLearn,y.rows()!=rangeData_);
    return false;
  }
  // prepare constainers
  Range xLearnRows = x.rows();
  xLearnRows.decLast(sizeTest_);
  xLearn.resize(xLearnRows, x.cols());
  xTest.resize(sizeTest_, x.cols());
  yLearn.resize(xLearnRows, y.cols());
  yTest.resize(sizeTest_, y.cols());
  // copy data
  int iLearnRow = xLearn.beginRows(), iTestRow = xTest.beginRows();
  for (int i = partitions_.begin(); i < partitions_.end(); ++i)
  {
    if (partitions_[i] == 1)
    {
      xTest.row(iTestRow) = x.row(i);
      yTest.row(iTestRow) = y.row(i);
      ++iTestRow;
    }
    else
    {
      xLearn.row(iLearnRow) = x.row(i);
      yLearn.row(iLearnRow) = y.row(i);
      ++iLearnRow;
    }
  }
  return true;
}

References STK::IRunnerBase::hasRun_, STK::IRunnerBase::msg_error_, partitions_, rangeData_, run(), sizeTest_, and STKERROR_NO_ARG.

◆ partition()

void STK::PartitionHandler::partition ( )

inlineprotected

create a random partition

Definition at line 169 of file STK_PartitionHandler.h.

{
  partitions_.resize(rangeData_);
  int endTest = partitions_.begin()+sizeTest_;
  //fill the container with the index of the partition (1 test, 0 learn)
  for(int i = partitions_.begin() ; i< endTest ;i++) { partitions_[i] = 1;}
  for(int i = endTest ; i< partitions_.end() ;i++)   { partitions_[i] = 0;}
  //make a random rearrangement
  int begin = partitions_.begin();
  for (int i=partitions_.end()-2; i>begin; --i)
  { std::swap(partitions_[i], partitions_[Law::UniformDiscrete::rand(begin, i+1)]);}
}

References partitions_, STK::Law::UniformDiscrete::rand(), rangeData_, STK::ICArray< Derived >::resize(), and sizeTest_.

Referenced by run().

◆ partitions()

CVectorXi const & STK::PartitionHandler::partitions ( ) const

inline

Returns: the partitions

Definition at line 34 of file STK_PartitionHandler.h.

34{ return partitions_;}

References partitions_.

◆ proportion()

Real const & STK::PartitionHandler::proportion ( ) const

inline

Returns: the number of folds

Definition at line 30 of file STK_PartitionHandler.h.

30{ return prop_;}

References prop_.

◆ rangeData()

Range const & STK::PartitionHandler::rangeData ( ) const

inline

Returns: the range of the data

Definition at line 32 of file STK_PartitionHandler.h.

32{ return rangeData_;}

References rangeData_.

Referenced by setData().

◆ run()

virtual bool STK::PartitionHandler::run ( )

inlinevirtual

run the computations.

Returns: true if no error occur during the running process, false otherwise

Implements STK::IRunnerBase.

Definition at line 36 of file STK_PartitionHandler.h.

37 { partition(); hasRun_ = true; return true;}

STK::PartitionHandler::partition

void partition()

create a random partition

Definition STK_PartitionHandler.h:169

References STK::IRunnerBase::hasRun_, and partition().

Referenced by getPartitions(), and getPartitions().

◆ setData()

void STK::PartitionHandler::setData	(	Range const &	rangeData,
		Real	prop
	)

inline

Definition at line 39 of file STK_PartitionHandler.h.

    {
      partitions_.clear();
      rangeData_ = rangeData;
      prop_     = prop;
      sizeTest_ = int(rangeData_.size() * prop_);
      hasRun_   = false;
    }

References STK::ICArray< Derived >::clear(), STK::IRunnerBase::hasRun_, partitions_, prop_, rangeData(), rangeData_, STK::TRange< UnknownSize >::size(), and sizeTest_.

Member Data Documentation

◆ partitions_

CVectorXi STK::PartitionHandler::partitions_

private

repartition of the sample into k-folds

Definition at line 67 of file STK_PartitionHandler.h.

Referenced by getPartitions(), getPartitions(), partition(), partitions(), and setData().

◆ prop_

Real STK::PartitionHandler::prop_

private

proportion

Definition at line 63 of file STK_PartitionHandler.h.

Referenced by PartitionHandler(), proportion(), and setData().

◆ rangeData_

Range STK::PartitionHandler::rangeData_

private

Range of the data set (number of rows)

Definition at line 61 of file STK_PartitionHandler.h.

Referenced by getPartitions(), getPartitions(), partition(), rangeData(), and setData().

◆ sizeTest_

int STK::PartitionHandler::sizeTest_

private

size of the test (should

Definition at line 65 of file STK_PartitionHandler.h.

Referenced by getPartitions(), getPartitions(), partition(), and setData().

The documentation for this class was generated from the following file:

STK_PartitionHandler.h

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PartitionHandler()

◆ ~PartitionHandler()

Member Function Documentation

◆ getPartitions() [1/2]

◆ getPartitions() [2/2]

◆ partition()

◆ partitions()

◆ proportion()

◆ rangeData()

◆ run()

◆ setData()

Member Data Documentation

◆ partitions_

◆ prop_

◆ rangeData_

◆ sizeTest_