GoldenSectionOrder::GoldenSectionOrderResults* GoldenSectionOrder::perform_order_selection(void) { GoldenSectionOrderResults* results = new GoldenSectionOrderResults(); NeuralNetwork* neural_network_pointer = training_strategy_pointer->get_loss_index_pointer()->get_neural_network_pointer(); MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer(); Vector<double> mu_loss(2); Vector<double> ln_loss(2); Vector<double> a_parameters; Vector<double> ln_parameters; Vector<double> mu_parameters; Vector<double> b_parameters; size_t optimal_order; Vector<double> optimum_parameters; Vector<double> optimum_loss(2); bool end = false; Vector<double> minimums(4); double minimum; size_t iterations = 0; double current_training_loss, current_selection_loss; time_t beginning_time, current_time; double elapsed_time; size_t a = minimum_order; size_t b = maximum_order; size_t ln = (int)(a+(1.-0.618)*(b-a)); size_t mu = (int)(a+0.618*(b-a)); if(display) { std::cout << "Performing order selection with golden section method..." << std::endl; } time(&beginning_time); mu_loss = perform_model_evaluation(mu); current_training_loss = mu_loss[0]; current_selection_loss = mu_loss[1]; mu_parameters = get_parameters_order(mu); results->order_data.push_back(mu); if(reserve_loss_data) { results->loss_data.push_back(current_training_loss); } if(reserve_selection_loss_data) { results->selection_loss_data.push_back(current_selection_loss); } if(reserve_parameters_data) { results->parameters_data.push_back(mu_parameters); } ln_loss = perform_model_evaluation(ln); current_training_loss = ln_loss[0]; current_selection_loss = ln_loss[1]; ln_parameters = get_parameters_order(ln); results->order_data.push_back(ln); if(reserve_loss_data) { results->loss_data.push_back(current_training_loss); } if(reserve_selection_loss_data) { results->selection_loss_data.push_back(current_selection_loss); } if(reserve_parameters_data) { results->parameters_data.push_back(ln_parameters); } time(¤t_time); elapsed_time = difftime(current_time, beginning_time); if(display) { std::cout << "Initial values: " << std::endl; std::cout << "a = " << a << " ln = " << ln << " mu = " << mu << " b = " << b << std::endl; std::cout << "ln final training loss: " << ln_loss[0] << std::endl; std::cout << "ln final selection loss: " << ln_loss[1] << std::endl; std::cout << "mu final training loss: " << mu_loss[0] << std::endl; std::cout << "mu final selection loss: " << mu_loss[1] << std::endl; std::cout << "Elapsed time: " << elapsed_time << std::endl; } if((ln == mu) || (ln > mu) || (mu < ln)) { end = true; if(display) { std::cout << "Algorithm finished " << std::endl; } results->stopping_condition = GoldenSectionOrder::AlgorithmFinished; } while(!end){ if(ln_loss[1] < mu_loss[1] || fabs(ln_loss[1] - mu_loss[1]) < tolerance) { b = mu; mu = ln; mu_loss = ln_loss; ln = (int)(a+(1.-0.618)*(b-a)); ln_loss = perform_model_evaluation(ln); current_training_loss = ln_loss[0]; current_selection_loss = ln_loss[1]; ln_parameters = get_parameters_order(ln); results->order_data.push_back(ln); if(reserve_loss_data) { results->loss_data.push_back(current_training_loss); } if(reserve_selection_loss_data) { results->selection_loss_data.push_back(current_selection_loss); } if(reserve_parameters_data) { results->parameters_data.push_back(ln_parameters); } } else { a = ln; ln = mu; ln_loss = mu_loss; mu = (int)(a+0.618*(b-a)); mu_loss = perform_model_evaluation(mu); current_training_loss = mu_loss[0]; current_selection_loss = mu_loss[1]; mu_parameters = get_parameters_order(mu); results->order_data.push_back(mu); if(reserve_loss_data) { results->loss_data.push_back(current_training_loss); } if(reserve_selection_loss_data) { results->selection_loss_data.push_back(current_selection_loss); } if(reserve_parameters_data) { results->parameters_data.push_back(mu_parameters); } } time(¤t_time); elapsed_time = difftime(current_time, beginning_time); iterations++; // Stopping criteria if((ln == mu) || (ln > mu)) { end = true; if(display) { std::cout << "Algorithm finished " << std::endl; } results->stopping_condition = GoldenSectionOrder::AlgorithmFinished; } else if(elapsed_time >= maximum_time) { end = true; if(display) { std::cout << "Maximum time reached." << std::endl; } results->stopping_condition = GoldenSectionOrder::MaximumTime; } else if(std::min(ln_loss[1],mu_loss[1]) <= selection_loss_goal) { end = true; if(display) { std::cout << "Selection loss reached." << std::endl; } results->stopping_condition = GoldenSectionOrder::SelectionLossGoal; } else if(iterations >= maximum_iterations_number) { end = true; if(display) { std::cout << "Maximum number of iterations reached." << std::endl; } results->stopping_condition = GoldenSectionOrder::MaximumIterations; } if(display && !end) { std::cout << "Iteration: " << iterations << std::endl; std::cout << "a = " << a << " ln = " << ln << " mu = " << mu << " b = " << b << std::endl; std::cout << "ln final training loss: " << ln_loss[0] << std::endl; std::cout << "ln final selection loss: " << ln_loss[1] << std::endl; std::cout << "mu final training loss: " << mu_loss[0] << std::endl; std::cout << "mu final selection loss: " << mu_loss[1] << std::endl; std::cout << "Elapsed time: " << elapsed_time << std::endl; } } minimums[0] = perform_model_evaluation(a)[1]; a_parameters = get_parameters_order(a); minimums[1] = perform_model_evaluation(ln)[1]; ln_parameters = get_parameters_order(ln); minimums[2] = perform_model_evaluation(mu)[1]; mu_parameters = get_parameters_order(mu); minimums[3] = perform_model_evaluation(b)[1]; b_parameters = get_parameters_order(b); time(¤t_time); elapsed_time = difftime(current_time, beginning_time); if(display) { std::cout << "Iteration: " << iterations << std::endl; std::cout << "a = " << a << " ln = " << ln << " mu = " << mu << " b = " << b << std::endl; std::cout << "a final training loss: " << perform_model_evaluation(a)[0] << std::endl; std::cout << "a final selection loss: " << perform_model_evaluation(a)[1] << std::endl; std::cout << "ln final training loss: " << ln_loss[0] << std::endl; std::cout << "ln final selection loss: " << ln_loss[1] << std::endl; std::cout << "mu final training loss: " << mu_loss[0] << std::endl; std::cout << "mu final selection loss: " << mu_loss[1] << std::endl; std::cout << "b final training loss: " << perform_model_evaluation(b)[0] << std::endl; std::cout << "b final selection loss: " << perform_model_evaluation(b)[1] << std::endl; std::cout << "Elapsed time: " << elapsed_time << std::endl; } minimum = minimums.calculate_minimum(); if(fabs(minimums[0] - minimum) < tolerance) { optimal_order = a; optimum_parameters = a_parameters; optimum_loss[0] = perform_model_evaluation(a)[0]; optimum_loss[1] = minimums[0]; } else if(fabs(minimums[1] - minimum) < tolerance) { optimal_order = ln; optimum_parameters = ln_parameters; optimum_loss[0] = perform_model_evaluation(ln)[0]; optimum_loss[1] = minimums[1]; } else if(fabs(minimums[2] - minimum) < tolerance) { optimal_order = mu; optimum_parameters = mu_parameters; optimum_loss[0] = perform_model_evaluation(mu)[0]; optimum_loss[1] = minimums[2]; } else { optimal_order = b; optimum_parameters = b_parameters; optimum_loss[0] = perform_model_evaluation(b)[0]; optimum_loss[1] = minimums[3]; } if(display) { std::cout << "Optimal order: " << optimal_order << std::endl; } const size_t last_hidden_layer = multilayer_perceptron_pointer->get_layers_number()-2; const size_t perceptrons_number = multilayer_perceptron_pointer->get_layer_pointer(last_hidden_layer)->get_perceptrons_number(); if(optimal_order > perceptrons_number) { multilayer_perceptron_pointer->grow_layer_perceptron(last_hidden_layer,optimal_order-perceptrons_number); } else { for (size_t i = 0; i < (perceptrons_number-optimal_order); i++) multilayer_perceptron_pointer->prune_layer_perceptron(last_hidden_layer,0); } multilayer_perceptron_pointer->set_parameters(optimum_parameters); #ifdef __OPENNN_MPI__ neural_network_pointer->set_multilayer_perceptron_pointer(multilayer_perceptron_pointer); #endif if(reserve_minimal_parameters) { results->minimal_parameters = optimum_parameters; } results->optimal_order = optimal_order; results->final_loss = optimum_loss[0]; results->final_selection_loss = optimum_loss[1]; results->elapsed_time = elapsed_time; results->iterations_number = iterations; return(results); }
GoldenSectionOrder::GoldenSectionOrderResults* GoldenSectionOrder::perform_order_selection(void) { GoldenSectionOrderResults* results = new GoldenSectionOrderResults(); NeuralNetwork* neural_network_pointer = training_strategy_pointer->get_performance_functional_pointer()->get_neural_network_pointer(); MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer(); const size_t inputs_number = multilayer_perceptron_pointer->get_inputs_number(); const size_t outputs_number = multilayer_perceptron_pointer->get_outputs_number(); Vector<double> mu_performance(2); Vector<double> ln_performance(2); Vector<double> a_parameters; Vector<double> ln_parameters; Vector<double> mu_parameters; Vector<double> b_parameters; bool end = false; Vector<double> minimums(4); double minimum; size_t iterations = 0; double current_training_performance, current_generalization_performance; time_t beginning_time, current_time; double elapsed_time; size_t a = minimum_order; size_t b = maximum_order; size_t ln = (int)(a+(1.-0.618)*(b-a)); size_t mu = (int)(a+0.618*(b-a)); if (display) std::cout << "Performing order selection with golden section method..." << std::endl; time(&beginning_time); mu_performance = calculate_performances(mu); current_training_performance = mu_performance[0]; current_generalization_performance = mu_performance[1]; mu_parameters = get_parameters_order(mu); results->order_data.push_back(mu); if (reserve_performance_data) { results->performance_data.push_back(current_training_performance); } if (reserve_generalization_performance_data) { results->generalization_performance_data.push_back(current_generalization_performance); } if (reserve_parameters_data) { results->parameters_data.push_back(mu_parameters); } ln_performance = calculate_performances(ln); current_training_performance = ln_performance[0]; current_generalization_performance = ln_performance[1]; ln_parameters = get_parameters_order(ln); results->order_data.push_back(ln); if (reserve_performance_data) { results->performance_data.push_back(current_training_performance); } if (reserve_generalization_performance_data) { results->generalization_performance_data.push_back(current_generalization_performance); } if (reserve_parameters_data) { results->parameters_data.push_back(ln_parameters); } time(¤t_time); elapsed_time = difftime(current_time, beginning_time); if (display) { std::cout << "Initial values : " << std::endl; std::cout << "a = " << a << " ln = " << ln << " mu = " << mu << " b = " << b << std::endl; std::cout << "ln final training performance : " << ln_performance[0] << std::endl; std::cout << "ln final generalization performance : " << ln_performance[1] << std::endl; std::cout << "mu final training performance : " << mu_performance[0] << std::endl; std::cout << "mu final generalization performance : " << mu_performance[1] << std::endl; std::cout << "Elapsed time : " << elapsed_time << std::endl; } if ((ln == mu) || (ln > mu) || (mu < ln)){ end = true; if (display) std::cout << "Algorithm finished " << std::endl; results->stopping_condition = GoldenSectionOrder::AlgorithmFinished; } while(!end){ if (ln_performance[1] < mu_performance[1] || fabs(ln_performance[1] - mu_performance[1]) < tolerance) { b = mu; mu = ln; mu_performance = ln_performance; ln = (int)(a+(1.-0.618)*(b-a)); ln_performance = calculate_performances(ln); current_training_performance = ln_performance[0]; current_generalization_performance = ln_performance[1]; ln_parameters = get_parameters_order(ln); results->order_data.push_back(ln); if (reserve_performance_data) { results->performance_data.push_back(current_training_performance); } if (reserve_generalization_performance_data) { results->generalization_performance_data.push_back(current_generalization_performance); } if (reserve_parameters_data) { results->parameters_data.push_back(ln_parameters); } }else { a = ln; ln = mu; ln_performance = mu_performance; mu = (int)(a+0.618*(b-a)); mu_performance = calculate_performances(mu); current_training_performance = mu_performance[0]; current_generalization_performance = mu_performance[1]; mu_parameters = get_parameters_order(mu); results->order_data.push_back(mu); if (reserve_performance_data) { results->performance_data.push_back(current_training_performance); } if (reserve_generalization_performance_data) { results->generalization_performance_data.push_back(current_generalization_performance); } if (reserve_parameters_data) { results->parameters_data.push_back(mu_parameters); } } time(¤t_time); elapsed_time = difftime(current_time, beginning_time); iterations++; // Stopping criteria if ((ln == mu) || (ln > mu)){ end = true; if (display) std::cout << "Algorithm finished " << std::endl; results->stopping_condition = GoldenSectionOrder::AlgorithmFinished; }else if (elapsed_time > maximum_time) { end = true; if (display) std::cout << "Maximum time reached." << std::endl; results->stopping_condition = GoldenSectionOrder::MaximumTime; }else if (fmin(ln_performance[1],mu_performance[1]) < selection_performance_goal) { end = true; if (display) std::cout << "Generalization performance reached." << std::endl; results->stopping_condition = GoldenSectionOrder::SelectionPerformanceGoal; }else if (iterations > maximum_iterations_number) { end = true; if (display) std::cout << "Maximum number of iterations reached." << std::endl; results->stopping_condition = GoldenSectionOrder::MaximumIterations; } if (display && !end) { std::cout << "Iteration : " << iterations << std::endl; std::cout << "a = " << a << " ln = " << ln << " mu = " << mu << " b = " << b << std::endl; std::cout << "ln final training performance : " << ln_performance[0] << std::endl; std::cout << "ln final generalization performance : " << ln_performance[1] << std::endl; std::cout << "mu final training performance : " << mu_performance[0] << std::endl; std::cout << "mu final generalization performance : " << mu_performance[1] << std::endl; std::cout << "Elapsed time : " << elapsed_time << std::endl; } } minimums[0] = calculate_performances(a)[1]; a_parameters = get_parameters_order(a); minimums[1] = calculate_performances(ln)[1]; ln_parameters = get_parameters_order(ln); minimums[2] = calculate_performances(mu)[1]; mu_parameters = get_parameters_order(mu); minimums[3] = calculate_performances(b)[1]; b_parameters = get_parameters_order(b); time(¤t_time); elapsed_time = difftime(current_time, beginning_time); if (display) { std::cout << "Iteration : " << iterations << std::endl; std::cout << "a = " << a << " ln = " << ln << " mu = " << mu << " b = " << b << std::endl; std::cout << "a final training performance : " << calculate_performances(a)[0] << std::endl; std::cout << "a final generalization performance : " << calculate_performances(a)[1] << std::endl; std::cout << "ln final training performance : " << ln_performance[0] << std::endl; std::cout << "ln final generalization performance : " << ln_performance[1] << std::endl; std::cout << "mu final training performance : " << mu_performance[0] << std::endl; std::cout << "mu final generalization performance : " << mu_performance[1] << std::endl; std::cout << "b final training performance : " << calculate_performances(b)[0] << std::endl; std::cout << "b final generalization performance : " << calculate_performances(b)[1] << std::endl; std::cout << "Elapsed time : " << elapsed_time << std::endl; } minimum = minimums.calculate_minimum(); if (fabs(minimums[0] - minimum) < tolerance) { if (display) std::cout << "Optimal order : " << a << std::endl; multilayer_perceptron_pointer->set(inputs_number, a, outputs_number); multilayer_perceptron_pointer->set_parameters(a_parameters); if (reserve_minimal_parameters) results->minimal_parameters = a_parameters; results->optimal_order = a; results->final_generalization_performance = minimums[0]; results->final_performance = calculate_performances(a)[0]; }else if (fabs(minimums[1] - minimum) < tolerance) { if (display) std::cout << "Optimal order : " << ln << std::endl; multilayer_perceptron_pointer->set(inputs_number, ln, outputs_number); multilayer_perceptron_pointer->set_parameters(ln_parameters); if (reserve_minimal_parameters) results->minimal_parameters = ln_parameters; results->optimal_order = ln; results->final_generalization_performance = minimums[1]; results->final_performance = calculate_performances(ln)[0]; }else if(fabs(minimums[2] - minimum) < tolerance) { if (display) std::cout << "Optimal order : " << mu << std::endl; multilayer_perceptron_pointer->set(inputs_number, mu, outputs_number); multilayer_perceptron_pointer->set_parameters(mu_parameters); if (reserve_minimal_parameters) results->minimal_parameters = mu_parameters; results->optimal_order = mu; results->final_generalization_performance = minimums[2]; results->final_performance = calculate_performances(mu)[0]; }else { if (display) std::cout << "Optimal order : " << b << std::endl; multilayer_perceptron_pointer->set(inputs_number, b, outputs_number); multilayer_perceptron_pointer->set_parameters(b_parameters); if (reserve_minimal_parameters) results->minimal_parameters = b_parameters; results->optimal_order = b; results->final_generalization_performance = minimums[3]; results->final_performance = calculate_performances(b)[0]; } results->elapsed_time = elapsed_time; results->iterations_number = iterations; return(results); }
int main() { std::mt19937 generator(time(nullptr)); std::vector<std::vector<double>> timeSeries; std::ifstream fromFile("resources/data.txt"); if (!fromFile.is_open()) { std::cerr << "Could not open data.txt!" << std::endl; return 1; } // Skip first line std::string line; std::getline(fromFile, line); int numEntries = 1; for (int i = 0; i < line.size(); i++) if (line[i] == ',') numEntries++; int numSkipEntries = 1; int numEntriesUse = numEntries - numSkipEntries; std::vector<double> minimums(numEntriesUse, 999999999.0); std::vector<double> maximums(numEntriesUse, -999999999.0); while (fromFile.good() && !fromFile.eof()) { std::vector<double> entries(numEntriesUse); std::string line; std::getline(fromFile, line); std::istringstream fromLine(line); std::string param; // Skip entries for (int i = 0; i < numSkipEntries; i++) { std::string entry; std::getline(fromLine, entry, ','); } for (int i = 0; i < numEntriesUse; i++) { std::string entry; std::getline(fromLine, entry, ','); if (entry == "") entries[i] = 0.0; else { double value = std::stod(entry); maximums[i] = std::max(maximums[i], value); minimums[i] = std::min(minimums[i], value); entries[i] = value; } } timeSeries.push_back(entries); } // Rescale for (int i = 0; i < timeSeries.size(); i++) { for (int j = 0; j < timeSeries[i].size(); j++) { timeSeries[i][j] = (timeSeries[i][j] - minimums[j]) / std::max(0.0001, (maximums[j] - minimums[j])); } } /*timeSeries.clear(); timeSeries.resize(10); timeSeries[0] = { 0.0f, 1.0f, 0.0f }; timeSeries[1] = { 0.0f, 0.0f, 0.0f }; timeSeries[2] = { 1.0f, 1.0f, 0.0f }; timeSeries[3] = { 0.0f, 0.0f, 1.0f }; timeSeries[4] = { 0.0f, 1.0f, 0.0f }; timeSeries[5] = { 0.0f, 0.0f, 1.0f }; timeSeries[6] = { 0.0f, 0.0f, 0.0f }; timeSeries[7] = { 0.0f, 0.0f, 0.0f }; timeSeries[8] = { 0.0f, 1.0f, 0.0f }; timeSeries[9] = { 0.0f, 1.0f, 1.0f };*/ std::vector<sdr::IPredictiveRSDR::LayerDesc> layerDescs(3); layerDescs[0]._width = 8; layerDescs[0]._height = 8; layerDescs[1]._width = 6; layerDescs[1]._height = 6; layerDescs[2]._width = 4; layerDescs[2]._height = 4; sdr::IPredictiveRSDR prsdr; prsdr.createRandom(4, 5, 8, layerDescs, -0.01f, 0.01f, 0.0f, generator); float avgError = 1.0f; float avgErrorDecay = 0.01f; for (int iter = 0; iter < 1000; iter++) { for (int i = 0; i < timeSeries.size(); i++) { float error = 0.0f; for (int j = 0; j < timeSeries[i].size(); j++) { error += std::pow(prsdr.getPrediction(j) - timeSeries[i][j], 2); prsdr.setInput(j, timeSeries[i][j]); } avgError = (1.0f - avgErrorDecay) * avgError + avgErrorDecay * error; prsdr.simStep(generator); if (i % 10 == 0) { std::cout << "Iteration " << i << ": " << avgError << std::endl; } } } return 0; }