Classifier_flda.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_FLDA_H_
#define _CLASSIFIER_FLDA_H_



#include "Classifier.hpp"



class Classifier_flda : public Classifier
  {
  public:

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

  // Copy ctor
  Classifier_flda
    (
    const Classifier_flda& c
    );

  // User defined ctor FLDA -- Overloaded
  Classifier_flda
    (
    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 for FLDA
  colvec w;

  // bias for FLDA
  double w0;
  };



Classifier_flda::Classifier_flda
  (
  const Classifier_flda& c
  )
  {
  // update projection vector attribute
  w = c.w;

  // update bias
  w0 = c.w0;

  // update the plus and minus classes
  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_flda::Classifier_flda
  (
  const mat& A,
  const mat& B
  )
  {
  // number of samples
  const u32 n_samplesA = A.n_rows;

  // samples' dimensionality
  const u32 n_samplesB = B.n_rows;

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

  // vector of classes means
  mat MC = zeros<mat>(2, d);

  // find classes means
  rowvec mA = mean(A);
  rowvec mB = mean(B);

  // initialize within-class covariance matrix
  mat SW = zeros<mat>(d, d);

  // compute the within-class covariace matrix for class A
  for(u32 i = 0; i < n_samplesA; i++)
    {
    rowvec tmp_vec = A.row(i) - mA;
    SW += (trans(tmp_vec) * tmp_vec);
    }

  // compute the within-class covariace matrix for class B
  for(u32 i = 0; i < n_samplesB; i++)
    {
    rowvec tmp_vec = B.row(i) - mB;
    SW += (trans(tmp_vec) * tmp_vec);
    }

  // add some noise in the diagonal for robustness
  SW.diag() += (10e-15 * ones<vec>(d,1));

  // compute the weight vector
  w = solve(SW, trans(mB - mA));

  // compute the bias
  w0 = as_scalar((mB + mA) * w) / 2.0;

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



inline
double
Classifier_flda::predict(const rowvec& t) const
  {
  // return prediction
  return w0 - as_scalar(t * w);
  }



#endif