// [ref] ${FANN_HOME}/examples/simple_pattern_recognition/simple_function_regression_application.cpp void simple_function_regression_example() { std::cout << "OpenNN. Simple Function Regression Application." << std::endl; // Data set object OpenNN::DataSet data_set; data_set.load_data("./data/neural_network/opennn/simple_function_regression.dat"); OpenNN::VariablesInformation* variables_information_pointer = data_set.get_variables_information_pointer(); variables_information_pointer->set_name(0, "x"); variables_information_pointer->set_name(1, "y"); OpenNN::Vector<OpenNN::Vector<std::string> > inputs_targets_information = variables_information_pointer->arrange_inputs_targets_information(); OpenNN::InstancesInformation *instances_information_pointer = data_set.get_instances_information_pointer(); instances_information_pointer->split_random_indices(0.75, 0.1, 0.25); const OpenNN::Vector<OpenNN::Vector<double> > inputs_targets_minimum_maximum = data_set.scale_inputs_targets_minimum_maximum(); // Neural network OpenNN::NeuralNetwork neural_network(1, 3, 1); neural_network.set_inputs_outputs_information(inputs_targets_information); neural_network.set_inputs_outputs_minimums_maximums(inputs_targets_minimum_maximum); // Performance functional object OpenNN::PerformanceFunctional performance_functional(&neural_network, &data_set); // Training strategy OpenNN::TrainingStrategy training_strategy(&performance_functional); training_strategy.perform_training(); neural_network.set_inputs_scaling_outputs_unscaling_methods("MeanStandardDeviation"); // Testing analysis object OpenNN::TestingAnalysis testing_analysis(&neural_network, &data_set); OpenNN::FunctionRegressionTesting::LinearRegressionAnalysisResults linear_regression_analysis_results = testing_analysis.get_function_regression_testing_pointer()->perform_linear_regression_analysis(); std::cout << "Linear regression parameters:" << std::endl << "Intercept: " << linear_regression_analysis_results.linear_regression_parameters[0][0] << std::endl << "Slope: " << linear_regression_analysis_results.linear_regression_parameters[0][1] << std::endl; // Save results data_set.save("./data/neural_network/opennn/simple_function_regression/data_set.xml"); neural_network.save("./data/neural_network/opennn/simple_function_regression/neural_network.xml"); neural_network.save_expression("./data/neural_network/opennn/simple_function_regression/expression.txt"); performance_functional.save("./data/neural_network/opennn/simple_function_regression/performance_functional.xml"); training_strategy.save("./data/neural_network/opennn/simple_function_regression/training_strategy.xml"); linear_regression_analysis_results.save("./data/neural_network/opennn/simple_function_regression/linear_regression_analysis_results.dat"); }
Matrix<double> InputsSelectionAlgorithm::calculate_logistic_correlations(void) const { // Control sentence (if debug) #ifdef __OPENNN_DEBUG__ std::ostringstream buffer; if(!training_strategy_pointer) { buffer << "OpenNN Exception: InputsSelectionAlgorithm class.\n" << "void check(void) const method.\n" << "Pointer to training strategy is NULL.\n"; throw std::logic_error(buffer.str()); } // Performance functional stuff if(!training_strategy_pointer->has_performance_functional()) { buffer << "OpenNN Exception: InputsSelectionAlgorithm class.\n" << "void check(void) const method.\n" << "Pointer to performance functional is NULL.\n"; throw std::logic_error(buffer.str()); } if(!training_strategy_pointer->get_performance_functional_pointer()->has_data_set()) { buffer << "OpenNN Exception: InputsSelectionAlgorithm class.\n" << "void check(void) const method.\n" << "Pointer to data set is NULL.\n"; throw std::logic_error(buffer.str()); } #endif // Problem stuff const PerformanceFunctional* performance_functional_pointer = training_strategy_pointer->get_performance_functional_pointer(); const DataSet* data_set_pointer = performance_functional_pointer->get_data_set_pointer(); const Variables& variables = data_set_pointer->get_variables(); const size_t inputs_number = variables.count_inputs_number(); const size_t targets_number = variables.count_targets_number(); const Vector<size_t> input_indices = variables.arrange_inputs_indices(); const Vector<size_t> target_indices = variables.arrange_targets_indices(); Matrix<double> correlations(inputs_number, targets_number); for(size_t i = 0; i < inputs_number; i++) { const Vector<double> inputs = data_set_pointer->get_variable(input_indices[i]); for(size_t j = 0; j < targets_number; j++) { const Vector<double> targets = data_set_pointer->get_variable(target_indices[j]); Matrix<double> data(inputs.size(), 2); data.set_column(0, inputs); data.set_column(1, targets); DataSet data_set(data); data_set.scale_inputs("MinimumMaximum"); Instances* instances_pointer = data_set.get_instances_pointer(); instances_pointer->set_training(); NeuralNetwork neural_network(1, 1); MultilayerPerceptron* multilayer_perceptron_pointer = neural_network.get_multilayer_perceptron_pointer(); multilayer_perceptron_pointer->set_layer_activation_function(0, Perceptron::Logistic); PerformanceFunctional performance_functional(&neural_network, &data_set); performance_functional.set_objective_type(PerformanceFunctional::MEAN_SQUARED_ERROR_OBJECTIVE); TrainingStrategy training_strategy(&performance_functional); training_strategy.set_main_type(TrainingStrategy::LEVENBERG_MARQUARDT_ALGORITHM); training_strategy.get_Levenberg_Marquardt_algorithm_pointer()->set_display(false); training_strategy.get_Levenberg_Marquardt_algorithm_pointer()->set_performance_goal(0.0); training_strategy.get_Levenberg_Marquardt_algorithm_pointer()->set_gradient_norm_goal(0.0); training_strategy.get_Levenberg_Marquardt_algorithm_pointer()->set_minimum_performance_increase(0.0); training_strategy.perform_training(); const Vector<double> outputs = neural_network.calculate_output_data(inputs.to_column_matrix()).to_vector(); correlations(i,j) = targets.calculate_linear_correlation(outputs); } } return(correlations); }