Model.hpp

#pragma once
 
#include <cereal/access.hpp>
#include <cereal/archives/binary.hpp>
#include <cereal/archives/portable_binary.hpp>
#include <cereal/types/base_class.hpp>
#include <cereal/types/common.hpp>
#include <cereal/types/polymorphic.hpp>
#include <csignal>
#include <fstream>
#include <string>
#include <type_traits>
 
#include "utils/Functions.hpp"
 
namespace NeuralNet {
class Model {
 public:
  template <typename T, typename = typename std::enable_if<
                            std::is_base_of<Model, T>::value>::type>
  static void save_to_file(const std::string &filename, T model) {
    // Serializing model to a binary file
    std::ofstream file(filename, std::ios::binary);
    cereal::BinaryOutputArchive archive(file);
    archive(model);
  };
 
  template <typename T, typename = typename std::enable_if<
                            std::is_base_of<Model, T>::value>::type>
  static void load_from_file(const std::string &filename, T &model) {
    // 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(model);
  };
 
  virtual void to_file(const std::string &filename) = 0;
  virtual void from_file(const std::string &filename) = 0;
 
  // Declare at least one virtual function
  virtual ~Model() = default;
 
 private:
  friend class cereal::access;
 
  // Serialization function
  template <class Archive>
  void save(Archive &archive) const {
    archive(loss, accuracy);
  };
 
  template <class Archive>
  void load(Archive &archive) {
    archive(loss, accuracy);
  };
 
 protected:
  friend class Callback;
  int cEpoch = 0;  // Current epoch
  double loss = 0, accuracy = 0, testLoss = 0, testAccuracy = 0;
 
  void registerSignals() const {
    // Registering signals
    signal(SIGINT, signalHandler);
    signal(SIGTERM, signalHandler);
  }
};
}  // namespace NeuralNet
 
CEREAL_REGISTER_TYPE(NeuralNet::Model);