ComputationalGraph.h

#pragma once
 
#if _MSC_VER >= 1900 && defined(_M_X64)
 
#include "ComputationalBase.h"
#include "Tensor.h"
 
namespace FLImaging
{
    namespace AI
    {
        template <typename T>
        class CTensor;
 
        template <typename T>
        class CBackendBase;
 
        template <typename T>
        class COptimizer;
 
        template <typename T>
        class FL_EXPORT CComputationalGraph : public CComputationalBase<T>
        {
 
        public:
            CComputationalGraph();
        protected:
            CComputationalGraph(const CComputationalGraph<T>& cg);
 
        public:
            virtual ~CComputationalGraph();
 
            virtual const CResult GetBinaryData(Base::CFLData& fldBinary, bool bSuperClass = false, int32_t i32Version = -1, bool bDumpMode = false) const override;
            virtual const CResult GetBinaryData(Base::CFLData* pFldBinary, bool bSuperClass = false, int32_t i32Version = -1, bool bDumpMode = false) const override;
 
            virtual const CResult SetBinaryData(const Base::CFLData& fldBinary, int64_t* pI64Offset = nullptr) override;
            virtual const CResult SetBinaryData(const Base::CFLData* pFldBinary, int64_t* pI64Offset = nullptr) override;
 
            const CResult Assign(const CComputationalGraph<T>& cg);
            virtual const CResult Clear() override;
 
            virtual CTensor<T>& Evaluate() override;
            virtual CTensor<T>& Forward() = 0;
            virtual CTensor<T>* Backward() = 0;
 
            virtual void ClearDerivativesRecursive() override;
            virtual void ResetDerivativesRecursive() override;
 
            virtual CComputationalBase<T>* Clone() const = 0;
 
            virtual const CResult Swap(CComputationalBase<T>& cbSwap) override;
 
            virtual const CResult SetDeviceIndex(int32_t i32DeviceIndex) override;
 
            virtual const CComputationalBase<T>* GetAt(const wchar_t* pWcsName) const override;
            virtual const CResult FindByValueAttribute(EValueAttribute eValueAttribute, std::vector<const CComputationalBase<T>*>& vctResult) const override;
            virtual const CResult FindByNodeOperator(ENodeOperator eNodeOperator, std::vector<const CComputationalBase<T>*>& vctResult) const;
 
            virtual const CResult SetOperand(int64_t i64Index, const CComputationalBase<T>* pCbOperand, bool bSetSourceReferenceType = false);
            virtual const CResult SetOperand(const std::vector<const CComputationalBase<T>*>& cbOperands, bool bSetSourceReferenceType = false);
            virtual CComputationalBase<T>* GetOperand(int64_t i64Index) const;
            virtual bool IsIntrinsicOperand(int64_t i64Index) const;
            virtual int64_t GetOperandCount() const override;
 
            virtual CTensor<T>* GetMemberTensor(int64_t i64Index) const;
            virtual int64_t GetMemberTensorCount() const;
 
            virtual CBackendBase<T>* GetMemberBackend(int64_t i64Index) const;
            virtual int64_t GetMemberBackendCount() const;
 
            virtual int64_t GetNextBatchSize(int64_t i64BatchSize) const override;
            virtual const CResult EnableTrainingMode(bool bMode, bool bRecursively = true) override;
 
            virtual const CResult PrintGraphInfo(bool bRecursively = true, bool bShapeOrderAsc = false, bool bIncludeTensors = false) const override;
 
            virtual const CResult SetParentOptimizer(COptimizer<T>* pParentOptimizer, bool bRecursive = true);
            virtual const COptimizer<T>* GetParentOptimizer() const;
 
            virtual int64_t GetClassType() const = 0;
 
            virtual int64_t GetOperandIndexForNextBatchSize() const;
            virtual int64_t GetRequiredDedicatedMemory(bool bTraining = false, bool bRecursively = true, int64_t i64BatchSize = 1) const override;
            virtual int64_t GetRequiredTemporaryMemory(bool bTraining = false, bool bRecursively = true, int64_t i64BatchSize = 1, int64_t i64MemoryIndex = 0) const override;
 
            virtual const CTensor<T>& GetDerivativeTemp() const;
 
            virtual int64_t GetSharedMemoryCount() const;
            virtual const CResult EnableTensorCore(bool bTensorCore = true) override;
 
            SupportToDuplicateAbstractObject(CComputationalGraph);
        protected:
            virtual const CResult InternalAssign(const CComputationalGraph<T>& cg);
 
            virtual const CResult InternalConnectNode(const CComputationalBase<T>& cbOperand1);
            virtual const CResult InternalConnectNode(const CComputationalBase<T>& cbOperand1, const CComputationalBase<T>& cbOperand2);
            virtual const CResult InternalConnectNode(const CComputationalBase<T>& cbOperand1, const CComputationalBase<T>& cbOperand2, const CComputationalBase<T>& cbOperand3);
            virtual const CResult InternalConnectNode(const std::initializer_list<const CComputationalBase<T>*>& ilOperands);
            virtual const CResult InternalConnectNode(const std::vector<const CComputationalBase<T>*>& vctOperands);
 
            virtual const CResult InternalCreateOperandsNode(int64_t i64OperandsCount);
 
            virtual const CResult ClearParentNode();
            virtual const CResult RemoveCurrentParentNode();
            virtual const CResult UpdateParentNode();
 
            virtual const CResult ClearOperand();
            virtual const CResult UpdateGeneration(bool bRecursive = false);
 
            enum EMaxCount
            {
                EMaxCount_Operands = 3,
                EMaxCount_Derivatives = 3,
            };
 
            virtual bool AreOperatorsValid() const;
            virtual bool AreOperatorsAndTheirValuesValid();
 
            virtual bool InitializeDerivativeVariable();
 
            CBackendBase<T>** m_ppMemberBackend;
            CTensor<T>** m_ppTsrMemberTensor;
            int64_t m_i64MemberTensorCount;
            int64_t m_i64MemberBackendCount;
 
            int64_t m_i64SharedMemoryCount;
 
            CComputationalBase<T>** m_pCbOperands;
            bool* m_pArrBIntrinsicOperand;
            int64_t m_i64OperandsCount;
            CTensor<T> m_tsrDerivativeTemp;
            COptimizer<T>* m_pParentOptimizer;
        private:
            friend class CComputationalGraphUtilities<T>;
            friend class COptimizer<T>;
        };
 
        typedef CComputationalGraph<float> CComputationalGraphF;
        typedef CComputationalGraph<double> CComputationalGraphD;
 
        typedef CComputationalGraph<float> CCGF;
        typedef CComputationalGraph<double> CCGD;
 
        template <typename T>
        using CCG = CComputationalGraph<T>;
    }
}
 
#endif