fn_ecoc_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)




void
one_vs_all_ecocone
  (
  vector<ClassData>& classes_vector,
  const int classifiers_type,
  imat& coding_matrix,
  vector<Classifier*>& classifiers_vector
  )
  {
  // number of classes
  u32 n_classes = classes_vector.size();

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

  // ================================================================ //
  // ||                        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_ecocone(): 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++;
      }

  }



void
one_vs_one_ecocone
  (
  vector<ClassData>& classes_vector,
  const int classifiers_type,
  imat& coding_matrix,
  vector<Classifier*>& classifiers_vector
  )
  {
  // variable to hold the number of classes
  u32 n_classes = classes_vector.size();

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

  // ================================================================ //
  // ||                        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_ecocone(): 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++;
        }

      }

  }



void
decoc_ecocone
  (
  vector<ClassData>& classes_vector,
  const int classifiers_type,
  const int criterion_option,
  imat& coding_matrix,
  vector<Classifier*>& classifiers_vector
  )
  {
  // ================================================================ //
  // ||                        Training Step                       || //
  // ================================================================ //

    decoc_coding
      (
      classes_vector,
      criterion_option,
      classifiers_type,
      coding_matrix,
      classifiers_vector
      );

  }



void
subdecoc_ecocone
  (
  vector<ClassData>& classes_vector,
  const int classifiers_type,
  const int criterion_option,
  const Threshold& thres,
  imat& coding_matrix,
  vector<Classifier*>& classifiers_vector
  )
  {
  // number of initial classes
  const u32 n_classes = classes_vector.size();

  // vector that keeps track of splitting
  vector<vec> class_tracker;

  // allocate coding matrix
  coding_matrix = zeros<imat>(n_classes, 2);

  // initialize class_tracker
  for(u32 i = 0; i < n_classes; i++)
    {
    vec temp = zeros<vec>(1);
    temp[0] = classes_vector[i].ClassIndex();
    class_tracker.push_back(temp);
    coding_matrix(i, 0) = i + 1;
    coding_matrix(i, 1) = i + 1;
    }

  // problem tracker vector -- used to store problem examined so far
  // in order to prune the unnecessary recursive steps of the
  // direct_subclass_encoding procedure
  vector<uvec> problem_tracker;

  // engage recursive subclass creation procedure
  direct_subclass_encoding
    (
    classes_vector,
    thres,
    criterion_option,
    classifiers_type,
    coding_matrix,
    classifiers_vector,
    classes_vector,
    class_tracker,
    problem_tracker
    );


  // by now the coding matrix is consisted of 2 columns. 1st column
  // represents initial class labels and 2nd colum represents resulting
  // classes indices (if label and index is the same then the initial
  // class didn't split into subclasses, if else the initial class
  // has been split into subclasses).

  // the next step is to use all the available information from the
  // recursive procedure direct_subclass_encoding in order to create the
  // codewords for each of the created classes (note: a class that has
  // been split into subclasses will be represented by as many codewords
  // in the coding matrix as the the number of its created subclasses)

  // create a temporary matrix to hold the codewords as well as the
  // class labels and indices (i.e., the first two rows of temp will be
  // the coding matrix so far)
  imat temp = zeros<imat>
                (
                coding_matrix.n_rows,
                coding_matrix.n_cols + classifiers_vector.size()
                );

  temp.cols(0, 1) = coding_matrix;

  // number of classifiers created
  const u32 n_classifiers = classifiers_vector.size();

  // number of encoding matrix rows
  const u32 n_rows = coding_matrix.n_rows;

  // for each classifier
  for(u32 i = 0; i < n_classifiers; i++)
    {
    // find the subclasses that the classifier recognizes and update the
    // corresponding column of the coding matrix with +1 or -1 according
    // to which set the subclass is contained (minus or plus subclass
    // set of classifier)

    // number of classes marked with +1 in current classifier
    const u32 n_plus_classes = classifiers_vector[i]->pos.size();

    // for plus subclasses
    for(u32 j = 0; j < n_plus_classes; j++)
      {

      // for each row of coding matrix
      for(u32 k = 0; k < n_rows; k++)
        {

        for
          (
          u32 l = 0;
          l < class_tracker[classifiers_vector[i]->pos[j]->ClassIndex() - 1].n_rows;
          l++
          )
          {
          // check if the subclass in the corresponding position of
          // class_tracker contains to the classifier
          if(
            class_tracker[classifiers_vector[i]->pos[j]->ClassIndex() - 1](l) ==
            coding_matrix(k, 1)
            )
            {
            temp(k, i + 2) = 1;
            }

          }

        }

      }

    // number of classes marked with -1 in current classifier
    const u32 n_minus_classes = classifiers_vector[i]->neg.size();

    // for minus subclasses
    for(u32 j = 0; j < n_minus_classes; j++)
      {

      // for each row of coding matrix
      for(u32 k = 0; k < n_rows; k++)
        {

        for
          (
          u32 l = 0;
          l < class_tracker[classifiers_vector[i]->neg[j]->ClassIndex() - 1].n_rows;
          l++
          )
          {

          // check if the subclass in the corresponding position of
          // class_tracker is contained in the classifier
          if(
            class_tracker[classifiers_vector[i]->neg[j]->ClassIndex() - 1](l) ==
            coding_matrix(k, 1)
            )
            {
            temp(k, i + 2) = -1;
            }

          }

        }

      }

    }

  // final coding matrix
  // each column represents a classifier
  // each row represents a codeword
  coding_matrix = temp.cols(2, temp.n_cols - 1);
  }



void
dense_random_ecocone
  (
  vector<ClassData>& classes_vector,
  const int classifiers_type,
  const u32 n_matrices,
  const u32 n_desired_classifiers,
  imat& coding_matrix,
  vector<Classifier*>& classifiers_vector
  )
  {
  // variable to hold the number of classes
  const u32 n_classes = classes_vector.size();

  // compute coding matrix for dense random ecoc design
  coding_matrix = create_dense_random_matrix
                    (
                    n_classes,
                    n_desired_classifiers,
                    n_matrices
                    );

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

    // start training
    for(u32 i = 0; i < coding_matrix.n_cols; i++)
      {
      // data matrix of positive classes for current column of coding
      // matrix
      mat first_bipartition;

      // data matrix of positive classes for current column of coding
      // matrix
      mat second_bipartition;

      // temporary vector to store pointers of positive classes
      vector<ClassData*> pos_classes;

      // temporary vector to store pointers of negative classes
      vector<ClassData*> neg_classes;

      // temporary number of possitive samples
      u32 n_pos = 0;

      // temporary number of negative samples
      u32 n_neg = 0;

      // iterate through number of classes
      for(u32 j = 0; j < n_classes; j++)
        {
        // if current class is considered positive
        if(coding_matrix(j, i) == 1)
          {
          // append samples of current class to the positive classes data
          // matrix
          first_bipartition = join_cols
                                (
                                first_bipartition,
                                classes_vector[j].Data()
                                );

          // add pointer of current class to temporary vector of positive
          // classes
          pos_classes.push_back(&(classes_vector[j]));

          // update number of positive samples
          n_pos += classes_vector[j].Samples();
          }
        else
          {
          // append samples of current class to the negative classe data
          // matrix
          second_bipartition = join_cols
                                 (
                                 second_bipartition,
                                 classes_vector[j].Data()
                                 );

          // add pointer of current class to temporary vector of
          // negative classes
          neg_classes.push_back(&(classes_vector[j]));

          // update number of positive samples
          n_neg += classes_vector[j].Samples();
          }

        }

      // according to user specified classifier
      switch(classifiers_type)
        {
        // Nearest Class Centroid Classifier
        case NCC:
          {
          Classifier_ncc* tmp = new Classifier_ncc
                                      (
                                      first_bipartition,
                                      second_bipartition
                                      );

          // update classifier classes
          tmp->pos = pos_classes;
          tmp->neg = neg_classes;
          tmp->n_pos = n_pos;
          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
                                       (
                                       first_bipartition,
                                       second_bipartition
                                       );

          // update classifier classes
          tmp->pos = pos_classes;
          tmp->neg = neg_classes;
          tmp->n_pos = n_pos;
          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
                                      (
                                      first_bipartition,
                                      second_bipartition
                                      );

          // update classifier classes
          tmp->pos = pos_classes;
          tmp->neg = neg_classes;
          tmp->n_pos = n_pos;
          tmp->n_neg = n_neg;

          // store classifier
          classifiers_vector.push_back(tmp);

          break;
          }

        // AdaBoost Classifier
        case ADABOOST:
          {
          Classifier_adaBoost* tmp = new Classifier_adaBoost
                                           (
                                           first_bipartition,
                                           second_bipartition
                                           );

          // update classifier classes
          tmp->pos = pos_classes;
          tmp->neg = neg_classes;
          tmp->n_pos = n_pos;
          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
                                     (
                                     first_bipartition,
                                     second_bipartition
                                     );

          // update classifier classes
          tmp->pos = pos_classes;
          tmp->neg = neg_classes;
          tmp->n_pos = n_pos;
          tmp->n_neg = n_neg;

          // store classifier
          classifiers_vector.push_back(tmp);

          break;
          }

        // Custom Classifier
        case CUSTOM_CLASSIFIER:
          {
          Classifier_custom* tmp = new Classifier_custom
                                         (
                                         first_bipartition,
                                         second_bipartition
                                         );

          // update classifier classes
          tmp->pos = pos_classes;
          tmp->neg = neg_classes;
          tmp->n_pos = n_pos;
          tmp->n_neg = n_neg;

          // store classifier
          classifiers_vector.push_back(tmp);

          break;
          }

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

          }

        }

      }

  }



void
sparse_random_ecocone
  (
  vector<ClassData>& classes_vector,
  const int classifiers_type,
  const u32 n_matrices,
  const u32 n_desired_classifiers,
  imat& coding_matrix,
  vector<Classifier*>& classifiers_vector
  )
  {
  // variable to hold the number of classes
  const u32 n_classes = classes_vector.size();

  // compute coding matrix for sparse random ecoc design
  coding_matrix = create_sparse_random_matrix
                    (
                    n_classes,
                    n_desired_classifiers,
                    n_matrices
                    );

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

    // start training
    for(u32 i = 0; i < coding_matrix.n_cols; i++)
      {
      // data matrix of positive classes for current column of coding
      // matrix
      mat first_bipartition;

      // data matrix of positive classes for current column of coding
      // matrix
      mat second_bipartition;

      // temporary vector to store pointers of positive classes
      vector<ClassData*> pos_classes;

      // temporary vector to store pointers of negative classes
      vector<ClassData*> neg_classes;

      // temporary number of possitive samples
      u32 n_pos = 0;

      // temporary number of negative samples
      u32 n_neg = 0;

      // iterate through number of classes
      for(u32 j = 0; j < n_classes; j++)
        {
        // if current class is considered positive
        if(coding_matrix(j, i) == 1)
          {
          // append samples of current class to the positive classes
          // data matrix
          first_bipartition = join_cols
                                (
                                first_bipartition,
                                classes_vector[j].Data()
                                );

          // add pointer of current class to temporary vector of
          // positive classes
          pos_classes.push_back(&(classes_vector[j]));

          // update number of positive samples
          n_pos += classes_vector[j].Samples();
          }
        else
          {
          // if current class is considered negative
          if(coding_matrix(j, i) == -1)
            {
            // append samples of current class to the negative classe
            // data matrix
            second_bipartition = join_cols
                                   (
                                   second_bipartition,
                                   classes_vector[j].Data()
                                   );

            // add pointer of current class to temporary vector of
            // negative classes
            neg_classes.push_back(&(classes_vector[j]));

            // update number of positive samples
            n_neg += classes_vector[j].Samples();
            }

          // otherwise current class is not considered

          }

        }

      // according to user specified classifier
      switch(classifiers_type)
        {
         // Nearest Class Centroid Classifier
        case NCC:
          {
          Classifier_ncc* tmp = new Classifier_ncc
                                      (
                                      first_bipartition,
                                      second_bipartition
                                      );

          // update classifier classes
          tmp->pos = pos_classes;
          tmp->neg = neg_classes;
          tmp->n_pos = n_pos;
          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
                                       (
                                       first_bipartition,
                                       second_bipartition
                                       );

          // update classifier classes
          tmp->pos = pos_classes;
          tmp->neg = neg_classes;
          tmp->n_pos = n_pos;
          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
                                      (
                                      first_bipartition,
                                      second_bipartition
                                      );

          // update classifier classes
          tmp->pos = pos_classes;
          tmp->neg = neg_classes;
          tmp->n_pos = n_pos;
          tmp->n_neg = n_neg;

          // store classifier
          classifiers_vector.push_back(tmp);

          break;
          }

        // AdaBoost Classifier
        case ADABOOST:
          {
          Classifier_adaBoost* tmp = new Classifier_adaBoost
                                           (
                                           first_bipartition,
                                           second_bipartition
                                           );

          // update classifier classes
          tmp->pos = pos_classes;
          tmp->neg = neg_classes;
          tmp->n_pos = n_pos;
          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
                                     (
                                     first_bipartition,
                                     second_bipartition
                                     );

          // update classifier classes
          tmp->pos = pos_classes;
          tmp->neg = neg_classes;
          tmp->n_pos = n_pos;
          tmp->n_neg = n_neg;

          // store classifier
          classifiers_vector.push_back(tmp);

          break;
          }

        // Custom Classifier
        case CUSTOM_CLASSIFIER:
          {
          Classifier_custom* tmp = new Classifier_custom
                                         (
                                         first_bipartition,
                                         second_bipartition
                                         );

          // update classifier classes
          tmp->pos = pos_classes;
          tmp->neg = neg_classes;
          tmp->n_pos = n_pos;
          tmp->n_neg = n_neg;

          // store classifier
          classifiers_vector.push_back(tmp);

          break;
          }

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

          }

        }

      }

  }



u32
ecoc_one
  (
  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 u32 n_matrices,
  const u32 n_desired_classifiers,
  const double validation,
  const int init_coding_strategy,
  const int ecocone_mode,
  const u32 max_iter,
  const double epsilon,
  const double wv,
  const bool verbose,
  ofstream& verbose_output,
  double& elapsed_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);

  // create classes vector
  vector<ClassData> classes_vector = create_class_vector
                                       (
                                       training_samples,
                                       tmp_training_labels
                                       );

  // classification error
  double error = 0.0;

  // predictions for each sample
  uvec predictions;

  // confussion matrix
  umat confussion;

  // number of misclassified samples
  u32 n_missed = 0;

  // coding matrix
  imat coding_matrix;

  // classifiers vector
  vector<Classifier*> classifiers_vector;

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

    // ============================================================== //
    // || Step No.1: Construct initial coding.                     || //
    // ============================================================== //

      // according to user entered initial coding strategy
      switch(init_coding_strategy)
        {
        // Discriminant Error Correcting Output Coding
        case DECOC:
          {
          decoc_ecocone
            (
            classes_vector,
            classifiers_type,
            criterion_option,
            coding_matrix,
            classifiers_vector
            );

          break;
          }

        // Discriminant Error Correcting Output Coding with subclasses
        case SUBDECOC:
          {
          subdecoc_ecocone
            (
            classes_vector,
            classifiers_type,
            criterion_option,
            thres,
            coding_matrix,
            classifiers_vector
            );

          break;
          }

        // One versus One, or All Pairs Coding
        case ONE_VS_ONE:
          {
          one_vs_one_ecocone
            (
            classes_vector,
            classifiers_type,
            coding_matrix,
            classifiers_vector
            );

          break;
          }

        // One versus All, or One Against All Coding
        case ONE_VS_ALL:
          {

          one_vs_all_ecocone
            (
            classes_vector,
            classifiers_type,
            coding_matrix,
            classifiers_vector
            );

          break;
          }

        // Dense Random Coding
        case DENSE_RANDOM:
          {
          dense_random_ecocone
            (
            classes_vector,
            classifiers_type,
            n_matrices,
            n_desired_classifiers,
            coding_matrix,
            classifiers_vector
            );

          break;
          }

        // Sparse Random Coding
        case SPARSE_RANDOM:
          {
          sparse_random_ecocone
            (
            classes_vector,
            classifiers_type,
            n_matrices,
            n_desired_classifiers,
            coding_matrix,
            classifiers_vector
            );

          break;
          }

        // User Custom Coding
        case CUSTOM_CODING:
          {

          break;
          }

        }


    // ============================================================== //
    // || Step No.2: Construct inner training and validation sets. || //
    // ============================================================== //

      // 2D matrix of inner training set
      mat St;

      // vector of class labels of inner training set
      uvec lt;

      // 2D matrix of the inner validation set
      mat Sv;

      // vector of class labels of inner validation set
      uvec lv;

      // iterate through training class objects data matrices
      for(u32 i = 0; i < n_classes; i++)
        {
        // temporary shuffled data matrix of current class
        // shuffle in order to avoid biased estimations
        mat tmp = shuffle(classes_vector[i].Data());

        // number of samples for inner training set
        const u32 n_train =
          floor(classes_vector[i].Samples() * (1.0 - validation));

        // append selected number of samples of current class to
        // training and validation set respectively
        St = join_cols(St, tmp.rows(0, n_train - 1));
        Sv = join_cols(Sv, tmp.rows(n_train, tmp.n_rows - 1));

        // update respective label vectors
        lt = join_cols(lt, (i + 1) * ones<uvec>(n_train));
        lv = join_cols(lv, (i + 1) * ones<uvec>(tmp.n_rows - n_train));
        }

    // ============================================================== //
    // || Step No.3: Test accuracy on the training and validation  || //
    // ||            sets St and Sv (initialization of error for   || //
    // ||            later while loop).                            || //
    // ============================================================== //

      // accuracy of current coding scheme on inner training set
      double at = 0.0;

      // accuracy of current coding scheme on inner validation set
      double av = 0.0;

      // confusion matrix for inner training set
      umat confussion_t;

      // confusion matrix for inner validation set
      umat confussion_v;

      // compute accuracy for inner training set
      decode
        (
        St,
        lt,
        coding_matrix,
        classifiers_vector,
        classes_vector,
        decoding_strategy,
        predictions,
        n_missed,
        at,
        confussion_t
        );

      // compute accuracy for inner validation set
      decode
        (
        Sv,
        lv,
        coding_matrix,
        classifiers_vector,
        classes_vector,
        decoding_strategy,
        predictions,
        n_missed,
        av,
        confussion_v
        );

      // compute accuracy for inner validation set

      double vw = 0.5;

      // initialize current error
      double error_cur = (vw * av) + ((1.0 - vw) * at);

      // initialize previous error
      double error_prev = 1.0;

      // number of iterations
      u32 iter = 0;

      bool exit_loop = false;

      // loop while conditions are met
      while
        (
        error_cur > epsilon &&
        error_cur < error_prev &&
        iter < max_iter &&
        exit_loop == false
        )
        {
        // select the classes with the highest error and find partition
        confussion = symmatu(confussion_v) + symmatu(confussion_t);

        // make diagonal elements equal to zero
        confussion.diag() = zeros<uvec>(confussion.n_rows);

        // maximum row index
        u32 max_row = 0;

        // maximum column index
        u32 max_col = 0;

        // find maximum element of confusion matrix
        confussion.max(max_row, max_col);

        // put classes in the pool according to ECOCONE mode
        switch(ecocone_mode)
          {
          // consider only a pair of classes in the adding column
          case PAIR:
            {
            // if confussion matrix isn't a zero matrix
            if(max_row != 0 && max_col != 0)
              {
              ivec newcol = zeros<ivec>(coding_matrix.n_rows);

              // add positive class
              newcol[max_row] = 1;

              // add negative class
              newcol[max_col] = -1;

              // check wether a same column already exists
              for(u32 i = 0; i < coding_matrix.n_cols; i++)
                {
                if
                  (
                  coding_matrix.n_rows ==
                  accu(newcol == coding_matrix.col(i)) ||
                  coding_matrix.n_rows ==
                  accu(-newcol == coding_matrix.col(i))
                  )
                  {
                  iter = max_iter;
                  break;
                  }

                }

              // if newly created problem isn't already in the coding
              // matrix
              if(iter < max_iter)
                {
                // update ECOC coding matrix
                coding_matrix = join_rows(coding_matrix, newcol);

                // construct and push classifier to vector of
                // classifiers
                Classifier* tmp_classifier =
                  construct_classifier
                    (
                    classes_vector[max_row].Data(),
                    classes_vector[max_col].Data(),
                    classifiers_type
                    );

                // update classifier's class objects
                tmp_classifier->pos.push_back
                                      (
                                      &(classes_vector[max_row])
                                      );

                tmp_classifier->neg.push_back
                                      (
                                      &(classes_vector[max_col])
                                      );

                // update classifier's number of possitive and negative
                // samples
                tmp_classifier->n_pos =
                  classes_vector[max_row].Samples();

                tmp_classifier->n_neg =
                  classes_vector[max_col].Samples();

                classifiers_vector.push_back(tmp_classifier);
                }

              // compute accuracy for inner training set
              decode
                (
                St,
                lt,
                coding_matrix,
                classifiers_vector,
                classes_vector,
                decoding_strategy,
                predictions,
                n_missed,
                at,
                confussion_t
                );

              // compute accuracy for inner validation set
              decode
                (
                Sv,
                lv,
                coding_matrix,
                classifiers_vector,
                classes_vector,
                decoding_strategy,
                predictions,
                n_missed,
                av,
                confussion_v
                );

              double tmp_error = (vw * av) + ((1.0 - vw) * at);

              // if newly created classifier improves the total error
              if(tmp_error <= error_cur)
                {
                error_prev = error_cur;
                error_cur = tmp_error;
                }
              else
                {
                // delete classifier
                Classifier* tmp_classifier =
                  classifiers_vector[classifiers_vector.size() - 1];

                // extract classifier from classifiers vector
                classifiers_vector.pop_back();

                delete tmp_classifier;

                // remove newly added column
                coding_matrix =
                  coding_matrix.cols(0, coding_matrix.n_cols - 2);

                // exit loop flag is true
                exit_loop = true;
                }

              }

            break;
            }

          // use SFFS to determine the new column of the ECOC matrix
          case ALL_CLASSES:
            {
            // temporary coding columns matrix
            imat tmpcodmat;

            // create vector of the rest classes
            vector<ClassData> rest_classes;

            // vector of temporary classifiers
            vector<Classifier*> cvec;

            // create vector of the rest classes
            vector<ClassData> curclasses;

            // push back classes with highest error
            curclasses.push_back(classes_vector[max_row]);
            curclasses.push_back(classes_vector[max_col]);

            // iterate through classes
            for(u32 i = 0; i < n_classes; i++)
              {
              if(i != max_row && i != max_col)
                {
                rest_classes.push_back(classes_vector[i]);
                }

              }

            // iterate through remaining classes
            for(u32 i = 0; i < rest_classes.size(); i++)
              {
              curclasses.push_back(rest_classes[i]);

              uvec bs = sffs(curclasses, criterion_option);

              // compute complements set's labels
              uvec bsc = complement(bs, curclasses.size());

              ivec tmpcol = zeros<ivec>(n_classes);

              // first bipartion matrix
              mat A;

              // add positive classes
              for(u32 j = 0; j < bs.n_elem; j++)
                {
                tmpcol[curclasses[bs[j]].ClassIndex() - 1] = 1;
                A = join_cols(A, curclasses[bs[j]].Data());
                }

              // second bipartion matrix
              mat B;

              // add negative classes
              for(u32 j = 0; j < bsc.n_elem; j++)
                {
                tmpcol[curclasses[bsc[j]].ClassIndex() - 1] = -1;
                B = join_cols(B, curclasses[bsc[j]].Data());
                }

              bool found = false;

              // check wether a same column already exists
              for(u32 j = 0; j < coding_matrix.n_cols; j++)
                {
                if
                  (
                  coding_matrix.n_rows ==
                  accu(tmpcol == coding_matrix.col(j)) ||
                  coding_matrix.n_rows ==
                  accu(-tmpcol == coding_matrix.col(j))
                  )
                  {
                  found = true;
                  break;
                  }

                }

              if(found == false)
                {
                // construct and push classifier to vector of classifiers
                Classifier* tmp_classifier =
                  construct_classifier(A, B, classifiers_type);

                // update classifier's class objects
                for(u32 j = 0; j < bs.n_elem; j++)
                  {
                  tmp_classifier->pos.push_back
                                        (
                                        &(classes_vector[curclasses[bs[j]].ClassIndex()])
                                        );

                  tmp_classifier->n_pos += curclasses[bs[j]].Samples();
                  }

                // update classifier's class objects
                for(u32 j = 0; j < bsc.n_elem; j++)
                  {
                  tmp_classifier->pos.push_back
                                        (
                                        &(classes_vector[curclasses[bsc[j]].ClassIndex()])
                                        );

                  tmp_classifier->n_neg += curclasses[bsc[j]].Samples();
                  }

                tmpcodmat = join_rows(tmpcodmat, tmpcol);

                // push back classifier
                cvec.push_back(tmp_classifier);
                }

              }

            // if confussion matrix isn't diagonal
            if(max_row != 0 && max_col != 0)
              {
              ivec newcol = zeros<ivec>(coding_matrix.n_rows);

              // add positive class
              newcol[max_row] = 1;

              // add negative class
              newcol[max_col] = -1;

              bool found = false;

              // check wether a same column already exists
              for(u32 i = 0; i < coding_matrix.n_cols; i++)
                {
                if
                  (
                  coding_matrix.n_rows ==
                  accu(newcol == coding_matrix.col(i)) ||
                  coding_matrix.n_rows ==
                  accu(-newcol == coding_matrix.col(i))
                  )
                  {
                  found = true;
                  break;
                  }

                }

              // if newly created problem isn't already in the coding
              // matrix
              if(found == false)
                {
                // update ECOC coding matrix
                tmpcodmat = join_rows(tmpcodmat, newcol);

                // construct and push classifier to vector of
                // classifiers
                Classifier* tmp_classifier =
                  construct_classifier
                    (
                    classes_vector[max_row].Data(),
                    classes_vector[max_col].Data(),
                    classifiers_type
                    );

                // update classifier's class objects
                tmp_classifier->pos.push_back
                                      (
                                      &(classes_vector[max_row])
                                      );

                tmp_classifier->neg.push_back
                                      (
                                      &(classes_vector[max_col])
                                      );

                // update classifier's number of possitive and negative
                // samples
                tmp_classifier->n_pos =
                  classes_vector[max_row].Samples();

                tmp_classifier->n_neg =
                  classes_vector[max_col].Samples();

                cvec.push_back(tmp_classifier);
                }

              }

            // best index
            u32 indx = 0;

            // best error
            double bserror = 100.0;

            // iterate through number of created classifiers
            for(u32 i = 0; i < cvec.size(); i++)
              {
              // temporarily push classifier to classifiers vector
              classifiers_vector.push_back(cvec[i]);

              // temporary confusion matrices
              umat tmpconfussion_t;
              umat tmpconfussion_v;

              // temporary coding matrix
              imat tmpcm = join_rows(coding_matrix, tmpcodmat.col(i));

              // compute accuracy for inner training set
              decode
                (
                St,
                lt,
                tmpcm,
                classifiers_vector,
                classes_vector,
                decoding_strategy,
                predictions,
                n_missed,
                at,
                tmpconfussion_t
                );

              // compute accuracy for inner validation set
              decode
                (
                Sv,
                lv,
                tmpcm,
                classifiers_vector,
                classes_vector,
                decoding_strategy,
                predictions,
                n_missed,
                av,
                tmpconfussion_v
                );

              double tmp_error = (vw * av) + ((1.0 - vw) * at);

              if(tmp_error <= bserror)
                {
                indx = i;
                bserror = tmp_error;
                confussion_v = tmpconfussion_v;
                confussion_t = tmpconfussion_t;
                }

              // remove classifier
              classifiers_vector.pop_back();
              }

            // newly create column and classifier
            for(u32 i = 0; i < cvec.size(); i++)
              {
              if(i == indx)
                {
                if(bserror <= error_cur)
                  {
                  error_prev = error_cur;
                  error_cur = bserror;
                  classifiers_vector.push_back(cvec[i]);
                  coding_matrix = join_rows
                                    (
                                    coding_matrix,
                                    tmpcodmat.col(i)
                                    );
                  }
                else
                  {
                  exit_loop = true;
                  }

                }
              else
                {
                delete cvec[i];
                }

              }

            break;
            }

          // exit with error
          default:
            {
            arma_debug_print
              (
              "ecoc_one(): Unknown ECOC One mode"
              );
            }

          }

        iter++;
        }

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

    // 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
  elapsed_time = timer.toc();

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

  // return number of misclassified samples
  return n_missed;
  }