src/main.cpp

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

#include <vector>
#include <string>
#include <map>
#include <iostream>

#include "Defaults.h"
#include "Utils/Args.h"

#include "AdaBoostMHLearner.h"
#include "Classifier.h"
#include "WeakLearners/BaseLearner.h"
#include "IO/ClassMappings.h" // for -classmap option

using namespace std;
using namespace MultiBoost;


void showBase()
{
   cout << "MultiBoost. An obvious name for a multi-class AdaBoost learner." << endl;
   cout << "----------------------------------------------------------------" << endl;
   cout << "Build: " << __DATE__ << " (" << __TIME__ << ") (C) Norman Casagrande 2005" << endl << endl;
   cout << "===> Type -help for help or -static to show the static options" << endl;

   exit(0);
}

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

void showHelp(nor_utils::Args& args, const vector<string>& learnersList)
{
   cout << "MultiBoost. An obvious name for a multi-class AdaBoost learner." << endl;
   cout << "------------------------ HELP SECTION --------------------------" << endl;

   args.printGroup("Parameters");

   cout << endl;
   cout << "For specific help options type:" << endl;
   cout << "   -h general: General options" << endl;
   cout << "   -h io: I/O options" << endl;
   cout << "   -h algo: Basic algorithm options" << endl;

   cout << endl;
   cout << "For weak learners specific options type:" << endl;
   
   vector<string>::const_iterator it;
   for (it = learnersList.begin(); it != learnersList.end(); ++it)
      cout << "   -h " << *it << endl;

   exit(0);
}

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

void showOptionalHelp(nor_utils::Args& args)
{
   string helpType;
   args.getValue("-h", 0, helpType);

   cout << "MultiBoost. An obvious name for a multi-class AdaBoost learner." << endl;
   cout << "----------------------------------------------------------------" << endl;

   if (helpType == "general")
      args.printGroup("General Options");
   else if (helpType == "io")
      args.printGroup("I/O Options");
   else if (helpType == "algo")
      args.printGroup("Basic Algorithm Options");
   else if ( BaseLearner::RegisteredLearners().hasLearner(helpType) )
      args.printGroup(helpType + " Options");
   else
      cerr << "ERROR: Unknown help section <" << helpType << ">" << endl;
}

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

void showStaticConfig()
{
   cout << "MultiBoost. An obvious name for a multi-class AdaBoost learner." << endl;
   cout << "------------------------ STATIC CONFIG -------------------------" << endl;

   cout << "- Sort type = ";
#if CONSERVATIVE_SORT
   cout << "CONSERVATIVE (slow)" << endl;
#else
   cout << "NON CONSERVATIVE (fast)" << endl;
#endif

   cout << "Comment: " << COMMENT << endl;
#ifndef NDEBUG
   cout << "Important: NDEBUG not active!!" << endl;
#endif

#if MB_DEBUG
   cout << "MultiBoost debug active (MB_DEBUG=1)!!" << endl;
#endif

   exit(0);  
}

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

int main(int argc, char* argv[])
{
   // Standard arguments
   nor_utils::Args args;

   args.declareArgument("-help");
   args.declareArgument("-static");

   args.declareArgument("-h", "Help", 1, "<optiongroup>");

   // Basic Arguments

   args.setGroup("Parameters");

   args.declareArgument("-train", "Performs training.", 2, "<dataFile> <nInterations>");
   args.declareArgument("-traintest", "Performs training and test at the same time.", 3, "<trainingDataFile> <testDataFile> <nInterations>");
   args.declareArgument("-test", "Test the model.", 2, "<dataFile> <shypFile>");

   // Options

   args.setGroup("General Options");

   args.declareArgument("-verbose", "Set the verbose level 0, 1 or 2 (0=no messages, 1=default, 2=all messages).", 1, "<val>");
   args.declareArgument("-outputinfo", "Output informations on the algorithm performances during training, on file <filename>.", 1, "<filename>");

   string learnersComment = "Available learners are:";

   vector<string> learnersList;
   BaseLearner::RegisteredLearners().getList(learnersList);
   vector<string>::const_iterator it;
   for (it = learnersList.begin(); it != learnersList.end(); ++it)
   {
      learnersComment += "\n ** " + *it;
      // defaultLearner is defined in Defaults.h
      if ( *it == defaultLearner )
         learnersComment += " (DEFAULT)";
   }

   args.declareArgument("-learnertype", "Change the type of weak learner. " + learnersComment, 1, "<learner>");

   args.setGroup("I/O Options");

   args.declareArgument("-classend", "The class is the last column instead of the first (or second if -hasfilename is active).");
   args.declareArgument("-classmap", "Specify a file with the list of classes. Use it when the test set has less classes than the training set.", 1, "<filename>");
   args.declareArgument("-hasfilename", "The data file has an additional column (the very first) which contains the filename.");
   args.declareArgument("-shypname", "The name of output strong hypothesis (default: " + string(SHYP_NAME) + "." + string(SHYP_EXTENSION) + ").", 1, "<filename>");

   args.setGroup("Basic Algorithm Options");

   args.declareArgument("-edgeoffset", "Defines the value of the edge offset (theta) (default: no edge offset).", 1, "<val>");

   for (it = learnersList.begin(); it != learnersList.end(); ++it)
   {
      args.setGroup(*it + " Options");
      // add weaklearner-specific options
      BaseLearner::RegisteredLearners().getLearner(*it)->declareArguments(args);
   }


   switch ( args.readArguments(argc, argv) )
   {
   case nor_utils::AOT_NO_ARGUMENTS:
      showBase();
      break;

   case nor_utils::AOT_UNKOWN_ARGUMENT:
      exit(1);
      break;

   case nor_utils::AOT_TOO_FEW_VALUES:
      showHelp(args, learnersList);
      break;
   }


   if ( args.hasArgument("-help") )
      showHelp(args, learnersList);
   if ( args.hasArgument("-static") )
      showStaticConfig();


   if ( args.hasArgument("-h") )
      showOptionalHelp(args);


   int verbose = 1;

   if ( args.hasArgument("-verbose") )
      args.getValue("-verbose", 0, verbose);

   if (args.hasArgument("-classmap") )
   {
      string classMapName;
      args.getValue("-classmap", 0, classMapName);
      ClassMappings::loadClassMapFile(classMapName);
   }

   if ( args.hasArgument("-train") )
   {
      // -train <dataFile> <nInterations>
      string trainFileName;
      args.getValue("-train", 0, trainFileName);

      int numInterations;
      args.getValue("-train", 1, numInterations);
      
      AdaBoostLearner learner(args, verbose);
      learner.run(numInterations, trainFileName);
   }
   else if ( args.hasArgument("-traintest") )
   {
      // -traintest <trainingDataFile> <testDataFile> <nInterations>
      string trainFileName;
      args.getValue("-traintest", 0, trainFileName);

      string testFileName;
      args.getValue("-traintest", 1, testFileName);

      int numInterations;
      args.getValue("-traintest", 2, numInterations);

      AdaBoostLearner learner(args, verbose);
      learner.run(numInterations, trainFileName, testFileName);
   } 
   else if ( args.hasArgument("-test") )
   {
      // -test <dataFile> <shypFile>
      string testFileName;
      args.getValue("-test", 0, testFileName);

      string shypFile;
      args.getValue("-test", 1, shypFile);

      Classifier classifier(args, verbose);
      classifier.run(testFileName, shypFile);
   }
 
   return 0;
}

---