src/Classifier.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 __CLASSIFIER_H
#define __CLASSIFIER_H

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

#include <string>
#include <cassert>

using namespace std;

namespace MultiBoost {


class Classifier
{
public:

   Classifier(nor_utils::Args& args, int verbose = 1);

   void run(const string& dataFileName, const string& shypFileName, const int numRanksEnclosed = 2);

protected:

   InputData* loadInputData(const string& dataFileName, const string& shypFileName);

   class ExampleResults 
   {
   public:

      ExampleResults(const int idx, const int numClasses) 
         :  idx(idx), votesVector(numClasses, 0) {}

      int idx; 

      vector<double> votesVector; 

      pair<int, double> getWinner(const int rank = 0)
      {
         assert(rank > 0);

         vector< pair<int, double> > rankedList;
         getRankedList(rankedList); // get the sorted rankings
         return rankedList[rank];
      }

      bool isWinner(const int idxRealClass, const int atLeastRank = 0) const
      {
         assert(atLeastRank >= 0);

         vector< pair<int, double> > rankedList;
         getRankedList(rankedList); // get the sorted rankings

         for (int i = 0; i <= atLeastRank; ++i)
         {
            if ( rankedList[i].first == idxRealClass )
               return true;
         }

         return false;
      }

   private:

      void getRankedList( vector< pair<int, double> >& rankedList ) const
      {
         rankedList.resize(votesVector.size());

         vector<double>::const_iterator vIt;
         int i;
         for (vIt = votesVector.begin(), i = 0; vIt != votesVector.end(); ++vIt, ++i )
            rankedList[i] = make_pair(i, *vIt);

         sort( rankedList.begin(), rankedList.end(), 
               nor_utils::comparePairOnSecond< int, double, greater<double> > );
      }
   }; // ExampleResults


   void computeResults(InputData* pData, vector<BaseLearner*>& weakHypotheses, 
                       vector< ExampleResults >& results);

   double getOverallError( InputData* pData, const vector<ExampleResults>& results, 
                           int atLeastRank = 0 );

   void getClassError( InputData* pData,  const vector<ExampleResults>& results, 
                       vector<double>& classError, int atLeastRank = 0  );

   int      _verbose;

   nor_utils::Args&  _args;  
   string   _outputInfoFile; 

};

} // end of namespace MultiBoost

#endif // __CLASSIFIER_H

---