ValidatorBase.h

#pragma once
 
#if _MSC_VER >= 1900 && defined(_M_X64)
 
#include <atomic>
 
namespace FLImaging
{
    namespace AI
    {
        template <typename T>
        class CComputationalGraph;
 
        template<typename T>
        class CInternalOptimizerBase;
 
        template<typename T>
        class CComputationalGraphPlaceholder;
 
        template<typename T>
        class CTensor;
 
        template <typename T>
        class FL_EXPORT CValidatorBase : public Base::CFLBase
        {
 
        public:
            CValidatorBase();
            CValidatorBase(const CValidatorBase<T>& validator);
            CValidatorBase(const CValidatorBase<T>* pValidator);
            virtual ~CValidatorBase();
 
            virtual const CResult Assign(const CValidatorBase<T>& validator);
            virtual const CResult Assign(const CValidatorBase<T>* pValidator);
 
            virtual const CResult Clear();
 
            virtual const CResult Initialize();
 
            virtual const CResult SetOptimizer(const CInternalOptimizerBase<T>* pOptimizer);
            virtual const CInternalOptimizerBase<T>* GetOptimizer() const;
 
            virtual const CResult SetValidationLabels(CTensor<T>* pTsrValidationLabels);
            virtual const CResult SetValidationLabels(const std::vector<CTensor<T>*>& vctValidationLabels);
            virtual const CResult SetValidationLabels(const std::vector<CTensor<T>*>* pVctValidationLabels);
            virtual const CTensor<T>* GetValidationLabels(int64_t i64Index = 0) const;
            virtual const CResult GetValidationLabels(std::vector<CTensor<T>*>& vctValidationLabels) const;
            virtual int64_t GetValidationLabelCount() const;
 
            virtual const CResult SetValidationFunctions(const CComputationalGraph<T>* pCgLabelLayer, const CComputationalGraph<T>* pCgValidationLayer);
            virtual const CResult GetValidationFunctions(CComputationalGraph<T>** ppCgLabelLayer, CComputationalGraph<T>** ppCgValidationLayer) const;
 
            virtual T Validate(int32_t* pI32IterationFeedback = nullptr) = 0;
 
            DeclareGetClassType();
            SupportToDuplicateAbstractObject(CValidatorBase<T>);
 
        protected:
            virtual void Throw(const CResult& res, const wchar_t* pWcsExtraMessage = nullptr) const override;
            virtual const CResult InitializeMiniBatch();
            virtual const CResult InitializeCurrentIteration(int64_t i64IterationIndex = 0);
            virtual const CResult LoadTensor(int64_t i64IterationIndex = 0);
 
        protected:
            CComputationalGraph<T>* m_pCgLabelLayer;
            CComputationalGraph<T>* m_pCgValidationLayer;
            CInternalOptimizerBase<T>* m_pOptimizer;
            std::vector<CTensor<T>*>& m_vctValidationLabels;
 
            std::vector<CTensor<T>*>& m_vctOrgTensors;
            std::vector<CTensor<T>*>& m_vctBatchTensors;
            std::vector<CComputationalGraphPlaceholder<T>*>& m_vctPlaceholders;
 
            bool m_bDifferent;
            int64_t m_i64InitialBatch;
 
            std::vector<CTensor<T>*>& m_vctDelayedLoader;
 
            volatile int64_t m_i64LoadCount;
            volatile bool m_bValidationTerminate;
            volatile bool m_bLoadNextIteration;
            volatile bool m_bEndSubdivision;
            CResult m_resLoadTensorResult;
        private:
            template<typename T>
            friend class COptimizer;
 
            template<typename T>
            friend class CInternalOptimizerBase;
 
            template<typename T>
            friend class COptimizerForStringBasedOCR;
        };
 
 
        typedef CValidatorBase<float> CValidatorBaseF;
        typedef CValidatorBase<double> CValidatorBaseD;
    }
}
 
#endif