ComputationalBase.h

#pragma once
 
#if _MSC_VER >= 1900 && defined(_M_X64)
 
#include "DefinitionsAI.h"
#include "ComputationalGraphUtilities.h"
 
namespace FLImaging
{
    namespace AI
    {
        template <typename T>
        class CTensor;
 
        template <typename T>
        class CComputationalGraph;
 
        template <typename T>
        class FL_EXPORT CComputationalBase : public CAlgorithmAIBase
        {
 
        public:
            CComputationalBase();
            virtual ~CComputationalBase();
 
            virtual bool IsInitialized() const;
            virtual const CResult SetInitialized(bool bSet);
 
            virtual const CResult Load(const wchar_t* pWcsFileName);
            virtual const CResult Save(const wchar_t* pWcsFileName);
 
            virtual const CResult GetBinaryData(Base::CFLData& fldBinary, bool bSuperClass = false, int32_t i32Version = -1, bool bDumpMode = false) const;
            virtual const CResult GetBinaryData(Base::CFLData* pFldBinary, bool bSuperClass = false, int32_t i32Version = -1, bool bDumpMode = false) const;
 
            virtual const CResult SetBinaryData(const Base::CFLData& fldBinary, int64_t* pI64Offset = nullptr);
            virtual const CResult SetBinaryData(const Base::CFLData* pFldBinary, int64_t* pI64Offset = nullptr);
 
            virtual const CResult Clear();
 
            const int64_t GetObjectNumber() const;
 
            CComputationalBase<T>& SetID(const wchar_t* pWcsName);
            CComputationalBase<T>& ID(const wchar_t* pWcsName);
            const wchar_t* GetID() const;
 
            virtual void Throw(const CResult& res, const wchar_t* pWcsExtraMessage = nullptr) const override;
 
            CComputationalBase<T>& EnableReference(bool bReference);
            bool IsReference() const;
 
            const CResult SetValueAttribute(EValueAttribute eType);
            EValueAttribute GetValueAttribute() const;
 
            ENodeType GetNodeType() const;
            EDataType GetDataType() const;
            ENodeOperator GetNodeOperator() const;
            virtual const std::vector<int64_t>& GetEstimatedShape(bool bRecursive = true) const;
            virtual CResult EnableNonTrainingMemoryInheritance(bool bEnable);
            virtual bool IsNonTrainingMemoryInheritanceEnabled() const;
            virtual const std::vector<int64_t>& GetShape() const;
            virtual const std::vector<int64_t>& GetShapeAsc() const;
            virtual const CResult ClearShape(bool bRecursive = false);
            virtual int64_t GetNextBatchSize(int64_t i64BatchSize) const;
 
            virtual CTensor<T>& Evaluate() = 0;
            virtual CTensor<T>& Forward() = 0;
            virtual CTensor<T>* Backward() = 0;
 
            virtual CTensor<T>& GetValue() const;
            virtual CTensor<T>* GetDerivative() const;
            virtual void ClearDerivativesRecursive();
            virtual void ResetDerivativesRecursive();
 
            virtual CComputationalBase<T>* Clone() const = 0;
 
            virtual const CResult Swap(CComputationalBase<T>& cbSwap);
 
            virtual const CComputationalBase<T>* GetAt(const wchar_t* pWcsName) const = 0;
            virtual const CResult FindByValueAttribute(EValueAttribute eValueAttribute, std::vector<const CComputationalBase<T>*>& vctResult) const = 0;
 
            virtual CComputationalBase<T>* GetOperand(int64_t i64Index) const;
            virtual bool IsIntrinsicOperand(int64_t i64Index) const;
            virtual int64_t GetOperandCount() const;
 
            virtual int64_t GetGeneration() const;
 
            virtual bool IsTrainingModeEnabled() const;
            virtual const CResult EnableTrainingMode(bool bMode, bool bRecursively = true);
 
            virtual const CResult PrintGraphInfo(bool bRecursively = true, bool bShapeOrderAsc = false, bool bIncludeTensors = false) const;
            virtual const CResult PrintNodeParamInfo() const;
 
            virtual bool IsTensorCoreAvailable() const;
 
            virtual int64_t GetAddGradientCount() const;
            virtual const CResult SetAddGradientCount(int64_t i64AddGradientCount);
 
            virtual int64_t GetRequiredDedicatedMemory(bool bTraining = false, bool bRecursively = true, int64_t i64BatchSize = 1) const = 0;
            virtual int64_t GetRequiredTemporaryMemory(bool bTraining = false, bool bRecursively = true, int64_t i64BatchSize = 1, int64_t i64MemoryIndex = 0) const = 0;
 
            virtual const CResult EnableRetainedValue(bool bRetained);
            virtual bool IsRetainedEnabled() const;
 
            virtual bool IsInplace() const;
 
            virtual int64_t GetParentNodeCount() const;
            virtual CComputationalBase<T>* GetParentNode(int64_t i64Index) const;
 
            virtual const CResult SetDeviceIndex(int32_t i32DeviceIndex);
            virtual int32_t GetDeviceIndex() const;
 
            virtual const CResult CreateValue();
            virtual const CResult ClearValue();
 
            virtual const CResult CreateDerivative();
            virtual const CResult ClearDerivative();
 
            const CResult SetValuePtr(CTensor<T>* pTsrValue);
            const CResult SetDerivativePtr(CTensor<T>* pTsrDerivative);
 
            virtual CTensor<T>* GetValuePtr();
 
            static CComputationalBase<T>* GetSingletonObject();
 
            virtual const CResult SetProcessingUnit(const Base::CProcessingUnitBase& puBase) override;
            virtual const CResult SetProcessingUnit(const Base::CProcessingUnitBase* pPuBase) override;
 
            virtual const CResult EnableTensorCore(bool bTensorCore = true);
            virtual bool IsTensorCoreEnabled() const;
 
            SupportToDuplicateAbstractObject(CComputationalBase);
        protected:
            const CResult InternalAssign(const CComputationalBase<T>& cb);
 
            virtual const CResult BeginForwardPerformanceCheck();
            virtual const CResult EndForwardPerformanceCheck();
 
            virtual const CResult BeginBackwardPerformanceCheck();
            virtual const CResult EndBackwardPerformanceCheck();
 
            bool m_bInitialized;
            bool m_bReference;
            ENodeType m_eNodeType;
            EDataType m_eDataType;
            EValueAttribute m_eValueAttribute;
            ENodeOperator m_eNodeOperator;
            wchar_t* m_pWcsName;
            bool m_bTrainingMode;
            int64_t m_i64ObjectNumber;
            bool m_bRetained;
            bool m_bInplace;
            bool m_bTensorCoreEnabled;
            int64_t m_i64AddGradientCount;
            int64_t m_i64Generation;
            int32_t m_i32DeviceIndex;
 
            CTensor<T>* m_pTsrValue;
            CTensor<T>* m_pTsrDerivative;
 
            Base::CPerformanceCounter m_perfForward;
            Base::CPerformanceCounter m_perfBackward;
 
            std::vector<int64_t>& m_vctShape;
            std::vector<int64_t>& m_vctShapeAsc;
 
            std::vector<CComputationalBase<T>*>& m_vctParentNodes;
 
            int64_t m_i64CommonVersion;
            bool m_bNonTrainingMemoryInheritance;
        private:
            friend class CComputationalGraph<T>;
            friend class CComputationalGraphUtilities<T>;
        };
 
        typedef CComputationalBase<float> CComputationalBaseF;
        typedef CComputationalBase<double> CComputationalBaseD;
 
        typedef CComputationalBase<float> CCBF;
        typedef CComputationalBase<double> CCBD;
 
        template <typename T>
        using CCB = CComputationalBase<T>;
    }
}
 
#endif