score.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef cMHN_COMMON_SCORE_H
#define cMHN_COMMON_SCORE_H
 
#include <functional>
#include <string>
 
#include <prc.hpp>
 
namespace cMHN
{
    template<class T>
    class Score
    {
    public:
        ~Score() = default;
        Score(Score const &) = default;
        Score(Score &&) = default;
        Score &operator=(Score const &) & = default;
        Score &operator=(Score &&) & = default;
        Score() = delete;
 
        explicit Score(auto const &pointwiseScore, auto const &pointwiseDSDP,
            auto const &name)
            : mPointwiseScore(pointwiseScore)
            , mPointwiseDSDP(pointwiseDSDP)
            , mName(name)
        {
        }
 
        auto pointwiseScore(T const &pDE, T const &pThetaE) const
        {
            return mPointwiseScore(pDE, pThetaE);
        }
 
        auto pointwiseDSDP(T const &pDE, T const &pThetaE) const
        {
            return mPointwiseDSDP(pDE, pThetaE);
        }
 
        auto name() const
        {
            return mName;
        }
 
    private:
        std::function<T(T, T)> mPointwiseScore;
        std::function<T(T, T)> mPointwiseDSDP;
        std::string mName;
    };
 
    template<class T>
    class KLTHScore : public Score<T>
    {
    public:
        ~KLTHScore() = default;
        KLTHScore(KLTHScore const &) = default;
        KLTHScore(KLTHScore &&) = default;
        KLTHScore &operator=(KLTHScore const &) & = default;
        KLTHScore &operator=(KLTHScore &&) & = default;
 
        explicit KLTHScore(T const &threshold)
            : Score<T>(
                  [this](T const &pDE, T const &pThetaE)
                  {
                      if(pThetaE > mThreshold)
                      {
                          return pDE * log(pThetaE);
                      }
                      else
                      {
                          T deltaPThetaE = pThetaE - mThreshold;
                          return pDE * log(mThreshold) +
                              pDE *
                              (deltaPThetaE / mThreshold -
                                  deltaPThetaE * deltaPThetaE /
                                      (T(2) * mThreshold * mThreshold));
                      }
                  },
                  [this](T const &pDE, T const &pThetaE)
                  {
                      if(pThetaE > mThreshold)
                      {
                          return pDE / pThetaE;
                      }
                      else
                      {
                          return -pDE * (pThetaE - T(2) * mThreshold) /
                              (mThreshold * mThreshold);
                      }
                  },
                  "KL-Taylor-Hybrid")
            , mThreshold(threshold)
        {
        }
 
        auto &threshold()
        {
            return mThreshold;
        }
 
        auto const threshold() const
        {
            return mThreshold;
        }
 
    private:
        T mThreshold;
    };
 
    template<class T>
    class KLepsScore : public Score<T>
    {
    public:
        ~KLepsScore() = default;
        KLepsScore(KLepsScore const &) = default;
        KLepsScore(KLepsScore &&) = default;
        KLepsScore &operator=(KLepsScore const &) & = default;
        KLepsScore &operator=(KLepsScore &&) & = default;
 
        explicit KLepsScore(T const &epsilon)
            : Score<T>(
                  [this](T const &pDE, T const &pThetaE)
                  {
                      return pDE * log(max(pThetaE, mEpsilon));
                  },
                  [this](T const &pDE, T const &pThetaE)
                  {
                      return pThetaE > mEpsilon ? pDE / pThetaE
                                                : pRC::zero<T>();
                  },
                  "KL-epsilon")
            , mEpsilon(epsilon)
        {
        }
 
        auto &threshold()
        {
            return mEpsilon;
        }
 
        auto const epsilon() const
        {
            return mEpsilon;
        }
 
    private:
        T mEpsilon;
    };
 
    template<class T>
    class sKLdynScore : public Score<T>
    {
    public:
        ~sKLdynScore() = default;
        sKLdynScore(sKLdynScore const &) = default;
        sKLdynScore(sKLdynScore &&) = default;
        sKLdynScore &operator=(sKLdynScore const &) & = default;
        sKLdynScore &operator=(sKLdynScore &&) & = default;
 
        explicit sKLdynScore(T const &delta)
            : Score<T>(
                  [this](T const &pDE, T const &pThetaE)
                  {
                      T eps = pRC::zero();
                      if(pThetaE < pRC::zero<T>())
                      {
                          eps = -(pRC::unit<T>() + mDelta) * pThetaE;
                      }
                      return (pDE + eps) * log(pThetaE + eps);
                  },
                  [this](T const &pDE, T const &pThetaE)
                  {
                      T eps = pRC::zero();
                      if(pThetaE < pRC::zero<T>())
                      {
                          eps = -(pRC::unit<T>() + mDelta) * pThetaE;
                      }
                      return (pDE + eps) / (pThetaE + eps);
                  },
                  "dynamic sKL")
            , mDelta(delta)
        {
        }
 
        auto &delta()
        {
            return mDelta;
        }
 
        auto const delta() const
        {
            return mDelta;
        }
 
    private:
        T mDelta;
    };
 
    template<class T>
    class sKLScore : public Score<T>
    {
    public:
        ~sKLScore() = default;
        sKLScore(sKLScore const &) = default;
        sKLScore(sKLScore &&) = default;
        sKLScore &operator=(sKLScore const &) & = default;
        sKLScore &operator=(sKLScore &&) & = default;
 
        explicit sKLScore(T const &epsilon)
            : Score<T>(
                  [this](T const &pDE, T const &pThetaE)
                  {
                      return (pDE + mEpsilon) * log(pThetaE + mEpsilon);
                  },
                  [this](T const &pDE, T const &pThetaE)
                  {
                      return (pDE + mEpsilon) / (pThetaE + mEpsilon);
                  },
                  "sKL")
            , mEpsilon(epsilon)
        {
        }
 
        auto &epsilon()
        {
            return mEpsilon;
        }
 
        auto const epsilon() const
        {
            return mEpsilon;
        }
 
    private:
        T mEpsilon;
    };
 
    template<class T>
    class KLScore : public Score<T>
    {
    public:
        ~KLScore() = default;
        KLScore(KLScore const &) = default;
        KLScore(KLScore &&) = default;
        KLScore &operator=(KLScore const &) & = default;
        KLScore &operator=(KLScore &&) & = default;
 
        explicit KLScore()
            : Score<T>(
                  [](T const &pDE, T const &pThetaE)
                  {
                      return pDE * log(pThetaE);
                  },
                  [](T const &pDE, T const &pThetaE)
                  {
                      return pDE / pThetaE;
                  },
                  "KL")
        {
        }
    };
}
 
#endif // cMHN_COMMON_SCORE_H