Newer
Older
//
// Created by martin on 20.08.19.
//
void optimize_via_particle_swarm(l4n::NeuralNetwork& net,
l4n::ErrorFunction& ef) {
/* TRAINING METHOD SETUP */
std::vector<double> domain_bounds(2 * (net.get_n_weights() + net.get_n_biases()));
for (size_t i = 0; i < domain_bounds.size() / 2; ++i) {
domain_bounds[2 * i] = -150;
domain_bounds[2 * i + 1] = 150;
double c1 = 1.7;
double c2 = 1.7;
double w = 0.7;
size_t n_particles = 300;
size_t iter_max = 500;
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
/* 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.7;
l4n::ParticleSwarm swarm_01(
&domain_bounds,
c1,
c2,
w,
gamma,
epsilon,
delta,
n_particles,
iter_max
);
swarm_01.optimize(ef);
net.copy_parameter_space(swarm_01.get_parameters());
/* ERROR CALCULATION */
std::cout << "Run finished! Error of the network[Particle swarm]: " << ef.eval(nullptr) << std::endl;
std::cout
<< "***********************************************************************************************************************"
<< std::endl;
}
double optimize_via_gradient_descent(l4n::NeuralNetwork& net,
l4n::ErrorFunction& ef) {
std::cout
<< "***********************************************************************************************************************"
<< std::endl;
l4n::GradientDescentBB gd(1e-6,
1000,
60000);
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
gd.optimize(ef);
net.copy_parameter_space(gd.get_parameters());
/* ERROR CALCULATION */
double err = ef.eval(nullptr);
std::cout << "Run finished! Error of the network[Gradient descent]: " << err << std::endl;
/* Just for validation test purposes - NOT necessary for the example to work! */
return err;
}
double optimize_via_LBMQ(l4n::NeuralNetwork& net,
l4n::ErrorFunction& ef) {
size_t max_iterations = 10000;
size_t batch_size = 0;
double tolerance = 1e-6;
double tolerance_gradient = tolerance;
double tolerance_parameters = tolerance;
std::cout
<< "***********************************************************************************************************************"
<< std::endl;
l4n::LevenbergMarquardt lm(
max_iterations,
batch_size,
tolerance,
tolerance_gradient,
tolerance_parameters
);
lm.optimize(ef);
net.copy_parameter_space(lm.get_parameters());
/* ERROR CALCULATION */
double err = ef.eval(nullptr);
// std::cout << "Run finished! Error of the network[Levenberg-Marquardt]: " << err << std::endl;
/* Just for validation test purposes - NOT necessary for the example to work! */
return err;
}
int main() {
try{
/* Specify cutoff functions */
// l4n::CutoffFunction1 cutoff1(10.1);
l4n::CutoffFunction2 cutoff1(8);
//l4n::CutoffFunction2 cutoff2(25);
// l4n::CutoffFunction2 cutoff2(15.2);
// l4n::CutoffFunction2 cutoff4(10.3);
// l4n::CutoffFunction2 cutoff5(12.9);
// l4n::CutoffFunction2 cutoff6(11);
// l4n::G1 sym_f1(&cutoff1);
l4n::G2 sym_f2(&cutoff1, 2.09, 0.8);
l4n::G2 sym_f3(&cutoff1, 0.01, 0.04);
// l4n::G2 sym_f4(&cutoff2, 0.02, 0.04);
// l4n::G2 sym_f5(&cutoff2, 2.09, 0.04);
// l4n::G3 sym_f4(&cutoff4, 0.3);
// l4n::G4 sym_f5(&cutoff5, 0.05, true, 0.05);
// l4n::G4 sym_f6(&cutoff5, 0.05, false, 0.05);
// l4n::G4 sym_f7(&cutoff6, 0.5, true, 0.05);
// l4n::G4 sym_f8(&cutoff6, 0.5, false, 0.05);
std::vector<l4n::SymmetryFunction*> helium_sym_funcs = {&sym_f2, &sym_f3}; //, &sym_f4, &sym_f5}; //, &sym_f6, &sym_f7, &sym_f8};
l4n::Element helium = l4n::Element("He",
helium_sym_funcs);
std::unordered_map<l4n::ELEMENT_SYMBOL, l4n::Element*> elements;
elements[l4n::ELEMENT_SYMBOL::He] = &helium;
/* Read data */
l4n::XYZReader reader("/home/bes0030/HE4+T0.xyz", true);
reader.read();
std::cout << "Finished reading data" << std::endl;
std::shared_ptr<l4n::DataSet> ds = reader.get_acsf_data_set(elements);
/* Create a neural network */
std::unordered_map<l4n::ELEMENT_SYMBOL, std::vector<unsigned int>> n_hidden_neurons;
n_hidden_neurons[l4n::ELEMENT_SYMBOL::He] = {20, 1};
std::unordered_map<l4n::ELEMENT_SYMBOL, std::vector<l4n::NEURON_TYPE>> type_hidden_neurons;
type_hidden_neurons[l4n::ELEMENT_SYMBOL::He] = {l4n::NEURON_TYPE::LOGISTIC, l4n::NEURON_TYPE::LINEAR};
l4n::ACSFNeuralNetwork net(elements, *reader.get_element_list(), reader.contains_charge(), n_hidden_neurons, type_hidden_neurons);
l4n::MSE mse(&net, ds.get());
optimize_via_particle_swarm(net, mse);
// double err1 = optimize_via_LBMQ(net, mse);
double err2 = optimize_via_gradient_descent(net, mse);
std::cout << "Weights: " << net.get_min_max_weight().first << " " << net.get_min_max_weight().second << std::endl;
/* Print fit comparison with real data */
std::vector<double> output;
output.resize(1);
for(auto e : *ds->get_data()) {
for(unsigned int i = 0; i < e.first.size(); i++) {
std::cout << e.first.at(i) << " ";
if(i % 2 == 1) {
std::cout << std::endl;
}
}
std::cout << "OUTS (DS, predict): " << e.second.at(0) << " ";
net.eval_single(e.first, output);
std::cout << output.at(0) << std::endl;
}
} catch (const std::exception& e) {
std::cerr << e.what() << std::endl;
exit(EXIT_FAILURE);
}
return 0;