Classifier.hpp

Go to the documentation of this file.

// Copyright (C) 2011 the authors listed below
// http://ecocpak.sourceforge.net
//
// Authors:
// - Dimitrios Bouzas (bouzas at ieee dot org)
// - Nikolaos Arvanitopoulos (niarvani at ieee dot org)
// - Anastasios Tefas (tefas at aiia dot csd dot auth dot gr)
//
// This file is part of the ECOC PAK C++ library. It is
// provided without any warranty of fitness for any purpose.
//
// You can redistribute this file and/or modify it under
// the terms of the GNU Lesser General Public License (LGPL)
// as published by the Free Software Foundation, either
// version 3 of the License or (at your option) any later
// version.
// (see http://www.opensource.org/licenses for more info)





#ifndef _CLASSIFIER_H_
#define _CLASSIFIER_H_



#include <iostream>
#include <vector>
using namespace std;


#include <armadillo>
using namespace arma;

#include "ClassData.hpp"



enum
  {
  NCC,              // - Nearest Mean Classifier.
  FLDA,             // - Fisher Linear Discriminant Analysis Followed by
                    //   NMC.
  SVM,              // - Support Vector Machine.
  ADABOOST,         // - Discrete AdaBoost.
  LEAST_SQUARES,    // - Sum of Least Error Squares Classifier.
  CUSTOM_CLASSIFIER // - Custom Classifier.
  };



class Classifier
  {
  public:

  // ================================================================ //
  // ||                        Auxiliary                           || //
  // ================================================================ //

  // print classifier info to specified output stream
  void print(ostream& out) const;

  // ================================================================ //
  // ||                  Overloaded Operators                      || //
  // ================================================================ //

  // overloaded equallity operator
  bool operator==(Classifier& c);

  // ================================================================ //
  // ||                     Member Functions                       || //
  // ================================================================ //

  // return prediction value of classifier for input feature vector
  virtual double predict(const rowvec& t) const = 0;

  // ================================================================ //
  // ||                         Attributes                         || //
  // ================================================================ //

  // training error attained by binary classifier on specific problem
  double training_error;

  // vector which holds pointers to ClassData objects that the
  // classifier considers them as possitive
  vector<ClassData*> pos;

  // vector which holds pointers to ClassData objects that the
  // classifier considers them as negative
  vector<ClassData*> neg;

  // number of possitive samples considered by binary classifier
  u32 n_pos;

  // number of negative samples considered by binary classifier
  u32 n_neg;
  };



// ================================================================== //
// ||                          Auxiliary                           || //
// ================================================================== //


void
Classifier::print(ostream& out = cout) const
  {
  out << "--- Classifier info ---" << endl;

  // classes marked with +1
  for(u32 i = 0; i < pos.size(); i++)
    {
    out << pos[i]->ClassIndex() << " ";
    }

  out << " vs ";

  // classes marked with -1
  for(u32 i = 0; i < neg.size(); i++)
    {
    out << neg[i]->ClassIndex() << " ";
    }

  out << endl;

  out << "Training Error: " << training_error << endl;
  }



// ================================================================== //
// ||                    Overloaded Operators                      || //
// ================================================================== //



bool
Classifier::operator==(Classifier& c)
  {
  // check wether vector of classes marked with +1 and vector of
  // classes marked with -1 are equal
  if(c.pos.size() != pos.size() || c.neg.size() != neg.size())
    {
    return false;
    }

  // check wether classifiers have the same classes marked with +1
  for(u32 i = 0; i < pos.size(); i++)
    {
    if(pos[i]->ClassIndex() != c.pos[i]->ClassIndex())
      {
      return false;
      }

    }

  // check wether classifiers have the same classes marked with -1
  for(u32 i = 0; i < neg.size(); i++)
    {
    if(neg[i]->ClassIndex() != c.neg[i]->ClassIndex())
      {
      return false;
      }

    }

  return true;
  }



#endif