simulator.cpp

//
// Created by martin on 25.11.18.
//

/**
 * This file serves for testing of various examples, have fun!
 *
 * @author Michal Kravčenko
 * @date 14.6.18 -
 */

#include <iostream>
#include <cstdio>
#include <fstream>
#include <vector>
#include <utility>
#include <algorithm>
#include <assert.h>

#include "4neuro.h"
#include "../CrossValidator/CrossValidator.h"


int main(int argc, char** argv){

    try {

        /* Read data from the file */
        l4n::CSVReader reader("/home/martin/Desktop/data_Heaviside.txt", "\t", true);  // File, separator, skip 1st line
        reader.read();  // Read from the file

        /* Create data set for both the training and testing of the neural network */
        std::vector<unsigned int> inputs = { 3 };  // Possible multiple inputs, e.g. {0,3}
        std::vector<unsigned int> outputs = { 1 };  // Possible multiple outputs, e.g. {1,2}

        l4n::DataSet ds = reader.get_data_set(&inputs, &outputs);  // Creation of data-set for NN
        ds.normalize();  // Normalization of data to prevent numerical problems

//        ds.print_data();  // Printing of data-set to check it

        /* Neural network construction */

        // Numbers of neurons in layers (including input and output layers)
        std::vector<unsigned int> neuron_numbers_in_layers = {1, 10, 10, 1};

        // Creation of fully connected feed-forward network with linear activation functions for input and output
        // layers and the specified a.f. for the hidden ones
        l4n::FullyConnectedFFN nn(&neuron_numbers_in_layers, l4n::NEURON_TYPE::LOGISTIC);

        /* Error function */
        l4n::MSE mse(&nn, &ds);  // First parameter - neural network, second parameter - data-set

        /* Domain - important for Particle Swarm method */
        std::vector<double> domain_bounds(2 * (nn.get_n_weights() + nn.get_n_biases()));
        for(size_t i = 0; i < domain_bounds.size() / 2; ++i){
            domain_bounds[2 * i] = -10;
            domain_bounds[2 * i + 1] = 10;
        }

        /* Training method */

        // Parameters
        // 1) domain_bounds Bounds for every optimized parameter (p1_lower, p1_upper, p2_lower, p2_upper...)
        // 2) c1 Cognitive parameter
        // 3) c2 Social parameter
        // 4) w Inertia weight
        // 5) gamma Threshold value for particle velocity - all particles must posses the same or slower velocity for the algorithm to end
        // 6) epsilon Radius of the cluster area (Euclidean distance)
        // 7) delta Amount of particles, which has to be in the cluster for the algorithm to stop (0-1)
        // 8) n_particles Number of particles in the swarm
        // 9) iter_max Maximal number of iterations - optimization will stop after that, even if not converged
  //    l4n::ParticleSwarm ps(&domain_bounds,
  //                          1.711897,
  //                          1.711897,
  //                          0.711897,
  //                          0.5,
  //                          20,
  //                          0.7,
  //                          600,
  //                          1000);

        // Parameters
        // 1) Threshold for the successful ending of the optimization - deviation from minima
        // 2) Number of iterations to reset step size to tolerance/10.0
        // 3) Maximal number of iterations - optimization will stop after that, even if not converged
        l4n::GradientDescent gs(1e-3, 100, 10);

        // Weight and bias randomization in the network according to the uniform distribution
        // Calling methods nn.randomize_weights() and nn.randomize_biases()
        nn.randomize_parameters();

//        gs.optimize(mse);  // Network training
//        std::vector<double> i(ds.get_input_dim());
//        std::vector<double> o(ds.get_output_dim());
//        nn.eval_single(i, o);  // Evaluate network for one input and save the result into the output vector

        /* Cross - validation */
        l4n::CrossValidator cv(&gs, &mse);

        // Parameters: 1) Number of data-set parts used for CV, 2) Number of tests performed
        cv.run_k_fold_test(10, 1);

        /* Save network to the text file */
        nn.save_text("test_net.4n");

        /* Check of the saved network */
        std::cout << std::endl << "The original network info:" << std::endl;
        nn.print_stats();
        nn.print_weights();

        l4n::NeuralNetwork nn_loaded("test_net.4n");
        std::cout << std::endl << "The loaded network info:" << std::endl;
        nn_loaded.print_stats();
        nn_loaded.print_weights();

        /* Example of evaluation of a single input, normalized input, de-normalized output */
        std::vector<double> input_norm(ds.get_input_dim()),
                            input(ds.get_input_dim()),
                            output_norm(ds.get_output_dim()),
                            expected_output_norm(ds.get_output_dim()),
                            output(ds.get_output_dim()),
                            expected_output(ds.get_output_dim());

        size_t data_idx = 0;
        ds.get_input(input_norm, data_idx);
        ds.get_output(expected_output_norm, data_idx);

        nn_loaded.eval_single(input_norm, output_norm);

        ds.de_normalize_single(output_norm, output);
        ds.de_normalize_single(input_norm, input);
        ds.de_normalize_single(expected_output_norm, expected_output);

        std::cout << std::endl << "input: ";
        for (auto el: input_norm) { std::cout << el << ", "; }
        std::cout << std::endl;
        std::cout << "output: ";
        for (auto el: output) { std::cout << el << ", "; }
        std::cout << std::endl;
        std::cout << "expected output: ";
        for (auto el: expected_output) { std::cout << el << ", "; }
        std::cout << std::endl;

        return 0;

    } catch(const std::runtime_error& e) {
        std::cerr << e.what() << std::endl;
        exit(EXIT_FAILURE);
    } catch(const std::out_of_range& e) {
        std::cerr << e.what() << std::endl;
        exit(EXIT_FAILURE);
    } catch(const std::invalid_argument& e) {
        std::cerr << e.what() << std::endl;
        exit(EXIT_FAILURE);
    }

}