net_test_harmonic_oscilator.cpp

/**
 * Example solving the eigenvalue problem:
 *
 *
 *
 * @author Michal Kravčenko
 * @date 3.9.18 -
 */

#include <random>
#include <iostream>
#include <fstream>

#include "../../include/4neuro.h"
#include "../Solvers/DESolver.h"

void test_harmonic_oscilator_fixed_E(double EE, double accuracy, size_t n_inner_neurons, size_t train_size, double ds, double de, size_t n_test_points, double ts, double te, size_t max_iters, size_t n_particles){
    std::cout << "Finding a solution via the Particle Swarm Optimization" << std::endl;
    std::cout << "********************************************************************************************************************************************" <<std::endl;

    /* SOLVER SETUP */
    size_t n_inputs = 1;
    size_t n_equations = 1;
    l4n::DESolver solver( n_equations, n_inputs, n_inner_neurons );

    /* SETUP OF THE EQUATIONS */
    l4n::MultiIndex alpha_0( n_inputs );
    l4n::MultiIndex alpha_2( n_inputs );
    alpha_2.set_partial_derivative(0, 2);

    /* the governing differential equation */
    char buff[255];
    std::sprintf(buff, "%f", -EE);
    std::string eigenvalue(buff);
    solver.add_to_differential_equation( 0, alpha_2, "-1.0" );
    solver.add_to_differential_equation( 0, alpha_0, "x^2" );
    solver.add_to_differential_equation( 0, alpha_0, eigenvalue );

    /* SETUP OF THE TRAINING DATA */
    std::vector<double> inp, out;

    double d1_s = ds, d1_e = de, frac;

    /* TRAIN DATA FOR THE GOVERNING DE */
    std::vector<std::pair<std::vector<double>, std::vector<double>>> data_vec_g;


    /* ISOTROPIC TRAIN SET */
    frac = (d1_e - d1_s) / (train_size - 1);
    for(unsigned int i = 0; i < train_size; ++i){
        inp = {frac * i + d1_s};
        out = {0.0};
        data_vec_g.emplace_back(std::make_pair(inp, out));
    }
//    inp = {0.0};
//    out = {1.0};
//    data_vec_g.emplace_back(std::make_pair(inp, out));

    l4n::DataSet ds_00(&data_vec_g);

    /* Placing the conditions into the solver */
    solver.set_error_function( 0, l4n::ErrorFunctionType::ErrorFuncMSE, &ds_00 );

    /* PARTICLE SWARM TRAINING METHOD SETUP */
    size_t total_dim = (2 + n_inputs) * n_inner_neurons;

    std::vector<double> params(total_dim), params_analytical(total_dim);
    std::random_device seeder;
    std::mt19937 gen(seeder());
    std::uniform_real_distribution<double> dist(-10.0, 10.0);

    std::vector<double> input(1);
    //must encapsulate each of the partial error functions
    std::vector<double> domain_bounds(2 * total_dim);
    for(unsigned int i = 0; i < total_dim; ++i){
        domain_bounds[2 * i] = -10.0;
        domain_bounds[2 * i + 1] = 10.0;
    }


    double c1 = 1.7, c2 = 1.7, w = 0.7;
    /* if the maximal velocity from the previous step is less than 'gamma' times the current maximal velocity, then one
     * terminating criterion is met */
    double gamma = 0.5;

    /* if 'delta' times 'n' particles are in the centroid neighborhood given by the radius 'epsilon', then the second
     * terminating criterion is met ('n' is the total number of particles) */
    double epsilon = 0.02;
    double delta = 0.9;
    solver.solve_via_particle_swarm( &domain_bounds, c1, c2, w, n_particles, max_iters, gamma, epsilon, delta );

    l4n::NeuralNetwork *solution = solver.get_solution( alpha_0 );
    std::vector<double> parameters(total_dim);//w1, a1, b1, w2, a2, b2, ... , wm, am, bm
    std::vector<double> *weight_params = solution->get_parameter_ptr_weights();
    std::vector<double> *biases_params = solution->get_parameter_ptr_biases();
    for(size_t i = 0; i < n_inner_neurons; ++i){
        parameters[3 * i] = weight_params->at(i);
        parameters[3 * i + 1] = weight_params->at(i + n_inner_neurons);
        parameters[3 * i + 2] = biases_params->at(i);

        printf("Path %3d. w%d = %15.8f, b%d = %15.8f, a%d = %15.8f\n", (int)(i + 1), (int)(i + 1), parameters[3 * i], (int)(i + 1), parameters[3 * i + 2], (int)(i + 1), parameters[3 * i + 1]);
    }

    /* ISOTROPIC TEST SET FOR BOUNDARY CONDITIONS */
    /* first boundary condition & its error */
    std::ofstream ofs("data_1d_osc.txt", std::ofstream::out);
    printf("Exporting files 'data_1d_osc.txt': %7.3f%%\r", 0.0);
    frac = (te - ts) / (n_test_points - 1);

    for(size_t i = 0; i < n_test_points; ++i){
        double x = frac * i + ts;

        inp[0] = x;
        solution->eval_single(inp, out);
        ofs << i + 1 << " " << x << " " << out[0] << " " << std::endl;

        printf("Exporting files 'data_1d_osc.txt': %7.3f%%\r", (100.0 * i) / (n_test_points - 1));
        std::cout.flush();
    }
    printf("Exporting files 'data_1d_osc.txt': %7.3f%%\n", 100.0);
    std::cout.flush();
    ofs.close();

    inp[0] = -1.0;
    solution->eval_single(inp, out);
    printf("y(-1) = %f\n", out[0]);
    inp[0] = 0.0;
    solution->eval_single(inp, out);
    printf("y( 0) = %f\n", out[0]);
    inp[0] = 1.0;
    solution->eval_single(inp, out);
    printf("y( 1) = %f\n", out[0]);
    std::cout << "********************************************************************************************************************************************" <<std::endl;
}

int main() {
    std::cout << "Running lib4neuro harmonic Oscilator example   1" << std::endl;
    std::cout << "********************************************************************************************************************************************" <<std::endl;
    std::cout << "          Governing equation: -y''(x) + x^2 * y(x) = E * y(x)" << std::endl;
    std::cout << "********************************************************************************************************************************************" <<std::endl;
    std::cout << "Expressing solution as y(x) = sum over [a_i / (1 + exp(bi - wxi*x ))], i in [1, n], where n is the number of hidden neurons" <<std::endl;
    std::cout << "********************************************************************************************************************************************" <<std::endl;

    double EE = -1.0;
    unsigned int n_inner_neurons = 2;
    unsigned int train_size = 10;
    double accuracy = 1e-3;
    double ds = -5.0;
    double de = 5.0;

    unsigned int test_size = 300;
    double ts = -6.0;
    double te = 6.0;

    size_t particle_swarm_max_iters = 1000;
    size_t n_particles = 100;
    test_harmonic_oscilator_fixed_E(EE, accuracy, n_inner_neurons, train_size, ds, de, test_size, ts, te, particle_swarm_max_iters, n_particles);

//    std::string expression_string = "-x";
//    std::string expression_string_1 = "1.0";
//    ExprtkWrapper f(expression_string);
//    ExprtkWrapper f1(expression_string_1);
//
//
//    f1.eval();
//
//    std::vector<double> inp(1);
//
//    inp = {150};
//    double result = f.eval(inp);
//
//    f1.eval();
//    inp = {15};
//    result = f.eval(inp);
    return 0;
}