Evaluator.h

#pragma once
 
#if _MSC_VER >= 1900 && defined(_M_X64)
 
#include "ComputationalGraphObjectDetection.h"
#include "ComputationalGraphMaskRCNN.h"
#include "Tensor.h"
#include <atomic>
 
namespace FLImaging
{
    namespace AI
    {
        template <typename T>
        class CComputationalGraph;
 
        template <typename T>
        class CComputationalGraphPlaceholder;
 
        template<typename T>
        class CBackendEvaluatorBase;
 
        template<typename T>
        class CBackendEvaluatorForObjectDetection;
 
        template<typename T>
        class CBackendEvaluatorForInstanceSegmentation;
 
        template <typename T>
        class FL_EXPORT CEvaluator : public CAlgorithmAIBase
        {
        public:
            enum EModelType
            {
                EModelType_Classifier = 0,
                EModelType_SemanticSegmentation,
                EModelType_ObjectDetection,
                EModelType_InstanceSegmentation,
                EModelType_AnomalyDetection,
                EModelType_SuperResolution,
                EModelType_DenoisingDiffusion,
                EModelType_StringBasedOCR,
            };
 
            CEvaluator();
            CEvaluator(const CEvaluator<T>& evaluator);
            CEvaluator(const CEvaluator<T>* pEvaluator);
            virtual ~CEvaluator();
 
            virtual const CResult Assign(const CEvaluator<T>& evaluator);
            virtual const CResult Assign(const CEvaluator<T>* pEvaluator);
 
            virtual const CResult Clear();
 
            virtual const CResult Initialize();
            virtual bool IsInitialized() const;
 
            virtual const CResult SetFunction(const CComputationalGraph<T>* pCgEvaluationLayer);
            virtual const CComputationalGraph<T>& GetFunction() const;
 
            virtual const CResult SetDeviceIndex(int32_t i32DeviceIndex);
            virtual const CResult SetDeviceIndex(const std::vector<int32_t>& vctDeviceIndices);
            virtual const CResult SetDeviceIndex(const std::vector<uint32_t>& vctDeviceIndices);
            virtual const CResult SetDeviceIndex(const Base::CFLArray<int32_t>& flaDeviceIndices);
            virtual const CResult SetDeviceIndex(const Base::CFLArray<uint32_t>& flaDeviceIndices);
            virtual const std::vector<int32_t>& GetDeviceIndex() const;
            virtual const CResult ResetDeviceIndex();
 
            virtual const CResult SetModelType(EModelType eModelType = EModelType_Classifier);
            virtual EModelType GetModelType();
 
            virtual const CResult SetMemoryLimitRatio(double f64MemoryLimitRatio = 1.);
            virtual double GetMemoryLimitRatio() const;
 
            virtual const CResult SetSamplingStep(int32_t i32TotalSamplingStep = 1000);
            virtual int32_t GetSamplingStep() const;
 
            virtual const CResult EnableDecoder(bool bDecoder = false);
            virtual bool IsDecoderEnabled() const;
 
            virtual const CResult Evaluate(Base::CFLArray<int32_t>* pFlaIterationFeedback = nullptr, bool* pBStopImmediatedly = nullptr, std::vector<bool>* pVctEvaluatedIndex = nullptr);
 
            virtual const CTensor<T>* GetResultEvaluation() const;
            virtual const std::vector<std::vector<std::vector<std::tuple<CObjectBox<float>, float, int64_t>>>>* GetResultBox() const;
            virtual const CInstanceSegmentationResult<T>* GetInstanceSegmentationResult() const;
            virtual int64_t GetTotalIteration() const;
            virtual int64_t GetActualTotalBatchSize() const;
 
            virtual const Base::CFLArray<uint32_t> GetInvolvedDeviceIndices() const;
 
            DeclareGetClassType();
            SupportToDuplicateAbstractObject(CEvaluator<T>);
 
        protected:
            virtual const CResult CopyBatchParams(bool bDifferent);
            virtual CBackendEvaluatorBase<T>* CreateNewBackendEvaluator();
 
        protected:
            std::vector<int32_t>& m_vctDeviceIndices;
            std::vector<int32_t>& m_vctActiveDeviceIndices;
            std::vector<int32_t>& m_vctDeviceInUse;
            std::vector<int32_t>& m_vctPrevDeviceIndices;
 
            CComputationalGraph<T>* m_pCgEvaluationLayer;
            CTensor<T> m_tsrResult;
 
            std::vector<CComputationalGraph<T>*>& m_vctFunctions;
 
            bool m_bGPUDevice;
            bool m_bDifferent;
            bool m_bInitialized;
            int64_t m_i64InitialBatch;
 
            int32_t m_i32DeviceCount;
 
            int64_t m_i64ActualMiniBatchSize;
            int64_t m_i64TotalIteration;
            int64_t m_i64TotalIterationPerDevice;
            int64_t m_i64TotalBatchSize;
            int64_t m_i64CurrentIteration;
 
            std::vector<CBackendEvaluatorBase<T>*>& m_vctEvaluator;
            EModelType m_eModelType;
            EModelType m_ePrevModelType;
 
            std::vector<std::vector<std::vector<std::tuple<CObjectBox<float>, float, int64_t>>>>& m_vct3BoxResult;
            CInstanceSegmentationResult<T> m_instanceSegmentationResult;
 
            double m_f64MemoryLimitRatio;
            double m_f64PrevMemoryLimitRatio;
 
            int32_t m_i32TotalSamplingStep;
            bool m_bDecoder;
        private:
            template<typename T>
            friend class CBackendEvaluatorBase;
 
            template<typename T>
            friend class CBackendEvaluatorForObjectDetection;
 
            template<typename T>
            friend class CBackendEvaluatorForInstanceSegmentation;
 
            template<typename T>
            friend class CBackendEvaluatorForDenoisingDiffusion;
 
            template<typename T>
            friend class CBackendEvaluatorForStringBasedOCR;
        };
 
 
        typedef CEvaluator<float> CEvaluatorF;
        typedef CEvaluator<double> CEvaluatorD;
    }
}
 
#endif