confusion_matrix.hpp

#pragma once
 
#include "../_cexports/c_polimago.h"
 
#include "../global.hpp"
#include "classification_test_result.hpp"
 
#include <vector>
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
 
namespace Polimago
{
namespace Testing
{
 
 
class PredictionResult
{
public:
  PredictionResult (const PredictionResult&) = default;
  PredictionResult& operator= (const PredictionResult&) = default;
 
private:
  PredictionResult (const ClassificationTestResult &res, int exampleIndex)
    : exampleIndex_ (exampleIndex), confidence_ (res.ExampleConfidences()[exampleIndex]),
      confidenceDistribution_ (res.ExampleConfidenceDistributions()[exampleIndex])
  {}
  friend class ConfusionMatrix;
 
public:
 
  int ExampleIndex () const noexcept
  {
    return exampleIndex_;
  }
 
 
  double Confidence () const noexcept
  {
    return confidence_;
  }
 
 
  std::vector<double> ConfidenceDistribution () const
  {
    return confidenceDistribution_;
  }
 
private:
  int exampleIndex_;
  double confidence_;
  std::vector<double> confidenceDistribution_;
};
 
 
class ConfusionMatrix
{
public:
 
  ConfusionMatrix (const ClassificationTestResult &res)
  {
    BuildConfusionMatrix (res);
    UpdateVisibleMatrix ();
  }
 
public:
 
  int TotalSamples (int classIndex) const
  {
    auto numClasses = NumClasses ();
    if (classIndex >= numClasses)
    {
      throw std::out_of_range ("class index out of range");
    }
 
    int sum = 0;
    for (decltype(numClasses) c = 0; c < numClasses; ++c)
    {
      sum += static_cast<int>(indexArray_[classIndex][c].size());
    }
    return sum;
  }
 
 
  int TotalSamples () const
  {
    auto numClasses = NumClasses ();
    int retval = 0;
    for (decltype(numClasses) i = 0; i < numClasses; ++i)
    {
      retval += TotalSamples(i);
    }
    return retval;
  }
 
 
  int TotalCorrect (int classIndex) const
  {
    auto numClasses = NumClasses ();
    if (classIndex >= numClasses)
    {
      throw std::out_of_range ("class index out of range");
    }
    return static_cast<int> (At (classIndex, classIndex).size());
  }
 
 
  int TotalCorrect () const
  {
    auto numClasses = NumClasses ();
    int sum = 0;
    for (decltype(numClasses) i = 0; i < numClasses; ++i)
    {
      sum += TotalCorrect (i);
    }
    return sum;
  }
 
 
  int TotalErrors (int classIndex) const
  {
    auto numClasses = NumClasses ();
    if (classIndex >= numClasses)
    {
      throw std::out_of_range ("class index out of range");
    }
 
    int sum = 0;
    for (decltype(numClasses) c = 0; c < numClasses; ++c)
    {
      sum += static_cast<int>(indexArray_[classIndex][c].size());
      if (c != classIndex)
      {
        sum += static_cast<int> (At (classIndex, c).size());
      }
    }
    return sum;
  }
 
 
  int TotalErrors () const
  {
    auto numClasses = NumClasses ();
    int retval = 0;
    for (decltype(numClasses) i = 0; i < numClasses; ++i)
    {
      retval += TotalErrors(i);
    }
    return retval;
  }
 
 
  int TotalRejects () const
  {
    int retval = 0;
    for (auto && r : rejects_)
    {
      retval += static_cast<int>(r.size());
    }
    return retval;
  }
 
 
  std::vector<PredictionResult> Rejects (int classIndex) const
  {
    if (classIndex >= rejects_.size())
    {
      throw std::out_of_range ("class index out of range");
    }
 
    return rejects_[classIndex];
  }
 
 
  int NumClasses () const noexcept
  {
    return static_cast<int>(indexArray_.size());
  }
 
 
  std::vector<PredictionResult> At (int trueClass, int predictedClass) const
  {
    if (trueClass >= NumClasses() || predictedClass >= NumClasses())
    {
      throw std::out_of_range ("class index out of range");
    }
 
    return visibleArray_[trueClass][predictedClass];
  }
 
 
  double ConfidenceThreshold() const noexcept
  {
    return confidenceThreshold_;
  }
 
 
  void SetConfidenceThreshold(double threshold)
  {
    if ((threshold < 0.0) || (threshold > 1.5))
    {
      throw std::out_of_range ("confidence threshold value must be within <0.0, 1.5>");
    }
    confidenceThreshold_ = threshold;
    UpdateVisibleMatrix();
  }
 
private:
  void BuildConfusionMatrix (const ClassificationTestResult &res)
  {
    auto numClasses = res.NumClasses ();
    auto numExamples = res.NumExamples ();
    rejects_.resize (numClasses);
 
    indexArray_.resize (numClasses);
    for (auto && indexRow : indexArray_)
    {
      indexRow.resize (numClasses);
    }
 
    for (decltype(numExamples) i = 0; i < numExamples; ++i)
    {
      auto trueIndex = res.TrueClassIndices()[i];
      auto predictedIndex = res.PredictedClassIndices()[i];
      indexArray_[trueIndex][predictedIndex].push_back(PredictionResult(res, i));
    }
  }
 
  void UpdateVisibleMatrix ()
  {
    for (auto && r : rejects_)
    {
      r.clear ();
    }
 
    if (ConfidenceThreshold() == 0.0)
    {
      visibleArray_ = indexArray_;
      return;
    }
 
    visibleArray_.resize (indexArray_.size());
    for (auto && visibleRow : visibleArray_)
    {
      visibleRow.resize (indexArray_[0].size());
    }
    for (size_t x = 0; x < visibleArray_.size (); ++x)
    {
      visibleArray_[x].resize (indexArray_[x].size());
      for (size_t y = 0; y < visibleArray_[x].size (); ++y)
      {
        for (auto && e : indexArray_[x][y])
        {
          if (e.Confidence () >= ConfidenceThreshold ())
          {
            visibleArray_[x][y].push_back (e);
          }
          else
          {
            rejects_[x].push_back (e);
          }
        }
      }
    }
  }
 
private:
  std::vector<std::vector<std::vector<PredictionResult>>> indexArray_;
  std::vector<std::vector<std::vector<PredictionResult>>> visibleArray_;
  std::vector<std::vector<PredictionResult>> rejects_;
  double confidenceThreshold_ = 0.0;
};
 
 
} /* namespace Testing */
 
using Testing::PredictionResult;
using Testing::ConfusionMatrix;
 
} /* namespace Polimago */
CVB_END_INLINE_NS
} /* namespace Cvb */