layer.h

/******************************************************
*   
*   GENERIC LAYER CLASS HEADER
*
******************************************************/
 
#ifndef LAYER_H 
#define LAYER_H 
 
//STD libs
#include<vector>
 
//OpenMP libs
#include<omp.h>
 
//Eigen
#include"Eigen/Dense"
 
//NeuranNet headers
#include"activation_functions.h"
 
/******************************************************
*   Generic layer class
******************************************************/
class layer
{
    public:
    //Ctors
    layer(){    };
    layer(const std::vector<std::vector<double>> &weights_,const std::vector<double> &biases_);
    layer(const std::vector<std::vector<double>> &weights_);
    layer(const Eigen::MatrixXd &weights_);
    layer(const Eigen::MatrixXd &weights_,const std::vector<double> &biases_);
    layer(const Eigen::MatrixXd &weights_,const Eigen::VectorXd &biases_);
    layer(const Eigen::MatrixXd &weights_,const Eigen::VectorXd &biases_, int in_dim, int out_dim);
 
    //Dtor
    virtual ~layer(){   };
    
    //Compute the output of the layer given an input
    virtual Eigen::VectorXd predict(const Eigen::VectorXd & input) {return input;};
    virtual std::vector<Eigen::VectorXd> predict_batch(const std::vector<Eigen::VectorXd> & input) {return input;};
    
    //Functions to get biases and weights from the network
    const Eigen::VectorXd get_biases();
    const Eigen::MatrixXd get_weights();
    const Eigen::MatrixXd get_weights_biases_as_mat();
    const Eigen::MatrixXd get_weights_biases_as_vec_col_maj();
    const Eigen::MatrixXd get_weights_biases_as_vec_row_maj();
    double get_weight(int i, int j);
    double get_bias(int i);
    
    //Set biases and weights (supposing they are alread
    void set_biases(const Eigen::VectorXd & biases_);
    void set_biases(const std::vector<double> & biases_);
    void set_weights(const Eigen::MatrixXd & weights_);
    void set_weight(int i, int j, double weight_);
    void set_bias(int i,double bias_);
    void set_weights_biases_compact(Eigen::MatrixXd &source);
    void set_weights_biases(Eigen::MatrixXd &source);
    void set_weights_biases_row_maj(Eigen::MatrixXd &source);
 
    //Get info about the layer
    int get_num_nodes();
    int get_input_size();
    int get_weights_rows();
    int get_weights_cols();
    std::string get_type();
        
    //Compute Jacobians w.r.t. weights/biases or inputs
    virtual Eigen::MatrixXd compute_partial_derivatives_wrt_inputs(Eigen::VectorXd &input) = 0;
    virtual Eigen::MatrixXd compute_partial_derivatives_wrt_weights_biases(Eigen::VectorXd &input) = 0;
 
    //Utils
    void transpose_weights();
    
    //Set the parameters to approximate x -> exp(-x) and x-> ln(1+exp(x)) for large values of the argument
    //See the description of the variables exp_max_cut and exp_zero_approx
    void set_exp_max_cut(double exp_max_cut_);
    void set_exp_zero_approx(double exp_zero_approx_);
    
    //Get the parameters to approximate x -> exp(-x) and x->ln(1+exp(x)) for large arguments
    double get_exp_max_cut();
    double get_exp_zero_approx();
     
    protected:
    //Biases and weights of the neural network
    Eigen::VectorXd biases;
    Eigen::MatrixXd weights;
    //Dimensions of the input/output spaces and of the weights matrix
    int weights_rows = 0;
    int input_dim = 0;
    int output_dim = 0; 
    int weights_cols = 0;
    //Type of layer
    std::string type; 
    //Parameters to approximate x -> exp(-x) and x-> ln(1+exp(x)) large arguments
    double exp_max_cut = 50.;
    double exp_zero_approx = 1.92874984e-22;
 
};
 
#endif /* layer_H */