示例#1
0
void VariablesTest::test_count_inputs_number(void)
{
   message += "test_count_inputs_number\n";

   Variables v;

   assert_true(v.count_inputs_number() == 0, LOG);
}
示例#2
0
void VariablesTest::test_set(void)
{
   message += "test_set\n";

   Variables v;

   // Instances and inputs and target variables

   v.set(1);

   assert_true(v.count_inputs_number() == 0, LOG);
   assert_true(v.count_targets_number() == 0, LOG);
}
示例#3
0
void VariablesTest::test_convert_time_series(void)
{
    message += "test_convert_time_series\n";

    Variables v;

    // Test

    v.set(1);

    v.convert_time_series(1);

    assert_true(v.get_variables_number() == 2, LOG);
    assert_true(v.count_inputs_number() == 1, LOG);
    assert_true(v.count_targets_number() == 1, LOG);
}
示例#4
0
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);