fn_decode.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
decode
  (
  const mat&                 Xt,
  const uvec&                lt,
  const imat&                coding_matrix,
  const vector<Classifier*>& classifiers_vector,
  const vector<ClassData>&   classes_vector,
  const int                  decoding_option,
        uvec&                predictions,
        u32&                 n_missed,
        double&              error,
        umat&                confussion
  )
  {
  // initialize
  n_missed = 0;
  error = 0.0;

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

  // number of samples
  const u32 n_samples = Xt.n_rows;

  // vector of winning rows of coding matrix for each sample in Xt
  predictions = zeros<uvec>(n_samples);

  // active bins of classes
  uvec bins = zeros<uvec>(coding_matrix.n_rows);

  // find number of initial classes
  for(u32 i = 0; i < classes_vector.size(); i++)
    {
    if(bins[classes_vector[i].ClassLabel() -1] == 0)
      {
      bins[classes_vector[i].ClassLabel() -1] = 1;
      }

    }

  // active classes (i.e,. not subclasses)
  uvec active = find(bins == 1);

  // number of classes
  const u32 n_classes = active.n_elem;

  // allocate confussion matrix
  confussion = zeros<umat>(n_classes, n_classes);

  // count missed samples according to user entered decoding strategy
  switch(decoding_option)
    {
    // Hamming, Euclidean and Laplacian decoding (generally
    // straightforward decoding strategies)
    case HAMMING:
    case EUCLIDEAN:
    case LAPLACIAN:
    case HAMMING_ATTENUATED:
    case EUCLIDEAN_ATTENUATED:
    case LINEAR_LOSS_BASED_DECODING:
    case EXPONENTIAL_LOSS_BASED_DECODING:
    case INVERSE_HAMMING_DECODING:
    case BETA_DENSITY_DECODING:
      {
      // iterate through testing samples
      for(u32 i = 0; i < n_samples; i++)
        {
        // current sample's codeword
        rowvec codeword = zeros<rowvec>(n_classifiers);

        for(u32 j = 0; j < n_classifiers; j++)
          {
          codeword[j] = classifiers_vector[j]->predict(Xt.row(i));
          }

        // used to hold the winning label (i.e., the class which has the
        // closest codeword to current testing sample's codeword)
        predictions[i] = decode_codeword
                           (
                           codeword,
                           coding_matrix,
                           decoding_option
                           );

        // if predicted label is not equal with actual sample's
        // label increase number of misclassified samples
        if(classes_vector[predictions[i] - 1].ClassLabel() != lt[i])
          {
          n_missed++;
          confussion(classes_vector[predictions[i] - 1].ClassLabel() - 1, lt[i] - 1)++;
          }
        else
          {
          confussion(lt[i] -1, lt[i] - 1)++;
          }

        }

      break;
      }

    // Loss Weighted Decoding
    case LINEAR_LOSS_WEIGHTED_DECODING:
      {
      n_missed = linear_loss_weighted_decoding
                   (
                   classifiers_vector,
                   classes_vector,
                   coding_matrix,
                   Xt,
                   lt,
                   predictions,
                   confussion
                   );

      break;
      }

    // Exponential Loss Weighted Decoding
    case EXPONENTIAL_LOSS_WEIGHTED_DECODING:
      {
      n_missed = exponential_loss_weighted_decoding
                   (
                   classifiers_vector,
                   classes_vector,
                   coding_matrix,
                   Xt,
                   lt,
                   predictions,
                   confussion
                   );

      break;
      }

    // Probabilistic Based Decoding
    case PROBABILISTIC_BASED_DECODING:
      {
      n_missed = probabilistic_decoding
                   (
                   classifiers_vector,
                   classes_vector,
                   coding_matrix,
                   Xt,
                   lt,
                   predictions,
                   confussion
                   );

      break;
      }

    // User Custom Decoding
    case CUSTOM_DECODING:
      {
      n_missed = custom_decoding
                   (
                   classifiers_vector,
                   classes_vector,
                   coding_matrix,
                   Xt,
                   lt,
                   predictions,
                   confussion
                   );

    break;
    }

    default:
      {
      arma_debug_print("decode(): Unknown Decoding Option");
      }

    }

  // compute total missclassification error
  error = double(n_missed) / double(n_samples);
  }