regulator.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef cMHN_COMMON_REGULATOR_H
#define cMHN_COMMON_REGULATOR_H
 
#include <functional>
#include <string>
 
#include <prc.hpp>
 
namespace cMHN
{
    template<class T, pRC::Size D>
    class Regulator
    {
    public:
        ~Regulator() = default;
        Regulator(Regulator const &) = default;
        Regulator(Regulator &&) = default;
        Regulator &operator=(Regulator const &) & = default;
        Regulator &operator=(Regulator &&) & = default;
        Regulator() = delete;
 
        explicit Regulator(auto const &score, auto const &grad,
            auto const &name, auto const &lambda = T(1e-2))
            : mScore(score)
            , mGrad(grad)
            , mLambda(lambda)
            , mName(name)
        {
        }
 
        auto score(pRC::Tensor<T, D, D> const &theta) const
        {
            return mLambda * mScore(theta);
        }
 
        auto grad(pRC::Tensor<T, D, D> const &theta) const
        {
            return mLambda * mGrad(theta);
        }
 
        auto &lambda()
        {
            return mLambda;
        }
 
        auto const lambda() const
        {
            return mLambda;
        }
 
        auto name() const
        {
            return mName;
        }
 
    private:
        std::function<T(pRC::Tensor<T, D, D>)> mScore;
        std::function<pRC::Tensor<T, D, D>(pRC::Tensor<T, D, D>)> mGrad;
        T mLambda;
        std::string mName;
    };
 
    template<class T, pRC::Size D>
    class L1Regulator : public Regulator<T, D>
    {
    public:
        ~L1Regulator() = default;
        L1Regulator(L1Regulator const &) = default;
        L1Regulator(L1Regulator &&) = default;
        L1Regulator &operator=(L1Regulator const &) & = default;
        L1Regulator &operator=(L1Regulator &&) & = default;
 
        explicit L1Regulator(T const &lambda)
            : Regulator<T, D>(
                  [](pRC::Tensor<T, D, D> const &theta)
                  {
                      return pRC::norm<1>(pRC::offDiagonal(theta))();
                  },
                  [](pRC::Tensor<T, D, D> const &theta)
                  {
                      return pRC::offDiagonal(pRC::sign(theta));
                  },
                  "L1", lambda)
        {
        }
    };
 
    template<class T, pRC::Size D>
    class L2Regulator : public Regulator<T, D>
    {
    public:
        ~L2Regulator() = default;
        L2Regulator(L2Regulator const &) = default;
        L2Regulator(L2Regulator &&) = default;
        L2Regulator &operator=(L2Regulator const &) & = default;
        L2Regulator &operator=(L2Regulator &&) & = default;
 
        explicit L2Regulator(T const &lambda)
            : Regulator<T, D>(
                  [](pRC::Tensor<T, D, D> const &theta)
                  {
                      return contract<0, 1, 0, 1>(offDiagonal(theta),
                          offDiagonal(theta))();
                  },
                  [](pRC::Tensor<T, D, D> const &theta)
                  {
                      return pRC::offDiagonal(T(2) * theta);
                  },
                  "L2", lambda)
        {
        }
    };
}
 
#endif // cMHN_COMMON_REGULATOR_H