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




double
custom_metric
  (
  rowvec test_code,
  rowvec class_code
  )
  {
// ================================================================== //
// ||                  DECLARATIONS - INITIALIZATION               || //
// ================================================================== //

  // output distance -- initialize
  double distance = 0.0;

  // ========== UNCOMMENT PIECE OF CODE IF NECESSARY ========== //
  // - size of codewords                                        //
  // ========================================================== //

    // %% UNCOMMENT BEGINNING %%
      // const unisigned int d = class_code.n_cols;
    // %% UNCOMMENT END %%

// ================================================================== //
// || INFO: If you want to use the raw C++ pointer to 1D arrays of || //
// ||       type "double*" or "unsigned int*" you have to uncomment|| //
// ||       the pieces of code below.                              || //
// ||                                                              || //
// ||       - The memptr() member function is used to obtain a     || //
// ||         raw pointer to the memory used for storing           || //
// ||         elements.                                            || //
// ||                                                              || //
// ||       - As soon as the size of the matrix/vector is          || //
// ||         changed, the pointer is no longer valid.             || //
// ||                                                              || //
// ||       - Data for matrices is stored in a column-by-column    || //
// ||         order.                                               || //
// ================================================================== //

    // ========== UNCOMMENT PIECE OF CODE IF NECESSARY ========== //
    // - Raw pointer to test codeword array                       //
    // ========================================================== //

      // %% UNCOMMENT BEGINNING %%
        // double* test_mem = test_code.memptr();
      // %% UNCOMMENT END %%

    // ========== UNCOMMENT PIECE OF CODE IF NECESSARY ========== //
    // - Raw pointer to class codeword array                      //
    // ========================================================== //

      // %% UNCOMMENT BEGINNING %%
        // double* class_mem = class_code.memptr();
      // %% UNCOMMENT END %%

// ================================================================== //
// ||                   START YOUR CODE HERE                       || //
// ================================================================== //


// ================================================================== //
// ||                     END YOUR CODE HERE                       || //
// ================================================================== //

  // return computed distance
  return distance;
  }



u32
custom_decoding
  (
  const vector<Classifier*>& classifiers_vector,
  const vector<ClassData>& classes_vector,
  const imat& coding_matrix,
  const mat& test_samples,
  const ucolvec& test_set_labels,
  uvec& predictions,
  umat& confussion
  )
  {
  #ifdef NCURSES_OUTPUT
  // print status header
  mvaddstr(3, 0, "Computing Custom Decoding:");
  refresh();
  #endif

// ================================================================== //
// ||                  DECLARATIONS - INITIALIZATION               || //
// ================================================================== //

  // number of test set samples
  const u32 n_test_samples = test_samples.n_rows;

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

  // number of classes -- subclasses
  const u32 n_classes = classes_vector.size();

  // number of missclassified test samples -- initialization
  u32 n_missed = 0;

  // test samples codewords matrix -- initialization, allocation
  mat test_codes = zeros<mat>(n_test_samples, n_classifiers);

// ================================================================== //
// ||            CONSTRUCT TEST SAMPLES CODEWORD MATRIX            || //
// ================================================================== //

  // iterate through test samples
  for(u32 i = 0; i < n_test_samples; i++)
    {

    // ============================================================== //
    // ||           CONSTRUCT i-TH TEST SAMPLE CODEWORD            || //
    // ============================================================== //

    // iterate through vector of available classifiers and compute
    // prediction of each classifier for current i-th test sample
    for(u32 j = 0; j < n_classifiers; j++)
      {
      // assign prediction value of j-th classifier for i-th
      // test feature vector
      test_codes(i,j) =
        classifiers_vector[j]->predict(test_samples.row(i));
      }

    // ============================================================== //
    // ||    DECODE CREATED CODEWORD AND ASSIGN PREDICTION LABEL   || //
    // ============================================================== //

    // winning coding matrix row -- initialize to first class
    u32 winner = 1;

    // winning distance -- initialize to first class
    double win_dist =
      custom_metric
        (
        test_codes.row(i),
        conv_to<rowvec>::from(coding_matrix.row(0))
        );

    // iterate through coding matrix to find the closest class codeword
    // i.e., the closest row of the coding matrix for current i-th
    // test sample previously created codeword for rest of coding matrix
    // rows
    for(u32 j = 1; j < n_classes; j++)
      {
      // compute current distance -- according to user difined metric
      double tmp_dist =
        custom_metric
          (
          test_codes.row(i),
          conv_to<rowvec>::from(coding_matrix.row(j))
          );

        // update best distance and winning row index if necessary
        if(tmp_dist < win_dist)
          {
          win_dist = tmp_dist;
          winner = j + 1;
          }
        else
          {
          // in ties random assignment for unbiased estimation
          if(tmp_dist == win_dist)
            {
            if((time(NULL) % 2) == 0)
              {
              win_dist = tmp_dist;
              winner = j + 1;
              }

            }

          }

    }

    predictions[i] = winner;

    // if current test sample missclassified increase missclassified
    // counter
    if(winner != classes_vector[test_set_labels[i] - 1].ClassLabel())
      {
      n_missed++;
      }

    confussion
      (
      classes_vector[winner - 1].ClassLabel(),
      classes_vector[test_set_labels[i] - 1].ClassLabel()
      )++;

    }

  return n_missed;
  }