Lightweight Neural Network++ documentation

Visit the lwnnplus home page, download the technical report in english or italian.

trainer.h

#ifndef TRAINER_H
#define TRAINER_H
/*
 * Lightweight Neural Net ++ - Trainer class
 * http://lwneuralnetplus.sourceforge.net/
 *
 * This C++ library provides the class trainer wich implements a 
 * the most used techniques for training a network
 *
 * By Lorenzo Masetti <lorenzo.masetti@libero.it> and Luca Cinti <lucacinti@supereva.it>
 *
 * 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 (at your option) any later version.
 * 
 */
#include <string>
#include <stdexcept>
#include <fstream>
using namespace std;

#include "network.h"
#include "iomanage.h"
#include "iomanagelwnnfann.h"

class trainer
{
public:
  /* Constructors */

  trainer (network * net, const string & error_filename =
           "", const string & accuracy_filename = "");

    trainer (int inputs, int outputs, int hidden,
             const string & error_filename =
             "", const string & accuracy_filename = "");

    trainer (const string & training_file, int hidden =
             0, const string & error_filename =
             "", const string & accuracy_filename = "",
             iomanage* iomanager = NULL);

    trainer (const trainer& t);


    virtual ~trainer ();

  /* Accessors and Mutators */


  int get_current_epoch();
  
  void start_at_epoch(int epoch);

  void clear();


  int get_max_epochs () const;

  void set_max_epochs (int nepochs);

  float get_min_error () const;

  void set_min_error (float error);

  bool set_wanted_accuracy( float accuracy);


  float get_wanted_accuracy();


  void set_error_filename (const string & filename);

  string get_error_filename() const;


  void set_accuracy_filename (const string & filename);

  string get_accuracy_filename() const;

  network *get_network () const;

  bool set_network (network * newnet);

  bool set_network_best();


  void set_training_validation (bool train_valid);

  bool get_training_validation () const;

  void set_epochs_checking_error (int epochs);

  int get_epochs_checking_error () const;


  int get_epochs_report () const;

  void  set_epochs_report (int e);

  void set_stop_on_overfit (bool stop, int batches_increasing =
                            0, float valid_higher = 0.0);

  bool get_stop_on_overfit () const;


  float get_best_error () const;

  int get_best_epoch () const;

  short int get_accuracy_mode () const;

  virtual void set_accuracy_mode (short int mode);

  /* Errors and accuracies Accessors */

  float get_accuracy_on_training () const;

  float get_accuracy_on_validation () const;

  float get_accuracy_on_certification () const;

  float get_error_on_training () const;


  float get_error_on_validation () const;


  float get_error_on_certification () const;

  int get_no_of_inputs () const;


  int get_no_of_outputs () const;

  short int get_stopping_cause() const;

  virtual string get_stopping_cause_string() const;


  /* Methods to load training, validation, certification set */

  void load_training (const string & filename);

  void load_validation (const string & filename);

  void load_certification (const string & filename);



  bool using_best_net () const;

  int train_online (bool verbose);


  int train_batch (bool verbose=false);


  int train_ssab (bool verbose=false, bool reset_ssab = false);

  int train_shuffle(bool verbose=false);

  int train (int mode=0, bool verbose=false);


  bool test ();

  bool validate ();

  bool certificate ();

  float show_results (bool verbose=false, int set = 1) const;

  void set_iomanager(iomanage* iomanager);
 
  iomanage* get_iomanager() const;

  const trainer& operator= (const trainer& other);

  static const short int NO_ACCURACY = 0;
  static const short int BINARY_ACCURACY = 1;

  static const short int MAXGUESS_ACCURACY = 2;

  static const short int STOPPING_UNDEFINED_CAUSE = 0;
  static const short int STOPPING_MAX_EPOCHS = 1;
  static const short int STOPPING_MIN_ERROR_REACHED_ON_TRAINING = 2;
  static const short int STOPPING_MIN_ERROR_REACHED_ON_BEST_ERROR = 3;
  static const short int STOPPING_OVERFIT = 4;
  static const short int STOPPING_MIN_ERROR_REACHED_ON_VALIDATION = 5;
  static const short int  STOPPING_WANTED_ACCURACY_REACHED = 6;
protected:
  virtual void print_input(float* input) const;

  virtual void print_output(float* output) const;

  virtual bool check (float *output, float *target) const;

  virtual bool continue_training (int start);

  /* These methods are declared protected because you might
   * need them in the implementation of continue_training()
   */ 

  void set_best_epoch(int epoch);
  

  void set_best_error_on_validation(float error);

  void set_stopping_cause(short int cause);

  network *get_best_net () const;


  void set_best_net(network* best);

private:
  /* Print accuracy on file */
  void print_accuracy () const;
  void set_defaults (bool construct_iomanager = true);
  void destroy (int n, float **input, float **output);
  void allocate_data (int npattern, float **&input, float **&target);
  void verbose_report ();

  float get_accuracy (int npatterns, float **input, float **target) const;
  float get_error (int npatterns, float **input, float **target) const;
  void compute_error_and_accuracy (float &error, float &accuracy,
                                   int npatterns, float **input,
                                   float **target);

  float compute_accuracy(int npatterns, float** input, float** target);

  void compute_accuracy_on_training();

  void reports (bool verbose);

  float show_on_set (bool verbose,int npatterns, float **input, float **target) const;

  static void print_vector(float* v, int n);
  void check_files();

  void copy_data(int n, float** input, float** target, float** srcinput, float** srctarget );
  void copy(const trainer& t);
  void free_trainer();
  
#ifdef DEBUG
  void print_input (float **, int np) const;
  void print_target (float **patt, int np) const;
#endif


  /* Input length */
  int ninput;
  /* Output length */
  int noutput;
  /* Number of trainig patterns */
  int npattern_training;
  /* Number of validation patterns */
  int npattern_validation;
  /* Number of certification patterns */
  int npattern_certification;

  /* current epoch */
  int epoch;
  
  /* computing error on validation set? */
  bool train_valid;
  /* each this number of epochs error is computed on validation set */
  int epochs_checking_error;

  /* epochs of report */
  int epochs_report;

  /* stop on overfit */
  bool stop_on_overfit;
  /* how much higher must be the error on validation set for stopping ? */
  float _higher_valid;
  short int accuracy_mode;

  /* Wanted accuracy on validation set. Training stops if this accuracy is reached */
  float wanted_accuracy;


  /* how many batches should pass with validation error increasing to
   * suppose overfitting?
   */
  int _batches_not_saving;
  /* epoch of the best net */
  int _best_epoch;
  
  /* stopping cause */
  short int stopping_cause;

  float error_on_training;
  float error_on_validation;
  float best_error_on_validation;
  float error_on_certification;
  float accuracy_on_training;
  float accuracy_on_validation;
  float accuracy_on_certification;

  /* Training set */
  float **training_set_input;
  float **training_set_target;
  /* Validation set */
  float **validation_set_input;
  float **validation_set_target;
  /* Certification set */
  float **certification_set_input;
  float **certification_set_target;
  /* Max number of epochs */
  int max_epochs;
  /* Min average error */
  float min_error;
  /* File used to store error trend */
  string error_filename;
  /* File used to store accuracy trend */
  string accuracy_filename;
  /* Neural network to train */
  network *net;

  /* Best Neural Network */
  network* best_net;

  /* Iomanager used to read patterns */
  iomanage* iomanager;
};

/****************************************
 * IMPLEMENTATION OF INLINE FUNCTIONS
 * ACCESSORS AND MUTATORS
 ****************************************/

inline float
trainer::get_min_error () const
{
  return min_error;
}


inline int
trainer::get_max_epochs () const
{
  return max_epochs;
}

inline network * trainer::get_network () const
{
  return net;
}

inline void
trainer::set_min_error (float error)
{
  min_error = error;
}

inline bool trainer::get_training_validation () const
{
  return train_valid;
}

inline bool trainer::using_best_net () const
{
  return (best_net != NULL);
}


inline float
trainer::get_best_error () const
{
  return best_error_on_validation;
}




inline bool trainer::get_stop_on_overfit () const
{
  return stop_on_overfit;
}

inline int
trainer::get_epochs_checking_error () const
{
  return epochs_checking_error;
}

inline
int trainer::get_epochs_report () const {
  return epochs_report;
}

inline int
trainer::get_best_epoch () const
{
  return _best_epoch;
}

inline short int
trainer::get_accuracy_mode () const
{
  return accuracy_mode;
}

inline float
trainer::get_error_on_training () const
{
  return error_on_training;
}

inline float
trainer::get_error_on_validation () const
{
  return error_on_validation;
}

inline float
trainer::get_error_on_certification () const
{
  return error_on_certification;
}

inline float
trainer::get_accuracy_on_training () const
{
  return accuracy_on_training;
}

inline float
trainer::get_accuracy_on_validation () const
{
  return accuracy_on_validation;
}

inline float
trainer::get_accuracy_on_certification () const
{
  return accuracy_on_certification;
}

inline
int trainer::get_no_of_inputs () const {
  return ninput;
}


inline
int trainer::get_no_of_outputs () const {
  return noutput;
}
  
inline
iomanage* trainer::get_iomanager() const {
  return iomanager;
}

inline
string trainer::get_error_filename() const {
  return error_filename;
}

inline
string trainer::get_accuracy_filename() const {
  return accuracy_filename;
}




inline
void trainer::set_best_epoch(int epoch) {
  _best_epoch = epoch;
}
  

inline
void trainer::set_best_error_on_validation(float error) {
  best_error_on_validation=error;
}

inline
int trainer::get_current_epoch() {
  return epoch;
}

inline
void trainer::start_at_epoch(int e) {
  epoch = e;
}

inline
short int trainer::get_stopping_cause() const {
  return stopping_cause;
}

inline
void trainer::set_stopping_cause(short int cause) {
  stopping_cause= cause;
}

inline
network* trainer::get_best_net() const {
  return best_net;
}

inline 
void trainer::set_best_net(network* best) {
  best_net = best;
}


inline
float trainer::get_wanted_accuracy() {
  return wanted_accuracy;
}

#endif

---