ANN.h

 
#pragma once
 
#include "Method.h"
#include "Grids/Grid.h"
#include "nnet/nnet.h"
 
namespace SSAGES
{
 
    class ANN : public Method
    {
    private:
        Eigen::VectorXi topol_;
 
        unsigned int sweep_, nsweep_;
 
        unsigned int citers_;
 
        nnet::neural_net net_;
 
        double pweight_, weight_;
 
        double temp_, kbt_;
 
        Grid<Eigen::VectorXd>* fgrid_;
 
        Grid<unsigned int>* hgrid_;
 
        Grid<double>* ugrid_;
 
        Eigen::MatrixXd hist_, bias_, rbias_;
 
        std::vector<double> lowerb_, upperb_;
 
        std::vector<double> lowerk_, upperk_;
 
        std::string outfile_;
 
        bool preloaded_;
 
        bool overwrite_;
 
        void TrainNetwork();
 
        void WriteBias();
 
    public: 
 
        ANN(const MPI_Comm& world, 
            const MPI_Comm& comm, 
            const Eigen::VectorXi& topol,
            Grid<Eigen::VectorXd>* fgrid,
            Grid<unsigned int>* hgrid,
            Grid<double>* ugrid,
            const std::vector<double>& lowerb,
            const std::vector<double>& upperb,
            const std::vector<double>& lowerk,
            const std::vector<double>& upperk,
            double temperature,
            double weight,
            unsigned int nsweep
        );
 
        void PreSimulation(Snapshot* snapshot, const class CVManager& cvmanager) override;
 
        void PostIntegration(Snapshot* snapshot, const class CVManager& cvmanager) override;
 
        void PostSimulation(Snapshot* snapshot, const class CVManager& cvmanager) override;
 
 
        void SetPrevWeight(double h)
        {
            pweight_ = h;
        }
 
 
        void SetOutput(const std::string& outfile)
        {
            outfile_ = outfile;
        }
 
 
        void SetOutputOverwrite(bool overwrite)
        {
            overwrite_ = overwrite;
        }
 
 
        void SetConvergeIters(unsigned int citers)
        {
            citers_ = citers;
        }
 
 
        void SetMaxIters(unsigned int iters)
        {
            auto params = net_.get_train_params();
            params.max_iter = iters;
            net_.set_train_params(params);
        }
 
 
        void SetMinLoss(double loss)
        {
            auto params = net_.get_train_params();
            params.min_loss = loss; 
            net_.set_train_params(params);
        }
 
        void ReadBias(const std::string&, const std::string&);
 
        static ANN* Build(
            const Json::Value& json,
            const MPI_Comm& world,
            const MPI_Comm& comm,
            const std::string& path);
 
        ~ANN()
        {
            delete fgrid_;
            delete hgrid_;
        }
    };
}