GridSearch.h

#ifndef GRT_GRID_SEARCH_HEADER
#define GRT_GRID_SEARCH_HEADER

#include "../../CoreModules/MLBase.h"
#include "../../CoreModules/GestureRecognitionPipeline.h"

#include <functional>

GRT_BEGIN_NAMESPACE

template< class T > 
class GridSearchRange {
public:
 GridSearchRange( const T _min = T(), const T _max = T(), const T _inc = T() ):min(_min),max(_max),inc(_inc){ value = min; expired = false; }

 GridSearchRange( const GridSearchRange &rhs ){
 this->value = rhs.value;
 this->min = rhs.min;
 this->max = rhs.max;
 this->inc = rhs.inc;
 this->expired = rhs.expired;
 }

 T next(){
 if( expired ) return value;
 if( value + inc < max ) value += inc;
 else{ value = max; }
 return value;
 }

 bool reset(){
 value = min;
 expired = false;
 return true;
 }

 bool getExpired() const { return expired; }
 
 T get() { if( value >= max ) expired = true; return value; }

 T value;
 T min;
 T max;
 T inc;
 bool expired;
};

template < class T >
class GridSearchParam {
public:

 GridSearchParam( std::function< bool(T) > func = nullptr, GridSearchRange<T> range = GridSearchRange<T>() ){
 this->func = func;
 this->range = range;
 }

 GridSearchParam( const GridSearchParam &rhs ){
 this->func = rhs.func;
 this->range = rhs.range;
 }

 bool reset(){
 return range.reset();
 }

 bool set(){
 if( !func ) return false;
 return func( range.get() );
 }

 bool update(){
 if( !func ) return false;
 return func( range.next() );
 }
 
 bool getExpired() const { return range.getExpired(); }

 T get(){ return range.get(); }

 std::function< bool(T) > func;
 GridSearchRange<T> range;
};

template< class T >
class GridSearch : public MLBase{
public:
 enum SearchType {MaxValueSearch=0,MinValueSearch};
 GridSearch() {
 classType = "GridSearch";
 infoLog.setProceedingText("[GridSearch]");
 debugLog.setProceedingText("[DEBUG GridSearch]");
 errorLog.setProceedingText("[ERROR GridSearch");
 trainingLog.setProceedingText("[TRAINING GridSearch]");
 warningLog.setProceedingText("[WARNING GridSearch]");
 }
 
 virtual ~GridSearch(){
 
 }

 bool addParameter( std::function< bool(unsigned int) > f , GridSearchRange< unsigned int > range ){
 params.push_back( GridSearchParam<unsigned int>( f, range ) );
 return true;
 }
 
 bool search( ){
 
 if( params.getSize() == 0 ){
 warningLog << "No parameters to search! Add some parameters!" << std::endl;
 return false;
 }

 switch( evalType ){
 case MaxValueSearch:
 bestResult = 0;
 break;
 case MinValueSearch:
 bestResult = grt_numeric_limits< Float >::max();
 break;
 default:
 errorLog << "recursive_search( unsigned int paramIndex ) - Unknown eval type!" << std::endl;
 return false;
 break; 
 }

 if( params.getSize() == 0 ) return false;
 unsigned int paramIndex = 0;
 return recursive_search( paramIndex );
 }

 Float getBestResult() const { return bestResult; }

 T getBestModel() const { return bestModel; }

 bool setModel( const T &model ){
 this->model = model;
 return true;
 }

 bool setEvaluationFunction( std::function< Float () > f, SearchType type = MaxValueSearch ){
 evalFunc = f;
 evalType = type;
 return true;
 }
 
protected:

 bool recursive_search( unsigned int paramIndex ){
 
 const unsigned int numParams = params.getSize();
 if( paramIndex >= numParams ){
 errorLog << "recursive_search( unsigned int paramIndex ) - Param Index out of bounds!" << std::endl;
 return false;
 }

 recursive_reset( paramIndex );

 bool stopAfterNextIter = false;
 Float result = 0.0;
 while( true ){

 //Make sure the parameter is set
 params[ paramIndex ].set();

 if( paramIndex+1 < numParams ) 
 recursive_search( paramIndex + 1 );
 
 if( paramIndex == numParams-1 ){ //If we are at the final parameter, run the evaluation

 //Evaluate the function using the current parameters
 result = evalFunc();
 
 switch( evalType ){
 case MaxValueSearch:
 if( result > bestResult ){
 bestResult = result;
 bestModel = model;
 }
 break;
 case MinValueSearch:
 if( result < bestResult ){
 bestResult = result;
 bestModel = model;
 }
 break;
 default:
 errorLog << "recursive_search( unsigned int paramIndex ) - Unknown eval type!" << std::endl;
 return false;
 break; 
 }
 }

 if( stopAfterNextIter ) break;

 //Update the parameter
 params[ paramIndex ].update();

 if( params[ paramIndex ].getExpired() ) stopAfterNextIter = true;
 }

 return true;
 }

 bool recursive_reset( unsigned int paramIndex ){
 const unsigned int numParams = params.getSize();
 if( paramIndex >= numParams ){
 errorLog << "recursive_reset( unsigned int paramIndex ) - Param Index out of bounds!" << std::endl;
 return false;
 }

 if( paramIndex+1 < numParams ) 
 recursive_reset( paramIndex + 1 );

 return params[ paramIndex ].reset();
 }

 Vector< GridSearchParam<unsigned int> > params;
 std::function< Float () > evalFunc; 
 SearchType evalType;
 Float bestResult;
 T model;
 T bestModel;
};

GRT_END_NAMESPACE

#endif // header guard