BackendEvaluatorBase.h

#pragma once
 
#if _MSC_VER >= 1900 && defined(_M_X64)
 
#include "DefinitionsAI.h"
#include "BackendBase.h"
#include "Tensor.h"
 
namespace FLImaging
{
    namespace AI
    {
        template <typename T>
        class CComputationalGraphPlaceholder;
 
        template <typename T>
        class CEvaluator;
 
        template <typename T>
        class CComputationalGraphUtilities;
 
        template <typename T>
        class CBackendEvaluatorForObjectDetection;
 
        template <typename T>
        class CBackendEvaluatorForInstanceSegmentation;
 
        template <typename T>
        class FL_EXPORT CBackendEvaluatorBase : public CBackendBase<T>
        {
        public:
            CBackendEvaluatorBase();
            CBackendEvaluatorBase(CEvaluator<T>* pEvaluator);
            CBackendEvaluatorBase(CBackendEvaluatorBase<T>& evaluator);
            CBackendEvaluatorBase(CBackendEvaluatorBase<T>* pEvaluator);
            virtual ~CBackendEvaluatorBase();
 
            virtual const CResult Clear() override;
 
            virtual const CResult Assign(CBackendEvaluatorBase<T>& evaluator);
            virtual const CResult Assign(CBackendEvaluatorBase<T>* pEvaluator);
 
            virtual const CResult Initialize();
 
            virtual const CResult Evaluate(int32_t* pI32IterationFeedback = nullptr, bool* pBStopImmediatedly = nullptr, std::vector<bool>* pVctEvaluatedIndex = nullptr);
 
            virtual const CResult SetEvaluatorIndex(int64_t i64EvaluatorIndex);
            virtual int64_t GetEvaluatorIndex() const;
 
            virtual const CResult SetMemoryLimitRatio(double f64MemoryLimitRatio);
            virtual double GetMemoryLimitRatio() const;
 
            virtual const CTensor<T>* GetResult() const;
 
            virtual const CResult SetProcessingUnit(const Base::CProcessingUnitBase& pub) override;
            virtual const CResult SetProcessingUnit(const Base::CProcessingUnitBase* pPub) override;
 
            DeclareGetClassType();
            SupportToDuplicateObject(CBackendEvaluatorBase<T>);
 
        protected:
            virtual void Throw(const CResult& res, const wchar_t* pWcsExtraMessage = nullptr) const override;
        protected:
            virtual const CResult InitializeMiniBatch();
            virtual const CResult MakeBatchTensor(bool bDifferent);
            virtual const CResult LoadTensor(int64_t i64IterationIndex = 0);
            virtual const CResult InitializeCurrentIteration(int64_t i64IterationIndex = 0);
        protected:
            std::vector<CTensor<T>*>& m_vctOrgTensors;
            std::vector<CTensor<T>*>& m_vctBatchTensors;
            std::vector<CComputationalGraphPlaceholder<T>*>& m_vctPlaceholders;
 
            CEvaluator<T>* m_pEvaluator;
            CTensor<T> m_tsrResult;
 
            int64_t m_i64EvaluatorIndex;
 
            int64_t m_i64ActualMiniBatchSize;
            int64_t m_i64AvailableMiniBatchSize;
            int64_t m_i64TotalIteration;
            int64_t m_i64TotalBatchSize;
            int64_t m_i64CurrentIteration;
 
            int64_t m_i64PrevInputSize;
            int64_t m_i64PrevPlaceholderSize;
            std::vector<std::tuple<ENodeType, EDataType, EValueAttribute, ENodeOperator, std::vector<int64_t>>>& m_vctPrevInputInfo;
            std::vector<std::vector<int64_t>>& m_vctPrevPlaceholderShape;
 
            bool m_bDifferent;
 
            std::vector<CTensor<T>*>& m_vctDelayedLoader;
            volatile int64_t m_i64LoadCount;
            volatile bool m_bEvaluationTerminate;
            volatile bool m_bLoadNextIteration;
            volatile bool m_bEndSubdivision;
            CResult m_resLoadTensorResult;
 
            double m_f64MemoryLimitRatio;
        protected:
            template <typename T>
            friend class CComputationalGraphUtilities;
 
            template <typename T>
            friend class CEvaluator;
 
            template <typename T>
            friend class CBackendEvaluatorForObjectDetection;
 
            template <typename T>
            friend class CBackendEvaluatorForInstanceSegmentation;
        };
    }
}
 
#endif