Training.h

Go to the documentation of this file.

// n2p2 - A neural network potential package
// Copyright (C) 2018 Andreas Singraber (University of Vienna)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef TRAINING_H
#define TRAINING_H
 
#include "Atom.h"
#include "Dataset.h"
#include "Stopwatch.h"
#include "Updater.h"
#include <cstddef> // std::size_t
#include <fstream> // std::ofstream
#include <map>     // std::map
#include <random>  // std::mt19937_64
#include <string>  // std::string
#include <vector>  // std::vector
 
namespace nnp
{
 
class Training : public Dataset
{
public:
    enum UpdaterType
    {
        UT_GD,
        UT_KF,
        UT_LM
    };
 
    enum ParallelMode
    {
        //PM_DATASET,
        /* Parallel gradient computation, update on rank 0.
         *
         * Data set is distributed via MPI, each tasks selects energy/force
         * update candidates, and computes errors and gradients, which are
         * collected on rank 0. Weight update is carried out on rank 0 and new
         * weights are redistributed to all tasks.
         */
        PM_TRAIN_RK0,
        PM_TRAIN_ALL
    };
 
    enum JacobianMode
    {
        JM_SUM,
        JM_TASK,
        JM_FULL
    };
 
    enum UpdateStrategy
    {
        US_COMBINED,
        US_ELEMENT
    };
 
    enum SelectionMode
    {
        SM_RANDOM,
        SM_SORT,
        SM_THRESHOLD
    };
 
    Training();
    ~Training();
    void                  selectSets();
    void                  writeSetsToFiles();
    void                  initializeWeights();
    void                  initializeWeightsMemory(UpdateStrategy updateStrategy
                                                      = US_COMBINED);
    void                  setStage(std::size_t stage);
    void                  dataSetNormalization();
    void                  setupTraining();
    std::vector<
    std::string>          setupNumericDerivCheck();
    void                  calculateNeighborLists();
    void                  calculateError(
                                   std::map<std::string,
                                   std::pair<
                                   std::string, std::string>> const fileNames);
    void                  calculateErrorEpoch();
    void                  printHeader();
    void                  printEpoch();
    void                  writeWeights(
                                      std::string const& nnName,
                                      std::string const& fileNameFormat) const;
    void                  writeWeightsEpoch() const;
    void                  writeLearningCurve(bool              append,
                                             std::string const fileName
                                                 = "learning-curve.out") const;
    void                  writeNeuronStatistics(
                                            std::string const& nnName,
                                            std::string const& fileName) const;
    void                  writeNeuronStatisticsEpoch() const;
    void                  resetNeuronStatistics();
    void                  writeUpdaterStatus(bool              append,
                                             std::string const fileNameFormat
                                                 = "updater.%03zu.out") const;
    void                  sortUpdateCandidates(std::string const& property);
    void                  shuffleUpdateCandidates(std::string const& property);
    void                  checkSelectionMode();
    void                  loop();
    void                  setEpochSchedule();
    void                  update(std::string const& property);
    double                getSingleWeight(std::size_t element,
                                          std::size_t index);
    void                  setSingleWeight(std::size_t element,
                                          std::size_t index,
                                          double      value);
    std::vector<
    std::vector<double> > calculateWeightDerivatives(Structure* structure);
    std::vector<
    std::vector<double> > calculateWeightDerivatives(Structure*  structure,
                                                     std::size_t atom,
                                                     std::size_t component);
    void                  setTrainingLogFileName(std::string fileName);
    std::size_t           getNumConnections(std::string id = "short") const;
    std::vector<
    std::size_t>          getNumConnectionsPerElement(
                                               std::string id = "short") const;
    std::vector<
    std::size_t>          getConnectionOffsets(std::string id = "short") const;
    void                  dPdc(std::string                       property,
                               Structure&                        structure,
                               std::vector<std::vector<double>>& dEdc);
    void                  dPdcN(
                             std::string                       property,
                             Structure&                        structure,
                             std::vector<std::vector<double>>& dEdc,
                             double                            delta = 1.0E-4);
 
private:
    struct UpdateCandidate
    {
        std::size_t s;
        std::size_t a;
        std::size_t c;
        double      error;
 
        bool operator<(UpdateCandidate const& rhs) const {
            return this->error > rhs.error;
        }
    };
 
    struct Property
    {
        Property(std::string const& property);
 
        std::string                  property;
        std::string                  displayMetric;
        std::string                  tiny;
        std::string                  plural;
        SelectionMode                selectionMode;
        std::size_t                  numTrainPatterns;
        std::size_t                  numTestPatterns;
        std::size_t                  taskBatchSize;
        std::size_t                  writeCompEvery;
        std::size_t                  writeCompAlways;
        std::size_t                  posUpdateCandidates;
        std::size_t                  rmseThresholdTrials;
        std::size_t                  countUpdates;
        std::size_t                  numUpdates;
        std::size_t                  patternsPerUpdate;
        std::size_t                  patternsPerUpdateGlobal;
        std::size_t                  numErrorsGlobal;
        double                       epochFraction;
        double                       rmseThreshold;
        std::vector<int>             errorsPerTask;
        std::vector<int>             offsetPerTask;
        std::vector<std::string>     errorMetrics;
        std::map<
        std::string, double>         errorTrain;
        std::map<
        std::string, double>         errorTest;
        std::vector<UpdateCandidate> updateCandidates;
        std::vector<
        std::vector<int>>            weightsPerTask;
        std::vector<
        std::vector<int>>            offsetJacobian;
        std::vector<
        std::vector<double>>         error;
        std::vector<
        std::vector<double>>         jacobian;
        std::map<
        std::size_t, SelectionMode>  selectionModeSchedule;
    };
 
    struct PropertyMap : std::map<std::string, Property>
    {
        Property& operator[](std::string const& key) {return this->at(key);}
        Property const& operator[](std::string const& key) const
        {
            return this->at(key);
        }
        bool exists(std::string const& key)
        {
            return (this->find(key) != this->end());
        }
    };
 
    UpdaterType              updaterType;
    ParallelMode             parallelMode;
    JacobianMode             jacobianMode;
    UpdateStrategy           updateStrategy;
    bool                     hasUpdaters;
    bool                     hasStructures;
    bool                     useForces;
    bool                     repeatedEnergyUpdates;
    bool                     freeMemory;
    bool                     writeTrainingLog;
    std::size_t              stage;
    std::size_t              numUpdaters;
    std::size_t              numEpochs;
    std::size_t              epoch;
    std::size_t              writeWeightsEvery;
    std::size_t              writeWeightsAlways;
    std::size_t              writeNeuronStatisticsEvery;
    std::size_t              writeNeuronStatisticsAlways;
    std::size_t              countUpdates;
    std::size_t              numWeights;
    double                   forceWeight;
    std::string              trainingLogFileName;
    std::string              nnId;
    std::ofstream            trainingLog;
    std::vector<int>         epochSchedule;
    std::vector<std::size_t> numWeightsPerUpdater;
    std::vector<std::size_t> weightsOffset;
    std::vector<std::string> pk;
#ifndef N2P2_FULL_SFD_MEMORY
    std::vector<double>      dGdxia;
#endif
    std::vector<
    std::vector<double> >    weights;
    std::vector<Updater*>    updaters;
    std::map<
    std::string, Stopwatch>  sw;
    std::mt19937_64          rngNew;
    std::mt19937_64          rngGlobalNew;
    PropertyMap              p;
 
 
    bool advance() const;
    void getWeights();
    void setWeights();
    void addTrainingLogEntry(int         proc,
                             std::size_t il,
                             double      f,
                             std::size_t isg,
                             std::size_t is);
    void addTrainingLogEntry(int         proc,
                             std::size_t il,
                             double      f,
                             std::size_t isg,
                             std::size_t is,
                             std::size_t ia,
                             std::size_t ic);
    void addTrainingLogEntry(int         proc,
                             std::size_t il,
                             double      f,
                             std::size_t isg,
                             std::size_t is,
                             std::size_t ia);
#ifndef N2P2_FULL_SFD_MEMORY
    void collectDGdxia(Atom const& atom,
                       std::size_t indexAtom,
                       std::size_t indexComponent);
#endif
    void randomizeNeuralNetworkWeights(std::string const& type);
    void setupSelectionMode(std::string const& property);
    void setupFileOutput(std::string const& type);
    void setupUpdatePlan(std::string const& property);
    void allocateArrays(std::string const& property);
    void writeTimingData(bool              append,
                         std::string const fileName = "timing.out");
};
 
}
 
#endif