fn_subdecoc.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)





u32
subdecoc
  (
  const mat& training_samples,
  const icolvec& training_labels,
  const mat& testing_samples,
  const icolvec& testing_labels,
  const Threshold& thres,
  const int decoding_strategy,
  const int classifiers_type,
  const int criterion_option,
  const bool verbose,
  imat& coding_matrix,
  ofstream& verbose_output,
  double& execution_time
  )
  {
  // timer object to count execution times
  wall_clock timer;

  // start timer
  timer.tic();

  // number of training samples
  const u32 n_training_samples = training_samples.n_rows;

  // number of samples attributes
  const u32 n_attributes = training_samples.n_cols;

  // number of testing samples
  const u32 n_testing_samples = testing_samples.n_rows;

  // variable to hold the number of classes
  u32 n_classes = 0;

  // adjust the training samples class labels to start from one
  // and count number of classes
  const icolvec tmp_training_labels =
    conv_to<icolvec>::from(process_labels(training_labels, n_classes));

  // adjust the testing samples class labels to start from one
  const uvec tmp_testing_labels = process_labels(testing_labels);

  // resulting classes after subclass techique
  vector<ClassData> classes_created_vector;

  // classifiers vector
  vector<Classifier*> classifiers_vector;

  // ================================================================ //
  // ||                        Training Step                       || //
  // ================================================================ //

    subclass_encoding
      (
      training_samples,
      tmp_training_labels,
      thres,
      criterion_option,
      classifiers_type,
      coding_matrix,
      classifiers_vector,
      classes_created_vector
      );

  // ================================================================ //
  // ||                        Testing Step                        || //
  // ================================================================ //

     // classification error
    double error = 0.0;

    // predictions for each sample
    uvec predictions;

    // confussion matrix
    umat confussion;

    // number of misclassified samples
    u32 n_missed = 0;

    // used to hold the number of missclassified testing samples
    decode
      (
      testing_samples,
      tmp_testing_labels,
      coding_matrix,
      classifiers_vector,
      classes_created_vector,
      decoding_strategy,
      predictions,
      n_missed,
      error,
      confussion
      );

  // if verbose output is activated
  if(verbose == true)
    {
    verbose_output << "* Predictions vs Labels: "
                   << endl << join_rows(predictions, tmp_testing_labels)
                   << endl << endl;
    verbose_output << "* Coding Matrix: " << endl << coding_matrix << endl << endl;

    verbose_output << "* Row    -   Class:" << endl;
    for(u32 i = 0; i < classes_created_vector.size(); i++)
      {
      verbose_output << "   " << i + 1 << "     -     "
                     << classes_created_vector[i].ClassLabel() << endl;
      }

    verbose_output << endl;


    verbose_output << "* Confusion Matrix: " << endl << confussion << endl;
    }

  // clean up classifiers vector
  for(u32 i = 0; i < classifiers_vector.size(); i++)
    {
    delete classifiers_vector[i];
    }

  // stop timer
  execution_time = timer.toc();

  // reset class counter
  ClassData::globalIndex = 0;

  // return number of misclassified samples
  return n_missed;
  }