fn_one_vs_all.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_all
  (
  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;

  // 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)
    );

  // allocate error correcting output codes matrix
  imat coding_matrix = -ones<imat>(n_classes, n_classes);

  // classifiers vector
  vector<Classifier*> classifiers_vector;

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

    // auxuliary column counter
    u32 k = 0;

    // iterate through number of classes
    for(u32 i = 0; i < n_classes; i++)
      {
      // negative classes data matrix
      mat X_neg;

      // negative classes vector
      vector<ClassData*> neg_classes;

      // number of negative examples
      u32 n_neg = 0;

      // iterate through classes to construct X_neg
      for(u32 j = 0; j < n_classes; j++)
        {
        // if class is considered negative
        if(j != i)
          {
          // append samples of current class to the of X_neg
          X_neg = join_cols(X_neg, classes_vector[j].Data());

          // store pointer to current class to temporary vector
          neg_classes.push_back(&(classes_vector[j]));

          // increase negative samples temporary counter
          n_neg += classes_vector[j].Samples();
          }

        }

      // create and store specific classifier
      switch(classifiers_type)
        {
        // Nearest Class Centroid Classifier
        case NCC:
          {
          Classifier_ncc* tmp = new Classifier_ncc
                                      (
                                      classes_vector[i].Data(),
                                      X_neg
                                      );

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

          // update classifier's negative classes
          tmp->neg = neg_classes;

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

          // update classifier's number of negative samples
          tmp->n_neg = n_neg;

          // 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(),
                                       X_neg
                                       );

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

          // update classifier's negative classes
          tmp->neg = neg_classes;

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

          // update classifier's number of negative samples
          tmp->n_neg = n_neg;

          // store classifier
          classifiers_vector.push_back(tmp);

          break;
          }

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

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

          // update classifier's negative classes
          tmp->neg = neg_classes;

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

          // update classifier's number of negative samples
          tmp->n_neg = n_neg;

          // store classifier
          classifiers_vector.push_back(tmp);

          break;
          }

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

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

          // update classifier's negative classes
          tmp->neg = neg_classes;

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

          // update classifier's number of negative samples
          tmp->n_neg = n_neg;

          // 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(),
                                     X_neg
                                     );

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

          // update classifier's negative classes
          tmp->neg = neg_classes;

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

          // update classifier's number of negative samples
          tmp->n_neg = n_neg;

          // store classifier
          classifiers_vector.push_back(tmp);

          break;
          }

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

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

          // update classifier's negative classes
          tmp->neg = neg_classes;

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

          // update classifier's number of negative samples
          tmp->n_neg = n_neg;

          // store classifier
          classifiers_vector.push_back(tmp);

          break;
          }

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

        }

      // update ECOC matrix in order to create 1 vs all configuration
      coding_matrix(i, 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)
    {
    predictions = join_rows(predictions, tmp_testing_labels);
    verbose_output << "* Predictions vs Labels: " << endl << predictions << 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;
  }