model_selection.h

/****************************************************************************************************************/
/*                                                                                                              */
/*   OpenNN: Open Neural Networks Library                                                                       */
/*   www.artelnics.com/opennn                                                                                   */
/*                                                                                                              */
/*   M O D E L   S E L E C T I O N   C L A S S   H E A D E R                                                    */
/*                                                                                                              */
/*   Roberto Lopez                                                                                              */ 
/*   Artelnics - Making intelligent use of data                                                                 */
/*   [email protected]                                                                                 */
/*                                                                                                              */
/****************************************************************************************************************/

#ifndef __MODELSELECTION_H__
#define __MODELSELECTION_H__

// System includes

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <cmath>
#include <ctime>

// OpenNN includes

#include "vector.h"
#include "matrix.h"

#include "performance_functional.h"

#include "training_strategy.h"

// TinyXml includes

#include "../tinyxml2/tinyxml2.h"

namespace OpenNN
{


class ModelSelection
{

public:  

   // DEFAULT CONSTRUCTOR

   explicit ModelSelection(void);

   // TRAINING STRATEGY CONSTRUCTOR

   explicit ModelSelection(TrainingStrategy*);

   // FILE CONSTRUCTOR

   explicit ModelSelection(const std::string&);

   // XML CONSTRUCTOR

   explicit ModelSelection(const tinyxml2::XMLDocument&);


   // DESTRUCTOR

   virtual ~ModelSelection(void);


    // ENUMERATIONS


    enum InputsSelectionMethod{MaximumLinearCorrelation, MaximumLogisticCorrelation, Exhaustive};


   // STRUCTURES


   struct ModelSelectionResults
   {

      Matrix< Vector<double> > parameters_data;


      Matrix<double> performance_data;


      Matrix<double> generalization_performance_data;


      Vector<double> minimal_parameters;


      Vector< Vector<double> > performance_data_statistics;


      Vector< Vector<double> > generalization_performance_data_statistics; 
   };

   // METHODS

   // Get methods

   TrainingStrategy* get_training_strategy_pointer(void) const;

   const Vector<size_t>& get_hidden_perceptrons_numbers(void) const;
   const size_t& get_parameters_assays_number(void) const;

   const bool& get_reserve_parameters_data(void) const;
   const bool& get_reserve_performance_data(void) const;
   const bool& get_reserve_generalization_performance_data(void) const;
   const bool& get_reserve_minimal_parameters(void) const;
   const bool& get_reserve_performance_data_statistics(void) const;
   const bool& get_reserve_generalization_performance_data_statistics(void) const;
   const bool& get_reserve_model_order_selection_plot(void) const;

   const InputsSelectionMethod& get_inputs_selection_method(void) const;

   const bool& get_display(void) const;

   // Set methods

   void set_training_strategy_pointer(TrainingStrategy*);

   void set_default(void);

   void set_hidden_perceptrons_numbers(const Vector<size_t>&);
   void set_parameters_assays_number(const size_t&);

   void set_assays_numbers(const size_t&, const size_t&);

   void set_reserve_parameters_data(const bool&);
   void set_reserve_performance_data(const bool&);
   void set_reserve_generalization_performance_data(const bool&);
   void set_reserve_minimal_parameters(const bool&);
   void set_reserve_performance_data_statistics(const bool&);
   void set_reserve_generalization_performance_data_statistics(const bool&);
   void set_reserve_model_order_selection_plot(const bool&);

   void set_inputs_selection_method(const InputsSelectionMethod&);

   void set_display(const bool&);

   // Correlation methods

   Matrix<double> calculate_linear_correlations(void) const;
   Matrix<double> calculate_logistic_correlations(void) const;

   // Model order selection methods

   void check(void) const;

   void perform_maximum_linear_correlation_inputs_selection(void) const;
   void perform_maximum_logistic_correlation_inputs_selection(void) const;
   void perform_exhaustive_inputs_selection(void) const;

   void perform_inputs_selection(void) const;

   ModelSelectionResults perform_order_selection(void) const;

   ModelSelectionResults perform_model_selection(void) const;

   // Serialization methods

   tinyxml2::XMLDocument* to_XML(void) const;
   void from_XML(const tinyxml2::XMLDocument&);

   void print(void) const;
   void save(const std::string&) const;
   void load(const std::string&);

private: 

   // MEMBERS


   TrainingStrategy* training_strategy_pointer;


   Vector< Vector<size_t> > inputs_indices;


   Vector<size_t> hidden_perceptrons_numbers;


   size_t parameters_assays_number;

   // Model selection results


   bool reserve_parameters_data;


   bool reserve_performance_data;


   bool reserve_generalization_performance_data;


   bool reserve_minimal_parameters;


   bool reserve_performance_data_statistics;


   bool reserve_generalization_performance_data_statistics;


   bool reserve_model_order_selection_plot;


   double correlation_goal;


   InputsSelectionMethod inputs_selection_method;

   
   bool display;
};

}

#endif

// OpenNN: Open Neural Networks Library.
// Copyright (c) 2005-2015 Roberto Lopez.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA