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





u32
linear_loss_weighted_decoding
  (
  const vector<Classifier*>& classifiers_vector,
  const vector<ClassData>& classes_vector,
  const imat& ecoc_matrix,
  const mat& test_set_samples,
  const uvec& test_set_labels,
  uvec& results,
  umat& confussion
  )
  {
  #ifdef NCURSES_OUTPUT
  // print status header
  mvaddstr(3, 0, "Computing decoding:");
  refresh();
  #endif

  // number of test set samples
  const u32 test_set_size = test_set_samples.n_rows;

  // number of misclasified test samples
  u32 error = 0;

  // allocate memory for hypothesis matrix
  mat hypothesis_matrix = zeros<mat>
                            (
                            ecoc_matrix.n_rows,
                            ecoc_matrix.n_cols
                            );

  // allocate memory for matrix that stores the results of the
  // classification procedure
  results = zeros<uvec>(test_set_size);

  // for each classifier
  for(u32 j = 0; j < classifiers_vector.size(); j++)
    {
    // for each subclass
    for(u32 i = 0; i < classes_vector.size(); i++)
      {
      // temporary sum
      double tmp_sum = 0.0;

      int sign;

      // for each sample in subclass i evaluate the classifier j
      for(u32 k = 0; k < classes_vector[i].Samples(); k++)
        {
        (
        classifiers_vector[j]->predict
                                (
                                classes_vector[i].Data().row(k)
                                ) < 0
        )
        ?
        sign = -1
        :
        sign = +1;

        if(sign == ecoc_matrix(i, j))
          {
          tmp_sum += 1;
          }

        }

      // assign to H(i,j) the sum divided by the number of samples in
      // subclass i
      hypothesis_matrix(i, j) =
        tmp_sum / double(classes_vector[i].Samples());
      }

    }

  // allocate memory for the weighted matrix
  // which is the normalization of the hpothesis matrix
  mat weighted_matrix = zeros<mat>
                          (
                          hypothesis_matrix.n_rows,
                          hypothesis_matrix.n_cols
                          );

  // column vector that holds the sum of each row of the hypothesis
  // matrix
  colvec tmp_sum = sum(hypothesis_matrix, 1);

  // normalize the rows of the hypothesis matrix and assign the results
  // in the corresponding index of the weighted matrix
  for(u32 i = 0; i < weighted_matrix.n_rows; i++)
    {

    if(tmp_sum[i] != 0.0)
      {
      for(u32 j = 0; j < weighted_matrix.n_cols; j++)
        {
        // divide each item of the hypothesis matrix
        // by the sum of the corresponding row
        weighted_matrix(i, j) = hypothesis_matrix(i, j) / tmp_sum[i];
        }

      }
    else
      {
      weighted_matrix.row(i).fill(0.0);
      }

    #ifdef NCURSES_OUTPUT
    // print spin chars
    mvaddch(3, 20, spin_chars[i & 3]);
    refresh();
    #endif
    }

  // allocate memory for the distances between the test_set samples and
  // each subclass
  mat distance = zeros<mat>(classes_vector.size(), test_set_size);

  // calculate the distance of each test_set sample from each subclass
  for(u32 s = 0; s < test_set_size; s++)
    {
    // initialize to maximum
    double m = numeric_limits<double>::max();

    // initialize to zero
    u32 index = 0;

    for(u32 i = 0; i < classes_vector.size(); i++)
      {
      double tmp_sum = 0.0;

      for(u32 j = 0; j < classifiers_vector.size(); j++)
        {
        double sign = 0.0;

        (
        classifiers_vector[j]->predict
                                (
                                test_set_samples.row(s)
                                ) < 0
        )
        ?
        sign = -1
        :
        sign = +1;

        // loss weighted decoding assignment
        tmp_sum +=
          (-1.0) * ecoc_matrix(i, j) * sign * weighted_matrix(i, j);
        }

      // distance of test_set sample s from subclass i
      distance(i, s) = tmp_sum;

      if(m > distance(i, s))
        {
        m = distance(i, s);
        index = i;
        }

      }

    // assign to the test_set sample i the class that it belongs after
    // the end of the procedure
    results[s] = classes_vector[index].ClassLabel();

    if(results[s] != test_set_labels[s])
      {
      error++;
      }

    confussion(results[s] - 1, test_set_labels[s] - 1)++;

    #ifdef NCURSES_OUTPUT
    // print spin chars
    mvaddch(3, 20, spin_chars[s & 3]);
    refresh();
    #endif
    }

  return error;
  }




u32
exponential_loss_weighted_decoding
  (
  const vector<Classifier*>& classifiers_vector,
  const vector<ClassData>& classes_vector,
  const imat& ecoc_matrix,
  const mat& test_set_samples,
  const uvec& test_set_labels,
  uvec& results,
  umat& confussion
  )
  {
  #ifdef NCURSES_OUTPUT
  // print status header
  mvaddstr(3, 0, "Computing decoding:");
  refresh();
  #endif

  // number of test set samples
  const u32 test_set_size = test_set_samples.n_rows;

  // number of misclasified test samples
  u32 error = 0;

  // allocate memory for hypothesis matrix
  mat hypothesis_matrix = zeros<mat>
                            (
                            ecoc_matrix.n_rows,
                            ecoc_matrix.n_cols
                            );

  // allocate memory for matrix that stores the results of the
  // classification procedure
  results = zeros<uvec>(test_set_size);

  // for each classifier
  for(u32 j = 0; j < classifiers_vector.size(); j++)
    {
    // for each subclass
    for(u32 i = 0; i < classes_vector.size(); i++)
      {
      // temporary sum
      double tmp_sum = 0.0;

      int sign;

      // for each sample in subclass i evaluate the classifier j
      for(u32 k = 0; k < classes_vector[i].Samples(); k++)
        {
        (
        classifiers_vector[j]->predict
                                (
                                classes_vector[i].Data().row(k)
                                ) < 0
        )
        ?
        sign = -1
        :
        sign = +1;

        if(sign == ecoc_matrix(i, j))
          {
          tmp_sum += 1;
          }

        }

      // assign to H(i,j) the sum divided by the number of samples in
      // subclass i
      hypothesis_matrix(i, j) =
        tmp_sum / double(classes_vector[i].Samples());
      }

    }

  // allocate memory for the weighted matrix
  // which is the normalization of the hpothesis matrix
  mat weighted_matrix = zeros<mat>
                          (
                          hypothesis_matrix.n_rows,
                          hypothesis_matrix.n_cols
                          );

  // column vector that holds the sum of each row of the hypothesis
  // matrix
  colvec tmp_sum = sum(hypothesis_matrix, 1);

  // normalize the rows of the hypothesis matrix and assign the results
  // in the corresponding index of the weighted matrix
  for(u32 i = 0; i < weighted_matrix.n_rows; i++)
    {

    if(tmp_sum[i] != 0.0)
      {
      for(u32 j = 0; j < weighted_matrix.n_cols; j++)
        {
        // divide each item of the hypothesis matrix
        // by the sum of the corresponding row
        weighted_matrix(i, j) = hypothesis_matrix(i, j) / tmp_sum[i];
        }

      }
    else
      {
      weighted_matrix.row(i).fill(0.0);
      }

    #ifdef NCURSES_OUTPUT
    // print spin chars
    mvaddch(3, 20, spin_chars[i & 3]);
    refresh();
    #endif
    }

  // allocate memory for the distances between the test_set samples and
  // each subclass
  mat distance = zeros<mat>(classes_vector.size(), test_set_size);

  // calculate the distance of each test_set sample from each subclass
  for(u32 s = 0; s < test_set_size; s++)
    {
    // initialize to maximum
    double m = numeric_limits<double>::max();

    // initialize to zero
    u32 index = 0;

    for(u32 i = 0; i < classes_vector.size(); i++)
      {
      double tmp_sum = 0.0;

      for(u32 j = 0; j < classifiers_vector.size(); j++)
        {
        double sign = 0.0;

        (
        classifiers_vector[j]->predict
                                (
                                test_set_samples.row(s)
                                ) < 0
        )
        ?
        sign = -1
        :
        sign = +1;

        // loss weighted decoding assignment
        tmp_sum +=
          exp((-1.0) * ecoc_matrix(i, j) * sign * weighted_matrix(i, j));
        }

      // distance of test_set sample s from subclass i
      distance(i, s) = tmp_sum;

      if(m > distance(i, s))
        {
        m = distance(i, s);
        index = i;
        }

      }

    // assign to the test_set sample i the class that it belongs after
    // the end of the procedure
    results[s] = classes_vector[index].ClassLabel();

    if(results[s] != test_set_labels[s])
      {
      error++;
      }

    confussion(results[s] - 1, test_set_labels[s] - 1)++;

    #ifdef NCURSES_OUTPUT
    // print spin chars
    mvaddch(3, 20, spin_chars[s & 3]);
    refresh();
    #endif
    }

  return error;
  }