ComputationalGraphMaskRCNN.h

#pragma once
 
#if _MSC_VER >= 1900 && defined(_M_X64)
 
#include "DefinitionsAI.h"
#include "ComputationalGraph.h"
#include "ComputationalGraphPlaceholder.h"
#include "Tensor.h"
#include "BackendSoftmax.h"
#include "BackendSoftmaxWithCrossEntropy.h"
#include "BackendBCEWithLogistLoss.h"
#include "BackendSmoothL1Loss.h"
#include "BackendMultiScaleRoIAlign.h"
#include "BackendLabel.h"
#include "Tensor.h"
#include <vector>
#include <utility>
#include <functional>
 
namespace FLImaging
{
    namespace AI
    {
        template <typename T>
        class CInternalMaskRCNNParameters;
 
        template <typename T>
        class FL_EXPORT CInstanceSegmentationResult
        {
        public:
            CInstanceSegmentationResult();
            ~CInstanceSegmentationResult();
            void Clear();
        public:
            std::vector<CTensor<T>>& vctTsrBoxes;
            std::vector<CTensor<T>>& vctTsrLabels;
            std::vector<CTensor<T>>& vctTsrScores;
            std::vector<CTensor<T>>& vctTsrMasks;
        };
 
        template <typename T>
        class FL_EXPORT CComputationalGraphMaskRCNN : public CComputationalGraph<T>
        {
        private:
            CComputationalGraphMaskRCNN();
 
        protected:
            CComputationalGraphMaskRCNN(const CComputationalGraphMaskRCNN<T>& cg);
 
        public:
            CComputationalGraphMaskRCNN(const CComputationalBase<T>& cgFeature, const CComputationalBase<T>& cbProposals, int64_t i64ClassCount);
            CComputationalGraphMaskRCNN(const std::initializer_list<const CComputationalBase<T>*>& liFeatures, const CComputationalBase<T>& cbProposals, int64_t i64ClassCount);
            CComputationalGraphMaskRCNN(const std::vector<const CComputationalBase<T>*>& vctFeatures, const CComputationalBase<T>& cbProposals, int64_t i64ClassCount);
            CComputationalGraphMaskRCNN(const std::vector<const CComputationalBase<T>*>& vctHeadIntermediateProposalMaskGraph);
 
            virtual ~CComputationalGraphMaskRCNN();
 
            virtual CTensor<T>& Forward() override;
            virtual CTensor<T>* Backward() override;
            virtual CComputationalBase<T>* Clone() const override;
 
            virtual const std::vector<int64_t>& GetEstimatedShape(bool bRecursive = true) const override;
 
            virtual const CResult SetForegroundIoUThreshold(T tForegroundIoUThreshold);
            virtual T GetForegroundIoUThreshold() const;
 
            virtual const CResult SetBackgroundIoUThreshold(T tBackgroundIoUThreshold);
            virtual T GetBackgroundIoUThreshold() const;
 
            virtual const CResult SetImageWidth(int64_t i64ImageWidth);
            virtual int64_t GetImageWidth() const;
 
            virtual const CResult SetImageHeight(int64_t i64ImageHeight);
            virtual int64_t GetImageHeight() const;
 
            virtual const CResult SetNMSType(ENonMaximumSuppressionType eNMS);
            virtual int64_t GetNMSType() const;
 
            virtual const CResult SetNMSIoUThreshold(T tNMSIoUThreshold);
            virtual T GetNMSIoUThreshold() const;
 
            virtual const CResult SetObjectnessThreshold(T tObjectnessThreshold);
            virtual T GetObjectnessThreshold() const;
 
            virtual const CResult SetDetectionPerBatch(int64_t i64DetectionPerBatch);
            virtual int64_t GetDetectionPerBatch() const;
 
            virtual const CResult SetSamplerResultBoxCount(int64_t i64SamplerResultBoxCount);
            virtual int64_t GetSamplerResultBoxCount() const;
 
            virtual const CResult SetSamplerPositiveFraction(T tSamplerPositiveFraction);
            virtual T GetSamplerPositiveFraction() const;
 
            virtual T GetFasterRCNNBoxLoss() const;
            virtual T GetFasterRCNNScoreLoss() const;
            virtual T GetRPNBoxLoss() const;
            virtual T GetRPNScoreLoss() const;
            virtual T GetMaskLoss() const;
            virtual T GetTotalLoss() const;
 
            virtual const CInstanceSegmentationResult<T>* GetMaskRCNNInferenceResult() const;
 
            static CComputationalBase<T>* MakeMaskRCNNHead(const std::vector<const CComputationalBase<T>*>& vctFetures, const CComputationalBase<T>& cbProposals, int64_t i64OutputSize = 7);
            static CComputationalBase<T>* MakeMaskRCNNIntermediate(const std::vector<const CComputationalBase<T>*>& vctFetures, const CComputationalBase<T>& cgMaskRCNNHead, const CComputationalBase<T>& cbClassLogist, const CComputationalBase<T>& cbBoxRegression, const CComputationalBase<T>& cbProposals, int64_t i64OutputSize = 14);
 
            DeclareGetClassType();
            SupportToDuplicateObjectWithoutCreateNewObject(CComputationalGraphMaskRCNN, *this);
        public:
            virtual const CResult PrintNodeParamInfo() const;
 
            virtual const CResult GetBinaryData(Base::CFLData& fldBinary, bool bSuperClass = false, int32_t i32Version = -1, bool bDumpMode = false) const override;
            virtual const CResult GetBinaryData(Base::CFLData* pFldBinary, bool bSuperClass = false, int32_t i32Version = -1, bool bDumpMode = false) const override;
 
            virtual const CResult SetBinaryData(const Base::CFLData& fldBinary, int64_t* pI64Offset = nullptr) override;
            virtual const CResult SetBinaryData(const Base::CFLData* pFldBinary, int64_t* pI64Offset = nullptr) override;
 
            virtual int64_t GetRequiredDedicatedMemory(bool bTraining = false, bool bRecursively = true, int64_t i64BatchSize = 1) const override;
            virtual int64_t GetOperandIndexForNextBatchSize() const override;
        protected:
            virtual const CResult GenerateGraph(const std::vector<const CComputationalBase<T>*>& vctFeatures, const CComputationalBase<T>& cbProposals, int64_t i64ClassCount);
            virtual const CResult MaskRCNNLoss(const CTensor<T>* pTsrMaskLogist, const std::vector<CTensor<T>>& vctTsrMaskProposal, const std::vector<CTensor<T>>& vctTsrGTMasks, const std::vector<CTensor<T>>& vctTsrGTLabels, const std::vector<std::vector<uint32_t>>& vctMatchedIndexes, CTensor<T>& tsrResultMaskLoss);
            virtual const CResult MaskRCNNInference(const CTensor<T>* pTsrMaskLogist, const std::vector<CTensor<T>>& m_vctLabel, std::vector<CTensor<T>>& vctResultMask);
            virtual const CResult MaskRCNNLoss_Backward(const CTensor<T>* pTsrMaskLogist, const CTensor<T>* pTsrMaskLossDy, CTensor<T>* pTsrMaskLogistDx, bool bMaskLogistAddGraident);
            virtual const CResult CreateTargetBuffer();
 
            virtual CInternalMaskRCNNParameters<T>& GetMaskRCNNParameters() const;
        protected:
            CBackendBCEWithLogistLoss<T> m_backendBCELoss;
            CBackendMultiScaleRoIAlign<T> m_backendRoIAlign;
            CBackendLabel<T> m_backendLabel;
            T m_tRPNBoxLoss;
            T m_tRPNScoreLoss;
            T m_tFasterRCNNBoxLoss;
            T m_tFasterRCNNScoreLoss;
            T m_tMaskLoss;
            T m_tTotalLoss;
 
            CTensor<T> m_tsrMaskLogistSelected;
            CTensor<T> m_tsrMaskTargetSelected;
            CTensor<T> m_tsrMaskLogistDxSelected;
            CTensor<T> m_tsrSelectedLabel;
            CTensor<T> m_tsrMaskLogistSigmoid;
 
            CTensor<T> m_tsrMaskTargetSelectedBuffer;
            CTensor<T> m_tsrMaskLogistSelectedBuffer;
            CTensor<T> m_tsrMaskLogistSelectedDxBuffer;
 
            std::vector<CTensor<T>>& m_vctTsrTargetMasks;
            CTensor<T> m_tsrTargetMasksBuffer;
 
            bool m_bBackwardEnabled;
        public:
            DeclareGetSignletonObject(CComputationalGraphMaskRCNN);
        };
 
        #define CCGFMaskRCNN(...) (*(new CComputationalGraphMaskRCNN<float>(__VA_ARGS__)))
        #define CCGDMaskRCNN(...) (*(new CComputationalGraphMaskRCNN<double>(__VA_ARGS__)))
        #define CCGTMaskRCNN(T, ...) (*(new CComputationalGraphMaskRCNN<T>(__VA_ARGS__)))
 
    }
}
 
#endif