Newer
Older
Michal Kravcenko
committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
136
137
138
139
/**
* DESCRIPTION OF THE FILE
*
* @author Michal Kravčenko
* @date 15.3.19 -
*/
#include <iostream>
#include <cstdio>
#include <fstream>
#include <vector>
#include <utility>
#include <algorithm>
#include <assert.h>
#include "4neuro.h"
#include "../LearningMethods/RandomSolution.h"
int main(int argc, char** argv) {
//TODO NORMALIZACI NEPOUZIVAT KVULI CASOVYM POSUNUM
bool normalize_data = false;
double prec = 1e-9;
double prec_lm = 1e-9;
int restart_interval = 500;
int max_n_iters_gradient = 10000;
int max_n_iters_gradient_lm = 10000;
int max_n_iters_swarm = 20;
int n_particles_swarm = 200;
unsigned long batch_size = 0;
int max_number_of_cycles = 1;
try {
/* PHASE 2 - TRAINING DATA LOADING, SIMPLE SIMULATION */
l4n::CSVReader reader1("../../../data_files/data_BACK_RH_1.csv", ";", true); // File, separator, skip 1st line
reader1.read(); // Read from the file
/* PHASE 2 - NEURAL NETWORK SPECIFICATION */
/* Create data set for both the first training of the neural network */
/* Specify which columns are inputs or outputs */
std::vector<unsigned int> inputs = { 0 }; // Possible multiple inputs, e.g. {0,3}, column indices starting from 0
std::vector<unsigned int> outputs = { 2 }; // Possible multiple outputs, e.g. {1,2}
l4n::DataSet ds1 = reader1.get_data_set(&inputs, &outputs); // Creation of data-set for NN
if(normalize_data){
ds1.normalize(); // Normalization of data to prevent numerical problems
}
/* Numbers of neurons in layers (including input and output layers) */
std::vector<size_t> neuron_numbers_in_layers = { 1, 3, 3, 1 };
/* for each valve (1 in this example) setup the times of change */
std::vector<std::vector<double>> t;
t.push_back({0});
/* for each valve (1 in this example) setup the magnitudes of change */
std::vector<std::vector<double>> xi;
xi.push_back({ds1.get_data()->at(0).second});
/* The simulator2 object */
l4n::Simulator sim(outputs.size(), neuron_numbers_in_layers, t, xi);
/* Error function */
l4n::MSE mse1(&sim, &ds1); // First parameter - neural network, second parameter - data-set
/* Particle Swarm method domain*/
std::vector<double> domain_bounds(2 * (sim.get_n_weights() + sim.get_n_biases()));
for (size_t i = 0; i < domain_bounds.size() / 2; ++i) {
domain_bounds[2 * i] = -0.1;
domain_bounds[2 * i + 1] = 0.1;
}
l4n::RandomSolution rnd;
l4n::LevenbergMarquardt leven(max_n_iters_gradient_lm, batch_size, prec_lm );
l4n::LearningSequence learning_sequence( 1e-6, max_number_of_cycles );
learning_sequence.add_learning_method( &rnd );
learning_sequence.add_learning_method( &leven );
/* Weight and bias randomization in the network accordingly to the uniform distribution */
sim.randomize_parameters();
/* Complex Optimization */
learning_sequence.optimize(mse1); // Network training
/* Save Neural network parameters to file */
sim.save_text("test_net_Gradient_Descent.4n");
/* PHASE 4 - TESTING DATA */
// /* Output file specification */
std::string filename = "simulator_output.txt";
std::ofstream output_file(filename);
if (!output_file.is_open()) {
throw std::runtime_error("File '" + filename + "' can't be opened!");
}
//
// /* Neural network loading */
l4n::NeuralNetwork nn3("test_net_Gradient_Descent.4n");
/* Check of the saved network - write to the file */
output_file << std::endl << "The loaded network info:" << std::endl;
nn3.write_stats(&output_file);
nn3.write_weights(&output_file);
nn3.write_biases(&output_file);
//
// /* Evaluate network on an arbitrary data-set and save results into the file */
l4n::CSVReader reader3("../../../data_files/data_BACK_RH_1.csv", ";", true); // File, separator, skip 1st line
reader3.read(); // Read from the file
//
// /* Create data set for both the testing of the neural network */
// /* Specify which columns are inputs or outputs */
//
l4n::DataSet ds3 = reader3.get_data_set(&inputs, &outputs); // Creation of data-set for NN
if(normalize_data){
ds3.normalize(); // Normalization of data to prevent numerical problems
}
//
// output_file << std::endl << "Evaluating network on the dataset: " << std::endl;
// ds3.store_data_text(&output_file);
//
output_file << "Output and the error:" << std::endl;
//
// /* Error function */
l4n::MSE mse3(&nn3, &ds3); // First parameter - neural network, second parameter - data-set
mse3.eval_on_data_set(&ds3, &output_file, nullptr, normalize_data, true);
/* Close the output file for writing */
output_file.close();
return 0;
}
catch (const std::exception& e) {
std::cerr << e.what() << std::endl;
exit(EXIT_FAILURE);
}
}