Classifier_ls.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_LS_H_
#define _CLASSIFIER_LS_H_



#include "Classifier.hpp"



class Classifier_ls: public Classifier
  {
  public:

  // ---------------------------------------------------------------- //
  // ------------------------ Constructors -------------------------- //
  // ---------------------------------------------------------------- //

  // Copy ctor -- Overloaded
  Classifier_ls
    (
    const Classifier_ls& c
    );

  // User defined ctor adaBoost -- Overloaded
  Classifier_ls
    (
    const mat& A,
    const mat& B
    );

  // ---------------------------------------------------------------- //
  // ---------------------- Member Functions ------------------------ //
  // ---------------------------------------------------------------- //

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

  // ---------------------------------------------------------------- //
  // --------------------- Overloaded Operators --------------------- //
  // ---------------------------------------------------------------- //

  // ---------------------------------------------------------------- //
  // -------------------------- Attributes -------------------------- //
  // ---------------------------------------------------------------- //

  // projection vector
  colvec w;
  };



Classifier_ls::Classifier_ls
  (
  const Classifier_ls& c
  )
  {
  // update seperating hyperplane vector
  w = c.w;

  // update the plus and minus labels
  pos = c.pos;
  neg = c.neg;

  // update number of possitive and negative samples
  n_pos = c.n_pos;
  n_neg = c.n_neg;

  // update training error
  training_error = c.training_error;
  }



Classifier_ls::Classifier_ls
  (
  const mat& A,
  const mat& B
  )
  {
  // number of first class feature vectors
  const u32 n_samplesA = A.n_rows;

  // number of second class feature vectors
  const u32 n_samplesB = B.n_rows;

  // number of attributes
  const u32 d = A.n_cols;

  // construct total datamatrix
  const mat X = join_cols(A,B);

  // construct labels
  colvec Y = join_cols
               (
               ones<colvec>(n_samplesA, 1),
               -ones<colvec>(n_samplesB, 1)
               );


  // compute seperation hyperplane vector
  w = solve((trans(X) * X) +  param.C * eye<mat>(d,d), trans(X) * Y);

  // initialize number of possitive and negative samples
  n_pos = 0;
  n_neg = 0;
  }



inline
double
Classifier_ls::predict(const rowvec& t) const
  {
  return as_scalar(t * w);
  }



#endif