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 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((pDE + eps) / (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 divergence")
            , 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((pDE + mEpsilon) / (pThetaE + mEpsilon));
                  },
                  [this](T const &pDE, T const &pThetaE)
                  {
                      return -(pDE + mEpsilon) / (pThetaE + mEpsilon);
                  },
                  "static sKL divergence")
            , 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(pDE / pThetaE);
                  },
                  [](T const &pDE, T const &pThetaE)
                  {
                      return -pDE / pThetaE;
                  },
                  "KL divergence")
        {
        }
    };
}
 
#endif // cMHN_COMMON_SCORE_H