Classifier_svm.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_SVM_H_
#define _CLASSIFIER_SVM_H_



#include "Classifier.hpp"



class Classifier_svm : public Classifier
  {
  public:

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

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

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

  // dtor
  ~Classifier_svm();

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

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

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

  // LIBSVM SVM model.
  struct svm_model model;
  };



Classifier_svm::Classifier_svm
  (
  const Classifier_svm& c
  )
  {
  svm_model* tmp = const_cast<svm_model*>(&(c.model));

  // update SVM model
  model = modelcpy(tmp);

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

  //  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_svm::Classifier_svm
  (
  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;

  // construct data matrix TODO::
  mat data_matrix = join_cols(A,B);
  colvec labels = join_cols
                     (
                     ones<colvec>(n_samplesA),
                     -ones<colvec>(n_samplesB)
                     );

  // LIBSVM problem -- set by read_training_file
  struct svm_problem problem;
  problem.x = dense_to_sparse(data_matrix);
  problem.l = n_samplesA + n_samplesB;
  problem.y = labels.memptr();

  // train LIBSVM model & copy
  svm_model* m = svm_train(&problem, &param);
  model = modelcpy(m);

  // clean up temporary created model
  delete_sparse_matrix(problem.x, problem.l);
  delete [] m->SV;

  for(u32 i = 0; i < m->nr_class - 1; i++)
    {
  delete [] m->sv_coef[i];
    }

  delete [] m->sv_coef;
  delete m->rho;
  delete [] m->label;
  delete m->probA;
  delete m->probB;
  delete m->nSV;
  delete m;

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



inline
double
Classifier_svm::predict(const rowvec& t) const
  {
  // temporary variable to hold classifier prediction
  double prediction = 0.0;

  // --- convert Armadillo row vector to LIBSVM type format --- //

  // indices of non zero elements
  ucolvec ind = find(t);

  // number of non zero elements
  const u32 n_elem = ind.n_elem;

  // allocate space for sparse row
  struct svm_node* x_space = new svm_node[n_elem + 1];

  // set last row element of sparse representation
  x_space[n_elem].index = -1;
  x_space[n_elem].value = 0;

  // fill in the rest of the elements
  for(u32 i = 0; i < n_elem; i++)
    {
    x_space[i].index = ind[i];
    x_space[i].value = t[ind[i]];
    }

  // compute prediction
  svm_predict_values(&model, x_space, &prediction);

  // delete temporary sparse representation
  delete [] x_space;

  // return prediction
  return prediction;
  }



Classifier_svm::~Classifier_svm()
  {
  delete_sparse_matrix(model.SV, model.l);

  for(u32 i = 0; i < model.nr_class - 1; i++)
    {
  delete [] model.sv_coef[i];
    }

  delete [] model.SV;
  delete [] model.sv_coef;
  delete model.rho;
  delete model.label;
  delete model.probA;
  delete model.probB;
  delete model.nSV;
  delete &model;
  }



#endif