fn_one_vs_one.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
one_vs_one
  (
  const mat& training_samples,
  const icolvec& training_labels,
  const mat& testing_samples,
  const icolvec& testing_labels,
  const int decoding_strategy,
  const int classifiers_type,
  const bool verbose,
  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;

  // vector to hold number of samples per class
  ucolvec n_samples_per_class;

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

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

  // decompose the training samples matrix into ClassData object
  vector<ClassData> classes_vector =
    create_class_vector
      (
      training_samples,
      conv_to<icolvec>::from(tmp_training_labels)
      );

  // declare empty classifiers vector
  // vector<Classifier*> classifiers_vector;

  // allocate error correcting output codes matrix
  imat coding_matrix = zeros<imat>
                         (
                         n_classes,
                         (n_classes * (n_classes - 1)) / 2
                         );

  // classifiers vector
  vector<Classifier*> classifiers_vector;

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

    // auxuliary column counter
    u32 k = 0;

    // start training of (K * (K - 1) / 2) classifiers, where K = number
    // of classes
    for(u32 i = 0; i < n_classes; i++)
      {
      for(u32 j = i+1; j < n_classes; j++)
        {
        switch(classifiers_type)
          {
          // Nearest Class Centroid Classifier
          case NCC:
            {
            Classifier_ncc* tmp = new Classifier_ncc
                                        (
                                        classes_vector[i].Data(),
                                        classes_vector[j].Data()
                                        );

            // update classifier's class objects
            tmp->pos.push_back(&(classes_vector[i]));
            tmp->neg.push_back(&(classes_vector[j]));

            // update classifier's number of possitive and negative
            // samples
            tmp->n_pos = classes_vector[i].Samples();
            tmp->n_neg = classes_vector[j].Samples();

            // store classifier
            classifiers_vector.push_back(tmp);

            break;
            }

          // Fisher Linear Discriminant followed by NCC
          case FLDA:
            {
            Classifier_flda* tmp = new Classifier_flda
                                        (
                                        classes_vector[i].Data(),
                                        classes_vector[j].Data()
                                        );

            // update classifier's class objects
            tmp->pos.push_back(&(classes_vector[i]));
            tmp->neg.push_back(&(classes_vector[j]));

            // update classifier's number of possitive and negative
            // samples
            tmp->n_pos = classes_vector[i].Samples();
            tmp->n_neg = classes_vector[j].Samples();

            // store classifier
            classifiers_vector.push_back(tmp);

            break;
            }

          // Support Vector Machine Classifier
          case SVM:
            {
            Classifier_svm* tmp = new Classifier_svm
                                        (
                                        classes_vector[i].Data(),
                                        classes_vector[j].Data()
                                        );

            // update classifier's class objects
            tmp->pos.push_back(&(classes_vector[i]));
            tmp->neg.push_back(&(classes_vector[j]));

            // update classifier's number of possitive and negative
            // samples
            tmp->n_pos = classes_vector[i].Samples();
            tmp->n_neg = classes_vector[j].Samples();

            // store classifier
            classifiers_vector.push_back(tmp);

            break;
            }

          // AdaBoost Classifier
          case ADABOOST:
            {
            Classifier_adaBoost* tmp = new Classifier_adaBoost
                                             (
                                             classes_vector[i].Data(),
                                             classes_vector[j].Data()
                                             );

            // update classifier's class objects
            tmp->pos.push_back(&(classes_vector[i]));
            tmp->neg.push_back(&(classes_vector[j]));

            // update classifier's number of possitive and negative
            // samples
            tmp->n_pos = classes_vector[i].Samples();
            tmp->n_neg = classes_vector[j].Samples();

            // store classifier
            classifiers_vector.push_back(tmp);

            break;
            }

          // Sum of Error Squares Classifier
          case LEAST_SQUARES:
            {
            Classifier_ls* tmp = new Classifier_ls
                                       (
                                        classes_vector[i].Data(),
                                        classes_vector[j].Data()
                                       );

            // update classifier's class objects
            tmp->pos.push_back(&(classes_vector[i]));
            tmp->neg.push_back(&(classes_vector[j]));

            // update classifier's number of possitive and negative
            // samples
            tmp->n_pos = classes_vector[i].Samples();
            tmp->n_neg = classes_vector[j].Samples();

            // store classifier
            classifiers_vector.push_back(tmp);

            break;
            }

          // Custom Classifier
          case CUSTOM_CLASSIFIER:
            {
            Classifier_custom* tmp = new Classifier_custom
                                           (
                                           classes_vector[i].Data(),
                                           classes_vector[j].Data()
                                           );

            // update classifier's class objects
            tmp->pos.push_back(&(classes_vector[i]));
            tmp->neg.push_back(&(classes_vector[j]));

            // update classifier's number of possitive and negative
            // samples
            tmp->n_pos = classes_vector[i].Samples();
            tmp->n_neg = classes_vector[j].Samples();

            // store classifier
            classifiers_vector.push_back(tmp);

            break;
            }

          default:
            {
            arma_debug_print("one_vs_one(): Unknown classifier's option");
            }

          }

        // update ECOC matrix in order to create 1 vs 1 configuration
        coding_matrix(i, k) =   1;
        coding_matrix(j, k) =  -1;

        // increase ECOC matrix column counter
        k++;
        }

      }

  // ================================================================ //
  // ||                        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_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 << "* 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;
  }