holdout_test_result_factory.hpp

#pragma once
 
#include "../_cexports/c_polimago.h"
 
#include "../global.hpp"
#include "../string.hpp"
#include "test_result_factory.hpp"
#include "predictor_base.hpp"
#include "predictor_factory_base.hpp"
#include "classification_predictor.hpp"
#include "../minos/training_set.hpp"
#include "../sample_database/sample_classification_image_list.hpp"
#include "../sample_database/sample_regression_image_list.hpp"
 
#include <memory>
#include <algorithm>
#include <iterator>
 
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
 
namespace Polimago
{
namespace Testing
{
 
 
class HoldoutTestResultFactory : public TestResultFactory
{
public:
 
  HoldoutTestResultFactory ()
    : TestResultFactory ()
  { }
 
  HoldoutTestResultFactory (const HoldoutTestResultFactory&) = default;
 
  HoldoutTestResultFactory& operator=(const HoldoutTestResultFactory&) = default;
 
  virtual ~HoldoutTestResultFactory () {};
 
public:
#if 0
 
  std::unique_ptr<ClassificationTestResult> RunTest (int holdoutSize, ClassificationType usage, const SampleDatabase::SampleRegressionImageList & database)
  {
    return Internal::DoResCallObjectOut<ClassificationTestResult>([&](void* & res)
    {
      return CVB_CALL_CAPI(PMLeaveOutTestOnSil (mts.Handle (), ..., holdoutSize, usage, preproCode_, featureResolution_, lambda_, iterpolation_ == InterpolationType::Linear, res));
    });
  }
 
 
  std::unique_ptr<RegressionTestResult> RunTest (int holdoutSize, const SampleDatabase::SampleRegressionImageList & database)
  {
    return Internal::DoResCallObjectOut<RegressionTestResult>([&](void* & res)
    {
      return CVB_CALL_CAPI(PMLeaveOutTestOnSil (mts.Handle (), ..., holdoutSize, CExports::CU_Regression, preproCode_, featureResolution_, lambda_, iterpolation_ == InterpolationType::Linear, res));
    });
  }
 
 
  std::unique_ptr<ClassificationTestResult> RunTest (int holdoutSize, ClassificationType usage, const Minos::TrainingSet & database)
  {
    return Internal::DoResCallObjectOut<ClassificationTestResult>([&](void* & res)
    {
      return CVB_CALL_CAPI(PMLeaveOutTestOnMts (mts.Handle (), ..., holdoutSize, usage, preproCode_, featureResolution_, lambda_, iterpolation_ == InterpolationType::Linear, res));
    });
  }
#endif
 
 
  InterpolationType Interpolation() const noexcept
  {
    return interpolation_;
  }
 
 
  void SetInterpolation(InterpolationType interpolation) noexcept
  {
    interpolation_ = interpolation;
  }
 
 
  double Lambda() const noexcept
  {
    return lambda_;
  }
 
 
  void SetLambda(double lambda)
  {
    if ((lambda < Training::PredictorFactoryBase::LambdaRange().Min ()) || (lambda > Training::PredictorFactoryBase::LambdaRange().Max ()))
    {
      throw std::out_of_range ("lambda value out of range");
    }
 
    lambda_ = lambda;
  }
 
 
  String Preprocessing() const
  {
    return preproCode_;
  }
 
 
  void SetPreprocessing(const String &code)
  {
    if (code.length () > Training::PredictorFactoryBase::PreprocessingMaxLength)
    {
      throw std::invalid_argument ("Preprocessing codes must not be longer than 15 characters");
    }
  std::string asciiCode (Internal::CastToAscii(code));
    std::transform(asciiCode.begin(), asciiCode.end(), asciiCode.begin(), [](char ch)
    {
      return static_cast<char>(std::tolower(ch));
    });
    if (asciiCode.find_first_not_of (Training::PredictorFactoryBase::PreprocessingValidCharacters().data()) != std::string::npos)
    {
      throw std::invalid_argument ("Preprocessing code contains invalid characters");
    }
 
    preproCode_.assign (asciiCode.begin(), asciiCode.end());
  }
 
 
  int FeatureResolution() const noexcept
  {
    return featureResolution_;
  }
 
 
  void SetFeatureResolution(int featureResolution)
  {
    if ((featureResolution < Training::PredictorFactoryBase::FeatureResolutionRange().Min ()) || (featureResolution > Training::PredictorFactoryBase::FeatureResolutionRange().Max ()))
    {
      throw std::out_of_range ("feature resolution value out of range");
    }
 
    featureResolution_ = featureResolution;
  }
 
private:
  InterpolationType interpolation_ = Training::PredictorFactoryBaseEx::InterpolationDefault;
  String preproCode_;
  double lambda_ = Training::PredictorFactoryBase::LambdaDefault;
  int featureResolution_ = Training::PredictorFactoryBase::FeatureResolutionDefault;
};
 
using HoldoutTestResultFactoryPtr = std::shared_ptr<HoldoutTestResultFactory>;
 
} /* namespace Testing */
 
using Testing::HoldoutTestResultFactory;
using Testing::HoldoutTestResultFactoryPtr;
 
} /* namespace Polimago */
CVB_END_INLINE_NS
} /* namespace Cvb */