neuron_selection.h

Go to the documentation of this file.

//   OpenNN: Open Neural Networks Library
//   www.opennn.net
//
//   N E U R O N   S E L E C T I O N   C L A S S   H E A D E R
//
//   Artificial Intelligence Techniques SL
//   artelnics@artelnics.com

 
#pragma once
 
namespace opennn
{
 
class TrainingStrategy;
struct TrainingResults;
struct NeuronsSelectionResults;

class NeuronSelection
{
public:

    enum class StoppingCondition {
        MaximumTime,                
        SelectionErrorGoal,         
        MaximumEpochs,              
        MaximumSelectionFailures,   
        MaximumNeurons              
    };

    NeuronSelection(TrainingStrategy* training_strategy = nullptr);
    virtual ~NeuronSelection() = default;

    const TrainingStrategy* get_training_strategy() const { return training_strategy; }

    bool has_training_strategy() const { return training_strategy; }

    bool get_display() const { return display; }

    void set(TrainingStrategy*);

    void set_training_strategy(TrainingStrategy* new_training_strategy) { training_strategy = new_training_strategy; }

    void set_default();

    void set_maximum_neurons(const Index new_maximum_neurons) { maximum_neurons = new_maximum_neurons; }
    void set_minimum_neurons(const Index new_minimum_neurons) { minimum_neurons = new_minimum_neurons; }
    void set_trials_number(const Index new_trials_number) { trials_number = new_trials_number; }

    void set_display(bool new_display) { display = new_display; }

    void set_validation_error_goal(const float new_validation_error_goal) { validation_error_goal = new_validation_error_goal; }
    void set_maximum_epochs(const Index new_maximum_epochs) { maximum_epochs = new_maximum_epochs; }
    void set_maximum_validation_failures(const Index new_maximum_validation_failures) { maximum_validation_failures = new_maximum_validation_failures; }
    void set_maximum_time(const float new_maximum_time) { maximum_time = new_maximum_time; }

void check() const;

    virtual NeuronsSelectionResults perform_neurons_selection() = 0;

    string get_name() const
    {
        return name;
    }

    virtual void from_JSON(const JsonDocument&) = 0;

    virtual void to_JSON(JsonWriter&) const = 0;

    void save(const filesystem::path&) const;
    void load(const filesystem::path&);

    virtual void print() const {}
 
protected:

    TrainingStrategy* training_strategy = nullptr;

    VectorR validation_error_history;

    VectorR training_error_history;

    Index minimum_neurons = 0;

    Index maximum_neurons = 0;

    Index trials_number = 1;

    float validation_error_goal = 0;

    Index maximum_epochs = 10;

    Index maximum_validation_failures = 100;

    float maximum_time = 0;

    bool display = true;

    string name;
};

struct NeuronsSelectionResults
{
   NeuronsSelectionResults(const Index maximum_epochs = 0);

   void resize_history(const Index new_size);

   string write_stopping_condition() const;

   void print() const;

   VectorI neurons_number_history;

   Index optimal_neurons_number = 1;

   VectorR optimal_parameters;

   VectorR training_error_history;

   VectorR validation_error_history;

   float optimum_training_error = 10.0f;

   float optimum_validation_error = 10.0f;

   NeuronSelection::StoppingCondition stopping_condition = NeuronSelection::StoppingCondition::MaximumTime;

   string elapsed_time;
};
 
}
 
// OpenNN: Open Neural Networks Library.
// Copyright(C) 2005-2026 Artificial Intelligence Techniques, SL.
// Licensed under the GNU Lesser General Public License v2.1 or later.