void Perceptron::initialize_bias_uniform(double minimum, double maximum)
{
// Control sentence (if debug)
#ifdef _DEBUG
if(minimum > maximum)
{
std::cerr << "Flood Error: Perceptron class." << std::endl
<< "initialize_bias_uniform(double, double) method." << std::endl
<< "Minimum value must be less than maximum value." << std::endl;
exit(1);
}
#endif
bias = calculate_random_uniform(minimum, maximum);
}
void Perceptron::initialize_bias_uniform(const double& minimum, const double& maximum)
{
// Control sentence (if debug)
#ifdef __OPENNN_DEBUG__
if(minimum > maximum)
{
std::ostringstream buffer;
buffer << "OpenNN Exception: Perceptron class.\n"
<< "initialize_bias_uniform(const double&, const double&) method.\n"
<< "Minimum value must be less than maximum value.\n";
throw std::logic_error(buffer.str());
}
#endif
bias = calculate_random_uniform(minimum, maximum);
}
SimulatedAnnealingOrder::SimulatedAnnealingOrderResults* SimulatedAnnealingOrder::perform_order_selection(void)
{
SimulatedAnnealingOrderResults* results = new SimulatedAnnealingOrderResults();
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();
size_t optimal_order, current_order;
Vector<double> optimum_performance(2);
Vector<double> current_order_performance(2);
Vector<double> optimum_parameters, current_parameters;
double current_training_performance, current_selection_performance;
bool end = false;
size_t iterations = 0;
size_t random_failures = 0;
size_t upper_bound;
size_t lower_bound;
time_t beginning_time, current_time;
double elapsed_time;
double temperature;
double boltzmann_probability;
double random_uniform;
if(display)
{
std::cout << "Performing order selection with simulated annealing method..." << std::endl;
}
time(&beginning_time);
optimal_order = (size_t)(minimum_order +
calculate_random_uniform(0.,1.)*(maximum_order - minimum_order));
optimum_performance = perform_model_evaluation(optimal_order);
optimum_parameters = get_parameters_order(optimal_order);
current_training_performance = optimum_performance[0];
current_selection_performance = optimum_performance[1];
temperature = current_selection_performance;
results->order_data.push_back(optimal_order);
if(reserve_performance_data)
{
results->performance_data.push_back(current_training_performance);
}
if(reserve_selection_performance_data)
{
results->selection_performance_data.push_back(current_selection_performance);
}
if(reserve_parameters_data)
{
results->parameters_data.push_back(optimum_parameters);
}
time(¤t_time);
elapsed_time = difftime(current_time, beginning_time);
if(display)
{
std::cout << "Initial values : " << std::endl;
std::cout << "Hidden perceptrons : " << optimal_order << std::endl;
std::cout << "Final selection performance : " << optimum_performance[1] << std::endl;
std::cout << "Final Training Performance : " << optimum_performance[0] << std::endl;
std::cout << "Temperature : " << temperature << std::endl;
std::cout << "Elapsed time : " << elapsed_time << std::endl;
}
while (!end){
upper_bound = std::min(maximum_order, optimal_order + (maximum_order-minimum_order)/3);
if(optimal_order <= (maximum_order-minimum_order)/3)
{
lower_bound = minimum_order;
}else
{
lower_bound = optimal_order - (maximum_order-minimum_order)/3;
}
current_order = (size_t)(lower_bound + calculate_random_uniform(0.,1.)*(upper_bound - lower_bound));
while (current_order == optimal_order)
{
current_order = (size_t)(lower_bound + calculate_random_uniform(0.,1.)*(upper_bound - lower_bound));
random_failures++;
if(random_failures >= 5 && optimal_order != minimum_order)
{
current_order = optimal_order - 1;
}else if(random_failures >= 5 && optimal_order != maximum_order)
{
current_order = optimal_order + 1;
}
}
random_failures = 0;
current_order_performance = perform_model_evaluation(current_order);
current_training_performance = current_order_performance[0];
current_selection_performance = current_order_performance[1];
current_parameters = get_parameters_order(current_order);
boltzmann_probability = std::min(1.0, exp(-(current_selection_performance-optimum_performance[1])/temperature));
random_uniform = calculate_random_uniform(0.,1.);
if(boltzmann_probability > random_uniform)
{
optimal_order = current_order;
optimum_performance = current_order_performance;
optimum_parameters = get_parameters_order(optimal_order);
}
time(¤t_time);
elapsed_time = difftime(current_time, beginning_time);
results->order_data.push_back(current_order);
if(reserve_performance_data)
{
results->performance_data.push_back(current_training_performance);
}
if(reserve_selection_performance_data)
{
results->selection_performance_data.push_back(current_selection_performance);
}
if(reserve_parameters_data)
{
results->parameters_data.push_back(current_parameters);
}
temperature = cooling_rate*temperature;
iterations++;
// Stopping criteria
if(temperature <= minimum_temperature)
{
end = true;
if(display)
{
std::cout << "Minimum temperature reached." << std::endl;
}
results->stopping_condition = SimulatedAnnealingOrder::MinimumTemperature;
}else if(elapsed_time > maximum_time)
{
end = true;
if(display)
{
std::cout << "Maximum time reached." << std::endl;
}
results->stopping_condition = SimulatedAnnealingOrder::MaximumTime;
}else if(optimum_performance[1] <= selection_performance_goal)
{
end = true;
if(display)
{
std::cout << "Selection performance reached." << std::endl;
}
results->stopping_condition = SimulatedAnnealingOrder::SelectionPerformanceGoal;
}else if(iterations >= maximum_iterations_number)
{
end = true;
if(display)
{
std::cout << "Maximum number of iterations reached." << std::endl;
}
results->stopping_condition = SimulatedAnnealingOrder::MaximumIterations;
}
if(display)
{
std::cout << "Iteration : " << iterations << std::endl;
std::cout << "Hidden neurons number : " << optimal_order << std::endl;
std::cout << "Selection performance : " << optimum_performance[1] << std::endl;
std::cout << "Training performance : " << optimum_performance[0] << std::endl;
std::cout << "Current temperature : " << temperature << std::endl;
std::cout << "Elapsed time : " << elapsed_time << std::endl;
}
}
size_t optimal_index = get_optimal_selection_performance_index();
optimal_order = order_history[optimal_index] ;
optimum_performance[0] = performance_history[optimal_index];
optimum_performance[1] = selection_performance_history[optimal_index];
optimum_parameters = get_parameters_order(optimal_order);
if(display)
{
std::cout << "Optimal order : " << optimal_order << std::endl;
std::cout << "Optimum selection performance : " << optimum_performance[1] << std::endl;
std::cout << "Corresponding training performance : " << optimum_performance[0] << 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);
if(reserve_minimal_parameters)
{
results->minimal_parameters = optimum_parameters;
}
results->optimal_order = optimal_order;
results->final_performance = optimum_performance[0];
results->final_selection_performance = optimum_performance[1];
results->elapsed_time = elapsed_time;
results->iterations_number = iterations;
return(results);
}