neural_network.h

/******************************************************
*   
*       NEURAL NETWORK CLASS
*
******************************************************/
 
#ifndef NEURAL_NETWORK_H 
#define NEURAL_NETWORK_H 
 
 
//STD libs
#include<math.h>
#include<vector>
#include<fstream>
#include<iostream>
#include<string>
 
//OpenMP libs
#include<omp.h>
 
//Eigen libs
#include"Eigen/Dense"
 
//Neural network libs
#include"layers.h"
#include"layer.h"
 
using namespace std;
 
class neural_network
{
    public:
    //ctor
    neural_network(){num_layers = 0;};
    neural_network(const std::vector<layer*> &ls);
    
    //dtor
    ~neural_network(){ for (int i = 0; i < num_layers; i++){ delete layers[i];}};
    
    //Info about the neural network
    
    int get_num_layers();
    void print_network_info();
    //Prediction functions
    
    void print_network_detailed_info();
    //Prediction functions (serial version). 
    Eigen::VectorXd predict(const Eigen::VectorXd &input);
    Eigen::VectorXd predict_to_layer(int tolayer,const Eigen::VectorXd &input);
    //Prediction functions - Parallel version
    std::vector<Eigen::VectorXd> predict(const std::vector<Eigen::VectorXd> &input);
    std::vector<Eigen::VectorXd> predict_to_layer(int tolayer,const std::vector<Eigen::VectorXd> &input);
    
    //Save/read the network
    
    void network_read(const std::string &filename);
    void network_save(const std::string &filename);
    
    //Builds the network
    void add_layer_all_parameters(int wrows, int wcols, int in_dim, int out_dim, std::string type);
    void add_fc_input_layer(int in_dim, int out_dim, std::string type);
    void add_fc_hidden_layer(int out_dim, std::string type);
    
    //Set and get biases and weights. To be used with the python wrapper
    void set_layer_weights(int num_layer, Eigen::MatrixXd& weights_);
    void set_layer_biases(int num_layer, Eigen::VectorXd& biases_);
    Eigen::MatrixXd get_layer_weights(int num_layer);
    Eigen::VectorXd get_layer_biases(int num_layer);
    
    //Loss functions
    double loss_mse(const std::vector<Eigen::VectorXd> &data, const std::vector<Eigen::VectorXd> &features);
    double accuracy(const std::vector<Eigen::VectorXd> &data, const std::vector<Eigen::VectorXd> &features);
    
    //SiMEC 1D algos
    
    void SiMEC_1D(std::string output_file, int steps, double delta, bool invert_build, Eigen::VectorXd ipoint);
    void SiMEC_1D_norm_proj(std::string output_file, int steps, double delta, bool invert_build, Eigen::VectorXd ipoint, Eigen::VectorXd &H_inf, Eigen::VectorXd &H_sup);
    void SiMEC_1D_stop_boundary(std::string output_file, int steps, double delta, bool invert_build, Eigen::VectorXd ipoint, Eigen::VectorXd &H_inf, Eigen::VectorXd &H_sup);
    
    //SiMExp 1D algos
    void SiMExp_1D(std::string output_file, double delta, double epsilon, int max_steps, bool invert_build, Eigen::VectorXd & ipoint);
    void ClassChange_1D(std::string output_file, int steps, double delta, bool invert_build, Eigen::VectorXd ipoint);
    
    
    
    layer* get_layer(int n)
    {
        return layers[n];
    }
        
    private:
    int num_layers;
    std::vector<layer*> layers; 
};
 
 
 
 
 
 
#endif /* NEURAL_NETWORK_H */