Newer
Older
Michal Kravcenko
committed
/**
* 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"
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
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;
DESolver solver( n_equations, n_inputs, n_inner_neurons );
/* SETUP OF THE EQUATIONS */
MultiIndex alpha_0( n_inputs );
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));
DataSet ds_00(&data_vec_g);
/* Placing the conditions into the solver */
solver.set_error_function( 0, 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 );
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;
}
Michal Kravcenko
committed
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);
Michal Kravcenko
committed
// 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);
Michal Kravcenko
committed
return 0;
}