training_strategy.h

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

#ifndef __TRAININGSTRATEGY_H__
#define __TRAININGSTRATEGY_H__

// System includes

#include <iostream>
#include <fstream>
#include <algorithm>
#include <functional>
#include <limits>
#include <cmath>
#include <ctime>

// OpenNN includes

#include "performance_functional.h"

#include "training_algorithm.h"

#include "random_search.h"
#include "evolutionary_algorithm.h"

#include "gradient_descent.h"
#include "conjugate_gradient.h"
#include "quasi_newton_method.h"
#include "levenberg_marquardt_algorithm.h"

#include "newton_method.h"

// TinyXml includes

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

namespace OpenNN
{

   
class TrainingStrategy
{

public:

   // DEFAULT CONSTRUCTOR

   explicit TrainingStrategy(void);

   // GENERAL CONSTRUCTOR

   explicit TrainingStrategy(PerformanceFunctional*);

   // XML CONSTRUCTOR

   explicit TrainingStrategy(const tinyxml2::XMLDocument&);

   // FILE CONSTRUCTOR

   explicit TrainingStrategy(const std::string&);

   // DESTRUCTOR

   virtual ~TrainingStrategy(void);

   // ENUMERATIONS


    enum InitializationType
    {
       NO_INITIALIZATION,
       RANDOM_SEARCH,
       EVOLUTIONARY_ALGORITHM,
       USER_INITIALIZATION
    };


    enum MainType
    {
       NO_MAIN,
       GRADIENT_DESCENT,
       CONJUGATE_GRADIENT,
       QUASI_NEWTON_METHOD,
       LEVENBERG_MARQUARDT_ALGORITHM,
       USER_MAIN
    };


    enum RefinementType
    {
       NO_REFINEMENT,
       NEWTON_METHOD,
       USER_REFINEMENT
    };


   // STRUCTURES 


   struct Results
   {

        explicit Results(void);


        virtual ~Results(void);

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


        RandomSearch::RandomSearchResults* random_search_results_pointer;


        EvolutionaryAlgorithm::EvolutionaryAlgorithmResults* evolutionary_algorithm_results_pointer;


        GradientDescent::GradientDescentResults* gradient_descent_results_pointer;


        ConjugateGradient::ConjugateGradientResults* conjugate_gradient_results_pointer;


        QuasiNewtonMethod::QuasiNewtonMethodResults* quasi_Newton_method_results_pointer;


        LevenbergMarquardtAlgorithm::LevenbergMarquardtAlgorithmResults* Levenberg_Marquardt_algorithm_results_pointer;


        NewtonMethod::NewtonMethodResults* Newton_method_results_pointer;

  };

   // METHODS

   // Checking methods

   void check_performance_functional(void) const;
   void check_training_algorithms(void) const;

   // Initialization methods

   void initialize_random(void);

   // Get methods

   PerformanceFunctional* get_performance_functional_pointer(void) const;

   bool has_performance_functional(void) const;

   RandomSearch* get_random_search_pointer(void) const;
   EvolutionaryAlgorithm* get_evolutionary_algorithm_pointer(void) const;

   GradientDescent* get_gradient_descent_pointer(void) const;
   ConjugateGradient* get_conjugate_gradient_pointer(void) const;
   QuasiNewtonMethod* get_quasi_Newton_method_pointer(void) const;
   LevenbergMarquardtAlgorithm* get_Levenberg_Marquardt_algorithm_pointer(void) const;

   NewtonMethod* get_Newton_method_pointer(void) const;

   const InitializationType& get_initialization_type(void) const;
   const MainType& get_main_type(void) const;
   const RefinementType& get_refinement_type(void) const;

   std::string write_initialization_type(void) const;
   std::string write_main_type(void) const;
   std::string write_refinement_type(void) const;

   std::string write_initialization_type_text(void) const;
   std::string write_main_type_text(void) const;
   std::string write_refinement_type_text(void) const;

   const bool& get_display(void) const;

   // Set methods

   void set(void);
   void set(PerformanceFunctional*);
   virtual void set_default(void);

   void set_performance_functional_pointer(PerformanceFunctional*);

   void set_initialization_type(const InitializationType&);
   void set_main_type(const MainType&);
   void set_refinement_type(const RefinementType&);

   void set_initialization_type(const std::string&);
   void set_main_type(const std::string&);
   void set_refinement_type(const std::string&);

   void set_display(const bool&);

   // Pointer methods

   void destruct_initialization(void);
   void destruct_main(void);
   void destruct_refinement(void);

   // Training methods

   // This method trains a neural network which has a performance functional associated. 

   Results perform_training(void);

   // Serialization methods

   std::string to_string(void) const;

   void print(void) const;

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

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

protected:


   PerformanceFunctional* performance_functional_pointer;


    RandomSearch* random_search_pointer;


    EvolutionaryAlgorithm* evolutionary_algorithm_pointer;


    GradientDescent* gradient_descent_pointer;


    ConjugateGradient* conjugate_gradient_pointer;


    QuasiNewtonMethod* quasi_Newton_method_pointer;


    LevenbergMarquardtAlgorithm* Levenberg_Marquardt_algorithm_pointer;


    NewtonMethod* Newton_method_pointer;


   InitializationType initialization_type;


   MainType main_type;


   RefinementType refinement_type;


   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