BackendGroupNorm.h

#pragma once
 
#if _MSC_VER >= 1900 && defined(_M_X64)
 
#include "BackendBase.h"
 
namespace FLImaging
{
    namespace AI
    {
        template <typename T>
        class FL_EXPORT CTensor;
 
        template <typename T>
        class FL_EXPORT CBackendBase;
 
        template <typename T>
        class FL_EXPORT CBackendGroupNorm : public CBackendBase<T>
        {
 
        public:
            CBackendGroupNorm();
            CBackendGroupNorm(const CBackendGroupNorm<T>& bgn);
            virtual ~CBackendGroupNorm();
 
            virtual const CResult SetEpsilon(T tEpsilon);
            virtual const CResult UseAffine(bool bAffine);
            virtual const CResult SetGroupCount(int64_t i64GroupCount);
            virtual T GetEpsilon();
            virtual bool IsAffineUsed();
            virtual int64_t GetGroupCount();
 
            virtual const CResult Forward(const CTensor<T>* pTsrX, const CTensor<T>* pTsrWeight, const CTensor<T>* pTsrBias, CTensor<T>* pTsrY, CTensor<T>* pTsrVarBuffer, CTensor<T>* pTsrMeanBuffer);
            virtual const CResult Derivative(const CTensor<T>* pTsrX, const CTensor<T>* pTsrWeight, const CTensor<T>* pTsrVarBuffer, const CTensor<T>* pTsrMeanBuffer, const CTensor<T>* pTsrDy, CTensor<T>* pTsrDx, CTensor<T>* pTsrDw, CTensor<T>* pTsrDb, bool bAddGradient, bool bWeightAddGradient, bool bBiasAddGradient);
 
        protected:
            virtual const CResult GroupNorm_CPU(const T* pTX, const T* pTWeight, const T* pTBias, T* pTY, T* pTVar, T* pTMean, int64_t i64AllGroupCount, int64_t i64ChannelCount, int64_t i64InnerSize);
            virtual const CResult Derivative_CPU(const T* pTX, const T* pTWeight, const T* pTVar, const T* pTMean, const T* pTDy, T* pTDx, T* pTDw, T* pTDb, int64_t i64AllGroupCount, int64_t i64ChannelCount, int64_t i64InnerSize);
 
            virtual double GetMean_CPU(const T* pTXStart, int64_t i64Count, double f64Scale, bool bMultiThread = false);
            virtual double GetVariance_CPU(const T* pTXStart, int64_t i64Count, double f64Mean, double f64Scale, bool bMultiThread = false);
            virtual const CResult GetDerivativeVarianceAndMean_CPU(const T* pTXStart, const T* pTDyStart, const T* pTWeightStart, T& tVarDerivative, T& tMeanDerivative, int64_t i64Count, int64_t i64InnerSize, T tMean, T tInnerDerivativeVariance, T tMinusInverseSqrtVarPlusE, T tScale, bool bMultiThread = false);
            virtual const CResult GetDerivativeVarianceAndMean_NoAffine_CPU(const T* pTXStart, const T* pTDyStart, T& tVarDerivative, T& tMeanDerivative, int64_t i64Count, T tMean, T tInnerDerivativeVariance, T tMinusInverseSqrtVarPlusE, T tScale, bool bMultiThread = false);
 
 
            DeclareGetClassType();
            SupportToDuplicateObjectWithoutCreateNewObject(CBackendGroupNorm<T>, *this);
 
        protected:
            T m_tEpsilon;
            bool m_bAffine;
            int64_t m_i64GroupCount;
        };
    }
}
 
#endif