void Atom::show(std::ostream &out) const
{
out << " element:"<< get_element_table().get_name(get_element());
out << " type: "<< get_atom_type();
if (get_input_index() != -1) {
out << " input index: " << get_input_index();
}
if (core::XYZ::particle_is_instance(get_particle())) {
out << " coords: " << core::XYZ(get_particle());
}
}
void handle_menu()
{
uint8_t input_index = get_input_index();
if (input_index < 0xFF)
{
menu[current_menu].actions[input_index]();
}
if (current_menu == 0 && time_has_changed)
{
home_redraw_time();
time_has_changed = false;
}
}
GrowingInputs::GrowingInputsResults* GrowingInputs::perform_inputs_selection(void)
{
#ifdef __OPENNN_DEBUG__
check();
#endif
GrowingInputsResults* results = new GrowingInputsResults();
size_t index;
size_t original_index;
const PerformanceFunctional* performance_functional_pointer = training_strategy_pointer->get_performance_functional_pointer();
NeuralNetwork* neural_network_pointer = performance_functional_pointer->get_neural_network_pointer();
DataSet* data_set_pointer = performance_functional_pointer->get_data_set_pointer();
Variables* variables = data_set_pointer->get_variables_pointer();
const size_t inputs_number = variables->count_inputs_number();
const size_t targets_number = variables->count_targets_number();
Vector< Statistics<double> > original_statistics;
ScalingLayer::ScalingMethod original_scaling_method;
bool has_scaling_layer = neural_network_pointer->has_scaling_layer();
if (has_scaling_layer)
{
original_statistics = neural_network_pointer->get_scaling_layer_pointer()->get_statistics();
original_scaling_method = neural_network_pointer->get_scaling_layer_pointer()->get_scaling_method();
}
Vector<bool> current_inputs(inputs_number, true);
Vector<Variables::Use> current_uses = variables->arrange_uses();
const Vector<Variables::Use> original_uses = current_uses;
double optimum_generalization_error = 1e10;
double optimum_performance_error;
Vector<bool> optimal_inputs;
Vector<double> optimal_parameters;
Vector<double> final_correlations;
Vector<double> final(2);
Vector<double> history_row;
double current_training_performance, current_generalization_performance;
double previous_generalization_performance;
bool flag_input = false;
bool end = false;
size_t iterations = 0;
size_t selection_failures = 0;
time_t beginning_time, current_time;
double elapsed_time;
if (display)
{
std::cout << "Performing growing inputs selection..." << std::endl;
std::cout << std::endl << "Calculating correlations..." << std::endl;
}
final_correlations = calculate_final_correlations();
if (display)
{
std::cout << "Correlations : \n";
for(size_t i = 0; i < final_correlations.size(); i++)
{
original_index = get_input_index(original_uses, i);
std::cout << "input : " << variables->arrange_names()[original_index] << ", correlation = " << final_correlations[i] << std::endl;
if (i == 9)
{
std::cout << "...\n";
break;
}
}
}
for (size_t i = 0; i < current_uses.size(); i++)
if(current_uses[i] == Variables::Input)
current_uses[i] = Variables::Unused;
current_inputs.set(inputs_number, false);
time(&beginning_time);
index = final_correlations.calculate_maximal_index();
if (final_correlations[index] >= 0.9999*targets_number)
{
original_index = get_input_index(original_uses, index);
current_uses[original_index] = Variables::Input;
current_inputs[index] = true;
variables->set_uses(current_uses);
set_neural_inputs(current_inputs);
if(display)
std::cout << "Maximal correlation(" << final_correlations[index] << ") is nearly 1. \n"
<< "The problem is linear separable with the input " << variables->arrange_names()[original_index] << ".\n\n" ;
final = calculate_performances(current_inputs);
