DiscriminativePCNetwork.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <memory>
#include <deepity/layers/DiscriminativePCLayer.h>
#include <deepity/utils/Optimize.h>
#include <deepity/utils/MemoryArena.h>

 
namespace Deep
{
    class PCNDiagnostics;
    class DiscriminativePCNetwork
    {
        std::vector<std::unique_ptr<DiscriminativePCLayer>> layers;
        int batchSize;
        bool autoSize = true;
 
    public:
        DiscriminativePCNetwork() : batchSize(0), autoSize(true) {}
        DiscriminativePCNetwork(int batchSize) : batchSize(batchSize), autoSize(false) {}

        ~DiscriminativePCNetwork() = default;

        DiscriminativePCNetwork(DiscriminativePCNetwork &&other) noexcept = default;
        DiscriminativePCNetwork &operator=(DiscriminativePCNetwork &&other) noexcept = default;

        void AddLayer(int size, int nextSize, float lr, float ir, float pr, float lmbda,
                      void (*act)(float *, size_t), void (*dAct)(float *, size_t, bool));

        void AddLayer(int size, int nextSize, float lr, float ir, float pr, float lmbda,
                      Deep::ActivationType aType, Deep::ActivationType dType);

        void RandomizeWeights(std::mt19937 &rng);

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

        float CalculateState();

        void UpdateState();

        void UpdateWeights();

        void UpdatePrecision();

        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);

        void ResetState() noexcept;

        const auto &GetLayers() const noexcept { return layers; }

        int GetBatchSize() const noexcept { return batchSize; }

        DiscriminativePCLayer *GetTerminalLayer() const
        {
            if (layers.empty())
                return nullptr;
            return layers.back().get();
        }

        void SetLearningRate(float lr)
        {
            for (auto &layer : layers)
                layer->SetLearningRate(lr);
        }

        void SetInferenceRate(float ir)
        {
            for (auto &layer : layers)
                layer->SetLearningRate(ir);
        }

        void SetPrecisionRate(float pr)
        {
            for (auto &layer : layers)
                layer->SetPrecisionRate(pr);
        }

        void SetLambda(float l)
        {
            for (auto &layer : layers)
                layer->SetLambda(l);
        }

        void SetOptimizer(OptimizerType opt) noexcept
        {
            for (auto &layer : layers)
                layer->SetOptimizer(opt);
        }

        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);

        bool Save(const std::string &filename) const noexcept;
        bool Load(const std::string &filename) noexcept;

        void Compile();
 
    private:
        std::unique_ptr<MemoryArena> arena;
        friend class PCNDiagnostics;
    };
}