Layer.hpp

#pragma once
 
#include <Eigen/Dense>
#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 <cmath>
#include <cstdlib>
#include <random>
#include <string>
#include <tuple>
 
#include "Network.hpp"
#include "activations/activations.hpp"
#include "utils/Enums.hpp"
#include "utils/Functions.hpp"
#include "utils/Serialize.hpp"
 
namespace NeuralNet {
// Should be updated when a new layer type is added
enum class LayerType { DEFAULT, DENSE, FLATTEN, DROPOUT };
 
class Layer {
  friend class Network;
 
 public:
  Layer(){};
 
  Eigen::MatrixXd getOutputs() const { return outputs; };
 
  int getNumNeurons() const { return nNeurons; };
 
  virtual std::string getSlug() const = 0;
 
  void printOutputs() {
    std::cout << this->outputs << "\n";
    return;
  };
 
  virtual Eigen::MatrixXd feedInputs(std::vector<double> inputs,
                                     bool training = false) {
    return this->feedInputs(Eigen::MatrixXd::Map(&inputs[0], inputs.size(), 1));
  };
 
  virtual Eigen::MatrixXd feedInputs(Eigen::MatrixXd inputs,
                                     bool training = false) = 0;
 
  virtual void feedInputs(std::vector<std::vector<std::vector<double>>> inputs,
                          bool training = false) {
    assert(false &&
           "Cannot feed 3d vectors, a Flatten layer could do it though");
    return;
  };
 
  const std::string typeStr() {
    static const std::map<LayerType, std::string> typeMap = {
        {LayerType::DEFAULT, "Base"},
        {LayerType::DENSE, "Dense"},
        {LayerType::FLATTEN, "Flatten"},
        {LayerType::DROPOUT, "Dropout"}};
 
    auto it = typeMap.find(this->type);
    if (it != typeMap.end()) return it->second;
 
    return "Unknown";
  };
 
  virtual ~Layer(){};
 
 private:
  // non-public serialization
  friend class cereal::access;
 
  // Necessary function for serializing Layer
  template <class Archive>
  void save(Archive &archive) const {
    archive(outputs, type, trainingOnly, nNeurons);
  };
 
  template <class Archive>
  void load(Archive &archive) {
    archive(outputs, type, trainingOnly, nNeurons);
  }
 
 protected:
  int nNeurons;
  Eigen::MatrixXd outputs;
  LayerType type = LayerType::DEFAULT;
  bool trainingOnly = false;  // If true skip during inferences
 
  void setOutputs(Eigen::MatrixXd outputs)  // used for the Flatten Layer
  {
    this->outputs = outputs;
  };
 
  void setOutputs(std::vector<double> outputs) {
    assert(outputs.size() == nNeurons);
    this->outputs =
        Eigen::MatrixXd ::Map(&outputs[0], this->getNumNeurons(), 1);
  };
 
  virtual Eigen::MatrixXd computeOutputs(Eigen::MatrixXd inputs,
                                         bool training = false) = 0;
 
  virtual void init(int args) {};
 
  Layer(std::tuple<int, int> inputShape)
      : nNeurons(std::get<0>(inputShape) *
                 std::get<1>(inputShape)){};  // Used in Flatten layer
};
}  // namespace NeuralNet
 
CEREAL_REGISTER_TYPE(NeuralNet::Layer);