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:
  ClassificationTestResult (ReleaseObjectGuard&& guard)
    : TestResultBase (std::move (guard))
  {
    auto numClasses = NumClasses ();
    for (decltype(numClasses) i = 0; i < numClasses; ++i)
    {
      const int classPredClassMaxLen = 256;
      Char lbl[classPredClassMaxLen];
      CVB_CALL_CAPI_CHECKED(PMGetTestResultClassLabelTyped(Handle(), i, lbl));
      classes_.push_back (lbl);
    }
 
    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:
 
  ClassificationTestResult (const String & fileName)
    : ClassificationTestResult (ReleaseObjectGuard(LoadInternal (fileName)))
  {
    if (NumClasses() == 0)
    {
      throw std::runtime_error ("Loading the ClassificationTestResult failed");
    }
  }
 
  ClassificationTestResult (ClassificationTestResult&&) noexcept = default;
 
  ClassificationTestResult& operator=(ClassificationTestResult&&) noexcept = default;
 
  virtual ~ClassificationTestResult () {};
 
 
  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> Load (const String & fileName)
  {
    return std::unique_ptr<ClassificationTestResult>(new ClassificationTestResult(fileName));
  }
 
 
  int NumClasses() const
  {
    return static_cast<int>(CVB_CALL_CAPI (PMGetTestResultNumClasses(Handle())));
  }
 
 
  int OutputDimension() const
  {
    return static_cast<int>(CVB_CALL_CAPI (PMGetTestResultOutputDimension(Handle())));
  }
 
 
  int NumErrors() const
  {
    return static_cast<int>(CVB_CALL_CAPI (PMGetTestResultNumErrors(Handle())));
  }
 
 
  double ErrorRate() const
  {
    return static_cast<int>(CVB_CALL_CAPI (PMGetTestResultErrorRate(Handle())));
  }
 
 
  std::vector<String> Classes() const
  {
    return classes_;
  }
 
 
  std::vector<double> ExampleConfidences() const
  {
    return exampleConfidences_;
  }
 
 
  std::vector<std::vector<double>> ExampleConfidenceDistributions() const
  {
    return exampleConfidenceDistributions_;
  }
 
 
  std::vector<int> TrueClassIndices() const
  {
    return trueClassIndices_;
  }
 
 
  std::vector<int> PredictedClassIndices() const
  {
    return predictedClassIndices_;
  }
 
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";
};
 
using ClassificationTestResultPtr = std::shared_ptr<ClassificationTestResult>;
 
 
} /* namespace Testing */
 
using Testing::ClassificationTestResult;
using Testing::ClassificationTestResultPtr;
 
} /* namespace Polimago */
CVB_END_INLINE_NS
} /* namespace Cvb */