src/WeakLearners/BaseLearner.h

Go to the documentation of this file.

/*
* This file is part of MultiBoost, a multi-class 
* AdaBoost learner/classifier
*
* Copyright (C) 2005 Norman Casagrande
* For informations write to nova77@gmail.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*
*/

#ifndef __BASE_LEARNER_H
#define __BASE_LEARNER_H

#include <algorithm>
#include <vector>

#include "IO/InputData.h"
#include "Utils/Args.h"

#include "Utils/StreamTokenizer.h"

using namespace std;


namespace MultiBoost {

class BaseLearner
{

private:


   class LearnersRegs
   {
   public:

      void addLearner(const string& learnerName, BaseLearner* pLearnerToRegister)
      { _learners[learnerName] = pLearnerToRegister; }

      bool hasLearner(const string& learnerName)
      { return ( _learners.find(learnerName) != _learners.end() ); }

      BaseLearner* getLearner(const string& learnerName)
      { return _learners[learnerName]; }

      void getList(vector<string>& learnersList)
      {
         learnersList.clear();
         learnersList.reserve(_learners.size());
         map<string, BaseLearner*>::const_iterator it;
         for (it = _learners.begin(); it != _learners.end(); ++it)
            learnersList.push_back( it->first );
      }

   private:
      map<string, BaseLearner*> _learners; 
   };


public:

   static LearnersRegs& RegisteredLearners()
   {
      // Construct On First Use Idiom:
      // Since static local objects are constructed the first time control flows 
      // over their declaration (only), the new LearnersRegs() statement will only 
      // happen once: the first time RegisteredLearners() is called. Every subsequent 
      // call will return the same LearnersRegs object (the one pointed to by ans). 
      static LearnersRegs* regLerners = new LearnersRegs();
      return *regLerners;
   }

   BaseLearner() : _smallVal(1E-10), _smoothingVal(_smallVal), _alpha(0) {}

   virtual void initOptions(nor_utils::Args& args) {}

   virtual void declareArguments(nor_utils::Args& args) = 0;

   virtual BaseLearner* create() = 0;

   virtual InputData* createInputData();

   virtual void run(InputData* pData) = 0;

   virtual char classify(InputData* pData, const int idx, const int classIdx) = 0;

   const double getAlpha() const { return _alpha; }

   virtual void save(ofstream& outputStream, const int numTabs = 0);

   virtual void load(nor_utils::StreamTokenizer& st);

protected:

   virtual void setSmoothingVal(const double smoothingVal) { _smoothingVal = smoothingVal; }

   virtual double getAlpha(const double error);

   virtual double getAlpha(const double eps_min, const double eps_pls);

   virtual double getAlpha(const double eps_min, const double eps_pls, double theta);

   double         _smoothingVal; 

   double         _alpha; 
   const double   _smallVal; 

};

// ------------------------------------------------------------------------------

} // end of namespace MultiBoost


#define REGISTER_LEARNER(X) \
struct Register_##X \
        { Register_##X() { BaseLearner::RegisteredLearners().addLearner(#X, new X()); } }; \
        static Register_##X r_##X;

#define REGISTER_LEARNER_NAME(NAME, X) \
struct Register_##X \
        { Register_##X() { BaseLearner::RegisteredLearners().addLearner(#NAME, new X()); } }; \
        static Register_##X r_##X;


#endif // __BASE_LEARNER_H

---