SimpleConvPCNetwork.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <memory>
#include <random>
#include <deepity/layers/SimpleConvPCLayer.h>
#include <deepity/utils/MemoryArena.h>
#include <deepity/utils/DeviceMemoryArena.h>
#include <deepity/backend/IComputeBackend.h>
#include <deepity/backend/DeviceType.h>

 
namespace Deep
{
    class PCNDiagnostics;

    class SimpleConvPCNetwork
    {
    public:
        explicit SimpleConvPCNetwork(int batchSize, DeviceType device = DeviceType::DEVICE_CPU) noexcept;
 
        SimpleConvPCNetwork(const SimpleConvPCNetwork &) = delete;
        SimpleConvPCNetwork &operator=(const SimpleConvPCNetwork &) = delete;
 
        ~SimpleConvPCNetwork() = default;

        void AddLayer(int inChannels, int outChannels,
                      int inHeight, int inWidth,
                      int kernelH, int kernelW,
                      int strideH = 1, int strideW = 1,
                      int padH = 0, int padW = 0,
                      float lr = 1e-6f, float ir = 0.1f, float lmbda = 1e-2f,
                      ActivationType aType = ActivationType::RELU,
                      ActivationType dType = ActivationType::dRELU);

        void SetOptimizer(OptimizerType opt) noexcept;

        void Compile();

        void RandomizeWeights(std::mt19937 &rng) noexcept;
        void ResetState() noexcept;

        void Clamp(const std::vector<float> &input) noexcept;

        float CalculateState() noexcept;
        void UpdateState() noexcept;

        void UpdateWeights() noexcept;

        SimpleConvPCLayer *GetTerminalLayer() noexcept { return layers.back().get(); }
        const auto &GetLayers() const noexcept { return layers; }
        int GetBatchSize() const noexcept { return batchSize; }

        float TrainStep(const std::vector<float> &x, const std::vector<float> &y, int inferenceSteps);

        std::vector<float> Predict(const std::vector<float> &x, int inferenceSteps);

        void ProjectForward() noexcept;
        float TrainStepWithProjection(const std::vector<float> &x, const std::vector<float> &y, int inferenceSteps);
        std::vector<float> PredictWithProjection(const std::vector<float> &x, int inferenceSteps);
 
    private:
        std::vector<std::unique_ptr<SimpleConvPCLayer>> layers;
        std::unique_ptr<IComputeBackend> backend;
        DeviceType device;
        std::unique_ptr<MemoryArena> cpuArena;
#if defined(DEEPITY_USE_CUDA)
        std::unique_ptr<DeviceMemoryArena> gpuArena;
#endif
        int batchSize;
        OptimizerType pendingOpt = OptimizerType::SGD;
        friend class PCNDiagnostics;
    };
} // namespace Deep