classification_test_result.hpp

#pragma once
 
#include "../_cexports/c_polimago.h"
 
#include "../global.hpp"
#include "../string.hpp"
#include "test_result_base.hpp"
 
#include <vector>
#include <memory>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace Polimago
  {
    namespace Testing
    {


      class ClassificationTestResult : public TestResultBase
      {
      private:
        explicit ClassificationTestResult(ReleaseObjectGuard &&guard)
            : TestResultBase(std::move(guard))
        {
          auto numClasses = NumClasses();
          for (decltype(numClasses) i = 0; i < numClasses; ++i)
          {
            std::array<Char, 256> lbl = {};
            CVB_CALL_CAPI_CHECKED(PMGetTestResultClassLabelTyped(Handle(), i, lbl.data()));
            classes_.push_back(lbl.data());
          }
 
          auto numExamples = NumExamples();
          for (decltype(numExamples) i = 0; i < numExamples; ++i)
          {
            auto confidence = CVB_CALL_CAPI(PMGetTestResultConfidence(Handle(), i));
            exampleConfidences_.push_back(confidence);
          }
 
          for (decltype(numExamples) i = 0; i < numExamples; ++i)
          {
            std::vector<double> confidenceDistribution;
            for (decltype(numClasses) j = 0; j < numClasses; ++j)
            {
              auto confidenceDistributionValue = CVB_CALL_CAPI(PMGetTestResultConfidenceDistribution(Handle(), i, j));
              confidenceDistribution.push_back(confidenceDistributionValue);
            }
            exampleConfidenceDistributions_.push_back(confidenceDistribution);
          }
 
          for (decltype(numExamples) i = 0; i < numExamples; ++i)
          {
            auto index = CVB_CALL_CAPI(PMGetTestResultTrueClassIndex(Handle(), i));
            trueClassIndices_.push_back(index);
          }
 
          for (decltype(numExamples) i = 0; i < numExamples; ++i)
          {
            auto index = CVB_CALL_CAPI(PMGetTestResultPredictedClass(Handle(), i));
            predictedClassIndices_.push_back(index);
          }
        }
 
        std::string ObjectName() const override
        {
          return thisObjectName_;
        }
 
      public:

        explicit ClassificationTestResult(const String &fileName)
            : ClassificationTestResult(ReleaseObjectGuard(LoadInternal(fileName)))
        {
          if (NumClasses() == 0)
          {
            throw std::runtime_error("Loading the ClassificationTestResult failed");
          }
        }
        explicit ClassificationTestResult(const String &fileName) {…}


        static std::unique_ptr<ClassificationTestResult> FromHandle(ReleaseObjectGuard &&guard)
        {
          if (!guard.Handle())
          {
            throw std::invalid_argument("invalid classification test result native handle");
          }
          return std::unique_ptr<ClassificationTestResult>(new ClassificationTestResult(std::move(guard)));
        }
        static std::unique_ptr<ClassificationTestResult> FromHandle(ReleaseObjectGuard &&guard) {…}


        static std::unique_ptr<ClassificationTestResult> Load(const String &fileName)
        {
          return std::make_unique<ClassificationTestResult>(fileName);
        }
        static std::unique_ptr<ClassificationTestResult> Load(const String &fileName) {…}


        int NumClasses() const
        {
          return static_cast<int>(CVB_CALL_CAPI(PMGetTestResultNumClasses(Handle())));
        }
        int NumClasses() const {…}


        int OutputDimension() const
        {
          return static_cast<int>(CVB_CALL_CAPI(PMGetTestResultOutputDimension(Handle())));
        }
        int OutputDimension() const {…}


        int NumErrors() const
        {
          return static_cast<int>(CVB_CALL_CAPI(PMGetTestResultNumErrors(Handle())));
        }
        int NumErrors() const {…}


        double ErrorRate() const
        {
          return static_cast<int>(CVB_CALL_CAPI(PMGetTestResultErrorRate(Handle())));
        }
        double ErrorRate() const {…}


        std::vector<String> Classes() const
        {
          return classes_;
        }
        std::vector<String> Classes() const {…}


        std::vector<double> ExampleConfidences() const
        {
          return exampleConfidences_;
        }
        std::vector<double> ExampleConfidences() const {…}


        std::vector<std::vector<double>> ExampleConfidenceDistributions() const
        {
          return exampleConfidenceDistributions_;
        }
        std::vector<std::vector<double>> ExampleConfidenceDistributions() const {…}


        std::vector<int> TrueClassIndices() const
        {
          return trueClassIndices_;
        }
        std::vector<int> TrueClassIndices() const {…}


        std::vector<int> PredictedClassIndices() const
        {
          return predictedClassIndices_;
        }
        std::vector<int> PredictedClassIndices() const {…}
 
      private:
        std::vector<String> classes_;
        std::vector<double> exampleConfidences_;
        std::vector<std::vector<double>> exampleConfidenceDistributions_;
        std::vector<int> trueClassIndices_;
        std::vector<int> predictedClassIndices_;
        const std::string thisObjectName_ = "Polimago Classification Test Resul";
      };
      class ClassificationTestResult : public TestResultBase {…};

      using ClassificationTestResultPtr = std::shared_ptr<ClassificationTestResult>;
 
    } /* namespace Testing */
    namespace Testing {…}
 
    using Testing::ClassificationTestResult;
    using Testing::ClassificationTestResultPtr;
 
  } /* namespace Polimago */
  CVB_END_INLINE_NS
} /* namespace Cvb */