InternalOptimizerBase.h

#pragma once
 
#if _MSC_VER >= 1900 && defined(_M_X64)
 
#include "DefinitionsAI.h"
#include "Tensor.h"
#include <vector>
 
namespace FLImaging
{
    namespace AI
    {
        template <typename T>
        class CComputationalGraph;
 
        template <typename T>
        class CComputationalGraphPlaceholder;
 
        template <typename T>
        class CLearningRateSchedulerBase;
 
        template <typename T>
        class CClassEqualizerBase;
 
        template <typename T>
        class CComputationalGraphAugmentationBase;
 
        template <typename T>
        class CValidatorBase;
 
        template <typename T>
        class COptimizer;
 
        template <typename T>
        class FL_EXPORT CInternalOptimizerBase : public CAlgorithmAIBase
        {
        public:
 
            CInternalOptimizerBase();
            virtual ~CInternalOptimizerBase();
 
            virtual const CResult Assign(const CInternalOptimizerBase<T>& ob);
            virtual const CResult Assign(const CInternalOptimizerBase<T>* pOb);
 
            virtual CInternalOptimizerBase<T>* Clone() const = 0;
 
            virtual const CResult Initialize();
            virtual const CResult InitializeBatch();
            virtual bool IsInitialized() const;
 
            virtual const CResult SetFunction(CComputationalGraph<T>& cgFunction);
            virtual CComputationalGraph<T>& GetFunction();
 
            virtual const CResult SetAugmentation(CComputationalGraph<T>* pCgAugmentation);
            virtual CComputationalGraph<T>* GetAugmentation();
 
            virtual const CResult Fit(T* pClippingThreshold= nullptr, int32_t* pI32IterationFeedbackFeedback = nullptr) = 0;
            virtual const CResult BackPropagation();
            virtual T Validate(int32_t* pI32IterationFeedback = nullptr);
 
            virtual const CTensor<T>& GetResult() const;
 
            virtual int64_t GetRequiredDedicatedMemory(int64_t i64BatchSize) const;
 
            virtual const CResult SetValidator(CValidatorBase<T>& vali);
            virtual const CResult SetValidator(CValidatorBase<T>* pVali);
            virtual const CValidatorBase<T>* GetValidator() const;
 
            virtual const std::vector<int64_t>& GetValidationIndices() const;
 
            virtual const CResult ResetDerivatives();
 
            virtual const CResult ClipGradient(T* pClippingThreshold = nullptr);
            virtual const CResult UpdateWeights() = 0;
 
            virtual const CResult EnableResetDerivatives(bool bResetDerivatives);
            virtual bool IsResetDerivativesEnabled() const;
 
            virtual int64_t GetTotalIteration() const;
 
            virtual const CResult InitializeMiniBatch();
 
            virtual const CResult SetDeviceIndex(int32_t i32DeviceIndex);
            virtual int32_t GetDeviceIndex() const;
 
            virtual const CResult SetOptimizerIndex(int32_t i32OptimizerIndex = 0);
            virtual int32_t GetOptimizerIndex() const;
 
            virtual const CResult SetMemoryLimitRatio(double f64MemoryLimitRatio = 1.);
            virtual double GetMemoryLimitRatio() const;
 
        protected:
            virtual void Throw(const CResult& res, const wchar_t* pWcsExtraMessage = nullptr) const override;
            virtual const CResult InitializeFit();
            virtual const CResult TerminateFit();
            virtual const CResult TerminateMiniBatch();
 
            virtual const CResult MakeBatchTensor();
 
            void ClearVariablesAndDerivatives();
 
            virtual const CResult InitializeCurrentIteration(int64_t i64SubdivisionIndex = 0);
            virtual const CResult LoadTensor(int64_t i64SubdivisionIndex = 0);
        protected:
            std::vector<CComputationalBase<T>*>& m_vctInputList;
            std::vector<CComputationalGraphPlaceholder<T>*>& m_vctPlaceholders;
            std::vector<CTensor<T>*>& m_vctOrgTensors;
            std::vector<int64_t>& m_vctLearnOrders;
            std::vector<int64_t>& m_vctValidationOrders;
            std::vector<CTensor<T>*>& m_vctBatchTensors;
 
            CComputationalGraph<T>* m_pCgFunction;
            CComputationalGraph<T>* m_pCgAugmentation;
            std::vector<std::pair<CTensor<T>*, CTensor<T>*>>* m_pVctVariablesAndDerivatives;
            bool m_bInitialized;
            bool m_bObjectAugmentationPrefeched;
            bool m_bFitTerminated;
            CResult m_resLoadTensorResult;
 
            CTensor<T> m_tsrResult;
            int64_t m_i64ResultCount;
 
            bool m_bResetDerivatives;
 
            T m_tLearningRate;
 
            //
            bool m_bDifferent;
            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_bActualUpdate;
 
            int32_t m_i32DeviceCount;
            int32_t m_i32DeviceIndex;
            int32_t m_i32OptimizerIndex;
            CValidatorBase<T>* m_pValidator;
 
            std::vector<CTensor<T>*>& m_vctDelayedLoader;
 
            int64_t m_i64MiniBatchSize;
            int64_t m_i64Subdivision;
            int64_t m_i64SubMiniBatchSize;
            int64_t m_i64ActualMiniBatchSize;
            int64_t m_i64TotalIteration;
            int64_t m_i64CurrentIteration;
 
            double m_f64MemoryLimitRatio;
 
            volatile int64_t m_i64LoadCount;
            volatile bool m_bLoadNextIteration;
            volatile bool m_bEndSubdivision;
            volatile bool m_bEndIteration;
            COptimizer<T>* m_pParentOptimizer;
        private:
            template<typename T>
            friend class CValidatorBase;
 
            template<typename T>
            friend class CValidatorForClassifier;
 
            template<typename T>
            friend class CValidatorForSemanticSegmentation;
 
            template<typename T>
            friend class CValidatorForObjectDetection;
 
            template<typename T>
            friend class CValidatorForAnomalyDetection;
 
            template<typename T>
            friend class CValidatorForSuperResolution;
 
            template<typename T>
            friend class CValidatorForInstanceSegmentation;
 
            template<typename T>
            friend class CValidatorForStringBasedOCR;
 
            template<typename T>
            friend class CValidatorForGAN;
 
            template<typename T>
            friend class COptimizer;
        };
 
        typedef CInternalOptimizerBase<float> CInternalOptimizerBaseF;
        typedef CInternalOptimizerBase<double> CInternalOptimizerBaseD;
    }
}
 
#endif