Network.hpp

#pragma once
 
#include <cereal/cereal.hpp>  // for defer
#include <cereal/types/memory.hpp>
#include <cereal/types/vector.hpp>
#include <cstdlib>
#include <memory>
#include <variant>
#include <vector>
 
#include "Model.hpp"
#include "callbacks/Callback.hpp"
#include "data/TrainingData.hpp"
#include "layers/Dense.hpp"
#include "layers/Dropout.hpp"
#include "layers/Flatten.hpp"
#include "layers/Layer.hpp"
#include "losses/losses.hpp"
#include "optimizers/Optimizer.hpp"
#include "optimizers/optimizers.hpp"
#include "utils/Formatters.hpp"
#include "utils/Functions.hpp"
#include "utils/Gauge.hpp"
#include "utils/Variants.hpp"
 
namespace NeuralNet {
class Layer;
 
class Network : public Model {
 public:
  Network();
 
  void setup(const std::shared_ptr<Optimizer> &optimizer,
             LOSS loss = LOSS::QUADRATIC);
 
  void addLayer(std::shared_ptr<Layer> &layer);
 
  void setLoss(LOSS loss);
 
  std::shared_ptr<Layer> getLayer(int index) const;
 
  std::shared_ptr<Layer> getOutputLayer() const;
 
  size_t getNumLayers() const;
 
  std::string getSlug() const;
 
  double train(std::vector<std::vector<double>> X, std::vector<double> y,
               int epochs = 1,
               const std::vector<std::shared_ptr<Callback>> callbacks = {},
               bool progBar = true);
 
  double train(std::vector<std::vector<std::vector<double>>> X,
               std::vector<double> y, int epochs = 1,
               const std::vector<std::shared_ptr<Callback>> callbacks = {},
               bool progBar = true);
 
  double train(
      TrainingData<std::vector<std::vector<double>>, std::vector<double>>
          trainingData,
      int epochs = 1,
      const std::vector<std::shared_ptr<Callback>> callbacks = {},
      bool progBar = true);
 
  double train(TrainingData<std::vector<std::vector<std::vector<double>>>,
                            std::vector<double>>
                   trainingData,
               int epochs = 1,
               const std::vector<std::shared_ptr<Callback>> callbacks = {},
               bool progBar = true);
 
  Eigen::MatrixXd predict(std::vector<std::vector<double>> inputs);
 
  Eigen::MatrixXd predict(std::vector<std::vector<std::vector<double>>> inputs);
 
  void to_file(const std::string &filename) override {
    // Serializing model to a binary file
    std::ofstream file(filename, std::ios::binary);
    cereal::BinaryOutputArchive archive(file);
    archive(*this);
  }
 
  void from_file(const std::string &filename) override {
    // Making sure the file exists and is binary
    assert(fileExistsWithExtension(filename, ".bin") &&
           "The file doesn't exists or is not binary '.bin'");
 
    // Deserializing the model from the binary file
    std::ifstream file(filename, std::ios::binary);
    cereal::BinaryInputArchive archive(file);
    archive(*this);
  }
 
  ~Network();
 
 private:
  // non-public serialization
  friend class cereal::access;
 
  std::vector<std::shared_ptr<Layer>> layers;
  LOSS lossFunc =
      LOSS::QUADRATIC;  // Storing the loss function for serialization
  bool progBar = true;
  double (*cmpLoss)(const Eigen::MatrixXd &, const Eigen::MatrixXd &);
  Eigen::MatrixXd (*cmpLossGrad)(const Eigen::MatrixXd &,
                                 const Eigen::MatrixXd &);
  std::shared_ptr<Optimizer> optimizer;
 
  template <class Archive>
  void save(Archive &archive) const {
    archive(cereal::base_class<Model>(this), layers, lossFunc);
    archive.serializeDeferments();
  };
 
  template <class Archive>
  void load(Archive &archive) {
    archive(cereal::base_class<Model>(this), layers, lossFunc);
    setLoss(lossFunc);
  }
 
  template <typename D1, typename D2>
  double onlineTraining(std::vector<D1> inputs, std::vector<D2> labels,
                        int epochs,
                        std::vector<std::shared_ptr<Callback>> callbacks = {});
 
  template <typename D1, typename D2>
  double trainer(TrainingData<D1, D2> trainingData, int epochs,
                 std::vector<std::shared_ptr<Callback>> callbacks = {});
 
  template <typename D1, typename D2>
  double miniBatchTraining(
      TrainingData<D1, D2> trainingData, int epochs,
      std::vector<std::shared_ptr<Callback>> callbacks = {});
 
  template <typename D1, typename D2>
  double batchTraining(TrainingData<D1, D2> trainingData, int epochs,
                       std::vector<std::shared_ptr<Callback>> callbacks = {});
 
  Eigen::MatrixXd forwardProp(
      std::vector<std::vector<std::vector<double>>> &inputs,
      bool training = false);
 
  Eigen::MatrixXd forwardProp(std::vector<std::vector<double>> &inputs,
                              bool training = false);
 
  Eigen::MatrixXd forwardProp(Eigen::MatrixXd &inputs, bool training = false);
 
  Eigen::MatrixXd feedForward(Eigen::MatrixXd inputs, int startIdx = 0,
                              bool training = false);
 
  void backProp(Eigen::MatrixXd &outputs, Eigen::MatrixXd &y);
 
  void trainingCheckpoint(std::string checkpointName,
                          std::vector<std::shared_ptr<Callback>> callbacks);
 
  double computeAccuracy(Eigen::MatrixXd &outputs, Eigen::MatrixXd &y);
 
  void updateOptimizerSetup(size_t numLayers);
};
}  // namespace NeuralNet
 
CEREAL_REGISTER_TYPE(NeuralNet::Network);
 
CEREAL_REGISTER_POLYMORPHIC_RELATION(NeuralNet::Model, NeuralNet::Network);