Here is my code:

// System includes
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cstring>
#include <time.h>
// OpenNN includes
#include "../../opennn/opennn.h"
#include <levenberg_marquardt_algorithm.h>
#include <quasi_newton_method.h>
using namespace OpenNN;
int main(void)
{
try
{
int rank = 0;
#ifdef __OPENNN_MPI__
int size = 1;
MPI_Init(NULL,NULL);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
#endif
if(rank == 0)
{
std::cout << "OpenNN. Airfoil Self-Noise Application." << std::endl;
}
srand((unsigned)time(NULL));
// Global variables
DataSet data_set;
NeuralNetwork neural_network;
LossIndex loss_index;
TrainingStrategy training_strategy;
// Local variables
DataSet local_data_set;
NeuralNetwork local_neural_network;
LossIndex local_loss_index;
TrainingStrategy local_training_strategy;
if(rank == 0)
{
// Data set
data_set.set_data_file_name("../data/temprenetinputs11.csv"); // controllare dati
data_set.set_separator("Space");
data_set.load_data();
printf("%s\n","data_set");
std::cout << typeid(data_set).name() << std::endl;
// Variables
Variables* variables_pointer = data_set.get_variables_pointer();
variables_pointer->set_name(0, "1");
variables_pointer->set_units(0, "pip");
variables_pointer->set_use(0, Variables::Input);
variables_pointer->set_name(1, "2");
variables_pointer->set_units(1, "pip");
variables_pointer->set_use(1, Variables::Input);
variables_pointer->set_name(2, "3");
variables_pointer->set_units(2, "pip");
variables_pointer->set_use(2, Variables::Input);
variables_pointer->set_name(3, "4");
variables_pointer->set_units(3, "pip");
variables_pointer->set_use(3, Variables::Input);
variables_pointer->set_name(4, "5");
variables_pointer->set_units(4, "pip");
variables_pointer->set_use(4, Variables::Input);
variables_pointer->set_name(5, "6");
variables_pointer->set_units(5, "pip");
variables_pointer->set_use(5, Variables::Input);
variables_pointer->set_name(6, "7");
variables_pointer->set_units(6, "pip");
variables_pointer->set_use(6, Variables::Input);
variables_pointer->set_name(7, "8");
variables_pointer->set_units(7, "pip");
variables_pointer->set_use(7, Variables::Input);
variables_pointer->set_name(8, "9");
variables_pointer->set_units(8, "pip");
variables_pointer->set_use(8, Variables::Input);
variables_pointer->set_name(9, "10");
variables_pointer->set_units(9, "pip");
variables_pointer->set_use(9, Variables::Input);
variables_pointer->set_name(10, "11");
variables_pointer->set_units(10, "pip");
variables_pointer->set_use(10, Variables::Input);
variables_pointer->set_name(11, "12");
variables_pointer->set_units(11, "pip");
variables_pointer->set_use(11, Variables::Input);
variables_pointer->set_name(12, "13");
variables_pointer->set_units(12, "pip");
variables_pointer->set_use(12, Variables::Input);
variables_pointer->set_name(13, "14");
variables_pointer->set_units(13, "pip");
variables_pointer->set_use(13, Variables::Input);
variables_pointer->set_name(14, "15");
variables_pointer->set_units(14, "pip");
variables_pointer->set_use(14, Variables::Input);
variables_pointer->set_name(15, "16");
variables_pointer->set_units(15, "pip");
variables_pointer->set_use(15, Variables::Input);
variables_pointer->set_name(16, "17");
variables_pointer->set_units(16, "pip");
variables_pointer->set_use(16, Variables::Input);
variables_pointer->set_name(17, "18");
variables_pointer->set_units(17, "pip");
variables_pointer->set_use(17, Variables::Input);
variables_pointer->set_name(18, "19");
variables_pointer->set_units(18, "pip");
variables_pointer->set_use(18, Variables::Input);
variables_pointer->set_name(19, "20");
variables_pointer->set_units(19, "pip");
variables_pointer->set_use(19, Variables::Input);
variables_pointer->set_name(20, "21");
variables_pointer->set_units(20, "pip");
variables_pointer->set_use(20, Variables::Input);
variables_pointer->set_name(21, "22");
variables_pointer->set_units(21, "pip");
variables_pointer->set_use(21, Variables::Input);
variables_pointer->set_name(22, "23");
variables_pointer->set_units(22, "pip");
variables_pointer->set_use(22, Variables::Input);
variables_pointer->set_name(23, "24");
variables_pointer->set_units(23, "pip");
variables_pointer->set_use(23, Variables::Input);
variables_pointer->set_name(24, "25");
variables_pointer->set_units(24, "pip");
variables_pointer->set_use(24, Variables::Input);
variables_pointer->set_name(25, "26");
variables_pointer->set_units(25, "pip");
variables_pointer->set_use(25, Variables::Input);
variables_pointer->set_name(26, "27");
variables_pointer->set_units(26, "pip");
variables_pointer->set_use(26, Variables::Input);
variables_pointer->set_name(27, "28");
variables_pointer->set_units(27, "pip");
variables_pointer->set_use(27, Variables::Input);
variables_pointer->set_name(28, "29");
variables_pointer->set_units(28, "pip");
variables_pointer->set_use(28, Variables::Input);
variables_pointer->set_name(29, "30");
variables_pointer->set_units(29, "pip");
variables_pointer->set_use(29, Variables::Input);
variables_pointer->set_name(30, "31");
variables_pointer->set_units(30, "pip");
variables_pointer->set_use(30, Variables::Input);
variables_pointer->set_name(31, "32");
variables_pointer->set_units(31, "pip");
variables_pointer->set_use(31, Variables::Input);
variables_pointer->set_name(32, "33");
variables_pointer->set_units(32, "pip");
variables_pointer->set_use(32, Variables::Input);
variables_pointer->set_name(33, "34");
variables_pointer->set_units(33, "pip");
variables_pointer->set_use(33, Variables::Input);
variables_pointer->set_name(34, "35");
variables_pointer->set_units(34, "pip");
variables_pointer->set_use(34, Variables::Input);
variables_pointer->set_name(35, "36");
variables_pointer->set_units(35, "pip");
variables_pointer->set_use(35, Variables::Input);
variables_pointer->set_name(36, "37");
variables_pointer->set_units(36, "pip");
variables_pointer->set_use(36, Variables::Input);
variables_pointer->set_name(37, "38");
variables_pointer->set_units(37, "pip");
variables_pointer->set_use(37, Variables::Input);
variables_pointer->set_name(38, "39");
variables_pointer->set_units(38, "pip");
variables_pointer->set_use(38, Variables::Input);
variables_pointer->set_name(39, "40");
variables_pointer->set_units(39, "pip");
variables_pointer->set_use(39, Variables::Input);
variables_pointer->set_name(40, "41");
variables_pointer->set_units(40, "pip");
variables_pointer->set_use(40, Variables::Input);
variables_pointer->set_name(41, "42");
variables_pointer->set_units(41, "pip");
variables_pointer->set_use(41, Variables::Input);
variables_pointer->set_name(42, "43");
variables_pointer->set_units(42, "pip");
variables_pointer->set_use(42, Variables::Input);
variables_pointer->set_name(43, "target");
variables_pointer->set_use(43, Variables::Target);
const Matrix<std::string> inputs_information = variables_pointer->arrange_inputs_information();
const Matrix<std::string> targets_information = variables_pointer->arrange_targets_information();
// Instances
Instances* instances_pointer = data_set.get_instances_pointer();
instances_pointer->split_random_indices();
//instances_pointer->split_random_indices(0.7, 0.15, 0.15);
const Vector< Statistics<double> > inputs_statistics = data_set.scale_inputs_minimum_maximum(); // mapminmax
const Vector< Statistics<double> > targets_statistics = data_set.scale_targets_minimum_maximum();
// Neural network
const size_t inputs_number = variables_pointer->count_inputs_number();
const size_t hidden_perceptrons_number = 100;
const size_t outputs_number = variables_pointer->count_targets_number();
neural_network.set(inputs_number, hidden_perceptrons_number, outputs_number); // quale funzione di attivazione?
//NeuralNetwork neural_network(inputs_number, hidden_perceptrons_number, outputs_number); // validation ??
Inputs* inputs = neural_network.get_inputs_pointer();
inputs->set_information(inputs_information);
Outputs* outputs = neural_network.get_outputs_pointer();
outputs->set_information(targets_information);
neural_network.construct_scaling_layer();
ScalingLayer* scaling_layer_pointer = neural_network.get_scaling_layer_pointer();
scaling_layer_pointer->set_statistics(inputs_statistics);
scaling_layer_pointer->set_scaling_method(ScalingLayer::NoScaling);
neural_network.construct_unscaling_layer();
UnscalingLayer* unscaling_layer_pointer = neural_network.get_unscaling_layer_pointer();
unscaling_layer_pointer->set_statistics(targets_statistics);
unscaling_layer_pointer->set_unscaling_method(UnscalingLayer::NoUnscaling);
// Loss index
loss_index.set_data_set_pointer(&data_set);
loss_index.set_neural_network_pointer(&neural_network); // mse??
loss_index.set_regularization_type(LossIndex::NEURAL_PARAMETERS_NORM); // ??
// Training strategy object
training_strategy.set(&loss_index);
//TrainingStrategy training_strategy(&neural_network, &data_set);
// non sono i dati
// Error :OpenNN Exception: TrainingStrategy class.
// LevenbergMarquardtAlgorithm* get_Levenberg_Marquardt_algorithm_pointer(void) const method.
// Levenberg_Marquardt algorithm pointer is NULL.
// ottenere il valore esatto del pointer es.:0.0000
// CASE 2 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LevenbergMarquardtAlgorithm* Levenberg_Marquardt_algorithm_pointer = training_strategy.get_Levenberg_Marquardt_algorithm_pointer();
Levenberg_Marquardt_algorithm_pointer->set_maximum_iterations_number(1000);
Levenberg_Marquardt_algorithm_pointer->set_display_period(10);
Levenberg_Marquardt_algorithm_pointer->set_minimum_loss_increase(1.0e-6);
Levenberg_Marquardt_algorithm_pointer ->set_reserve_loss_history(true);
// CASE 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
QuasiNewtonMethod* quasi_Newton_method_pointer = training_strategy.get_quasi_Newton_method_pointer();
quasi_Newton_method_pointer->set_maximum_iterations_number(1000);
quasi_Newton_method_pointer->set_display_period(10);
quasi_Newton_method_pointer->set_minimum_loss_increase(1.0e-6);
quasi_Newton_method_pointer->set_reserve_loss_history(true);
// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
#ifdef __OPENNN_MPI__
MPI_Barrier(MPI_COMM_WORLD);
local_data_set.set_MPI(&data_set);
local_neural_network.set_MPI(&neural_network);
local_loss_index.set_MPI(&local_data_set,&local_neural_network,&loss_index);
local_training_strategy.set_MPI(&local_loss_index,&training_strategy);
MPI_Barrier(MPI_COMM_WORLD);
TrainingStrategy::Results training_strategy_results = local_training_strategy.perform_training();
#else
TrainingStrategy::Results training_strategy_results = training_strategy.perform_training();
#endif
if(rank == 0)
{
#ifdef __OPENNN_MPI__
neural_network.set_multilayer_perceptron_pointer(local_neural_network.get_multilayer_perceptron_pointer());
#endif
// Testing analysis
TestingAnalysis testing_analysis(&neural_network, &data_set);
TestingAnalysis::LinearRegressionResults linear_regression_results = testing_analysis.perform_linear_regression_analysis();
// Save results
ScalingLayer* scaling_layer_pointer = neural_network.get_scaling_layer_pointer();
UnscalingLayer* unscaling_layer_pointer = neural_network.get_unscaling_layer_pointer();
scaling_layer_pointer->set_scaling_method(ScalingLayer::MinimumMaximum);
unscaling_layer_pointer->set_unscaling_method(UnscalingLayer::MinimumMaximum);
data_set.save("../data/data_set.xml");
neural_network.save("../data/neural_network.xml");
neural_network.save_expression("../data/expression.txt");
loss_index.save("../data/loss_index.xml");
training_strategy.save("../data/training_strategy.xml");
training_strategy_results.save("../data/training_strategy_results.dat");
linear_regression_results.save("../data/linear_regression_analysis_results.dat");
}
#ifdef __OPENNN_MPI__
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
#endif
return(0);
}
catch(std::exception& e)
{
std::cerr << e.what() << std::endl;
std::getchar();
return(1);
}
}
// OpenNN: Open Neural Networks Library.
// Copyright (C) 2005-2015 Roberto Lopez.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA[0_1552982666677_main.cpp](Uploading 100%)

Thanks!