ComputationalGraphUtilities.h

#pragma once
 
#if _MSC_VER >= 1900 && defined(_M_X64)
 
#include <map>
 
namespace FLImaging
{
    namespace AI
    {
        template <typename T>
        class CComputationalBase;
 
        template <typename T>
        class CComputationalGraph;
 
        template <typename T>
        class CTensor;
 
        template <typename T>
        class CInternalOptimizerBase;
 
        template <typename T>
        class FL_EXPORT CComputationalGraphUtilities : public Base::CFLBase
        {
        private:
            CComputationalGraphUtilities();
 
        public:
            virtual ~CComputationalGraphUtilities();
 
            static const CResult SetBinaryData(const Base::CFLData* pFldModel, CComputationalBase<T>** ppResultModel, int64_t i64Base = 0, int64_t i64Size = -1);
            static const CResult SetBinaryData(const Base::CFLData* pFldModel, std::vector<Base::CFLString<wchar_t>>& vctModelID, CComputationalBase<T>** ppResultModel, std::vector<int64_t>& vctModelOffset, int64_t i64Base = 0, int64_t i64Size = -1);
            static const CResult GetBinaryData(const CComputationalBase<T>* pModel, Base::CFLData* pFldResult, bool bDumpMode = false, bool bAppend = false);
 
            static const CResult Load(const wchar_t* pWcsFileName, CComputationalBase<T>** ppResultModel);
            static const CResult Save(const wchar_t* pWcsFileName, const CComputationalBase<T>* pModel, bool bDumpMode = false);
 
            static const CResult GetSequentialNode(const CComputationalBase<T>* pModel, std::vector<const CComputationalBase<T>*>* pVctResult, bool bIncludeIntrinsicOperands = false, bool bIncludePlaceholderOperands = false, bool bStartFromTailNode = true, bool bOnlyActivatedNodes = true);
            static const CResult GetSequentialNode(std::vector<const CComputationalBase<T>*>& vctModels, std::vector<const CComputationalBase<T>*>* pVctResult, bool bIncludeIntrinsicOperands = false, bool bIncludePlaceholderOperands = false, bool bStartFromTailNode = true, bool bOnlyActivatedNodes = true);
            static const CResult GetSequentialNode(const CComputationalBase<T>* pModelStart, const CComputationalBase<T>* pModelEnd, std::vector<const CComputationalBase<T>*>* pVctResult, bool bIncludeIntrinsicOperands = false, bool bIncludePlaceholderOperands = false);
 
            static const CResult Evaluate(CComputationalBase<T>& cgLastLayer, CTensor<T>* pTsrOutput, int64_t i64DeviceIndex, const std::vector<int64_t>* pVctBatchIndices = nullptr, int32_t* pI32IterationFeedback = nullptr, int32_t i32MiniBatch = 0);
            static T Validate(CComputationalBase<T>& cgLabelLayer, CComputationalBase<T>& cgLastLayer, const std::vector<int64_t>* pVctBatchIndices = nullptr, int32_t* pI32IterationFeedback = nullptr);
            static const CResult Delete(CComputationalBase<T>* pCgLayer, bool bDeletePlaceholder = false);
            static const CResult Delete2(CComputationalBase<T>* pCgLayer);
            static int64_t GetMaxMiniBatch(CComputationalBase<T>* pModel, bool bTrainingMode, int64_t i64DeviceIndex, int64_t i64MaxMiniBatchRange = 0, double f64MemoryLimitRatio = 1., CInternalOptimizerBase<T>* pOptimizer = nullptr);
            static int64_t GetRequiredOptimizerMemory(CInternalOptimizerBase<T>* pOptimizer, int64_t i64MiniBatchSize = 1);
            static int64_t GetUniformMiniBatch(CComputationalBase<T>* pModel, bool bTrainingMode, int64_t i64MaxBatch = 0);
            static const CResult SetProcessingUnit(CComputationalBase<T>* pModel, const Base::CProcessingUnitBase* pPuBase, bool bRecursive = true);
 
            static const CResult ClearTensorMemory(CComputationalBase<T>* pModel);
 
            static const CResult RegisterComputationalBaseObjects(CComputationalBase<T>* pObject);
            static CComputationalBase<T>* CreateComputationalBaseObject(const Base::CFLString<char>& astrClassNameWithNamespace);
 
            static CComputationalGraphUtilities<T>* GetSingletonObject();
 
            static const CResult DuplicateGraph(const CComputationalBase<T>* pCgSource, CComputationalBase<T>** ppCgTarget, int32_t i32TargetDeviceNumber);
 
            static const CResult SetRetainedGraph(CComputationalBase<T>* pModel);
            static const CResult SetAddGradientCount(CComputationalBase<T>* pModel, int64_t i64AddGraidentCount);
 
            static const CResult GetGPUName(Base::CFLString<wchar_t>& strGPUName, int32_t& i32ComputeCapabilityMajor, int32_t& i32ComputeCapabilityMinor, int32_t i32DeviceIndex);
            static const CResult GetGPUMemoryInfo(int64_t& i64AvailableGPUMemory, int64_t& i64TotalGPUMemory, int32_t i32DeviceIndex);
            static const CResult ClearAllSharedMemory();
            static const CResult ResetCudaMemory(int32_t i32DeviceIndex);
 
            static const CResult SetCudaDevice(int32_t i32DeviceIndex);
            DeclareGetClassType();
 
            static const CResult ReApplyComputationalGraph(CComputationalGraph<T>* pReapplyCGCost, int64_t i64ReapplyClassCount, int64_t i64ChCount);
            static const CResult ReApplyComputationalGraph(CComputationalGraph<T>* pReapplyModel, const std::vector<Base::CFLString<wchar_t>>& vctGraphName, const std::vector<int64_t>& vctReapplyCount, const std::vector<bool>& vctAdjustToOut);
            static const CResult TransferModel(CComputationalGraph<T>* pTarget, const CComputationalGraph<T>* pSource);
            static const CResult TransferModel(std::vector<const CComputationalBase<T>*>& vctTarget, const std::vector<const CComputationalBase<T>*>& vctSource);
 
        public:
            std::map<Base::CFLString<char>, CComputationalBase<T>*>& m_mapSingletonObjects;
 
        protected:
            virtual void Throw(const CResult& res, const wchar_t* pWcsExtraMessage = nullptr) const override;
 
        private:
            static CComputationalGraphUtilities<T>* GetSingletonInstance();
        };
 
        typedef CComputationalGraphUtilities<float> CComputationalGraphUtilitiesF;
        typedef CComputationalGraphUtilities<double> CComputationalGraphUtilitiesD;
    }
}
 
#endif