classifier_factory.hpp

#pragma once
 
#include "../_cexports/c_minos.h"
 
#include "../global.hpp"
 
#include "classifier.hpp"
#include "training_set.hpp"
 
#include <memory>
#include <utility>
#include <cmath>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace Minos
  {


    class ClassifierFactory
    {
    public:
      ClassifierFactory() noexcept
          : indifferenceRadius_(IndifferenceRadiusDefault())
          , negativeDensity_(NegativeDensityDefault())
          , contrastTrigger_(ContrastTriggerDefault())
          , ensembleSize_(EnsembleSizeDefault())
          , polydromy_(PolydromyDefault())
          , minPairFeatures_(MinPairFeaturesDefault())
      {
      }
 
    public:

      std::unique_ptr<Classifier> Learn(const TrainingSet &trainingSet)
      {
        CExports::TLearnControlStructure lcs = {};
        lcs.Param1                           = static_cast<CExports::cvbval_t>(indifferenceRadius_);
        lcs.Param2                           = static_cast<CExports::cvbval_t>(lround(negativeDensity_ * 1000.0));
        lcs.Param3                           = static_cast<CExports::cvbval_t>(contrastTrigger_);
        lcs.Param4                           = static_cast<CExports::cvbval_t>(ensembleSize_);
        lcs.Param5                           = static_cast<CExports::cvbval_t>(polydromy_);
        lcs.Param6                           = static_cast<CExports::cvbval_t>(minPairFeatures_);
        LearnProgressData progressData       = {trainingSet, false};
        lcs.Data                             = &progressData;
        lcs.ShowProgress                     = NativeLearnProgress;
 
        CExports::CLF clf = nullptr;
        CVB_CALL_CAPI_CHECKED(LearnCLFFromMTSTyped(trainingSet.Handle(), trainingSet.FileName().c_str(), lcs, clf));
        if (progressData.wasInterrupted)
        {
          CVB_CALL_CAPI(ReleaseObject(clf));
          return nullptr;
        }
        HandleGuard<Classifier> clfGuard(clf);
 
        CVB_CALL_CAPI(SetCLFQualityType(clf, CExports::Quality_ReturnCorrelation));
        CVB_CALL_CAPI(SetCLFThreshold(clf, 0.6));
        return Classifier::FromHandle(std::move(clfGuard));
      }
      std::unique_ptr<Classifier> Learn(const TrainingSet &trainingSet) {…}


      static int IndifferenceRadiusDefault() noexcept
      {
        return 6;
      }
      static int IndifferenceRadiusDefault() noexcept {…}


      static double NegativeDensityDefault() noexcept
      {
        return 1.0;
      }
      static double NegativeDensityDefault() noexcept {…}


      static int ContrastTriggerDefault() noexcept
      {
        return 8;
      }
      static int ContrastTriggerDefault() noexcept {…}


      static int EnsembleSizeDefault() noexcept
      {
        return 15;
      }
      static int EnsembleSizeDefault() noexcept {…}


      static int PolydromyDefault() noexcept
      {
        return 2;
      }
      static int PolydromyDefault() noexcept {…}


      static int MinPairFeaturesDefault() noexcept
      {
        return 20;
      }
      static int MinPairFeaturesDefault() noexcept {…}
 
    public:

      int IndifferenceRadius() const noexcept
      {
        return indifferenceRadius_;
      }
      int IndifferenceRadius() const noexcept {…}


      void SetIndifferenceRadius(int indifferenceRadius)
      {
        if (indifferenceRadius < 0)
        {
          throw std::invalid_argument("indifference radius value must be >=0");
        }
        indifferenceRadius_ = indifferenceRadius;
      }
      void SetIndifferenceRadius(int indifferenceRadius) {…}


      double NegativeDensity() const noexcept
      {
        return negativeDensity_;
      }
      double NegativeDensity() const noexcept {…}


      void SetNegativeDensity(double negativeDensity)
      {
        if (negativeDensity < 0.0 || negativeDensity > 1.0)
        {
          throw std::invalid_argument("negative density value must be in [0.0, 1.0]");
        }
        negativeDensity_ = negativeDensity;
      }
      void SetNegativeDensity(double negativeDensity) {…}


      int ContrastTrigger() const noexcept
      {
        return contrastTrigger_;
      }
      int ContrastTrigger() const noexcept {…}


      void SetContrastTrigger(int contrastTrigger)
      {
        if (contrastTrigger < 1 || contrastTrigger > 254)
        {
          throw std::invalid_argument("contrast trigger value must be in [1, 254]");
        }
        contrastTrigger_ = contrastTrigger;
      }
      void SetContrastTrigger(int contrastTrigger) {…}


      int EnsembleSize() const noexcept
      {
        return ensembleSize_;
      }
      int EnsembleSize() const noexcept {…}


      void SetEnsembleSize(int ensembleSize)
      {
        if (ensembleSize < 1)
        {
          throw std::invalid_argument("ensemble size value must be >0");
        }
        ensembleSize_ = ensembleSize;
      }
      void SetEnsembleSize(int ensembleSize) {…}


      int Polydromy() const noexcept
      {
        return polydromy_;
      }
      int Polydromy() const noexcept {…}


      void SetPolydromy(int polydromy)
      {
        if (polydromy < 1)
        {
          throw std::invalid_argument("polydromy value must be >0");
        }
        polydromy_ = polydromy;
      }
      void SetPolydromy(int polydromy) {…}


      int MinPairFeatures() const noexcept
      {
        return minPairFeatures_;
      }
      int MinPairFeatures() const noexcept {…}


      void SetMinPairFeatures(int minPairFeatures)
      {
        if (minPairFeatures < 1)
        {
          throw std::invalid_argument("minimum feature count value must be >0");
        }
        minPairFeatures_ = minPairFeatures;
      }
      void SetMinPairFeatures(int minPairFeatures) {…}
 
    private:
      struct LearnProgressData
      {
        const TrainingSet &currentlyProcessed;
        bool wasInterrupted;
      };
 
      static CExports::cvbbool_t __stdcall NativeLearnProgress(void *pPrivate, CExports::MTSINSTANCE instance,
                                                               CExports::cvbval_t total, CExports::cvbval_t correct,
                                                               CExports::cvbval_t current)
      {
        LearnProgressData *pdata = reinterpret_cast<LearnProgressData *>(pPrivate);
        if (pdata)
        {
        }
        (void)instance;
        (void)total;
        (void)correct;
        (void)current;
        return false;
      }
 
    private:
      int indifferenceRadius_;
      double negativeDensity_;
      int contrastTrigger_;
      int ensembleSize_;
      int polydromy_;
      int minPairFeatures_;
    };
    class ClassifierFactory {…};
 
  } /* namespace Minos */
  CVB_END_INLINE_NS
} /* namespace Cvb */