src/Classifier.cpp

/*
* 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
*
*/

#include "IO/Serialization.h"
#include "IO/OutputInfo.h"
#include "Classifier.h"

namespace MultiBoost {

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

Classifier::Classifier(nor_utils::Args &args, int verbose)
: _args(args), _verbose(verbose)
{
   // The file with the step-by-step information
   if ( args.hasArgument("-outputinfo") )
      args.getValue("-outputinfo", 0, _outputInfoFile);
}

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

void Classifier::run(const string& dataFileName, const string& shypFileName, const int numRanksEnclosed)
{
   InputData* pData = loadInputData(dataFileName, shypFileName);

   if (_verbose > 0)
   {
      cout << "Loading strong hypothesis...";
      cout.flush();
   }

   // The class that loads the weak hypotheses
   UnSerialization us;

   // Where to put the weak hypotheses
   vector<BaseLearner*> weakHypotheses;

   // loads them
   us.loadHypotheses(shypFileName, weakHypotheses);

   // where the results go
   vector< ExampleResults > results;

   if (_verbose > 0)
   {
      cout << "Classifying...";
      cout.flush();
   }

   // get the results
   computeResults( pData, weakHypotheses, results);

   const int numClasses = ClassMappings::getNumClasses();
   const int numExamples = pData->getNumExamples();

   if (_verbose > 0)
   {
      cout << "Done!" << endl;

      // well.. if verbose = 0 no results are displayed! :)
      vector< vector<double> > rankedError(numRanksEnclosed);

      // Get the per-class error for the numRanksEnclosed-th ranks
      for (int i = 0; i < numRanksEnclosed; ++i)
         getClassError( pData, results, rankedError[i], i );

      // output it
      cout << endl;
      cout << "Error Summary" << endl;
      cout << "=============" << endl;

      for ( int l = 0; l < numClasses; ++l )
      {
         // first rank (winner): rankedError[0]
         cout << "Class '" << ClassMappings::getClassNameFromIdx(l) << "': "
              << rankedError[0][l] * 100 << "%";

         // output the others on its side
         if (numRanksEnclosed > 1 && _verbose > 1)
         {
            cout << " (";
            for (int i = 1; i < numRanksEnclosed; ++i)
               cout << " " << i+1 << ":[" << rankedError[i][l] * 100 << "%]";
            cout << " )";
         }

         cout << endl;
      }

      // the overall error
      cout << "\n--> Overall Error: " << getOverallError(pData, results, 0) * 100 << "%";

      // output the others on its side
      if (numRanksEnclosed > 1 && _verbose > 1)
      {
         cout << " (";
         for (int i = 1; i < numRanksEnclosed; ++i)
            cout << " " << i+1 << ":[" << getOverallError(pData, results, i) * 100 << "%]";
         cout << " )";
      }

      cout << endl;

   } // verbose

   // delete the input data file
   if (pData) 
      delete pData;
}

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

InputData* Classifier::loadInputData(const string& dataFileName, const string& shypFileName)
{
   // open file
   ifstream inFile(shypFileName.c_str());
   if (!inFile.is_open())
   {
      cerr << "ERROR: Cannot open strong hypothesis file <" << shypFileName << ">!" << endl;
      exit(1);
   }

   // Declares the stream tokenizer
   nor_utils::StreamTokenizer st(inFile, "<>\n\r\t");

   // Move until it finds the multiboost tag
   if ( !UnSerialization::seekSimpleTag(st, "multiboost") )
   {
      // no multiboost tag found: this is not the correct file!
      cerr << "ERROR: Not a valid MultiBoost Strong Hypothesis file!!" << endl;
      exit(1);
   }

   // Move until it finds the algo tag
   string basicLearnerName = UnSerialization::seekAndParseEnclosedValue<string>(st, "algo");

   // Check if the weak learner exists
   if ( !BaseLearner::RegisteredLearners().hasLearner(basicLearnerName) )
   {
      cerr << "ERROR: Weak learner <" << basicLearnerName << "> not registered!!" << endl;
      exit(1);
   }

   // get the training input data, and load it
   InputData* pData = BaseLearner::RegisteredLearners().getLearner(basicLearnerName)->createInputData();

   // set the non-default arguments of the input data
   pData->initOptions(_args);
   // load the data
   pData->load(dataFileName, IT_TEST, _verbose);

   return pData;
}

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

// Returns the results into ptRes
void Classifier::computeResults(InputData* pData, vector<BaseLearner*>& weakHypotheses, 
                                vector< ExampleResults >& results)
{
   assert( !weakHypotheses.empty() );

   const int numClasses = ClassMappings::getNumClasses();
   const int numExamples = pData->getNumExamples();

   // Initialize the output info
   OutputInfo* pOutInfo = NULL;

   if ( !_outputInfoFile.empty() )
      pOutInfo = new OutputInfo(_outputInfoFile);

   // Creating the results structures. See file Structures.h for the
   // PointResults structure
   results.clear();
   results.reserve(numExamples);
   for (int i = 0; i < numExamples; ++i)
      results.push_back( ExampleResults(i, numClasses) );

   // iterator over all the weak hypotheses
   vector<BaseLearner*>::const_iterator whyIt; 
   int t;

   // for every feature: 1..T
   for (whyIt = weakHypotheses.begin(), t = 0; 
        whyIt != weakHypotheses.end(); ++whyIt, ++t)
   {
      double alpha = (*whyIt)->getAlpha();

      // for every class
      for (int l = 0; l < numClasses; ++l)
      {
         // for every point
         for (int i = 0; i < numExamples; ++i)
            results[i].votesVector[l] += alpha * (*whyIt)->classify(pData, i, l);
      }

      // if needed output the step-by-step information
      if ( pOutInfo )
      {
         pOutInfo->outputIteration(t);
         pOutInfo->outputError(pData, *whyIt);

         // Margins and edge requires an update of the weight,
         // therefore I keep them out for the moment
         //outInfo.outputMargins(pData, *whyIt);
         //outInfo.outputEdge(pData, *whyIt);
         pOutInfo->endLine();
      }
   }

   if (pOutInfo)
      delete pOutInfo;

}

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

double Classifier::getOverallError( InputData* pData, const vector<ExampleResults>& results, 
                                    int atLeastRank )
{
   const int numExamples = pData->getNumExamples();
   int numErrors = 0;

   assert(atLeastRank >= 0);

   for (int i = 0; i < numExamples; ++i)
   {
      // if the real class is not the one with the highest vote in the
      // vote vector, then it is an error!
      if ( !results[i].isWinner( pData->getClass(i), atLeastRank ) )
         ++numErrors;
   }  

   // makes the error between 0 and 1
   return (double)numErrors / (double)numExamples;
}

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

void Classifier::getClassError( InputData* pData, const vector<ExampleResults>& results, 
                                vector<double>& classError, int atLeastRank )
{
   const int numExamples = pData->getNumExamples();
   const int numClasses = ClassMappings::getNumClasses();

   int numErrors = 0;
   classError.resize( numClasses, 0 );

   assert(atLeastRank >= 0);

   for (int i = 0; i < numExamples; ++i)
   {
      // if the real class is not the one with the highest vote in the
      // vote vector, then it is an error!
      if ( !results[i].isWinner( pData->getClass(i), atLeastRank ) )
         ++classError[ pData->getClass(i) ];
   }

   // makes the error between 0 and 1
   for (int l = 0; l < numClasses; ++l)
      classError[l] /= (double)pData->getNumExamplesPerClass(l);
}

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

} // end of namespace MultiBoost

---