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 &other)            = default;
        PredictionResult &operator=(const PredictionResult &other) = default;
        PredictionResult(PredictionResult &&other)                 = default;
        PredictionResult &operator=(PredictionResult &&other)      = default;
        ~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_;
        }
        int ExampleIndex() const noexcept {…}


        double Confidence() const noexcept
        {
          return confidence_;
        }
        double Confidence() const noexcept {…}


        std::vector<double> ConfidenceDistribution() const
        {
          return confidenceDistribution_;
        }
        std::vector<double> ConfidenceDistribution() const {…}
 
      private:
        int exampleIndex_;
        double confidence_;
        std::vector<double> confidenceDistribution_;
      };
      class PredictionResult {…};


      class ConfusionMatrix
      {
      public:

        explicit ConfusionMatrix(const ClassificationTestResult &res)
        {
          BuildConfusionMatrix(res);
          UpdateVisibleMatrix();
        }
        explicit ConfusionMatrix(const ClassificationTestResult &res) {…}
 
      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(int classIndex) const {…}


        int TotalSamples() const
        {
          auto numClasses = NumClasses();
          int retval      = 0;
          for (decltype(numClasses) i = 0; i < numClasses; ++i)
          {
            retval += TotalSamples(i);
          }
          return retval;
        }
        int TotalSamples() const {…}


        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(int classIndex) const {…}


        int TotalCorrect() const
        {
          auto numClasses = NumClasses();
          int sum         = 0;
          for (decltype(numClasses) i = 0; i < numClasses; ++i)
          {
            sum += TotalCorrect(i);
          }
          return sum;
        }
        int TotalCorrect() const {…}


        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(int classIndex) const {…}


        int TotalErrors() const
        {
          auto numClasses = NumClasses();
          int retval      = 0;
          for (decltype(numClasses) i = 0; i < numClasses; ++i)
          {
            retval += TotalErrors(i);
          }
          return retval;
        }
        int TotalErrors() const {…}


        int TotalRejects() const
        {
          int retval = 0;
          for (auto &&r : rejects_)
          {
            retval += static_cast<int>(r.size());
          }
          return retval;
        }
        int TotalRejects() const {…}


        std::vector<PredictionResult> Rejects(int classIndex) const
        {
          if (classIndex >= rejects_.size())
          {
            throw std::out_of_range("class index out of range");
          }
 
          return rejects_[classIndex];
        }
        std::vector<PredictionResult> Rejects(int classIndex) const {…}


        int NumClasses() const noexcept
        {
          return static_cast<int>(indexArray_.size());
        }
        int NumClasses() const noexcept {…}


        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];
        }
        std::vector<PredictionResult> At(int trueClass, int predictedClass) const {…}


        double ConfidenceThreshold() const noexcept
        {
          return confidenceThreshold_;
        }
        double ConfidenceThreshold() const noexcept {…}


        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();
        }
        void SetConfidenceThreshold(double threshold) {…}
 
      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;
      };
      class ConfusionMatrix {…};
 
    } /* namespace Testing */
 
    using Testing::ConfusionMatrix;
    using Testing::PredictionResult;
 
  } /* namespace Polimago */
  CVB_END_INLINE_NS
} /* namespace Cvb */