predictor_factory_base.hpp

#pragma once
 
#include "../_cexports/c_polimago.h"
 
#include "../global.hpp"
#include "../string.hpp"
#include "../value_range.hpp"
#include "predictor_base.hpp"
#include "test_result_base.hpp"
 
#include <algorithm>
#include <iterator>
#include <cctype>
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
 
namespace Polimago
{
namespace Training
{
 
 
class PredictorFactoryBase
{
protected:
  PredictorFactoryBase ()
    : preproCode_(), lambda_(LambdaDefault)
  {}
 
  PredictorFactoryBase (const PredictorFactoryBase&) = default;
 
  PredictorFactoryBase& operator=(const PredictorFactoryBase&) = default;
 
  virtual ~PredictorFactoryBase () = default;
 
public:
  static constexpr double LambdaDefault = 0.1;
 
  static ValueRange<double> LambdaRange ()
  {
    return ValueRange<double> (0.0, 10.0);
  }
 
  static constexpr int FeatureResolutionDefault = 1;
 
  static ValueRange<int> FeatureResolutionRange ()
  {
    return ValueRange<int> (0, 10);
  }
 
  static constexpr int PreprocessingMaxLength = 15;
 
  
  
 
  static constexpr std::array<char, 4> PreprocessingValidCharacters()
  {
    return{ 'p', 'a', 's', '+' };
  }
 
 
  double Lambda() const noexcept
  {
    return lambda_;
  }
 
 
  void SetLambda(double lambda)
  {
    if ((lambda < LambdaRange().Min ()) || (lambda > 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 () > 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 (PreprocessingValidCharacters().data()) != std::string::npos)
    {
      throw std::invalid_argument ("Preprocessing code contains invalid characters");
    }
 
    preproCode_.assign (asciiCode.begin(), asciiCode.end());
  }
 
 
  static String FormatPreprocessingCode (const String &input)
  {
    std::string asciiCode;
    std::transform(input.begin(), input.end(), std::back_inserter(asciiCode), [](const String::value_type ch)
    {
      return static_cast<char>(std::tolower(static_cast<char>(ch)));
    });
 
    String retval;
    for (auto c : asciiCode)
    {
      auto preprocessingValidCharacters = PreprocessingValidCharacters();
      if (std::find (preprocessingValidCharacters.begin(), preprocessingValidCharacters.end(), c) != preprocessingValidCharacters.end()
          && retval.length () < PreprocessingMaxLength)
      {
        retval.push_back (c);
      }
    }
    return retval;
  }
 
protected:
  void UseSettingsFromPredictor (const PredictorBase &clf)
  {
    preproCode_ = clf.Preprocessing();
    lambda_ = clf.Lambda();
  }
 
protected:
  String preproCode_;
  double lambda_;
};
 
using PredictorFactoryBasePtr = std::shared_ptr<PredictorFactoryBase>;
 
 
class PredictorFactoryBaseEx : public PredictorFactoryBase
{
protected:
  PredictorFactoryBaseEx ()
    : PredictorFactoryBase (),
      featureResolution_(FeatureResolutionDefault), interpolation_(InterpolationDefault)
  {}
 
  PredictorFactoryBaseEx (const PredictorFactoryBaseEx&) = default;
 
  PredictorFactoryBaseEx& operator=(const PredictorFactoryBaseEx&) = default;
 
  virtual ~PredictorFactoryBaseEx () = default;
 
public:
  static constexpr InterpolationType InterpolationDefault = InterpolationType::Linear;
 
 
  InterpolationType Interpolation() const noexcept
  {
    return interpolation_;
  }
 
 
  void SetInterpolation(InterpolationType interpolation) noexcept
  {
    interpolation_ = interpolation;
  }
 
 
  int FeatureResolution() const noexcept
  {
    return featureResolution_;
  }
 
 
  void SetFeatureResolution(int featureResolution)
  {
    if ((featureResolution < FeatureResolutionRange().Min ()) || (featureResolution > FeatureResolutionRange().Max ()))
    {
      throw std::out_of_range ("feature resolution value out of range");
    }
 
    featureResolution_ = featureResolution;
  }
 
protected:
  void UseSettingsFromPredictor (const PredictorBaseEx &clf)
  {
    PredictorFactoryBase::UseSettingsFromPredictor (clf);
    featureResolution_ = clf.FeatureResolution();
    interpolation_ = clf.Interpolation ();
  }
 
  void UseSettingsFromTestResult (const Testing::TestResultBase &res)
  {
    interpolation_ = res.Interpolation ();
    preproCode_ = res.Preprocessing();
    lambda_ = res.Lambda();
    featureResolution_ = res.FeatureResolution();
  }
 
private:
  int featureResolution_;
  InterpolationType interpolation_;
};
 
using PredictorFactoryBaseExPtr = std::shared_ptr<PredictorFactoryBaseEx>;
 
 
} /* namespace Training */
 
using Training::PredictorFactoryBase;
using Training::PredictorFactoryBasePtr;
using Training::PredictorFactoryBaseEx;
using Training::PredictorFactoryBaseExPtr;
 
} /* namespace Polimago */
CVB_END_INLINE_NS
} /* namespace Cvb */