From f0effb91311a231b3ecff8b483dac67fc1e53b3b Mon Sep 17 00:00:00 2001 From: rubenareces Date: Mon, 13 Jan 2025 08:15:12 +0100 Subject: [PATCH 01/10] merge --- examples/mnist/main.cpp | 14 +++++++------- opennn/neural_network.cpp | 11 ++++------- 2 files changed, 11 insertions(+), 14 deletions(-) diff --git a/examples/mnist/main.cpp b/examples/mnist/main.cpp index 642ed3955..7877e0324 100644 --- a/examples/mnist/main.cpp +++ b/examples/mnist/main.cpp @@ -32,16 +32,16 @@ int main() const Index channels = 1; const Index targets = 2; - //ImageDataSet image_data_set(samples_number, {image_height, image_width, channels}, {targets}); + ImageDataSet image_data_set(samples_number, {image_height, image_width, channels}, {targets}); - //image_data_set.set_data_random(); + image_data_set.set_data_random(); - //image_data_set.set(DataSet::SampleUse::Training); + image_data_set.set(DataSet::SampleUse::Training); - ImageDataSet image_data_set(0,{0,0,0},{0}); + //ImageDataSet image_data_set(0,{0,0,0},{0}); //image_data_set.set_data_path("data"); - image_data_set.set_data_path("C:/mnist/train"); + //image_data_set.set_data_path("C:/mnist/train"); //image_data_set.set_data_path("C:/binary_mnist"); //image_data_set.set_data_path("C:/Users/Roberto Lopez/Documents/opennn/examples/mnist/data"); //image_data_set.set_data_path("C:/melanoma_dataset_bmp"); @@ -49,13 +49,13 @@ int main() //image_data_set.set_data_path("C:/melanoma_supersmall"); //image_data_set.set_input_dimensions({24,24,1}); - image_data_set.read_bmp(); + //image_data_set.read_bmp(); // Neural network NeuralNetwork neural_network(NeuralNetwork::ModelType::ImageClassification, image_data_set.get_input_dimensions(), - { 32 }, + { 8 }, image_data_set.get_target_dimensions()); //neural_network.print(); diff --git a/opennn/neural_network.cpp b/opennn/neural_network.cpp index 45ae8d22a..f86fa5818 100644 --- a/opennn/neural_network.cpp +++ b/opennn/neural_network.cpp @@ -983,12 +983,10 @@ void NeuralNetwork::forward_propagate(const vector>& inp const vector>> layer_input_pairs = forward_propagation.get_layer_input_pairs(input_pair); - for (Index i = first_layer_index; i <= last_layer_index; i++){ - + for (Index i = first_layer_index; i <= last_layer_index; i++) layers[i]->forward_propagate(layer_input_pairs[i], - forward_propagation.layers[i], - is_training);} - + forward_propagation.layers[i], + is_training); } @@ -1092,8 +1090,6 @@ Tensor NeuralNetwork::calculate_outputs(const Tensor& inputs) forward_propagate({input_pair}, forward_propagation); - //forward_propagation.print(); - const pair outputs_pair = forward_propagation.layers[layers_number - 1]->get_outputs_pair(); @@ -1103,6 +1099,7 @@ Tensor NeuralNetwork::calculate_outputs(const Tensor& inputs) Tensor NeuralNetwork::calculate_outputs(const Tensor& inputs) { + cout << "Esta funcion no funciona, arreglar al volver" << endl; const Index layers_number = get_layers_number(); if (layers_number == 0) From a7a76e39d07d86ba072c9a1d57859db6e7dfcaa1 Mon Sep 17 00:00:00 2001 From: rubenareces Date: Wed, 15 Jan 2025 09:22:24 +0100 Subject: [PATCH 02/10] confusion matrix fix --- opennn/neural_network.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/opennn/neural_network.cpp b/opennn/neural_network.cpp index b26fcfac8..3fce05f89 100644 --- a/opennn/neural_network.cpp +++ b/opennn/neural_network.cpp @@ -986,7 +986,7 @@ void NeuralNetwork::forward_propagate(const vector>& inp const Index last_layer_index = is_training ? last_trainable_layer_index : layers_number - 1; const vector>> layer_input_pairs = forward_propagation.get_layer_input_pairs(input_pair); - + for (Index i = first_layer_index; i <= last_layer_index; i++) layers[i]->forward_propagate(layer_input_pairs[i], forward_propagation.layers[i], @@ -1103,7 +1103,6 @@ Tensor NeuralNetwork::calculate_outputs(const Tensor& inputs) Tensor NeuralNetwork::calculate_outputs(const Tensor& inputs) { - cout << "Esta funcion no funciona, arreglar al volver" << endl; const Index layers_number = get_layers_number(); if (layers_number == 0) @@ -1113,7 +1112,7 @@ Tensor NeuralNetwork::calculate_outputs(const Tensor& inputs) ForwardPropagation forward_propagation(batch_samples_number, this); - const pair input_pair((type*)inputs.data(), { {inputs.dimension(0), inputs.dimension(1), inputs.dimension(2), inputs.dimension(3)}}); + const pair input_pair((type*)inputs.data(), { {batch_samples_number, inputs.dimension(1), inputs.dimension(2), inputs.dimension(3)}}); forward_propagate({input_pair}, forward_propagation); @@ -1955,7 +1954,7 @@ vector>> ForwardPropagation::get_layer_input_pair vector>> layer_input_pairs(layers_number); - //layer_input_pairs[0] = batch_input_pairs; + layer_input_pairs[0] = batch_input_pairs; const Index first_trainable_layer_index = neural_network->get_first_trainable_layer_index(); From c637ef65f3411b7aeeb5d604be70df299fe74ed5 Mon Sep 17 00:00:00 2001 From: RoberLopez Date: Wed, 15 Jan 2025 15:22:47 +0100 Subject: [PATCH 03/10] clean --- opennn/data_set.cpp | 7 +- opennn/genetic_algorithm.cpp | 216 +++++++++---------------- opennn/genetic_algorithm.h | 17 +- opennn/growing_neurons.cpp | 36 ++--- opennn/opennn.vcxproj | 1 - opennn/statistics.cpp | 5 +- opennn/stochastic_gradient_descent.cpp | 12 +- opennn/tensors.cpp | 1 - opennn/testing_analysis.cpp | 81 ++++------ opennn/testing_analysis.h | 3 + 10 files changed, 143 insertions(+), 236 deletions(-) diff --git a/opennn/data_set.cpp b/opennn/data_set.cpp index 7cc3d2707..20e9e7283 100755 --- a/opennn/data_set.cpp +++ b/opennn/data_set.cpp @@ -3408,10 +3408,8 @@ void DataSet::set_data_rosenbrock() } - void DataSet::set_data_classification() -{ - +{ const Index samples_number = get_samples_number(); const Index input_variables_number = get_variables_number(VariableUse::Input); const Index target_variables_number = get_variables_number(VariableUse::Target); @@ -3531,7 +3529,8 @@ void DataSet::impute_missing_values_unuse() #pragma omp parallel for for(Index i = 0; i & GeneticAlgorithm::get_original_unused_raw_variables() void GeneticAlgorithm::set_default() { - if (!training_strategy) - return; - - if (!training_strategy->has_neural_network()) + if (!training_strategy || !training_strategy->has_neural_network()) return; const Index genes_number = training_strategy->get_data_set()->get_input_and_unused_variables_number(); - Index individuals_number = 40; + const Index individuals_number = 40; maximum_epochs_number = 100; @@ -110,14 +107,14 @@ void GeneticAlgorithm::set_default() parameters.resize(individuals_number); - for(Index i = 0; i < individuals_number; i++) {parameters(i).resize(genes_number);} + for(Index i = 0; i < individuals_number; i++) + parameters(i).resize(genes_number); training_errors.resize(individuals_number); selection_errors.resize(individuals_number); fitness.resize(individuals_number); - fitness.setConstant(type(-1.0)); selection.resize(individuals_number); @@ -216,12 +213,10 @@ void GeneticAlgorithm::initialize_population_random() original_input_raw_variable_indices = data_set->get_raw_variable_indices(DataSet::VariableUse::Input); original_target_raw_variable_indices = data_set->get_raw_variable_indices(DataSet::VariableUse::Target); - - //const vector& raw_variables = data_set->get_raw_variables(); - original_unused_raw_variable_indices = data_set->get_raw_variable_indices(DataSet::VariableUse::None); - const Index raw_variables_number = original_input_raw_variable_indices.size() + original_unused_raw_variable_indices.size(); + const Index raw_variables_number = original_input_raw_variable_indices.size() + + original_unused_raw_variable_indices.size(); const Index random_raw_variables_number = data_set->get_raw_variables_number(DataSet::VariableUse::Input); @@ -231,54 +226,50 @@ void GeneticAlgorithm::initialize_population_random() (random_raw_variables_number > 500) ? type(0.6) : type(1); - // Original inputs raw_variables - original_input_raw_variables.resize(raw_variables_number, false); for(size_t i = 0; i < original_input_raw_variable_indices.size(); i++) original_input_raw_variables[original_input_raw_variable_indices[i]] = true; - // Initialization a random population - population.setConstant(false); Tensor individual_raw_variables(raw_variables_number); - individual_raw_variables.setConstant(false); Tensor individual_variables(genes_number); - individual_variables.setConstant(false); cout << "Creating initial random population" << endl; const int upper_limit = int(ceil(random_raw_variables_number * percentage) - 1); - for(Index i = 0; i < individuals_number; i++) - { - random_device rd; + random_device rd; + + mt19937 gen(rd()); - mt19937 g(rd()); + uniform_int_distribution<> dist(1, upper_limit); + for(Index i = 0; i < individuals_number; i++) + { individual_raw_variables.setConstant(false); - const int random_number = rand() % upper_limit + 1; + const int random_number = get_random_type(1, upper_limit); fill_n(individual_raw_variables.data(), random_number, true); - shuffle(individual_raw_variables.data(), individual_raw_variables.data() + individual_raw_variables.size(), g); + shuffle(individual_raw_variables.data(), individual_raw_variables.data() + individual_raw_variables.size(), gen); - individual_variables = get_individual_variables(individual_raw_variables); + individual_variables = get_individual_genes(individual_raw_variables); if(is_equal(individual_variables, false)) { - Tensor individual_raw_variables_false = get_individual_raw_variables(individual_variables); + Tensor individual_raw_variables_false = get_individual_raw_genes(individual_variables); for(Index j = 0; j < raw_variables_number; j++) if(original_input_raw_variables[j]) individual_raw_variables_false(j) = true; - individual_variables = get_individual_variables(individual_raw_variables_false); + individual_variables = get_individual_genes(individual_raw_variables_false); } if(is_equal(individual_variables, false)) @@ -298,13 +289,12 @@ void GeneticAlgorithm::calculate_inputs_activation_probabilities() //outdated const Index raw_variables_number = data_set->get_raw_variables_number(DataSet::VariableUse::Input); - const Tensor correlations_matrix = data_set->calculate_input_target_raw_variable_pearson_correlations(); - - const Tensor correlations = get_correlation_values(correlations_matrix).chip(0, 1); + const Tensor correlation_matrix + = data_set->calculate_input_target_raw_variable_pearson_correlations(); - const Tensor correlations_abs = correlations.abs(); + const Tensor absolute_correlations = get_correlation_values(correlation_matrix).chip(0, 1).abs(); - const Tensor rank = calculate_rank_greater(correlations_abs); + const Tensor rank = calculate_rank_greater(absolute_correlations); Tensor fitness_correlations(raw_variables_number); @@ -320,7 +310,7 @@ void GeneticAlgorithm::calculate_inputs_activation_probabilities() //outdated } -void GeneticAlgorithm::initialize_population_correlations() // outdated +void GeneticAlgorithm::initialize_population_correlations() { DataSet* data_set = training_strategy->get_data_set(); @@ -330,9 +320,9 @@ void GeneticAlgorithm::initialize_population_correlations() // outdated const Index genes_number = get_genes_number(); - const Index raw_variables_number = data_set->get_raw_variables_number(DataSet::VariableUse::Input); + const Index input_raw_variables_number = data_set->get_raw_variables_number(DataSet::VariableUse::Input); - Tensor individual_raw_variables(raw_variables_number); + Tensor individual_raw_variables(input_raw_variables_number); Tensor individual_variables(genes_number); @@ -352,7 +342,7 @@ void GeneticAlgorithm::initialize_population_correlations() // outdated individual_variables.setConstant(false); - raw_variables_active = 1 + rand() % raw_variables_number; + raw_variables_active = 1 + rand() % input_raw_variables_number; while(count(individual_raw_variables.data(), individual_raw_variables.data() + individual_raw_variables.size(), 1) < raw_variables_active) { @@ -360,7 +350,7 @@ void GeneticAlgorithm::initialize_population_correlations() // outdated individual_raw_variables(0) = arrow < inputs_activation_probabilities(0) && !individual_raw_variables(0); - for(Index j = 1; j < raw_variables_number; j++) + for(Index j = 1; j < input_raw_variables_number; j++) if(arrow >= inputs_activation_probabilities(j - 1) && arrow < inputs_activation_probabilities(j) && !individual_raw_variables(j)) @@ -368,9 +358,9 @@ void GeneticAlgorithm::initialize_population_correlations() // outdated } if(is_equal(individual_raw_variables, false)) - individual_raw_variables(rand()%raw_variables_number) = true; + individual_raw_variables(rand()%input_raw_variables_number) = true; - individual_variables = get_individual_variables(individual_raw_variables); + individual_variables = get_individual_genes(individual_raw_variables); for(Index j = 0; j < genes_number; j++) population(i, j) = individual_variables(j); @@ -418,7 +408,7 @@ void GeneticAlgorithm::evaluate_population() cout << "\nIndividual " << i + 1 << endl; - individual_raw_variables_indices = get_individual_as_raw_variables_indexes_from_variables(individual); + individual_raw_variables_indices = get_raw_variable_indices(individual); inputs_number(i) = individual_raw_variables_indices.size(); @@ -550,9 +540,9 @@ void GeneticAlgorithm::perform_crossover() Tensor new_population(individuals_number, genes_number); - Tensor parent_1_variables; + Tensor parent_1_genes; - Tensor parent_2_variables; + Tensor parent_2_genes; Tensor descendent_variables; @@ -560,9 +550,9 @@ void GeneticAlgorithm::perform_crossover() Tensor descendent_raw_variables(raw_variables_number); - Tensor parent_1_raw_variables; + Tensor parent_1_raw_genes; - Tensor parent_2_raw_variables; + Tensor parent_2_raw_genes; random_device rd; @@ -572,41 +562,41 @@ void GeneticAlgorithm::perform_crossover() shuffle(parent_1_indices.data(), parent_1_indices.data() + parent_1_indices.size(), g); - vector parent_2_indices = get_selected_individuals_indices(); + const vector parent_2_indices = get_selected_individuals_indices(); Index descendent_index = 0; for(size_t i = 0; i < parent_1_indices.size(); i++) { - parent_1_variables = population.chip(parent_1_indices[i], 0); + parent_1_genes = population.chip(parent_1_indices[i], 0); - parent_1_raw_variables = get_individual_raw_variables(parent_1_variables); + parent_1_raw_genes = get_individual_raw_genes(parent_1_genes); - parent_2_variables = population.chip(parent_2_indices[i], 0); + parent_2_genes = population.chip(parent_2_indices[i], 0); - descendent_raw_variables = get_individual_raw_variables(parent_2_variables); + descendent_raw_variables = get_individual_raw_genes(parent_2_genes); for(Index j = 0; j < 2; j++) { - descendent_raw_variables = parent_1_raw_variables; + descendent_raw_variables = parent_1_raw_genes; for(Index k = 0; k < raw_variables_number; k++) - if(parent_1_raw_variables(k) != parent_2_raw_variables(k)) + if(parent_1_raw_genes(k) != parent_2_raw_genes(k)) descendent_raw_variables(k) = get_random_bool(); - descendent_genes = get_individual_variables(descendent_raw_variables); + descendent_genes = get_individual_genes(descendent_raw_variables); if(is_equal(descendent_genes, false)) { //const vector& raw_variables = data_set->get_raw_variables(); - Tensor individual_raw_variables_false = get_individual_raw_variables(descendent_genes); + Tensor individual_raw_variables_false = get_individual_raw_genes(descendent_genes); for(Index k = 0; k < raw_variables_number; k++) if(original_input_raw_variables[k]) individual_raw_variables_false(k) = true; - descendent_genes = get_individual_variables(individual_raw_variables_false); + descendent_genes = get_individual_genes(individual_raw_variables_false); } if(is_equal(descendent_genes, false)) @@ -640,22 +630,22 @@ void GeneticAlgorithm::perform_mutation() { individual_variables = population.chip(i, 0); - individual_raw_variables = get_individual_raw_variables(individual_variables); + individual_raw_variables = get_individual_raw_genes(individual_variables); for(Index j = 0; j < raw_variables_number; j++) individual_raw_variables(j) ^= (type(rand())/type(RAND_MAX) < mutation_rate); - new_individual_variables = get_individual_variables(individual_raw_variables); + new_individual_variables = get_individual_genes(individual_raw_variables); if(is_equal(new_individual_variables, false)) { - Tensor individual_raw_variables_false = get_individual_raw_variables(new_individual_variables); + Tensor individual_raw_variables_false = get_individual_raw_genes(new_individual_variables); for(Index j = 0; j < raw_variables_number; j++) if(original_input_raw_variables[j]) individual_raw_variables_false[j] = true; - new_individual_variables = get_individual_variables(individual_raw_variables_false); + new_individual_variables = get_individual_genes(individual_raw_variables_false); } if(is_equal(new_individual_variables, false)) @@ -708,7 +698,7 @@ InputsSelectionResults GeneticAlgorithm::perform_inputs_selection() vector optimal_inputs_raw_variables_indices; - std::time(&beginning_time); + time(&beginning_time); input_selection_results.optimum_selection_error = numeric_limits::max(); @@ -752,7 +742,7 @@ InputsSelectionResults GeneticAlgorithm::perform_inputs_selection() input_selection_results.optimal_inputs = population.chip(optimal_individual_index, 0); - optimal_inputs_raw_variables_indices = get_individual_as_raw_variables_indexes_from_variables(input_selection_results.optimal_inputs); + optimal_inputs_raw_variables_indices = get_raw_variable_indices(input_selection_results.optimal_inputs); data_set->set_input_target_raw_variable_indices(optimal_inputs_raw_variables_indices, original_target_raw_variable_indices); @@ -793,30 +783,27 @@ InputsSelectionResults GeneticAlgorithm::perform_inputs_selection() // Stopping criteria - if(elapsed_time >= maximum_time) - { - stop = true; - - if(display) cout << "Epoch " << epoch << "\nMaximum time reached: " << write_time(elapsed_time) << endl; + stop = true; + if (elapsed_time >= maximum_time) + { + if (display) cout << "Epoch " << epoch << "\nMaximum time reached: " << write_time(elapsed_time) << endl; input_selection_results.stopping_condition = InputsSelection::StoppingCondition::MaximumTime; } - - if(epoch >= maximum_epochs_number - 1) + else if (epoch >= maximum_epochs_number - 1) { - stop = true; - - if(display) cout << "Epoch " << epoch << "\nMaximum epochs number reached: " << epoch << endl; - + if (display) cout << "Epoch " << epoch << "\nMaximum epochs number reached: " << epoch << endl; input_selection_results.stopping_condition = InputsSelection::StoppingCondition::MaximumEpochs; } + else + { + stop = false; + } if(stop) { input_selection_results.elapsed_time = write_time(elapsed_time); - input_selection_results.resize_history(epoch + 1); - break; } @@ -832,9 +819,9 @@ InputsSelectionResults GeneticAlgorithm::perform_inputs_selection() // Set data set stuff - vector optimal_raw_variables = get_individual_as_raw_variables_indexes_from_variables(input_selection_results.optimal_inputs); + const vector optimal_raw_variable_indices = get_raw_variable_indices(input_selection_results.optimal_inputs); - data_set->set_input_target_raw_variable_indices(optimal_raw_variables, original_target_raw_variable_indices); + data_set->set_input_target_raw_variable_indices(optimal_raw_variable_indices, original_target_raw_variable_indices); const vector input_variable_scalers = data_set->get_variable_scalers(DataSet::VariableUse::Input); @@ -861,11 +848,12 @@ InputsSelectionResults GeneticAlgorithm::perform_inputs_selection() } -Tensor GeneticAlgorithm::get_individual_raw_variables(Tensor& individual) // upadted +Tensor GeneticAlgorithm::get_individual_raw_genes(const Tensor& individual) { DataSet* data_set = training_strategy->get_data_set(); - const Index raw_variables_number = original_input_raw_variable_indices.size() + original_unused_raw_variable_indices.size(); + const Index raw_variables_number = original_input_raw_variable_indices.size() + + original_unused_raw_variable_indices.size(); Tensor raw_variables_from_variables(raw_variables_number); raw_variables_from_variables.setConstant(false); @@ -894,12 +882,12 @@ Tensor GeneticAlgorithm::get_individual_raw_variables(Tensor& i } -vector GeneticAlgorithm::get_individual_as_raw_variables_indexes_from_variables(Tensor& individual) // updated +vector GeneticAlgorithm::get_raw_variable_indices(const Tensor& individual) // updated { - Tensor individual_raw_variables = get_individual_raw_variables(individual); + const Tensor individual_raw_variables = get_individual_raw_genes(individual); - Tensor inputs_pre_indexes(individual_raw_variables.size()); - inputs_pre_indexes.setConstant(false); + Tensor inputs_pre_indices(individual_raw_variables.size()); + inputs_pre_indices.setConstant(false); Index original_input_index = 0; @@ -907,20 +895,20 @@ vector GeneticAlgorithm::get_individual_as_raw_variables_indexes_from_var { if(individual_raw_variables(i) && original_input_raw_variables[i]) { - inputs_pre_indexes(i) = true; + inputs_pre_indices(i) = true; original_input_index = i; } } - const Index indices_dimension = count(inputs_pre_indexes.data(), - inputs_pre_indexes.data() + inputs_pre_indexes.size(), + const Index indices_dimension = count(inputs_pre_indices.data(), + inputs_pre_indices.data() + inputs_pre_indices.size(), true); - if(is_equal(inputs_pre_indexes, false)) + if(is_equal(inputs_pre_indices, false)) { cout << "/." << endl; - inputs_pre_indexes(original_input_index) = true; + inputs_pre_indices(original_input_index) = true; } Index index = 0; @@ -928,14 +916,14 @@ vector GeneticAlgorithm::get_individual_as_raw_variables_indexes_from_var vector indices(indices_dimension); for(Index i = 0; i < individual_raw_variables.size(); i++) - if(inputs_pre_indexes(i)) + if(inputs_pre_indices(i)) indices[index] = i; return indices; } -Tensor GeneticAlgorithm::get_individual_variables(Tensor& individual_raw_variables) +Tensor GeneticAlgorithm::get_individual_genes(const Tensor& individual_raw_variables) { DataSet* data_set = training_strategy->get_data_set(); @@ -985,8 +973,6 @@ Tensor GeneticAlgorithm::get_individual_variables(Tensor& indi } } - // None variables (no set unused initial raw_variables as inputs) - Tensor individual_raw_variables_to_variables_returned(genes_number); individual_raw_variables_to_variables_returned.setConstant(false); @@ -1040,54 +1026,10 @@ Tensor GeneticAlgorithm::get_individual_variables(Tensor& indi } -// Tensor GeneticAlgorithm::get_individual_variables_to_indexes(Tensor& individual) -// { -// DataSet* data_set = training_strategy->get_data_set(); - -// const Index raw_variables_number = data_set->get_raw_variables_number(VariableUse::Input); - -// Tensor new_indexes(individual); - -// Index variable_index = 0; - -// if(data_set->has_categorical_raw_variables()) -// { -// for(Index i = 0; i < raw_variables_number; i++) -// { -// if(data_set->get_raw_variable_type(i) == DataSet::RawVariableType::Categorical) -// { -// const Index categories_number = data_set->get_raw_variables()(i).get_categories_number(); - -// if(!(find(individual.data() + variable_index, individual.data() + variable_index + categories_number, 1) == individual.data() + variable_index + categories_number)) -// { -// new_indexes(i) = true; -// } -// else -// { -// new_indexes(i) = false; -// } -// variable_index += categories_number; -// } -// else -// { -// new_indexes(i) = individual(variable_index); - -// variable_index++; -// } -// } -// } - -// return new_indexes; -// } - - Tensor GeneticAlgorithm::to_string_matrix() const { const Index individuals_number = get_individuals_number(); - Tensor labels(6); - Tensor values(6); - Tensor string_matrix(6, 2); string_matrix.setValues({ @@ -1104,11 +1046,7 @@ Tensor GeneticAlgorithm::to_string_matrix() const Index GeneticAlgorithm::weighted_random(const Tensor& weights) //¿void? { - random_device rd; - mt19937 gen(rd()); - uniform_real_distribution dist(0, 1); - - type randomNumber = type(dist(gen)); + const type random_number = get_random_type(0, 1); type sum = type(0); @@ -1116,7 +1054,7 @@ Index GeneticAlgorithm::weighted_random(const Tensor& weights) //¿void { sum += weights(i); - if(randomNumber <= sum && !selection(i)) + if(random_number <= sum && !selection(i)) { selection(i) = true; return i; diff --git a/opennn/genetic_algorithm.h b/opennn/genetic_algorithm.h index 28c9d3356..00aa21c0a 100644 --- a/opennn/genetic_algorithm.h +++ b/opennn/genetic_algorithm.h @@ -43,7 +43,7 @@ class GeneticAlgorithm : public InputsSelection const InitializationMethod& get_initialization_method() const; - virtual void set_default(); + void set_default(); void set_population(const Tensor&); @@ -81,19 +81,17 @@ class GeneticAlgorithm : public InputsSelection void perform_mutation(); - Tensor get_individual_raw_variables(Tensor&); + Tensor get_individual_raw_genes(const Tensor&); - Tensor get_individual_variables(Tensor&); + Tensor get_individual_genes(const Tensor&); vector get_selected_individuals_indices (); - vector get_individual_as_raw_variables_indexes_from_variables( Tensor&); - - void set_unused_raw_variables(vector&); + vector get_raw_variable_indices(const Tensor&); const vector& get_original_unused_raw_variables(); - InputsSelectionResults perform_inputs_selection () override; + InputsSelectionResults perform_inputs_selection() override; Tensor to_string_matrix() const; @@ -107,11 +105,10 @@ class GeneticAlgorithm : public InputsSelection void load(const filesystem::path&); +private: + Tensor, 1> parameters; -private: - - vector initial_raw_variables_indices; vector original_input_raw_variables; vector original_unused_raw_variable_indices; diff --git a/opennn/growing_neurons.cpp b/opennn/growing_neurons.cpp index 9ecab2692..d2c9ae193 100644 --- a/opennn/growing_neurons.cpp +++ b/opennn/growing_neurons.cpp @@ -159,50 +159,37 @@ NeuronsSelectionResults GrowingNeurons::perform_neurons_selection() // Stopping criteria + end = true; + if(elapsed_time >= maximum_time) { - end = true; - - if(display) cout << "Epoch " << epoch << "\nMaximum time reached: " << write_time(elapsed_time) << endl; - + if (display) cout << "Epoch " << epoch << "\nMaximum time reached: " << write_time(elapsed_time) << endl; neurons_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::MaximumTime; } - - if(training_results.get_selection_error() <= selection_error_goal) + else if(training_results.get_selection_error() <= selection_error_goal) { - end = true; - if(display) cout << "Epoch " << epoch << "\nSelection error goal reached: " << training_results.get_selection_error() << endl; - neurons_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::SelectionErrorGoal; } - - if(epoch >= maximum_epochs_number) + else if(epoch >= maximum_epochs_number) { - end = true; - if(display) cout << "Epoch " << epoch << "\nMaximum epochs number reached: " << epoch << endl; - neurons_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::MaximumEpochs; } - - if(selection_failures >= maximum_selection_failures) + else if(selection_failures >= maximum_selection_failures) { - end = true; - if(display) cout << "Epoch " << epoch << "\nMaximum selection failures reached: " << selection_failures << endl; - neurons_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::MaximumSelectionFailures; } - - if(neurons_number >= maximum_neurons) + else if(neurons_number >= maximum_neurons) { - end = true; - if(display) cout << "Epoch " << epoch << "\nMaximum number of neurons reached: " << neurons_number << endl; - neurons_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::MaximumNeurons; } + else + { + end = false; + } if(end) { @@ -218,7 +205,6 @@ NeuronsSelectionResults GrowingNeurons::perform_neurons_selection() neural_network->get_layer(last_trainable_layer_index - 1).get()->set_output_dimensions({ neurons_number }); neural_network->get_layer(last_trainable_layer_index).get()->set_input_dimensions({ neurons_number }); - neural_network->set_parameters(neurons_selection_results.optimal_parameters); if(display) neurons_selection_results.print(); diff --git a/opennn/opennn.vcxproj b/opennn/opennn.vcxproj index 790f70c90..9d75b9a7d 100644 --- a/opennn/opennn.vcxproj +++ b/opennn/opennn.vcxproj @@ -317,7 +317,6 @@ - diff --git a/opennn/statistics.cpp b/opennn/statistics.cpp index bc8941bb9..de4b9fb55 100644 --- a/opennn/statistics.cpp +++ b/opennn/statistics.cpp @@ -1329,9 +1329,8 @@ vector descriptives(const Tensor& matrix, if(isnan(value)) continue; - if(value < minimums(j)) minimums(j) = value; - - if(value > maximums(j)) maximums(j) = value; + minimums(j) = min(minimums(j), value); + maximums(j) = max(maximums(j), value); sums(j) += double(value); squared_sums(j) += double(value)*double(value); diff --git a/opennn/stochastic_gradient_descent.cpp b/opennn/stochastic_gradient_descent.cpp index 55a71be9d..4eabc7461 100644 --- a/opennn/stochastic_gradient_descent.cpp +++ b/opennn/stochastic_gradient_descent.cpp @@ -379,30 +379,32 @@ TrainingResults StochasticGradientDescent::perform_training() // Stopping criteria + stop_training = true; + if(epoch == maximum_epochs_number) { if(display) cout << "Epoch " << epoch << "\nMaximum epochs number reached: " << epoch << endl; - stop_training = true; results.stopping_condition = StoppingCondition::MaximumEpochsNumber; } else if(elapsed_time >= maximum_time) { if(display) cout << "Epoch " << epoch << "\nMaximum training time reached: " << write_time(elapsed_time) << endl; - stop_training = true; results.stopping_condition = StoppingCondition::MaximumTime; } else if(results.training_error_history(epoch) < training_loss_goal) { - stop_training = true; + if (display) cout << "Epoch " << epoch << "\nLoss goal reached: " << results.training_error_history(epoch) << endl; results.stopping_condition = StoppingCondition::LossGoal; - if(display) cout << "Epoch " << epoch << "\nLoss goal reached: " << results.training_error_history(epoch) << endl; } else if(selection_failures >= maximum_selection_failures) { if(display) cout << "Epoch " << epoch << "\nMaximum selection failures reached: " << selection_failures << endl; - stop_training = true; results.stopping_condition = StoppingCondition::MaximumSelectionErrorIncreases; } + else + { + stop_training = false; + } if(stop_training) { diff --git a/opennn/tensors.cpp b/opennn/tensors.cpp index 71b5d2f11..682b57dd2 100644 --- a/opennn/tensors.cpp +++ b/opennn/tensors.cpp @@ -8,7 +8,6 @@ #include "../eigen/Eigen/Dense" -//#include "strings_utilities.h" #include "tensors.h" namespace opennn diff --git a/opennn/testing_analysis.cpp b/opennn/testing_analysis.cpp index 2e917408e..0718b54e1 100644 --- a/opennn/testing_analysis.cpp +++ b/opennn/testing_analysis.cpp @@ -124,7 +124,6 @@ void TestingAnalysis::print_linear_correlations() const Tensor TestingAnalysis::perform_goodness_of_fit_analysis() const { - check(); // Data set @@ -171,33 +170,34 @@ void TestingAnalysis::print_goodness_of_fit_analysis() const } -Tensor TestingAnalysis::calculate_error_data() const -{ - const Index testing_samples_number = data_set->get_samples_number(DataSet::SampleUse::Testing); - +Tensor TestingAnalysis::calculate_error() const +{ const Tensor inputs = data_set->get_data(DataSet::SampleUse::Testing, DataSet::VariableUse::Input); const Tensor targets = data_set->get_data(DataSet::SampleUse::Testing, DataSet::VariableUse::Target); - // Neural network + const Tensor outputs = neural_network->calculate_outputs(inputs); - const Index outputs_number = neural_network->get_outputs_number(); + const Tensor error = (outputs - targets); + + return error; +} - const Tensor outputs = neural_network->calculate_outputs(inputs); +Tensor TestingAnalysis::calculate_error_data() const +{ + const Index testing_samples_number = data_set->get_samples_number(DataSet::SampleUse::Testing); - UnscalingLayer* unscaling_layer = static_cast(neural_network->get_first(Layer::Type::Unscaling)); + const Index outputs_number = neural_network->get_outputs_number(); - const Tensor& outputs_minimum = unscaling_layer->get_minimums(); + UnscalingLayer* unscaling_layer = static_cast(neural_network->get_first(Layer::Type::Unscaling)); - const Tensor& outputs_maximum = unscaling_layer->get_maximums(); + const Tensor& output_minimums = unscaling_layer->get_minimums(); - // Error data + const Tensor& output_maximums = unscaling_layer->get_maximums(); Tensor error_data(testing_samples_number, 3, outputs_number); - // Absolute error - - const Tensor difference_absolute_value = (outputs - targets).abs(); + const Tensor absolute_errors = calculate_error().abs(); #pragma omp parallel for @@ -205,9 +205,9 @@ Tensor TestingAnalysis::calculate_error_data() const { for(Index j = 0; j < testing_samples_number; j++) { - error_data(j, 0, i) = difference_absolute_value(j,i); - error_data(j, 1, i) = difference_absolute_value(j,i)/abs(outputs_maximum(i)-outputs_minimum(i)); - error_data(j, 2, i) = difference_absolute_value(j,i)*type(100.0)/abs(outputs_maximum(i)-outputs_minimum(i)); + error_data(j, 0, i) = absolute_errors(j,i); + error_data(j, 1, i) = absolute_errors(j,i)/abs(output_maximums(i)-output_minimums(i)); + error_data(j, 2, i) = absolute_errors(j,i)*type(100.0)/abs(output_maximums(i)-output_minimums(i)); } } @@ -217,26 +217,16 @@ Tensor TestingAnalysis::calculate_error_data() const Tensor TestingAnalysis::calculate_percentage_error_data() const { - // Data set - const Index testing_samples_number = data_set->get_samples_number(DataSet::SampleUse::Testing); - const Tensor inputs = data_set->get_data(DataSet::SampleUse::Testing, DataSet::VariableUse::Input); - - const Tensor targets = data_set->get_data(DataSet::SampleUse::Testing, DataSet::VariableUse::Target); - - // Neural network - const Index outputs_number = neural_network->get_outputs_number(); - const Tensor outputs = neural_network->calculate_outputs(inputs); - UnscalingLayer* unscaling_layer = static_cast(neural_network->get_first(Layer::Type::Unscaling)); - const Tensor& outputs_minimum = unscaling_layer->get_minimums(); - const Tensor& outputs_maximum = unscaling_layer->get_maximums(); + const Tensor& output_minimums = unscaling_layer->get_minimums(); + const Tensor& output_maximums = unscaling_layer->get_maximums(); - const Tensor difference_value = outputs - targets; + const Tensor errors = calculate_error(); // Error data @@ -246,7 +236,7 @@ Tensor TestingAnalysis::calculate_percentage_error_data() const for(Index i = 0; i < testing_samples_number; i++) for(Index j = 0; j < outputs_number; j++) - error_data(i, j) = difference_value(i, j)*type(100.0)/abs(outputs_maximum(j) - outputs_minimum(j)); + error_data(i, j) = errors(i, j)*type(100.0)/abs(output_maximums(j) - output_minimums(j)); return error_data; } @@ -265,7 +255,7 @@ vector TestingAnalysis::calculate_absolute_errors_descriptives() c vector TestingAnalysis::calculate_absolute_errors_descriptives(const Tensor& targets, - const Tensor& outputs) const + const Tensor& outputs) const { const Tensor difference = (targets-outputs).abs(); @@ -286,7 +276,7 @@ vector TestingAnalysis::calculate_percentage_errors_descriptives() vector TestingAnalysis::calculate_percentage_errors_descriptives(const Tensor& targets, - const Tensor& outputs) const + const Tensor& outputs) const { const Tensor difference = type(100)*(targets-outputs).abs()/targets; @@ -797,8 +787,8 @@ Tensor TestingAnalysis::calculate_confusion_binary_classification(cons for(Index i = 0; i < testing_samples_number; i++) { - target = targets(i,0); - output = outputs(i,0); + target = targets(i, 0); + output = outputs(i, 0); if(target >= decision_threshold && output >= decision_threshold) true_positive++; @@ -879,8 +869,6 @@ Tensor TestingAnalysis::calculate_confusion() const { check(); - //const Index outputs_number = neural_network->get_outputs_number(); - Tensor inputs = data_set->get_data(DataSet::SampleUse::Testing, DataSet::VariableUse::Input); const Tensor targets = data_set->get_data(DataSet::SampleUse::Testing, DataSet::VariableUse::Target); @@ -939,14 +927,14 @@ Tensor TestingAnalysis::calculate_sentimental_analysis_transformer_con testing_target.chip(i, 0) = targets.chip(i, 0); } - if(input_dimensions.size() == 1) { - Tensor outputs = transformer->calculate_outputs(testing_input, testing_context); - cout< outputs = transformer->calculate_outputs(testing_input, testing_context); + Tensor reduced_outputs(outputs.dimension(0), targets.dimension(1)); - for (Index i = 0; i < outputs.dimension(0); i++) { + for (Index i = 0; i < outputs.dimension(0); i++) + { reduced_outputs(i,0) = outputs(i,1,9); reduced_outputs(i,1) = outputs(i,1,10); } @@ -1151,8 +1139,8 @@ type TestingAnalysis::calculate_area_under_curve_confidence_limit(const Tensor& roc_cur for(Index i = 0; i < points_number; i++) { - //const type distance = sqrt(roc_curve(i,0)*roc_curve(i,0) + (roc_curve(i,1) - type(1))*(roc_curve(i,1) - type(1))); - const type distance = hypot(roc_curve(i, 0), roc_curve(i, 1) - type(1)); if(distance < minimun_distance) @@ -1466,10 +1452,9 @@ Tensor TestingAnalysis::calculate_calibration_plot(const Tensor TestingAnalysis::calculate_output_histogram(const Tensor& outputs, const Index& bins_number) const { - const Tensor output_column = outputs.chip(0,1); - Tensor output_histogram (1); + Tensor output_histogram(1); output_histogram(0) = histogram(output_column, bins_number); diff --git a/opennn/testing_analysis.h b/opennn/testing_analysis.h index 2a02c313f..3fb9ee0e4 100644 --- a/opennn/testing_analysis.h +++ b/opennn/testing_analysis.h @@ -92,6 +92,9 @@ class TestingAnalysis // Error data + Tensor calculate_error() const; + + Tensor calculate_error_data() const; Tensor calculate_percentage_error_data() const; From f3adf01329a87f281112a2cc3f2d210a0a6cead0 Mon Sep 17 00:00:00 2001 From: RoberLopez Date: Wed, 15 Jan 2025 16:30:45 +0100 Subject: [PATCH 04/10] clean --- opennn/correlations.cpp | 4 +- opennn/data_set.cpp | 27 +-------- opennn/data_set.h | 4 +- opennn/genetic_algorithm.cpp | 92 +++++++++++-------------------- opennn/genetic_algorithm.h | 10 +--- opennn/growing_inputs.cpp | 53 ++++++------------ opennn/growing_neurons.cpp | 47 +++++++--------- opennn/inputs_selection.h | 36 ++++++------ opennn/perceptron_layer_3d.cpp | 2 +- opennn/probabilistic_layer_3d.cpp | 2 +- tests/growing_neurons_test.cpp | 6 +- 11 files changed, 101 insertions(+), 182 deletions(-) diff --git a/opennn/correlations.cpp b/opennn/correlations.cpp index b52cd3002..36f067940 100644 --- a/opennn/correlations.cpp +++ b/opennn/correlations.cpp @@ -721,7 +721,7 @@ Correlation logistic_correlation_vector_matrix(const ThreadPoolDevice* thread_po DataSet data_set(x_filtered.size(), {1}, {y_filtered.dimension(1)}); - data_set.set_input_target_raw_variable_indices(input_columns_indices, target_columns_indices); + data_set.set_raw_variable_indices(input_columns_indices, target_columns_indices); data_set.set(DataSet::SampleUse::Training); @@ -841,7 +841,7 @@ Correlation logistic_correlation_matrix_matrix(const ThreadPoolDevice* thread_po data_set.set_data(data); - data_set.set_input_target_raw_variable_indices(input_columns_indices, target_columns_indices); + data_set.set_raw_variable_indices(input_columns_indices, target_columns_indices); data_set.set(DataSet::SampleUse::Training); diff --git a/opennn/data_set.cpp b/opennn/data_set.cpp index bd7c9390c..054c06eb1 100755 --- a/opennn/data_set.cpp +++ b/opennn/data_set.cpp @@ -971,27 +971,6 @@ Index DataSet::get_used_raw_variables_number() const } -Index DataSet::get_input_and_unused_variables_number() const -{ - Index raw_variables_number = 0; - - for(Index i = 0; i < raw_variables_number; i++) - { - const RawVariable& raw_variable = raw_variables[i]; - - if(raw_variable.use != VariableUse::Input && raw_variable.use != VariableUse::None) - continue; - - if(raw_variable.type == RawVariableType::Categorical) - raw_variables_number += raw_variable.categories.size(); - else - raw_variables_number++; - } - - return raw_variables_number; -} - - const vector& DataSet::get_raw_variables() const { return raw_variables; @@ -1113,8 +1092,8 @@ void DataSet::set_raw_variables(const VariableUse& variable_use) } -void DataSet::set_input_target_raw_variable_indices(const vector& input_raw_variables, - const vector& target_raw_variables) +void DataSet::set_raw_variable_indices(const vector& input_raw_variables, + const vector& target_raw_variables) { set_raw_variables(VariableUse::None); @@ -1126,7 +1105,7 @@ void DataSet::set_input_target_raw_variable_indices(const vector& input_r } -// void DataSet::set_input_target_raw_variable_indices(const vector& input_raw_variables, +// void DataSet::set_raw_variable_indices(const vector& input_raw_variables, // const vector& target_raw_variables) // { // set_raw_variables(VariableUse::None); diff --git a/opennn/data_set.h b/opennn/data_set.h index 7cf5d3f09..e295bd8e5 100755 --- a/opennn/data_set.h +++ b/opennn/data_set.h @@ -136,7 +136,6 @@ class DataSet inline Index get_raw_variables_number() const { return raw_variables.size(); } Index get_raw_variables_number(const VariableUse&) const; Index get_used_raw_variables_number() const; - Index get_input_and_unused_variables_number() const; const vector& get_raw_variables() const; vector get_raw_variables(const VariableUse&) const; @@ -266,8 +265,7 @@ class DataSet virtual void set_raw_variable_uses(const vector&); void set_raw_variables(const VariableUse&); - void set_input_target_raw_variable_indices(const vector&, const vector&); - //void set_input_target_raw_variable_indices(const vector&, const vector&); + void set_raw_variable_indices(const vector&, const vector&); void set_input_raw_variables_unused(); //void set_input_raw_variables(const Tensor&, const Tensor&); diff --git a/opennn/genetic_algorithm.cpp b/opennn/genetic_algorithm.cpp index 698f84090..edfb8f4bf 100644 --- a/opennn/genetic_algorithm.cpp +++ b/opennn/genetic_algorithm.cpp @@ -82,18 +82,12 @@ const GeneticAlgorithm::InitializationMethod& GeneticAlgorithm::get_initializati } -const vector& GeneticAlgorithm::get_original_unused_raw_variables() -{ - return original_unused_raw_variable_indices; -} - - void GeneticAlgorithm::set_default() { if (!training_strategy || !training_strategy->has_neural_network()) return; - const Index genes_number = training_strategy->get_data_set()->get_input_and_unused_variables_number(); + const Index genes_number = training_strategy->get_data_set()->get_variables_number(DataSet::VariableUse::Input); const Index individuals_number = 40; @@ -205,7 +199,7 @@ void GeneticAlgorithm::initialize_population_random() { DataSet* data_set = training_strategy->get_data_set(); - const Index genes_number = data_set->get_input_and_unused_variables_number(); + const Index genes_number = data_set->get_variables_number(DataSet::VariableUse::Input); const Index individuals_number = get_individuals_number(); @@ -213,10 +207,8 @@ void GeneticAlgorithm::initialize_population_random() original_input_raw_variable_indices = data_set->get_raw_variable_indices(DataSet::VariableUse::Input); original_target_raw_variable_indices = data_set->get_raw_variable_indices(DataSet::VariableUse::Target); - original_unused_raw_variable_indices = data_set->get_raw_variable_indices(DataSet::VariableUse::None); - const Index raw_variables_number = original_input_raw_variable_indices.size() - + original_unused_raw_variable_indices.size(); + const Index original_input_raw_variables_number = original_input_raw_variable_indices.size(); const Index random_raw_variables_number = data_set->get_raw_variables_number(DataSet::VariableUse::Input); @@ -226,14 +218,14 @@ void GeneticAlgorithm::initialize_population_random() (random_raw_variables_number > 500) ? type(0.6) : type(1); - original_input_raw_variables.resize(raw_variables_number, false); + original_input_raw_variables.resize(original_input_raw_variables_number, false); for(size_t i = 0; i < original_input_raw_variable_indices.size(); i++) original_input_raw_variables[original_input_raw_variable_indices[i]] = true; population.setConstant(false); - Tensor individual_raw_variables(raw_variables_number); + Tensor individual_raw_variables(original_input_raw_variables_number); individual_raw_variables.setConstant(false); Tensor individual_variables(genes_number); @@ -265,7 +257,7 @@ void GeneticAlgorithm::initialize_population_random() { Tensor individual_raw_variables_false = get_individual_raw_genes(individual_variables); - for(Index j = 0; j < raw_variables_number; j++) + for(Index j = 0; j < original_input_raw_variables_number; j++) if(original_input_raw_variables[j]) individual_raw_variables_false(j) = true; @@ -386,10 +378,6 @@ void GeneticAlgorithm::evaluate_population() NeuralNetwork* neural_network = loss_index->get_neural_network(); - // Optimization algorithm - - Tensor individual; - // Model selection const Index individuals_number = get_individuals_number(); @@ -400,25 +388,24 @@ void GeneticAlgorithm::evaluate_population() Tensor inputs_number(individuals_number); - vector input_names; - for(Index i = 0; i < individuals_number; i++) { - individual = population.chip(i, 0); + const Tensor individual = population.chip(i, 0); cout << "\nIndividual " << i + 1 << endl; - individual_raw_variables_indices = get_raw_variable_indices(individual); + const vector individual_raw_variables_indices = get_raw_variable_indices(individual); inputs_number(i) = individual_raw_variables_indices.size(); // Neural network - data_set->set_input_target_raw_variable_indices(individual_raw_variables_indices, original_target_raw_variable_indices); + data_set->set_raw_variable_indices(individual_raw_variables_indices, + original_target_raw_variable_indices); data_set->scrub_missing_values(); - input_names = data_set->get_variable_names(DataSet::VariableUse::Input); + const vector input_names = data_set->get_variable_names(DataSet::VariableUse::Input); neural_network->set_input_dimensions({ data_set->get_variables_number(DataSet::VariableUse::Input) }); @@ -432,9 +419,9 @@ void GeneticAlgorithm::evaluate_population() parameters(i) = neural_network->get_parameters(); - training_errors(i) = type(training_results.get_training_error()); + training_errors(i) = training_results.get_training_error(); - selection_errors(i) = type(training_results.get_selection_error()); + selection_errors(i) = training_results.get_selection_error(); if(display) cout << "Training error: " << training_results.get_training_error() << endl @@ -442,7 +429,7 @@ void GeneticAlgorithm::evaluate_population() << "Variables number: " << input_names.size() << endl << "Inputs number: " << data_set->get_raw_variables_number(DataSet::VariableUse::Input) << endl; - data_set->set_input_target_raw_variable_indices(original_input_raw_variable_indices, original_target_raw_variable_indices); + data_set->set_raw_variable_indices(original_input_raw_variable_indices, original_target_raw_variable_indices); } // Mean generational selection and training error calculation (primitive way) @@ -478,14 +465,12 @@ Tensor GeneticAlgorithm::calculate_selection_probabilities() { const Index individuals_number = get_individuals_number(); - const Index sum_from_1_to_n = individuals_number * (individuals_number + 1) / 2; + const Index sum_1_n = individuals_number * (individuals_number + 1) / 2; Tensor probabilities(individuals_number); for(Index i = 0; i < individuals_number; i++) - probabilities(i) = (type(individuals_number) - type(fitness(i) - 1)) / sum_from_1_to_n; - -// const Tensor selection_probabilities = probabilities.cumsum(0); + probabilities(i) = (type(individuals_number) - type(fitness(i) - 1)) / sum_1_n; return probabilities; } @@ -528,13 +513,11 @@ vector GeneticAlgorithm::get_selected_individuals_indices() void GeneticAlgorithm::perform_crossover() { - //DataSet* data_set = training_strategy->get_data_set(); - const Index individuals_number = get_individuals_number(); const Index genes_number = get_genes_number(); - const Index raw_variables_number = original_input_raw_variable_indices.size() + original_unused_raw_variable_indices.size(); + const Index raw_variables_number = original_input_raw_variable_indices.size(); // Couples generation @@ -544,9 +527,9 @@ void GeneticAlgorithm::perform_crossover() Tensor parent_2_genes; - Tensor descendent_variables; + Tensor descendent_variables; - Tensor descendent_genes(genes_number); + Tensor descendent_genes(genes_number); Tensor descendent_raw_variables(raw_variables_number); @@ -616,26 +599,20 @@ void GeneticAlgorithm::perform_mutation() { const Index individuals_number = get_individuals_number(); - const Index raw_variables_number = original_input_raw_variable_indices.size() + original_unused_raw_variable_indices.size(); + const Index raw_variables_number = original_input_raw_variable_indices.size(); const Index genes_number = get_genes_number(); - Tensor individual_variables(genes_number); - - Tensor new_individual_variables(genes_number); - - Tensor individual_raw_variables(raw_variables_number); - for(Index i = 0; i < individuals_number; i++) { - individual_variables = population.chip(i, 0); + const Tensor individual_variables = population.chip(i, 0); - individual_raw_variables = get_individual_raw_genes(individual_variables); + Tensor individual_raw_variables = get_individual_raw_genes(individual_variables); for(Index j = 0; j < raw_variables_number; j++) - individual_raw_variables(j) ^= (type(rand())/type(RAND_MAX) < mutation_rate); + individual_raw_variables(j) ^= (get_random_type(0, 1) < mutation_rate); - new_individual_variables = get_individual_genes(individual_raw_variables); + Tensor new_individual_variables = get_individual_genes(individual_raw_variables); if(is_equal(new_individual_variables, false)) { @@ -678,7 +655,7 @@ InputsSelectionResults GeneticAlgorithm::perform_inputs_selection() DataSet* data_set = loss_index->get_data_set(); - // Neural network0 + // Neural network NeuralNetwork* neural_network = loss_index->get_neural_network(); @@ -700,10 +677,6 @@ InputsSelectionResults GeneticAlgorithm::perform_inputs_selection() time(&beginning_time); - input_selection_results.optimum_selection_error = numeric_limits::max(); - - training_strategy->get_optimization_algorithm()->set_display(false); - Index generation_selected = 0; for(Index epoch = 0; epoch < maximum_epochs_number; epoch++) @@ -736,7 +709,7 @@ InputsSelectionResults GeneticAlgorithm::perform_inputs_selection() { generation_selected = epoch; - data_set->set_input_target_raw_variable_indices(original_input_raw_variable_indices, original_target_raw_variable_indices); + data_set->set_raw_variable_indices(original_input_raw_variable_indices, original_target_raw_variable_indices); // Neural network @@ -744,7 +717,7 @@ InputsSelectionResults GeneticAlgorithm::perform_inputs_selection() optimal_inputs_raw_variables_indices = get_raw_variable_indices(input_selection_results.optimal_inputs); - data_set->set_input_target_raw_variable_indices(optimal_inputs_raw_variables_indices, original_target_raw_variable_indices); + data_set->set_raw_variable_indices(optimal_inputs_raw_variables_indices, original_target_raw_variable_indices); input_selection_results.optimal_input_raw_variables_names = data_set->get_raw_variable_names(DataSet::VariableUse::Input); @@ -759,10 +732,10 @@ InputsSelectionResults GeneticAlgorithm::perform_inputs_selection() } else { - data_set->set_input_target_raw_variable_indices(original_input_raw_variable_indices,original_target_raw_variable_indices); + data_set->set_raw_variable_indices(original_input_raw_variable_indices,original_target_raw_variable_indices); } - data_set->set_input_target_raw_variable_indices(original_input_raw_variable_indices, original_target_raw_variable_indices); + data_set->set_raw_variable_indices(original_input_raw_variable_indices, original_target_raw_variable_indices); time(¤t_time); @@ -821,7 +794,7 @@ InputsSelectionResults GeneticAlgorithm::perform_inputs_selection() const vector optimal_raw_variable_indices = get_raw_variable_indices(input_selection_results.optimal_inputs); - data_set->set_input_target_raw_variable_indices(optimal_raw_variable_indices, original_target_raw_variable_indices); + data_set->set_raw_variable_indices(optimal_raw_variable_indices, original_target_raw_variable_indices); const vector input_variable_scalers = data_set->get_variable_scalers(DataSet::VariableUse::Input); @@ -852,8 +825,7 @@ Tensor GeneticAlgorithm::get_individual_raw_genes(const Tensor& { DataSet* data_set = training_strategy->get_data_set(); - const Index raw_variables_number = original_input_raw_variable_indices.size() - + original_unused_raw_variable_indices.size(); + const Index raw_variables_number = original_input_raw_variable_indices.size(); Tensor raw_variables_from_variables(raw_variables_number); raw_variables_from_variables.setConstant(false); @@ -927,7 +899,7 @@ Tensor GeneticAlgorithm::get_individual_genes(const Tensor& in { DataSet* data_set = training_strategy->get_data_set(); - const Index genes_number = data_set->get_input_and_unused_variables_number(); + const Index genes_number = data_set->get_variables_number(DataSet::VariableUse::Input); const Index raw_variables_number = individual_raw_variables.size(); Tensor individual_raw_variables_to_variables(genes_number); diff --git a/opennn/genetic_algorithm.h b/opennn/genetic_algorithm.h index 00aa21c0a..0b67ea677 100644 --- a/opennn/genetic_algorithm.h +++ b/opennn/genetic_algorithm.h @@ -89,8 +89,6 @@ class GeneticAlgorithm : public InputsSelection vector get_raw_variable_indices(const Tensor&); - const vector& get_original_unused_raw_variables(); - InputsSelectionResults perform_inputs_selection() override; Tensor to_string_matrix() const; @@ -111,7 +109,9 @@ class GeneticAlgorithm : public InputsSelection vector original_input_raw_variables; - vector original_unused_raw_variable_indices; + vector original_input_raw_variable_indices; + vector original_target_raw_variable_indices; + vector original_unused_raw_variables; Tensor inputs_activation_probabilities; @@ -134,10 +134,6 @@ class GeneticAlgorithm : public InputsSelection Tensor optimal_individuals_history; - vector original_input_raw_variable_indices; - - vector original_target_raw_variable_indices; - Index genes_number; type mutation_rate; diff --git a/opennn/growing_inputs.cpp b/opennn/growing_inputs.cpp index 325fd42ac..6da0ce02d 100644 --- a/opennn/growing_inputs.cpp +++ b/opennn/growing_inputs.cpp @@ -41,31 +41,16 @@ const Index& GrowingInputs::get_maximum_selection_failures() const void GrowingInputs::set_default() { maximum_selection_failures = 100; - - if(!training_strategy || !training_strategy->has_neural_network()) - { - maximum_inputs_number = 100; - } - else - { - training_strategy->get_neural_network()->get_display(); - - const Index inputs_number = training_strategy->get_data_set()->get_raw_variables_number(DataSet::VariableUse::Input); - - maximum_selection_failures = 100; - - maximum_inputs_number = inputs_number; - } - minimum_inputs_number = 1; - minimum_correlation = type(0); - trials_number = 3; - maximum_epochs_number = 1000; - maximum_time = type(3600.0); + + if (training_strategy && training_strategy->has_neural_network()) + maximum_inputs_number = training_strategy->get_data_set()->get_raw_variables_number(DataSet::VariableUse::Input); + else + maximum_inputs_number = 100; } @@ -73,7 +58,7 @@ void GrowingInputs::set_maximum_inputs_number(const Index& new_maximum_inputs_nu { const Index inputs_number = training_strategy->get_data_set()->get_raw_variables_number(DataSet::VariableUse::Input); - maximum_inputs_number = min(new_maximum_inputs_number,inputs_number); + maximum_inputs_number = min(new_maximum_inputs_number, inputs_number); } @@ -112,7 +97,7 @@ InputsSelectionResults GrowingInputs::perform_inputs_selection() const vector raw_variable_names = data_set->get_raw_variable_names(); - vector input_raw_variables_names; + vector input_raw_variable_names; const Tensor correlations = get_correlation_values(data_set->calculate_input_target_raw_variable_pearson_correlations()); @@ -159,21 +144,16 @@ InputsSelectionResults GrowingInputs::perform_inputs_selection() bool stop = false; for(Index i = 0; i < maximum_epochs_number; i++) - { - + { data_set->set_raw_variable_use(correlations_rank_descending[raw_variable_index], DataSet::VariableUse::Input); Index input_raw_variables_number = data_set->get_raw_variables_number(DataSet::VariableUse::Input); - Index input_variables_number = data_set->get_variables_number(DataSet::VariableUse::Input); + const Index input_variables_number = data_set->get_variables_number(DataSet::VariableUse::Input); if (input_raw_variables_number < minimum_inputs_number) - { - // @todo - continue; - } - Index epoch = input_raw_variables_number - minimum_inputs_number + 1; + const Index epoch = input_raw_variables_number - minimum_inputs_number + 1; neural_network->set_input_dimensions({ input_variables_number }); if(display) @@ -183,9 +163,9 @@ InputsSelectionResults GrowingInputs::perform_inputs_selection() << "Input raw_variables number: " << input_raw_variables_number << endl << "Inputs: " << endl; - input_raw_variables_names = data_set->get_raw_variable_names(DataSet::VariableUse::Input); + input_raw_variable_names = data_set->get_raw_variable_names(DataSet::VariableUse::Input); - print_vector(input_raw_variables_names); + print_vector(input_raw_variable_names); } type minimum_training_error = numeric_limits::max(); @@ -226,8 +206,8 @@ InputsSelectionResults GrowingInputs::perform_inputs_selection() if(display) cout << "Trial number: " << j+1 << endl - << " Training error: " << training_results.get_training_error() << endl - << " Selection error: " << training_results.get_selection_error() << endl; + << " Training error: " << training_results.get_training_error() << endl + << " Selection error: " << training_results.get_selection_error() << endl; } if(previus_training_error < minimum_training_error) @@ -301,14 +281,13 @@ InputsSelectionResults GrowingInputs::perform_inputs_selection() break; } - raw_variable_index++; } // Set data set stuff - data_set->set_input_target_raw_variable_indices(input_selection_results.optimal_input_raw_variables_indices, - target_raw_variable_indices); + data_set->set_raw_variable_indices(input_selection_results.optimal_input_raw_variables_indices, + target_raw_variable_indices); data_set->print(); diff --git a/opennn/growing_neurons.cpp b/opennn/growing_neurons.cpp index d2c9ae193..3f53767e6 100644 --- a/opennn/growing_neurons.cpp +++ b/opennn/growing_neurons.cpp @@ -33,15 +33,10 @@ const Index& GrowingNeurons::get_maximum_selection_failures() const void GrowingNeurons::set_default() { minimum_neurons = 1; - maximum_neurons = 10; - trials_number = 3; - neurons_increment = 1; - maximum_selection_failures = 100; - maximum_time = type(3600); } @@ -60,7 +55,7 @@ void GrowingNeurons::set_maximum_selection_failures(const Index& new_maximum_sel NeuronsSelectionResults GrowingNeurons::perform_neurons_selection() { - NeuronsSelectionResults neurons_selection_results(maximum_epochs_number); + NeuronsSelectionResults neuron_selection_results(maximum_epochs_number); if(display) cout << "Performing growing neurons selection..." << endl; @@ -106,7 +101,7 @@ NeuronsSelectionResults GrowingNeurons::perform_neurons_selection() neural_network->get_layer(last_trainable_layer_index - 1).get()->set_output_dimensions({ neurons_number }); neural_network->get_layer(last_trainable_layer_index).get()->set_input_dimensions({ neurons_number }); - neurons_selection_results.neurons_number_history(epoch) = neurons_number; + neuron_selection_results.neurons_number_history(epoch) = neurons_number; // Loss index @@ -129,16 +124,16 @@ NeuronsSelectionResults GrowingNeurons::perform_neurons_selection() minimum_training_error = training_results.get_training_error(); minimum_selection_error = training_results.get_selection_error(); - neurons_selection_results.training_error_history(epoch) = minimum_training_error; - neurons_selection_results.selection_error_history(epoch) = minimum_selection_error; + neuron_selection_results.training_error_history(epoch) = minimum_training_error; + neuron_selection_results.selection_error_history(epoch) = minimum_selection_error; } - if(minimum_selection_error < neurons_selection_results.optimum_selection_error) + if(minimum_selection_error < neuron_selection_results.optimum_selection_error) { - neurons_selection_results.optimal_neurons_number = neurons_number; - neurons_selection_results.optimal_parameters = neural_network->get_parameters(); - neurons_selection_results.optimum_training_error = minimum_training_error; - neurons_selection_results.optimum_selection_error = minimum_selection_error; + neuron_selection_results.optimal_neurons_number = neurons_number; + neuron_selection_results.optimal_parameters = neural_network->get_parameters(); + neuron_selection_results.optimum_training_error = minimum_training_error; + neuron_selection_results.optimum_selection_error = minimum_selection_error; } } @@ -148,10 +143,10 @@ NeuronsSelectionResults GrowingNeurons::perform_neurons_selection() << "Selection error: " << training_results.get_selection_error() << endl << "Elapsed time: " << write_time(elapsed_time) << endl; - if(neurons_selection_results.optimum_selection_error > previous_selection_error) + if(neuron_selection_results.optimum_selection_error > previous_selection_error) selection_failures++; - previous_selection_error = neurons_selection_results.optimum_selection_error; + previous_selection_error = neuron_selection_results.optimum_selection_error; time(¤t_time); @@ -164,27 +159,27 @@ NeuronsSelectionResults GrowingNeurons::perform_neurons_selection() if(elapsed_time >= maximum_time) { if (display) cout << "Epoch " << epoch << "\nMaximum time reached: " << write_time(elapsed_time) << endl; - neurons_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::MaximumTime; + neuron_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::MaximumTime; } else if(training_results.get_selection_error() <= selection_error_goal) { if(display) cout << "Epoch " << epoch << "\nSelection error goal reached: " << training_results.get_selection_error() << endl; - neurons_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::SelectionErrorGoal; + neuron_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::SelectionErrorGoal; } else if(epoch >= maximum_epochs_number) { if(display) cout << "Epoch " << epoch << "\nMaximum epochs number reached: " << epoch << endl; - neurons_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::MaximumEpochs; + neuron_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::MaximumEpochs; } else if(selection_failures >= maximum_selection_failures) { if(display) cout << "Epoch " << epoch << "\nMaximum selection failures reached: " << selection_failures << endl; - neurons_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::MaximumSelectionFailures; + neuron_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::MaximumSelectionFailures; } else if(neurons_number >= maximum_neurons) { if(display) cout << "Epoch " << epoch << "\nMaximum number of neurons reached: " << neurons_number << endl; - neurons_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::MaximumNeurons; + neuron_selection_results.stopping_condition = GrowingNeurons::StoppingCondition::MaximumNeurons; } else { @@ -193,9 +188,9 @@ NeuronsSelectionResults GrowingNeurons::perform_neurons_selection() if(end) { - neurons_selection_results.resize_history(epoch+1); + neuron_selection_results.resize_history(epoch+1); - neurons_selection_results.elapsed_time = write_time(elapsed_time); + neuron_selection_results.elapsed_time = write_time(elapsed_time); break; } @@ -205,11 +200,11 @@ NeuronsSelectionResults GrowingNeurons::perform_neurons_selection() neural_network->get_layer(last_trainable_layer_index - 1).get()->set_output_dimensions({ neurons_number }); neural_network->get_layer(last_trainable_layer_index).get()->set_input_dimensions({ neurons_number }); - neural_network->set_parameters(neurons_selection_results.optimal_parameters); + neural_network->set_parameters(neuron_selection_results.optimal_parameters); - if(display) neurons_selection_results.print(); + if(display) neuron_selection_results.print(); - return neurons_selection_results; + return neuron_selection_results; } diff --git a/opennn/inputs_selection.h b/opennn/inputs_selection.h index 90a49bfe4..a969e8bdd 100644 --- a/opennn/inputs_selection.h +++ b/opennn/inputs_selection.h @@ -104,45 +104,45 @@ struct InputsSelectionResults void set(const Index& = 0); - string write_stopping_condition() const; + string write_stopping_condition() const; - void resize_history(const Index& new_size); + void resize_history(const Index& new_size); - void print() const; + void print() const; - // Neural network + // Neural network - Tensor optimal_parameters; + Tensor optimal_parameters; - // Loss index + // Loss index - Tensor training_error_history; + Tensor training_error_history; - Tensor selection_error_history; + Tensor selection_error_history; // Mean Selection Error of different neural networks - Tensor mean_selection_error_history; + Tensor mean_selection_error_history; // Mean Training Error of different neural networks - Tensor mean_training_error_history; + Tensor mean_training_error_history; - type optimum_training_error = numeric_limits::max(); + type optimum_training_error = numeric_limits::max(); - type optimum_selection_error = numeric_limits::max(); + type optimum_selection_error = numeric_limits::max(); - vector optimal_input_raw_variables_names; + vector optimal_input_raw_variables_names; - vector optimal_input_raw_variables_indices; + vector optimal_input_raw_variables_indices; - Tensor optimal_inputs; + Tensor optimal_inputs; - // Model selection + // Model selection - InputsSelection::StoppingCondition stopping_condition = InputsSelection::StoppingCondition::MaximumTime; + InputsSelection::StoppingCondition stopping_condition = InputsSelection::StoppingCondition::MaximumTime; - string elapsed_time; + string elapsed_time; }; } diff --git a/opennn/perceptron_layer_3d.cpp b/opennn/perceptron_layer_3d.cpp index 64b503ae4..343dd9a89 100644 --- a/opennn/perceptron_layer_3d.cpp +++ b/opennn/perceptron_layer_3d.cpp @@ -225,7 +225,7 @@ void PerceptronLayer3D::set_parameters_glorot() #pragma omp parallel for for(Index i = 0; i < synaptic_weights.size(); i++) - synaptic_weights(i) = minimum + (maximum - minimum)*type(rand() / (RAND_MAX + 1.0)); + synaptic_weights(i) = get_random_type(minimum, maximum); } diff --git a/opennn/probabilistic_layer_3d.cpp b/opennn/probabilistic_layer_3d.cpp index 18a8a019d..ad06e3b8f 100644 --- a/opennn/probabilistic_layer_3d.cpp +++ b/opennn/probabilistic_layer_3d.cpp @@ -222,7 +222,7 @@ void ProbabilisticLayer3D::set_parameters_glorot() #pragma omp parallel for for(Index i = 0; i < synaptic_weights.size(); i++) - synaptic_weights(i) = minimum + (maximum - minimum) * type(rand() / (RAND_MAX + 1.0)); + synaptic_weights(i) = get_random_type(minimum, maximum); } diff --git a/tests/growing_neurons_test.cpp b/tests/growing_neurons_test.cpp index dc6487ca3..66c6ccf30 100644 --- a/tests/growing_neurons_test.cpp +++ b/tests/growing_neurons_test.cpp @@ -63,7 +63,7 @@ TEST(GrowingNeuronsTest, NeuronsSelection) TrainingStrategy training_strategy; GrowingNeurons growing_neurons(&training_strategy); - NeuronsSelectionResults neurons_selection_results; + NeuronsSelectionResults neuron_selection_results; training_strategy.set_loss_method(TrainingStrategy::LossMethod::MEAN_SQUARED_ERROR); training_strategy.set_optimization_method(TrainingStrategy::OptimizationMethod::QUASI_NEWTON_METHOD); @@ -136,9 +136,9 @@ void GrowingNeuronsTest::test_perform_neurons_selection() //EXPECT_EQ(neural_network.get_layers_neurons_numbers()[0] == inputs_number); - neurons_selection_results = growing_neurons.perform_neurons_selection(); + neuron_selection_results = growing_neurons.perform_neurons_selection(); - EXPECT_EQ(neurons_selection_results.stopping_condition == NeuronsSelection::StoppingCondition::MaximumNeurons); + EXPECT_EQ(neuron_selection_results.stopping_condition == NeuronsSelection::StoppingCondition::MaximumNeurons); } From 113c1907806d1cd3924efc4434e2193ebef99a80 Mon Sep 17 00:00:00 2001 From: RoberLopez Date: Wed, 15 Jan 2025 16:56:35 +0100 Subject: [PATCH 05/10] clean --- opennn/genetic_algorithm.cpp | 37 ++++++++------------------------ opennn/genetic_algorithm.h | 2 -- opennn/growing_neurons.cpp | 4 ++-- opennn/neurons_selection.cpp | 39 ++++++++++++---------------------- opennn/neurons_selection.h | 2 +- opennn/perceptron_layer_3d.cpp | 1 + 6 files changed, 26 insertions(+), 59 deletions(-) diff --git a/opennn/genetic_algorithm.cpp b/opennn/genetic_algorithm.cpp index edfb8f4bf..2b3a1f796 100644 --- a/opennn/genetic_algorithm.cpp +++ b/opennn/genetic_algorithm.cpp @@ -87,7 +87,7 @@ void GeneticAlgorithm::set_default() if (!training_strategy || !training_strategy->has_neural_network()) return; - const Index genes_number = training_strategy->get_data_set()->get_variables_number(DataSet::VariableUse::Input); + const Index genes_number = get_genes_number(); const Index individuals_number = 40; @@ -129,7 +129,7 @@ void GeneticAlgorithm::set_population(const Tensor& new_population) void GeneticAlgorithm::set_genes_number(const Index& new_genes_number) { - genes_number = new_genes_number; + // @todo } @@ -141,28 +141,17 @@ void GeneticAlgorithm::set_maximum_epochs_number(const Index& new_maximum_epochs void GeneticAlgorithm::set_individuals_number(const Index& new_individuals_number) { - if(!training_strategy) - throw runtime_error("Training strategy is null"); - - const DataSet* data_set = training_strategy->get_data_set(); + if (!training_strategy || !training_strategy->get_data_set()) + throw runtime_error("Training strategy or data set is null"); - if (!data_set) - throw runtime_error("Data set is null"); - - const Index new_genes_number = data_set->get_variables_number(DataSet::VariableUse::Input); + const Index new_genes_number = training_strategy->get_data_set()->get_variables_number(DataSet::VariableUse::Input); population.resize(new_individuals_number, new_genes_number); - parameters.resize(new_individuals_number); - training_errors.resize(new_individuals_number); - selection_errors.resize(new_individuals_number); - fitness.resize(new_individuals_number); - fitness.setConstant(type(-1.0)); - selection.resize(new_individuals_number); elitism_size = min(elitism_size, new_individuals_number); @@ -199,15 +188,9 @@ void GeneticAlgorithm::initialize_population_random() { DataSet* data_set = training_strategy->get_data_set(); - const Index genes_number = data_set->get_variables_number(DataSet::VariableUse::Input); - + const Index genes_number = get_genes_number(); const Index individuals_number = get_individuals_number(); - population.resize(individuals_number, genes_number); - - original_input_raw_variable_indices = data_set->get_raw_variable_indices(DataSet::VariableUse::Input); - original_target_raw_variable_indices = data_set->get_raw_variable_indices(DataSet::VariableUse::Target); - const Index original_input_raw_variables_number = original_input_raw_variable_indices.size(); const Index random_raw_variables_number = data_set->get_raw_variables_number(DataSet::VariableUse::Input); @@ -432,8 +415,6 @@ void GeneticAlgorithm::evaluate_population() data_set->set_raw_variable_indices(original_input_raw_variable_indices, original_target_raw_variable_indices); } - // Mean generational selection and training error calculation (primitive way) - const Tensor sum_training_errors = training_errors.sum(); const Tensor sum_selection_errors = selection_errors.sum(); @@ -501,11 +482,11 @@ vector GeneticAlgorithm::get_selected_individuals_indices() { vector selection_indices(count(selection.data(), selection.data() + selection.size(), 1)); - Index activated_index_count = 0; + Index count = 0; for(Index i = 0; i < selection.size(); i++) if(selection(i)) - selection_indices[activated_index_count++] = i; + selection_indices[count++] = i; return selection_indices; } @@ -899,7 +880,7 @@ Tensor GeneticAlgorithm::get_individual_genes(const Tensor& in { DataSet* data_set = training_strategy->get_data_set(); - const Index genes_number = data_set->get_variables_number(DataSet::VariableUse::Input); + const Index genes_number = get_genes_number(); const Index raw_variables_number = individual_raw_variables.size(); Tensor individual_raw_variables_to_variables(genes_number); diff --git a/opennn/genetic_algorithm.h b/opennn/genetic_algorithm.h index 0b67ea677..eb003ab85 100644 --- a/opennn/genetic_algorithm.h +++ b/opennn/genetic_algorithm.h @@ -134,8 +134,6 @@ class GeneticAlgorithm : public InputsSelection Tensor optimal_individuals_history; - Index genes_number; - type mutation_rate; Index elitism_size; diff --git a/opennn/growing_neurons.cpp b/opennn/growing_neurons.cpp index 3f53767e6..52f0f75bb 100644 --- a/opennn/growing_neurons.cpp +++ b/opennn/growing_neurons.cpp @@ -249,8 +249,8 @@ void GrowingNeurons::from_XML(const XMLDocument& document) if(!root_element) throw runtime_error("GrowingNeurons element is nullptr.\n"); - minimum_neurons = read_xml_index(root_element, "MinimumNeurons"); - maximum_neurons = read_xml_index(root_element, "MaximumNeurons"); + set_minimum_neurons(read_xml_index(root_element, "MinimumNeurons")); + set_maximum_neurons(read_xml_index(root_element, "MaximumNeurons")); set_neurons_increment(read_xml_index(root_element, "NeuronsIncrement")); set_trials_number(read_xml_index(root_element, "TrialsNumber")); set_selection_error_goal(read_xml_type(root_element, "SelectionErrorGoal")); diff --git a/opennn/neurons_selection.cpp b/opennn/neurons_selection.cpp index 857519424..fb5d017b7 100644 --- a/opennn/neurons_selection.cpp +++ b/opennn/neurons_selection.cpp @@ -87,36 +87,24 @@ void NeuronsSelection::set_training_strategy(TrainingStrategy* new_training_stra void NeuronsSelection::set_default() { - if(!training_strategy) - return; - - NeuralNetwork* neural_network = training_strategy->get_neural_network(); - - if(!neural_network) + if (!(training_strategy && training_strategy->get_neural_network())) return; - const Index inputs_number = neural_network->get_inputs_number(); - const Index outputs_number = neural_network->get_outputs_number(); + const Index inputs_number = training_strategy->get_neural_network()->get_inputs_number(); + const Index outputs_number = training_strategy->get_neural_network()->get_outputs_number(); minimum_neurons = 1; - - // Heuristic value for the maximum_neurons - - maximum_neurons = 2*(inputs_number + outputs_number); + maximum_neurons = 2 * (inputs_number + outputs_number); trials_number = 1; - display = true; - // Stopping criteria - selection_error_goal = type(0); - maximum_epochs_number = 1000; maximum_time = type(3600); } -void NeuronsSelection::set_maximum_neurons_number(const Index& new_maximum_neurons) +void NeuronsSelection::set_maximum_neurons(const Index& new_maximum_neurons) { maximum_neurons = new_maximum_neurons; } @@ -216,18 +204,17 @@ void NeuronsSelection::check() const string NeuronsSelection::write_time(const type& time) const { - const int hours = int(time) / 3600; - int seconds = int(time) % 3600; - const int minutes = seconds / 60; - seconds = seconds % 60; + const int total_seconds = static_cast(time); + const int hours = total_seconds / 3600; + const int minutes = (total_seconds % 3600) / 60; + const int seconds = total_seconds % 60; ostringstream elapsed_time; + elapsed_time << setfill('0') << setw(2) + << hours << ":" + << minutes << ":" + << seconds << endl; - elapsed_time << setfill('0') << setw(2) - << hours << ":" - << minutes << ":" - << seconds << endl; - return elapsed_time.str(); } diff --git a/opennn/neurons_selection.h b/opennn/neurons_selection.h index a34d9062c..e9551efd6 100644 --- a/opennn/neurons_selection.h +++ b/opennn/neurons_selection.h @@ -44,7 +44,7 @@ class NeuronsSelection void set_default(); - void set_maximum_neurons_number(const Index&); + void set_maximum_neurons(const Index&); void set_minimum_neurons(const Index&); void set_trials_number(const Index&); diff --git a/opennn/perceptron_layer_3d.cpp b/opennn/perceptron_layer_3d.cpp index 343dd9a89..99ae3ba07 100644 --- a/opennn/perceptron_layer_3d.cpp +++ b/opennn/perceptron_layer_3d.cpp @@ -28,6 +28,7 @@ Index PerceptronLayer3D::get_inputs_number_xxx() const return inputs_number_xxx; } + Index PerceptronLayer3D::get_inputs_depth() const { return synaptic_weights.dimension(0); From 8839ba67c660e3e71563e3334f24ac8dd73d7e9a Mon Sep 17 00:00:00 2001 From: RoberLopez Date: Wed, 15 Jan 2025 17:30:36 +0100 Subject: [PATCH 06/10] clean --- tests/genetic_algorithm_test.cpp | 17 ++-- tests/growing_neurons_test.cpp | 2 +- tests/transformer_test.cpp | 130 +++++++++++++++---------------- 3 files changed, 72 insertions(+), 77 deletions(-) diff --git a/tests/genetic_algorithm_test.cpp b/tests/genetic_algorithm_test.cpp index a11965ecc..2dd769599 100644 --- a/tests/genetic_algorithm_test.cpp +++ b/tests/genetic_algorithm_test.cpp @@ -117,7 +117,7 @@ void GeneticAlgorithmTest::test_initialize_population() TEST(GeneticAlgorithmTest, FitnessAssignment) { -/* + DataSet data_set; Tensor selection_errors; @@ -156,7 +156,7 @@ TEST(GeneticAlgorithmTest, FitnessAssignment) selection_errors(1) = type(3); selection_errors(2) = type(2); selection_errors(3) = type(1); - +/* genetic_algorithm.set_selection_errors(selection_errors); genetic_algorithm.perform_fitness_assignment(); @@ -171,7 +171,7 @@ TEST(GeneticAlgorithmTest, FitnessAssignment) TEST(GeneticAlgorithmTest, Selection) { -/* + Tensor population; Tensor selection; @@ -179,9 +179,7 @@ TEST(GeneticAlgorithmTest, Selection) Tensor selection_errors; Tensor fitness; - - // Test 1 - +/* genetic_algorithm.set_individuals_number(4); fitness.resize(4); @@ -277,9 +275,10 @@ TEST(GeneticAlgorithmTest, Selection) TEST(GeneticAlgorithmTest, Crossover) { -/* + Tensor data(10,5); data.setRandom(); + /* data_set.set_data(data); Tensor population; @@ -393,7 +392,7 @@ TEST(GeneticAlgorithmTest, Mutation) TEST(GeneticAlgorithmTest, InputSelection) { -/* + Tensor data; InputsSelectionResults input_selection_results; @@ -409,7 +408,7 @@ TEST(GeneticAlgorithmTest, InputSelection) data(i,2) = type(10.0); data(i,3) = type(i); } - +/* data_set.set_data(data); neural_network.set(NeuralNetwork::ModelType::Approximation, {2}, {6}, {1}); diff --git a/tests/growing_neurons_test.cpp b/tests/growing_neurons_test.cpp index 66c6ccf30..09e0c7573 100644 --- a/tests/growing_neurons_test.cpp +++ b/tests/growing_neurons_test.cpp @@ -70,7 +70,7 @@ TEST(GrowingNeuronsTest, NeuronsSelection) training_strategy.set_display(false); growing_neurons.set_trials_number(1); - growing_neurons.set_maximum_neurons_number(7); + growing_neurons.set_maximum_neurons(7); growing_neurons.set_selection_error_goal(type(1.0e-3f)); growing_neurons.set_display(false); diff --git a/tests/transformer_test.cpp b/tests/transformer_test.cpp index e6bc587da..f14060384 100644 --- a/tests/transformer_test.cpp +++ b/tests/transformer_test.cpp @@ -73,7 +73,7 @@ TEST(Transformer, GeneralConstructor) TEST(Transformer, Outputs) { - /* + Tensor inputs; Tensor context; Tensor outputs; @@ -84,17 +84,19 @@ TEST(Transformer, Outputs) // Test two layers perceptron with all zeros - input_length = 1; - context_length = 1; - input_dimensions = 1; - context_dimension = 1; - embedding_depth = 1; - perceptron_depth = 1; - heads_number = 1; - layers_number = 1; -/* - transformer.set({ input_length, context_length, input_dimensions, context_dimension, - embedding_depth, perceptron_depth, heads_number, layers_number }); + Index input_length = 1; + Index context_length = 1; + Index input_dimensions = 1; + Index context_dimension = 1; + Index embedding_depth = 1; + Index perceptron_depth = 1; + Index heads_number = 1; + Index layers_number = 1; + Index batch_samples_number = 1; + + Transformer transformer(input_length, context_length, input_dimensions, context_dimension, + embedding_depth, perceptron_depth, heads_number, layers_number); + transformer.set_parameters_constant(type(0)); inputs.resize(batch_samples_number, input_length); @@ -105,9 +107,9 @@ TEST(Transformer, Outputs) outputs = transformer.calculate_outputs(inputs, context); - EXPECT_EQ(outputs.dimension(0) == batch_samples_number); - EXPECT_EQ(outputs.dimension(1) == input_length); - EXPECT_EQ(outputs.dimension(2) == input_dimensions); + EXPECT_EQ(outputs.dimension(0), batch_samples_number); + EXPECT_EQ(outputs.dimension(1), input_length); + EXPECT_EQ(outputs.dimension(2), input_dimensions); //EXPECT_EQ(outputs.abs() < type(NUMERIC_LIMITS_MIN)); @@ -117,7 +119,7 @@ TEST(Transformer, Outputs) Index inputs_number = 2; Index neurons_number = 4; Index outputs_number = 5; - +/* transformer.set(Transformer::ModelType::Approximation, { inputs_number}, {neurons_number}, {outputs_number }); transformer.set_parameters_constant(type(0)); @@ -248,78 +250,72 @@ TEST(Transformer, Outputs) TEST(Transformer, ForwardPropagate) { -/* - { - // Test - - batch_samples_number = 1; - - input_length = 4; - context_length = 3; - input_dimensions = 5; - context_dimension = 6; + Index batch_samples_number = 1; - embedding_depth = 4; - perceptron_depth = 6; - heads_number = 4; - layers_number = 1; + Index input_length = 4; + Index context_length = 3; + Index input_dimensions = 5; + Index context_dimension = 6; - bool is_training = true; + Index embedding_depth = 4; + Index perceptron_depth = 6; + Index heads_number = 4; + Index layers_number = 1; - data.resize(batch_samples_number, context_length + 2 * input_length); + bool is_training = true; +/* + data.resize(batch_samples_number, context_length + 2 * input_length); - for(Index i = 0; i < batch_samples_number; i++) - { - for(Index j = 0; j < context_length; j++) - data(i, j) = type(rand() % context_dimension); + for(Index i = 0; i < batch_samples_number; i++) + { + for(Index j = 0; j < context_length; j++) + data(i, j) = type(rand() % context_dimension); - for(Index j = 0; j < 2 * input_length; j++) - data(i, j + context_length) = type(rand() % input_dimensions); - } + for(Index j = 0; j < 2 * input_length; j++) + data(i, j + context_length) = type(rand() % input_dimensions); + } - data_set.set(data); + data_set.set(data); - data_set.set(DataSet::SampleUse::Training); + data_set.set(DataSet::SampleUse::Training); - for(Index i = 0; i < context_length; i++) - data_set.set_raw_variable_use(i, DataSet::VariableUse::Context); + for(Index i = 0; i < context_length; i++) + data_set.set_raw_variable_use(i, DataSet::VariableUse::Context); - for(Index i = 0; i < input_length; i++) - data_set.set_raw_variable_use(i + context_length, DataSet::VariableUse::Input); + for(Index i = 0; i < input_length; i++) + data_set.set_raw_variable_use(i + context_length, DataSet::VariableUse::Input); - for(Index i = 0; i < input_length; i++) - data_set.set_raw_variable_use(i + context_length + input_length, DataSet::VariableUse::Target); + for(Index i = 0; i < input_length; i++) + data_set.set_raw_variable_use(i + context_length + input_length, DataSet::VariableUse::Target); - training_samples_indices = data_set.get_sample_indices(DataSet::SampleUse::Training); - context_variables_indices = data_set.get_variable_indices(DataSet::VariableUse::Context); - input_variables_indices = data_set.get_variable_indices(DataSet::VariableUse::Input); - target_variables_indices = data_set.get_variable_indices(DataSet::VariableUse::Target); + training_samples_indices = data_set.get_sample_indices(DataSet::SampleUse::Training); + context_variables_indices = data_set.get_variable_indices(DataSet::VariableUse::Context); + input_variables_indices = data_set.get_variable_indices(DataSet::VariableUse::Input); + target_variables_indices = data_set.get_variable_indices(DataSet::VariableUse::Target); - batch.set(batch_samples_number, &data_set); + batch.set(batch_samples_number, &data_set); - batch.fill(training_samples_indices, input_variables_indices, target_variables_indices, context_variables_indices); + batch.fill(training_samples_indices, input_variables_indices, target_variables_indices, context_variables_indices); - transformer.set({ input_length, context_length, input_dimensions, context_dimension, - embedding_depth, perceptron_depth, heads_number, layers_number }); + transformer.set({ input_length, context_length, input_dimensions, context_dimension, + embedding_depth, perceptron_depth, heads_number, layers_number }); - ForwardPropagation forward_propagation(data_set.get_samples_number(DataSet::SampleUse::Training), &transformer); + ForwardPropagation forward_propagation(data_set.get_samples_number(DataSet::SampleUse::Training), &transformer); - transformer.forward_propagate(batch.get_input_pairs(), forward_propagation, is_training); + transformer.forward_propagate(batch.get_input_pairs(), forward_propagation, is_training); - ProbabilisticLayer3DForwardPropagation* probabilistic_layer_forward_propagation - = static_cast(forward_propagation.layers[transformer.get_layers_number() - 1]); + ProbabilisticLayer3DForwardPropagation* probabilistic_layer_forward_propagation + = static_cast(forward_propagation.layers[transformer.get_layers_number() - 1]); - Tensor probabilistic_activations = probabilistic_layer_forward_propagation->outputs; + Tensor probabilistic_activations = probabilistic_layer_forward_propagation->outputs; - EXPECT_EQ(probabilistic_activations.rank() == 3); - EXPECT_EQ(probabilistic_activations.dimension(0) == batch_samples_number); - EXPECT_EQ(probabilistic_activations.dimension(1) == input_length); - EXPECT_EQ(probabilistic_activations.dimension(2) == input_dimensions + 1); + EXPECT_EQ(probabilistic_activations.rank() == 3); + EXPECT_EQ(probabilistic_activations.dimension(0) == batch_samples_number); + EXPECT_EQ(probabilistic_activations.dimension(1) == input_length); + EXPECT_EQ(probabilistic_activations.dimension(2) == input_dimensions + 1); - EXPECT_EQ(check_activations_sums(probabilistic_activations)); + EXPECT_EQ(check_activations_sums(probabilistic_activations)); - } - { // Test From cc09ea4309262b034888a5d807d12ad2d302f9a3 Mon Sep 17 00:00:00 2001 From: RoberLopez Date: Thu, 16 Jan 2025 10:23:20 +0100 Subject: [PATCH 07/10] clean --- opennn/batch.cpp | 6 +- opennn/language_data_set.cpp | 3 - opennn/learning_rate_algorithm.cpp | 73 ++++++++++++++++++++---- opennn/learning_rate_algorithm.h | 89 +++--------------------------- opennn/strings_utilities.cpp | 41 ++------------ 5 files changed, 77 insertions(+), 135 deletions(-) diff --git a/opennn/batch.cpp b/opennn/batch.cpp index f211b5e14..5a27f3d2e 100644 --- a/opennn/batch.cpp +++ b/opennn/batch.cpp @@ -182,9 +182,7 @@ void Batch::print() const << "Input dimensions:" << endl; print_vector(input_dimensions); - - - /* + if(input_dimensions.size() == 4) { const TensorMap> inputs((type*)input_tensor.data(), @@ -195,7 +193,7 @@ void Batch::print() const cout << inputs << endl; } - */ + cout << "Decoder:" << endl << "Decoder dimensions:" << endl; diff --git a/opennn/language_data_set.cpp b/opennn/language_data_set.cpp index 352b0d577..97a2c0650 100644 --- a/opennn/language_data_set.cpp +++ b/opennn/language_data_set.cpp @@ -69,9 +69,6 @@ void LanguageDataSet::set_target_vocabulary(const unordered_map& void LanguageDataSet::set_data_random() { /* - data_path.clear(); - - set(batch_samples_number, decoder_length + 2 * completion_length); for(Index i = 0; i < batch_samples_number; i++) { diff --git a/opennn/learning_rate_algorithm.cpp b/opennn/learning_rate_algorithm.cpp index 142616dc2..6af88ba9b 100644 --- a/opennn/learning_rate_algorithm.cpp +++ b/opennn/learning_rate_algorithm.cpp @@ -79,20 +79,10 @@ void LearningRateAlgorithm::set(LossIndex* new_loss_index) void LearningRateAlgorithm::set_default() { -/* - delete thread_pool; - delete thread_pool_device; - - const unsigned int threads_number = thread::hardware_concurrency(); - thread_pool = new ThreadPool(n); - thread_pool_device = new ThreadPoolDevice(thread_pool, n); - const unsigned int threads_number = thread::hardware_concurrency(); thread_pool = make_unique(threads_number); thread_pool_device = make_unique(thread_pool.get(), threads_number); -*/ - // TRAINING OPERATORS learning_rate_method = LearningRateMethod::BrentMethod; @@ -446,6 +436,69 @@ void LearningRateAlgorithm::from_XML(const XMLDocument& document) set_display(read_xml_bool(root_element, "Display")); } + +LearningRateAlgorithm::Triplet::Triplet() +{ + A = make_pair(numeric_limits::max(), numeric_limits::max()); + U = make_pair(numeric_limits::max(), numeric_limits::max()); + B = make_pair(numeric_limits::max(), numeric_limits::max()); +} + + +type LearningRateAlgorithm::Triplet::get_length() const +{ + return abs(B.first - A.first); +} + + +pair LearningRateAlgorithm::Triplet::minimum() const +{ + Tensor losses(3); + + losses.setValues({ A.second, U.second, B.second }); + + const Index minimal_index = opennn::minimal_index(losses); + + if (minimal_index == 0) return A; + else if (minimal_index == 1) return U; + else return B; +} + + +string LearningRateAlgorithm::Triplet::struct_to_string() const +{ + ostringstream buffer; + + buffer << "A = (" << A.first << "," << A.second << ")\n" + << "U = (" << U.first << "," << U.second << ")\n" + << "B = (" << B.first << "," << B.second << ")" << endl; + + return buffer.str(); +} + + +void LearningRateAlgorithm::Triplet::print() const +{ + cout << struct_to_string() + << "Lenght: " << get_length() << endl; +} + + +void LearningRateAlgorithm::Triplet::check() const +{ + if (U.first < A.first) + throw runtime_error("U is less than A:\n" + struct_to_string()); + + if (U.first > B.first) + throw runtime_error("U is greater than B:\n" + struct_to_string()); + + if (U.second >= A.second) + throw runtime_error("fU is equal or greater than fA:\n" + struct_to_string()); + + if (U.second >= B.second) + throw runtime_error("fU is equal or greater than fB:\n" + struct_to_string()); +} + } diff --git a/opennn/learning_rate_algorithm.h b/opennn/learning_rate_algorithm.h index 82538cd25..14e17a42c 100644 --- a/opennn/learning_rate_algorithm.h +++ b/opennn/learning_rate_algorithm.h @@ -27,14 +27,9 @@ class LearningRateAlgorithm struct Triplet { - Triplet() - { - A = make_pair(numeric_limits::max(), numeric_limits::max()); - U = make_pair(numeric_limits::max(), numeric_limits::max()); - B = make_pair(numeric_limits::max(), numeric_limits::max()); - } + Triplet(); - inline bool operator == (const Triplet& other_triplet) const + bool operator == (const Triplet& other_triplet) const { if(A == other_triplet.A && U == other_triplet.U @@ -44,59 +39,15 @@ class LearningRateAlgorithm return false; } - inline type get_length() const - { - return abs(B.first - A.first); - } - + type get_length() const; - inline pair minimum() const - { - Tensor losses(3); - - losses.setValues({A.second, U.second, B.second}); + pair minimum() const; - const Index minimal_index = opennn::minimal_index(losses); + string struct_to_string() const; - if(minimal_index == 0) return A; - else if(minimal_index == 1) return U; - else return B; - } + void print() const; - - inline string struct_to_string() const - { - ostringstream buffer; - - buffer << "A = (" << A.first << "," << A.second << ")\n" - << "U = (" << U.first << "," << U.second << ")\n" - << "B = (" << B.first << "," << B.second << ")" << endl; - - return buffer.str(); - } - - - inline void print() const - { - cout << struct_to_string() - << "Lenght: " << get_length() << endl; - } - - - inline void check() const - { - if(U.first < A.first) - throw runtime_error("U is less than A:\n" + struct_to_string()); - - if(U.first > B.first) - throw runtime_error("U is greater than B:\n" + struct_to_string()); - - if(U.second >= A.second) - throw runtime_error("fU is equal or greater than fA:\n" + struct_to_string()); - - if(U.second >= B.second) - throw runtime_error("fU is equal or greater than fB:\n" + struct_to_string()); - } + void check() const; pair A; @@ -105,49 +56,31 @@ class LearningRateAlgorithm pair B; }; - // Get - LossIndex* get_loss_index() const; bool has_loss_index() const; - // Training operators - const LearningRateMethod& get_learning_rate_method() const; string write_learning_rate_method() const; - // Training parameters - const type& get_learning_rate_tolerance() const; - - // Utilities const bool& get_display() const; - // Set - void set(LossIndex* = nullptr); void set_loss_index(LossIndex*); void set_threads_number(const int&); - // Training operators - void set_learning_rate_method(const LearningRateMethod&); void set_learning_rate_method(const string&); - // Training parameters - void set_learning_rate_tolerance(const type&); - // Utilities - void set_display(const bool&); void set_default(); - // Learning rate - type calculate_golden_section_learning_rate(const Triplet&) const; type calculate_Brent_method_learning_rate(const Triplet&) const; @@ -160,8 +93,6 @@ class LearningRateAlgorithm ForwardPropagation&, BackPropagation&, OptimizationAlgorithmData&) const; - - // Serialization void from_XML(const XMLDocument&); @@ -169,20 +100,14 @@ class LearningRateAlgorithm private: - // FIELDS - LossIndex* loss_index = nullptr; - // TRAINING OPERATORS - LearningRateMethod learning_rate_method; type learning_rate_tolerance; type loss_tolerance; - // UTILITIES - bool display = true; const type golden_ratio = type(1.618); diff --git a/opennn/strings_utilities.cpp b/opennn/strings_utilities.cpp index dccf9aaa6..24d9df586 100644 --- a/opennn/strings_utilities.cpp +++ b/opennn/strings_utilities.cpp @@ -352,37 +352,6 @@ void replace_double_char_with_label(string &str, const string &target_char, cons void replace_substring_within_quotes(string &str, const string &target, const string &replacement) { -/* - regex r("\"([^\"]*)\""); - - string result; - smatch match; - - string prefix = str; - - string::const_iterator search_start(str.begin()); - - - while(regex_search(prefix, match, r)) - { - string match_str = match.str(); - string replaced_str = match_str; - size_t position = 0; - - while((position = replaced_str.find(target, position)) != string::npos) - { - replaced_str.replace(position, target.length(), replacement); - position += replacement.length(); - } - - result += match.prefix().str() + replaced_str; - prefix = match.suffix().str(); - } - - result += prefix; - str = result; -*/ - regex r("\"([^\"]*)\""); string result; string::const_iterator search_start(str.begin()); @@ -390,8 +359,8 @@ void replace_substring_within_quotes(string &str, const string &target, const st while (regex_search(search_start, str.cend(), match, r)) { - result += string(search_start, match[0].first); // Append text before match - string quoted_content = match[1].str(); // Extract quoted content + result += string(search_start, match[0].first); + string quoted_content = match[1].str(); size_t position = 0; while ((position = quoted_content.find(target, position)) != string::npos) @@ -400,11 +369,11 @@ void replace_substring_within_quotes(string &str, const string &target, const st position += replacement.length(); } - result += "\"" + quoted_content + "\""; // Append updated quoted content - search_start = match[0].second; // Move search start past the current match + result += "\"" + quoted_content + "\""; + search_start = match[0].second; } - result += string(search_start, str.cend()); // Append remaining text + result += string(search_start, str.cend()); str = result; } From 252504b9b1df25356ab8b0c618eff386e81d2fe4 Mon Sep 17 00:00:00 2001 From: RoberLopez Date: Thu, 16 Jan 2025 11:25:26 +0100 Subject: [PATCH 08/10] clean --- examples/airfoil_self_noise/main.cpp | 2 +- opennn/genetic_algorithm.cpp | 14 ++------------ opennn/genetic_algorithm.h | 4 +--- opennn/growing_inputs.cpp | 2 +- opennn/growing_inputs.h | 2 +- opennn/inputs_selection.h | 2 +- opennn/model_selection.cpp | 6 +++--- opennn/model_selection.h | 2 +- opennn/neural_network.cpp | 25 ------------------------- tests/correlations_test.cpp | 3 ++- tests/genetic_algorithm_test.cpp | 9 ++++++--- tests/growing_inputs_test.cpp | 4 ++-- tests/test.cpp | 2 +- 13 files changed, 22 insertions(+), 55 deletions(-) diff --git a/examples/airfoil_self_noise/main.cpp b/examples/airfoil_self_noise/main.cpp index 430ff03b8..c3d0630ed 100644 --- a/examples/airfoil_self_noise/main.cpp +++ b/examples/airfoil_self_noise/main.cpp @@ -77,7 +77,7 @@ int main() ModelSelection model_selection(&training_strategy); - model_selection.perform_inputs_selection(); + model_selection.perform_input_selection(); /* // Testing analysis diff --git a/opennn/genetic_algorithm.cpp b/opennn/genetic_algorithm.cpp index 2b3a1f796..16f2db644 100644 --- a/opennn/genetic_algorithm.cpp +++ b/opennn/genetic_algorithm.cpp @@ -95,8 +95,6 @@ void GeneticAlgorithm::set_default() mutation_rate = type(0.0010); - // Population stuff - population.resize(individuals_number, genes_number); parameters.resize(individuals_number); @@ -113,11 +111,9 @@ void GeneticAlgorithm::set_default() selection.resize(individuals_number); - // Training operators - elitism_size = Index(ceil(individuals_number / 4)); - set_initialization_method(GeneticAlgorithm::InitializationMethod::Random); + initialization_method = GeneticAlgorithm::InitializationMethod::Random; } @@ -127,12 +123,6 @@ void GeneticAlgorithm::set_population(const Tensor& new_population) } -void GeneticAlgorithm::set_genes_number(const Index& new_genes_number) -{ - // @todo -} - - void GeneticAlgorithm::set_maximum_epochs_number(const Index& new_maximum_epochs_number) { maximum_epochs_number = new_maximum_epochs_number; @@ -614,7 +604,7 @@ void GeneticAlgorithm::perform_mutation() } -InputsSelectionResults GeneticAlgorithm::perform_inputs_selection() +InputsSelectionResults GeneticAlgorithm::perform_input_selection() { if(display) cout << "Performing genetic inputs selection...\n" << endl; diff --git a/opennn/genetic_algorithm.h b/opennn/genetic_algorithm.h index eb003ab85..6b6f2458d 100644 --- a/opennn/genetic_algorithm.h +++ b/opennn/genetic_algorithm.h @@ -49,8 +49,6 @@ class GeneticAlgorithm : public InputsSelection void set_individuals_number(const Index& new_individuals_number=4); - void set_genes_number(const Index&); - void set_initialization_method(const GeneticAlgorithm::InitializationMethod&); void set_mutation_rate(const type&); @@ -89,7 +87,7 @@ class GeneticAlgorithm : public InputsSelection vector get_raw_variable_indices(const Tensor&); - InputsSelectionResults perform_inputs_selection() override; + InputsSelectionResults perform_input_selection() override; Tensor to_string_matrix() const; diff --git a/opennn/growing_inputs.cpp b/opennn/growing_inputs.cpp index 6da0ce02d..30e86f67a 100644 --- a/opennn/growing_inputs.cpp +++ b/opennn/growing_inputs.cpp @@ -74,7 +74,7 @@ void GrowingInputs::set_maximum_selection_failures(const Index& new_maximum_sele } -InputsSelectionResults GrowingInputs::perform_inputs_selection() +InputsSelectionResults GrowingInputs::perform_input_selection() { InputsSelectionResults input_selection_results(maximum_epochs_number); diff --git a/opennn/growing_inputs.h b/opennn/growing_inputs.h index c721af715..cef836090 100644 --- a/opennn/growing_inputs.h +++ b/opennn/growing_inputs.h @@ -35,7 +35,7 @@ class GrowingInputs : public InputsSelection void set_maximum_selection_failures(const Index&); - InputsSelectionResults perform_inputs_selection() override; + InputsSelectionResults perform_input_selection() override; Tensor to_string_matrix() const; diff --git a/opennn/inputs_selection.h b/opennn/inputs_selection.h index a969e8bdd..e5addaa89 100644 --- a/opennn/inputs_selection.h +++ b/opennn/inputs_selection.h @@ -65,7 +65,7 @@ class InputsSelection Index get_input_index(const Tensor&, const Index&) const; - virtual InputsSelectionResults perform_inputs_selection() = 0; + virtual InputsSelectionResults perform_input_selection() = 0; string write_time(const type&) const; diff --git a/opennn/model_selection.cpp b/opennn/model_selection.cpp index f18007344..452e1b9ba 100644 --- a/opennn/model_selection.cpp +++ b/opennn/model_selection.cpp @@ -182,15 +182,15 @@ NeuronsSelectionResults ModelSelection::perform_neurons_selection() } -InputsSelectionResults ModelSelection::perform_inputs_selection() +InputsSelectionResults ModelSelection::perform_input_selection() { switch(inputs_selection_method) { case InputsSelectionMethod::GROWING_INPUTS: - return growing_inputs.perform_inputs_selection(); + return growing_inputs.perform_input_selection(); case InputsSelectionMethod::GENETIC_ALGORITHM: - return genetic_algorithm.perform_inputs_selection(); + return genetic_algorithm.perform_input_selection(); } return InputsSelectionResults(); diff --git a/opennn/model_selection.h b/opennn/model_selection.h index 30df84d30..43bb18ca8 100644 --- a/opennn/model_selection.h +++ b/opennn/model_selection.h @@ -63,7 +63,7 @@ class ModelSelection NeuronsSelectionResults perform_neurons_selection(); - InputsSelectionResults perform_inputs_selection(); + InputsSelectionResults perform_input_selection(); // Serialization diff --git a/opennn/neural_network.cpp b/opennn/neural_network.cpp index 3fce05f89..b8bcf09a6 100644 --- a/opennn/neural_network.cpp +++ b/opennn/neural_network.cpp @@ -928,31 +928,6 @@ Index NeuralNetwork::get_layers_number(const Layer::Type& layer_type) const } -// bool NeuralNetwork::is_input_layer(const vector& this_layer_inputs_indices) const -// { -// const Index input_layers_number = this_layer_inputs_indices.size(); - -// for(Index i = 0; i < input_layers_number; i++) -// if(this_layer_inputs_indices[i] == -1) -// return true; - -// return false; -// } - - -// bool NeuralNetwork::is_context_layer(const vector& this_layer_inputs_indices) const -// { -// // @todo Is this ok? -// const Index layers_number = get_layers_number(); - -// for(Index i = 0; i < layers_number; i++) -// if(this_layer_inputs_indices[i] == -2) -// return true; - -// return false; -// } - - void NeuralNetwork::set_parameters_constant(const type& value) const { const Index layers_number = get_layers_number(); diff --git a/tests/correlations_test.cpp b/tests/correlations_test.cpp index 276544de7..ed2b03b93 100644 --- a/tests/correlations_test.cpp +++ b/tests/correlations_test.cpp @@ -33,8 +33,9 @@ TEST_F(CorrelationsTest, SpearmanCorrelation) Tensor y(10); y.setValues({ type(1), type(3), type(7), type(9), type(10), type(16), type(20), type(28), type(44), type(100) }); - +/* EXPECT_NEAR(linear_correlation_spearman(thread_pool_device.get(), x, y).r, type(1), NUMERIC_LIMITS_MIN); +*/ } diff --git a/tests/genetic_algorithm_test.cpp b/tests/genetic_algorithm_test.cpp index 2dd769599..2d7dfc010 100644 --- a/tests/genetic_algorithm_test.cpp +++ b/tests/genetic_algorithm_test.cpp @@ -9,6 +9,9 @@ TEST(GeneticAlgorithmTest, DefaultConstructor) GeneticAlgorithm genetic_algorithm; EXPECT_EQ(genetic_algorithm.has_training_strategy(), false); + EXPECT_EQ(genetic_algorithm.get_population().dimension(0), 0); + + } @@ -419,7 +422,7 @@ TEST(GeneticAlgorithmTest, InputSelection) genetic_algorithm.set_selection_error_goal(1); - input_selection_results = genetic_algorithm.perform_inputs_selection(); + input_selection_results = genetic_algorithm.perform_input_selection(); EXPECT_EQ(input_selection_results.stopping_condition == InputsSelection::StoppingCondition::SelectionErrorGoal); EXPECT_EQ(input_selection_results.selection_error_history(0) <= 1); @@ -452,7 +455,7 @@ TEST(GeneticAlgorithmTest, InputSelection) genetic_algorithm.set_selection_error_goal(type(0)); genetic_algorithm.set_maximum_epochs_number(1); - input_selection_results = genetic_algorithm.perform_inputs_selection(); + input_selection_results = genetic_algorithm.perform_input_selection(); EXPECT_EQ(genetic_algorithm.get_maximum_iterations_number() == 1); EXPECT_EQ(genetic_algorithm.get_selection_error_goal() < 1); @@ -481,7 +484,7 @@ TEST(GeneticAlgorithmTest, InputSelection) genetic_algorithm.set_selection_error_goal(type(0.01)); genetic_algorithm.set_maximum_epochs_number(10); - input_selection_results = genetic_algorithm.perform_inputs_selection(); + input_selection_results = genetic_algorithm.perform_input_selection(); EXPECT_EQ(input_selection_results.get_epochs_number() <= 100); */ diff --git a/tests/growing_inputs_test.cpp b/tests/growing_inputs_test.cpp index d016fb598..bd7d713cd 100644 --- a/tests/growing_inputs_test.cpp +++ b/tests/growing_inputs_test.cpp @@ -30,7 +30,7 @@ TEST(GrowingInputsTest, InputSelection) EXPECT_EQ(growing_inputs.has_training_strategy(), true); -// InputsSelectionResults input_selection_results = growing_inputs.perform_inputs_selection(); +// InputsSelectionResults input_selection_results = growing_inputs.perform_input_selection(); } /* @@ -65,7 +65,7 @@ void GrowingInputsTest::test_perform_inputs_selection() TrainingStrategy training_strategy1(&neural_network, &data_set); - //input_selection_results = growing_inputs.perform_inputs_selection(); + //input_selection_results = growing_inputs.perform_input_selection(); EXPECT_EQ(input_selection_results.optimal_input_raw_variables_indices[0] < 2); diff --git a/tests/test.cpp b/tests/test.cpp index b678c0d1f..4433e167b 100644 --- a/tests/test.cpp +++ b/tests/test.cpp @@ -4,7 +4,7 @@ int main(int argc, char **argv) { ::testing::InitGoogleTest(&argc, argv); - //::testing::GTEST_FLAG(filter) = "FlattenLayerTest"; + //::testing::GTEST_FLAG(filter) = "GeneticAlgorithmTest"; //::testing::GTEST_FLAG(filter) = "PoolingLayerTests/*"; //::testing::GTEST_FLAG(filter) = "ConvolutionalLayerTests/*"; From 5068f0ce26c3f0c4a42c5f62323a6b0b06c7450a Mon Sep 17 00:00:00 2001 From: rubenareces Date: Fri, 17 Jan 2025 09:15:38 +0100 Subject: [PATCH 09/10] merge --- examples/mnist/main.cpp | 14 ++-- opennn/adaptive_moment_estimation.cpp | 2 +- opennn/convolutional_layer.cpp | 92 ++++++++++++++++++++------- opennn/neural_network.cpp | 14 ++-- 4 files changed, 83 insertions(+), 39 deletions(-) diff --git a/examples/mnist/main.cpp b/examples/mnist/main.cpp index 893f99528..e4536123b 100644 --- a/examples/mnist/main.cpp +++ b/examples/mnist/main.cpp @@ -32,30 +32,30 @@ int main() const Index channels = 1; const Index targets = 3; - //ImageDataSet image_data_set(samples_number, {image_height, image_width, channels}, {targets}); + ImageDataSet image_data_set(samples_number, {image_height, image_width, channels}, {targets}); - //image_data_set.set_data_random(); + image_data_set.set_data_random(); - ImageDataSet image_data_set(0,{0,0,0},{0}); + //ImageDataSet image_data_set(0,{0,0,0},{0}); //image_data_set.set_data_path("data"); //image_data_set.set_data_path("C:/mnist/train"); - image_data_set.set_data_path("C:/binary_mnist"); + //image_data_set.set_data_path("C:/binary_mnist"); //image_data_set.set_data_path("C:/Users/Roberto Lopez/Documents/opennn/examples/mnist/data"); //image_data_set.set_data_path("C:/melanoma_dataset_bmp"); //image_data_set.set_data_path("C:/melanoma_dataset_bmp_small"); //image_data_set.set_data_path("C:/melanoma_supersmall"); //image_data_set.set_input_dimensions({24,24,1}); - image_data_set.read_bmp(); + //image_data_set.read_bmp(); - //image_data_set.set(DataSet::SampleUse::Training); + image_data_set.set(DataSet::SampleUse::Training); // Neural network NeuralNetwork neural_network(NeuralNetwork::ModelType::ImageClassification, image_data_set.get_dimensions(DataSet::VariableUse::Input), - { 8 }, + { 4 }, image_data_set.get_dimensions(DataSet::VariableUse::Target)); //neural_network.print(); diff --git a/opennn/adaptive_moment_estimation.cpp b/opennn/adaptive_moment_estimation.cpp index 6b3582b9a..9f0bba462 100644 --- a/opennn/adaptive_moment_estimation.cpp +++ b/opennn/adaptive_moment_estimation.cpp @@ -165,7 +165,7 @@ TrainingResults AdaptiveMomentEstimation::perform_training() const Index training_samples_number = data_set->get_samples_number(DataSet::SampleUse::Training); const Index selection_samples_number = data_set->get_samples_number(DataSet::SampleUse::Selection); - const vector input_variables_descriptives = data_set->scale_variables(DataSet::VariableUse::Input); + //const vector input_variables_descriptives = data_set->scale_variables(DataSet::VariableUse::Input); const Index training_batch_samples_number = min(training_samples_number, batch_samples_number); diff --git a/opennn/convolutional_layer.cpp b/opennn/convolutional_layer.cpp index af45f5da6..f2e0eb39e 100644 --- a/opennn/convolutional_layer.cpp +++ b/opennn/convolutional_layer.cpp @@ -78,7 +78,7 @@ void ConvolutionalLayer::calculate_convolutions(const Tensor& inputs, 1); convolution.device(*thread_pool_device) = inputs.convolve(kernel, convolutions_dimensions) + biases(kernel_index); - } + } } @@ -193,9 +193,6 @@ void ConvolutionalLayer::forward_propagate(const vector> unique_ptr& layer_forward_propagation, const bool& is_training) { - //cout << "Calculando tiempo convolution forward..." << endl; - //auto start = chrono::high_resolution_clock::now(); - const TensorMap> inputs = tensor_map_4(input_pairs[0]); ConvolutionalLayerForwardPropagation* convolutional_layer_forward_propagation = @@ -221,20 +218,10 @@ void ConvolutionalLayer::forward_propagate(const vector> */ } - //auto start_activations = chrono::high_resolution_clock::now(); if (is_training) calculate_activations(outputs, activation_derivatives); else - calculate_activations(outputs, empty); - - /* - auto end = chrono::high_resolution_clock::now(); - auto duration = chrono::duration_cast(end - start); - cout << "Tiempo convolution forward propagate: " - << duration.count() / 1000 << "::" - << duration.count() % 1000 - << " segundos::milisegundos" << endl; - */ + calculate_activations(outputs, empty); } @@ -243,7 +230,8 @@ void ConvolutionalLayer::back_propagate(const vector>& i unique_ptr& forward_propagation, unique_ptr& back_propagation) const { - //auto start = chrono::high_resolution_clock::now(); + cout << "Calculando tiempo convolution backward..." << endl; + auto start = chrono::high_resolution_clock::now(); // Convolutional layer const Index batch_samples_number = back_propagation->batch_samples_number; @@ -374,12 +362,12 @@ void ConvolutionalLayer::back_propagate(const vector>& i } } - //auto end = chrono::high_resolution_clock::now(); - //auto duration = chrono::duration_cast(end - start); - //cout << "Tiempo convolution back propagate: " - // << duration.count() / 1000 << "::" - // << duration.count() % 1000 - // << " segundos::milisegundos" << endl; + auto end = chrono::high_resolution_clock::now(); + auto duration = chrono::duration_cast(end - start); + cout << "Tiempo convolution back propagate: " + << duration.count() / 1000 << "::" + << duration.count() % 1000 + << " segundos::milisegundos" << endl; } @@ -618,14 +606,70 @@ void ConvolutionalLayer::set(const dimensions& new_input_dimensions, set_convolution_type(new_convolution_type); biases.resize(kernels_number); - set_random(biases); + biases.setZero(); + //set_random(biases); synaptic_weights.resize(kernel_height, kernel_width, kernel_channels, kernels_number); - set_random(synaptic_weights); + float* data_ptr = synaptic_weights.data(); + + data_ptr[0] = 0.05f; + data_ptr[1] = -0.04f; + data_ptr[2] = -0.09f; + data_ptr[3] = 0.09f; + + // Fila 2 + data_ptr[4] = 0.03f; + data_ptr[5] = -0.05f; + data_ptr[6] = -0.08f; + data_ptr[7] = 0.09f; + + // Fila 3 + data_ptr[8] = 0.07f; + data_ptr[9] = 0.02f; + data_ptr[10] = 0.02f; + data_ptr[11] = -0.08f; + + // Fila 4 + data_ptr[12] = 0.04f; + data_ptr[13] = -0.01f; + data_ptr[14] = -0.08f; + data_ptr[15] = -0.04f; + + // Fila 5 + data_ptr[16] = -0.06f; + data_ptr[17] = -0.08f; + data_ptr[18] = -0.06f; + data_ptr[19] = -0.09f; + + // Fila 6 + data_ptr[20] = 0.05f; + data_ptr[21] = -0.07f; + data_ptr[22] = 0.06f; + data_ptr[23] = -0.09f; + + // Fila 7 + data_ptr[24] = 0.09f; + data_ptr[25] = 0.04f; + data_ptr[26] = 0.01f; + data_ptr[27] = -0.06f; + + // Fila 8 + data_ptr[28] = 0.01f; + data_ptr[29] = 0.03f; + data_ptr[30] = -0.05f; + data_ptr[31] = -0.01f; + + // Fila 9 + data_ptr[32] = 0.02f; + data_ptr[33] = -0.02f; + data_ptr[34] = -0.07f; + data_ptr[35] = 0.01f; + + //set_random(synaptic_weights); moving_means.resize(kernels_number); moving_standard_deviations.resize(kernels_number); diff --git a/opennn/neural_network.cpp b/opennn/neural_network.cpp index 3fce05f89..3c0b16cc4 100644 --- a/opennn/neural_network.cpp +++ b/opennn/neural_network.cpp @@ -441,7 +441,7 @@ void NeuralNetwork::set_image_classification(const dimensions& input_dimensions, { const dimensions kernel_dimensions = { 3, 3, get_output_dimensions()[2], complexity_dimensions[i] }; const dimensions stride_dimensions = { 1, 1 }; - const ConvolutionalLayer::ConvolutionType convolution_type = ConvolutionalLayer::ConvolutionType::Valid; + const ConvolutionalLayer::ConvolutionType convolution_type = ConvolutionalLayer::ConvolutionType::Same; add_layer(make_unique(get_output_dimensions(), kernel_dimensions, @@ -455,12 +455,12 @@ void NeuralNetwork::set_image_classification(const dimensions& input_dimensions, const dimensions padding_dimensions = { 0, 0 }; const PoolingLayer::PoolingMethod pooling_method = PoolingLayer::PoolingMethod::MaxPooling; - add_layer(make_unique(get_output_dimensions(), - pool_dimensions, - pooling_stride_dimensions, - padding_dimensions, - pooling_method, - "pooling_layer_" + to_string(i + 1))); + //add_layer(make_unique(get_output_dimensions(), + // pool_dimensions, + // pooling_stride_dimensions, + // padding_dimensions, + // pooling_method, + // "pooling_layer_" + to_string(i + 1))); } add_layer(make_unique(get_output_dimensions())); From e3c55caf45cc1b3f1a93268e5f814db4c61ce269 Mon Sep 17 00:00:00 2001 From: rubenareces Date: Mon, 20 Jan 2025 12:02:06 +0100 Subject: [PATCH 10/10] convolution padding same fix --- examples/mnist/main.cpp | 20 ++++++++-------- opennn/convolutional_layer.cpp | 43 ++++++++++++++-------------------- opennn/cross_entropy_error.cpp | 7 ------ opennn/neural_network.cpp | 26 ++++++++++---------- 4 files changed, 40 insertions(+), 56 deletions(-) diff --git a/examples/mnist/main.cpp b/examples/mnist/main.cpp index dc4f3fdaa..fbc6da26f 100644 --- a/examples/mnist/main.cpp +++ b/examples/mnist/main.cpp @@ -27,35 +27,35 @@ int main() const Index samples_number = 3; - const Index image_height = 2; - const Index image_width = 2; - const Index channels = 1; + const Index image_height = 3; + const Index image_width = 3; + const Index channels = 3; const Index targets = 3; - ImageDataSet image_data_set(samples_number, {image_height, image_width, channels}, {targets}); + //ImageDataSet image_data_set(samples_number, {image_height, image_width, channels}, {targets}); - image_data_set.set_data_random(); + //image_data_set.set_data_random(); - //ImageDataSet image_data_set(0,{0,0,0},{0}); + ImageDataSet image_data_set(0,{0,0,0},{0}); //image_data_set.set_data_path("data"); //image_data_set.set_data_path("C:/mnist/train"); - //image_data_set.set_data_path("C:/binary_mnist"); + image_data_set.set_data_path("C:/binary_mnist"); //image_data_set.set_data_path("C:/Users/Roberto Lopez/Documents/opennn/examples/mnist/data"); //image_data_set.set_data_path("C:/melanoma_dataset_bmp"); //image_data_set.set_data_path("C:/melanoma_dataset_bmp_small"); //image_data_set.set_data_path("C:/melanoma_supersmall"); //image_data_set.set_input_dimensions({24,24,1}); - //image_data_set.read_bmp(); + image_data_set.read_bmp(); - image_data_set.set(DataSet::SampleUse::Training); + //image_data_set.set(DataSet::SampleUse::Training); // Neural network NeuralNetwork neural_network(NeuralNetwork::ModelType::ImageClassification, image_data_set.get_dimensions(DataSet::VariableUse::Input), - { 1 }, + { 8 }, image_data_set.get_dimensions(DataSet::VariableUse::Target)); // Training strategy diff --git a/opennn/convolutional_layer.cpp b/opennn/convolutional_layer.cpp index 8b9b03bee..36cac4c73 100644 --- a/opennn/convolutional_layer.cpp +++ b/opennn/convolutional_layer.cpp @@ -205,7 +205,7 @@ void ConvolutionalLayer::forward_propagate(const vector> Tensor& activation_derivatives = convolutional_layer_forward_propagation->activation_derivatives; preprocess_inputs(inputs, preprocessed_inputs); - + calculate_convolutions(preprocessed_inputs, outputs); if(batch_normalization) @@ -230,8 +230,8 @@ void ConvolutionalLayer::back_propagate(const vector>& i unique_ptr& forward_propagation, unique_ptr& back_propagation) const { - cout << "Calculando tiempo convolution backward..." << endl; - auto start = chrono::high_resolution_clock::now(); + //cout << "Calculando tiempo convolution backward..." << endl; + //auto start = chrono::high_resolution_clock::now(); // Convolutional layer const Index batch_samples_number = back_propagation->batch_samples_number; @@ -256,6 +256,8 @@ void ConvolutionalLayer::back_propagate(const vector>& i ConvolutionalLayerForwardPropagation* convolutional_layer_forward_propagation = static_cast(forward_propagation.get()); + Tensor& preprocessed_inputs = convolutional_layer_forward_propagation->preprocessed_inputs; + const Tensor& activation_derivatives = convolutional_layer_forward_propagation->activation_derivatives; // Back propagation @@ -292,10 +294,9 @@ void ConvolutionalLayer::back_propagate(const vector>& i const Eigen::array, 2> paddings = { make_pair(pad_top, pad_bottom), make_pair(pad_left, pad_right) }; - cout << "Inputs: \n" << inputs << endl; - cout << "Deltas: \n" << deltas << endl; - - cout << "synaptic weigths:\n" << synaptic_weights << endl; + // Inputs + + preprocess_inputs(inputs, preprocessed_inputs); // Convolutions derivatives @@ -307,7 +308,7 @@ void ConvolutionalLayer::back_propagate(const vector>& i // Synaptic weigth derivatives - //#pragma omp parallel for + #pragma omp parallel for for (Index kernel_index = 0; kernel_index < kernels_number; kernel_index++) { const TensorMap> kernel_convolutions_derivatives( @@ -323,18 +324,8 @@ void ConvolutionalLayer::back_propagate(const vector>& i kernel_width, kernel_channels); - kernel_synaptic_weights_derivatives = inputs.convolve(kernel_convolutions_derivatives, convolutions_dimensions_3d); + kernel_synaptic_weights_derivatives = preprocessed_inputs.convolve(kernel_convolutions_derivatives, convolutions_dimensions_3d); } - - cout << "synaptic_weight_derivatives:\n" << convolutional_layer_back_propagation->synaptic_weight_derivatives << endl; - cout << "synaptic_weight dimension[0]:" << synaptic_weights.dimension(0) << endl; - cout << "synaptic_weight dimension[1]:" << synaptic_weights.dimension(1) << endl; - cout << "synaptic_weight dimension[2]:" << synaptic_weights.dimension(2) << endl; - cout << "synaptic_weight dimension[3]:" << synaptic_weights.dimension(3) << endl; - cout << "synaptic_weight_derivatives dimension[0]:" << convolutional_layer_back_propagation->synaptic_weight_derivatives.dimension(0) << endl; - cout << "synaptic_weight_derivatives dimension[1]:" << convolutional_layer_back_propagation->synaptic_weight_derivatives.dimension(1) << endl; - cout << "synaptic_weight_derivatives dimension[2]:" << convolutional_layer_back_propagation->synaptic_weight_derivatives.dimension(2) << endl; - cout << "synaptic_weight_derivatives dimension[3]:" << convolutional_layer_back_propagation->synaptic_weight_derivatives.dimension(3) << endl; // Input derivatives @@ -376,12 +367,12 @@ void ConvolutionalLayer::back_propagate(const vector>& i } } - auto end = chrono::high_resolution_clock::now(); - auto duration = chrono::duration_cast(end - start); - cout << "Tiempo convolution back propagate: " - << duration.count() / 1000 << "::" - << duration.count() % 1000 - << " segundos::milisegundos" << endl; + //auto end = chrono::high_resolution_clock::now(); + //auto duration = chrono::duration_cast(end - start); + //cout << "Tiempo convolution back propagate: " + // << duration.count() / 1000 << "::" + // << duration.count() % 1000 + // << " segundos::milisegundos" << endl; } @@ -818,7 +809,7 @@ pair ConvolutionalLayer::get_padding() const const Index kernel_width = get_kernel_width(); const Index row_stride = get_row_stride(); - //const Index column_stride = get_column_stride(); + const Index column_stride = get_column_stride(); const Index pad_rows = std::max(0, ((static_cast(input_height) / row_stride) - 1) * row_stride + kernel_height - input_height) / 2; const Index pad_columns = std::max(0, ((static_cast(input_width) / column_stride) - 1) * column_stride + kernel_width - input_width) / 2; diff --git a/opennn/cross_entropy_error.cpp b/opennn/cross_entropy_error.cpp index 797e4962a..23624a69d 100644 --- a/opennn/cross_entropy_error.cpp +++ b/opennn/cross_entropy_error.cpp @@ -82,13 +82,6 @@ void CrossEntropyError::calculate_multiple_error(const Batch& batch, // Back propagation - //const Index layers_number = back_propagation.neural_network.layers.size(); - - //ProbabilisticLayerBackPropagation* probabilistic_layer_back_propagation = - // static_cast(back_propagation.neural_network.layers[layers_number - 1].get()); - - //probabilistic_layer_back_propagation->targets = targets; - Tensor& error = back_propagation.error; error.device(*thread_pool_device) = (targets*outputs.log()).sum() / type(-batch_samples_number); diff --git a/opennn/neural_network.cpp b/opennn/neural_network.cpp index e4afafdf1..1accd9423 100644 --- a/opennn/neural_network.cpp +++ b/opennn/neural_network.cpp @@ -439,26 +439,26 @@ void NeuralNetwork::set_image_classification(const dimensions& input_dimensions, { const dimensions kernel_dimensions = { 3, 3, get_output_dimensions()[2], complexity_dimensions[i] }; const dimensions stride_dimensions = { 1, 1 }; - const ConvolutionalLayer::ConvolutionType convolution_type = ConvolutionalLayer::ConvolutionType::Valid; + const ConvolutionalLayer::ConvolutionType convolution_type = ConvolutionalLayer::ConvolutionType::Same; - //add_layer(make_unique(get_output_dimensions(), - // kernel_dimensions, - // ConvolutionalLayer::ActivationFunction::RectifiedLinear, - // stride_dimensions, - // convolution_type, - // "convolutional_layer_" + to_string(i+1))); + add_layer(make_unique(get_output_dimensions(), + kernel_dimensions, + ConvolutionalLayer::ActivationFunction::RectifiedLinear, + stride_dimensions, + convolution_type, + "convolutional_layer_" + to_string(i+1))); const dimensions pool_dimensions = { 2, 2 }; const dimensions pooling_stride_dimensions = { 2, 2 }; const dimensions padding_dimensions = { 0, 0 }; const PoolingLayer::PoolingMethod pooling_method = PoolingLayer::PoolingMethod::MaxPooling; - //add_layer(make_unique(get_output_dimensions(), - // pool_dimensions, - // pooling_stride_dimensions, - // padding_dimensions, - // pooling_method, - // "pooling_layer_" + to_string(i + 1))); + add_layer(make_unique(get_output_dimensions(), + pool_dimensions, + pooling_stride_dimensions, + padding_dimensions, + pooling_method, + "pooling_layer_" + to_string(i + 1))); } add_layer(make_unique(get_output_dimensions()));