src/WeakLearners/StumpLearner.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 __STUMP_LEARNER_H
#define __STUMP_LEARNER_H

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

#include <vector>
#include <fstream>

using namespace std;


namespace MultiBoost {

class StumpLearner : public BaseLearner
{
public:

   StumpLearner() 
      : _theta(0), _abstention(ABST_NO_ABSTENTION), _selectedColumn(-1) {}

   virtual void initOptions(nor_utils::Args& args);

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

   virtual InputData* createInputData(); 

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


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

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

protected:

   virtual char phi(double val, int classIdx) = 0;

   struct sRates
   {
      sRates() : classIdx(-1), rPls(0), rMin(0), rZero(0) {} 

      int     classIdx; 

      double  rPls; 
      double  rMin; 
      double  rZero; 

      bool operator<(const sRates& el) const
      {
         return el.rPls * el.rMin < this->rPls * this->rMin;
      }
   };

   virtual double getEnergy(vector<sRates>& mu, double& alpha, vector<char>& v);

   virtual double doGreedyAbstention(vector<sRates>& mu,  double currEnergy, 
                                     sRates& eps, double& alpha, vector<char>& v);

   virtual double doFullAbstention(const vector<sRates>& mu,  double currEnergy, 
                                   sRates& eps, double& alpha, vector<char>& v);

   vector<char>   _v;
   int            _selectedColumn; 

   double         _theta; 

   enum eAbstType
   {
      ABST_NO_ABSTENTION, 
      ABST_GREEDY, 
      ABST_FULL 
   };
   eAbstType       _abstention; 

   vector<double> _rightErrors; 
   vector<double> _leftErrors; 
   vector<double> _bestErrors; 

   vector<double> _weightsPerClass; 
   vector<double> _halfWeightsPerClass; 

};

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

} // end of namespace MultiBoost

#endif // __STUMP_LEARNER_H

---