Lightweight Neural Network++ documentation

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

network.h

#ifndef NETWORK_H
#define NETWORK_H
/*
 * Lightweight Neural Net ++ 
 * http://lwneuralnetplus.sourceforge.net/
 *
 * This C++ library provides the class network wich implements a 
 * feed forward neural network with backpropagation,
 * You can use logistic or tanh as sigmoidal function
 * Library provides on line training, momentum, 
 * batch training and superSAB training.
 *
 * By Lorenzo Masetti <lorenzo.masetti@libero.it> and Luca Cinti <lucacinti@supereva.it>
 * Based on lwneuralnet C library by Peter Van Rossum <petervr@debian.org>, Luca Cinti and Lorenzo Masetti 
 * http://lwneuralnet.sourceforge.net
 *
 *
 * 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.
 * 
 */
#define NET_LOGISTIC 0
#define NET_TANH 1


#include <stdio.h>
#include <stdexcept>
#include <iostream>
#include <vector>
using namespace std;

class network
{

public:

  static const int LOGISTIC = NET_LOGISTIC;
  static const int TANH = NET_TANH;


    network (int activ, int no_of_layers, ...);


    network (int activ, vector<int> layers);


    network (const char *filename, bool binary = true);

    network (const network & b);

   ~network ();

  void randomize (float range);

  /****************************************
   * Accessors
   ****************************************/

  float get_momentum () const;

  float get_learning_rate () const;


  int get_no_of_inputs () const;


  int get_no_of_outputs () const;


  int get_no_of_layers () const;

  int get_no_of_neurons (int l) const;


  float get_weight (int l, int nl, int nu) const;


  int get_no_of_patterns () const;


  int get_activation () const;


  float get_output_error () const;

  /* Accessors for parameters of SuperSab */

  float get_max_learning_rate ();

  float get_min_learning_rate ();

  float get_ssab_up_factor ();

  float get_ssab_down_factor ();


  /****************************************
   * Mutators
   ****************************************/

  void set_learning_rate (float learning_rate);


  void set_activation (int num_func);


  void set_momentum (float momentum);

  /* Mutators for parameter of SuperSab training */


  void set_max_learning_rate (float max);
  

  void set_min_learning_rate (float min);

  void set_ssab_up_factor (float factor);

  void set_ssab_down_factor (float factor);



  /****************************************
   * File I/O for binary files
   ****************************************/


  void save (const char *filename) const;


  void load (const char *filename);

  /****************************************
   * Friendly printing
   ****************************************/

  void friendly_print (const bool show = false) const;

  /****************************************
   * File I/O for Text Files
   ****************************************/

  /* Please note that Text File format is provided for compatibility
   * with old lwneuralnet format but it should not be used.
   * Howewer textual format could be used
   * for portability between machines that use different binary encoding for
   * floating point numbers 
   *
   * NOTE FOR LWNEURALNET USERS:
   *
   * Text files containing networks created by lwneuralnet might have a 
   * different format, which does not have the number of sigmoidal function
   * as first information. But, since in old versions logistic function was 
   * the only one provided, you can convert those files by the command 
   * echo 0 > newfile.net; cat oldfile.net >> newfile.net
   *
   * 
   * Starting from version 0.88 textload method provides a solution to this
   * problem:
   * if the first number in text file is >= 2 it is interpreted as the number
   * of layers and the function is set to logistic.
   */

  void print () const;



  void textsave (const char *filename) const;


  void textload (const char *filename);


  /****************************************
   * Errors
   *
   * Before calling these routines, compute() should have been called to
   * compute the ouputs for a given input. This routine compares the
   * actual output of the neural network (which is stored internally in
   * the neural network) and the intended output (in target).
   *
   ****************************************/

  float compute_output_error (const float *target);


  float compute_average_error (const float *target) const;


  float compute_quadratic_error (const float *target) const;


  float compute_max_error (const float *target) const;


  /****************************************
   * Evaluation and Training
   ****************************************/

  void compute (const float *input, float *output);

  void train ();


  /****************************************
   * SuperSab
   ****************************************/


  bool is_ssab_active () const;

  int count_weights () const;

  int begin_ssab ();

  void train_ssab ();

  int reset_ssab ();


  void free_ssab ();


  bool save_ssab (const char *filename) const;


  bool load_ssab (const char *filename);


  int ssab_print_nus () const;


  int ssab_stats(float& average, float &max, float &min, int &n_max, int &n_min);

  /****************************************
   * Batch Training
   ****************************************/


  void begin_batch ();

  void train_batch ();


  void end_batch ();


  void end_batch_ssab ();

  /****************************************
   * Modification
   ****************************************/

  void jolt (float factor, float range);

  /****************************************
   * Overloaded operators
   ****************************************/

  const network & operator= (const network & b);


  /* PRIVATE */

private:
  /* [Internal]
   * Structs for neurons and layers 
   */

  typedef struct
  {
    float output;
    float error;
    float *weight;
    float *delta;
    float *sumdeltas;
  }
  neuron_t;

  typedef struct
  {
    int no_of_neurons;
    neuron_t *neuron;
  }
  layer_t;


  void reset_deltas ();
  void reset_sumdeltas ();
  void reset_deltas_and_sumdeltas ();

  void allocate_layer (layer_t * layer, int no_of_neurons);

  void allocate_weights (layer_t * lower, layer_t * upper);
  void allocate_l (int act, int layers, const int *arglist);

  void fbprint (FILE * file) const;
  void fbscan (FILE * file);

  void do_load (const char *filename);
  void do_textload (const char *filename);

  void fprint (FILE * file) const;

  void fscan (FILE * file);

  void set_input (const float *input);

  void get_output (float *output);

  static float sigmoidal (float x, int num_func);
  void propagate_layer (layer_t * lower, layer_t * upper);
  void forward_pass ();
  void backpropagate_layer (layer_t * lower, layer_t * upper);

  void backward_pass ();
  void adjust_weights ();

  void adjust_weights_ssab ();

  int fprint_ssab (FILE * file) const;

  int fscan_ssab (FILE * file);


  void adjust_sumdeltas_batch ();

  void adjust_weights_batch ();

  void adjust_weights_batch_ssab ();
  void copy (const network & b);
  void destroy ();


  int no_of_layers;
  float momentum;
  float learning_rate;
  float global_error;
  int no_of_patterns;
  layer_t *layer;
  layer_t *input_layer;
  layer_t *output_layer;
  int activation;
  float *nus;

  float maxnu;
  float minnu;
  float nuup;
  float nudown;

  /* operator<< is declared friend because it needs to access private fields */
  friend ostream & operator<< (ostream &, const network &);

};

ostream & operator<< (ostream & os, const network & net);


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


/****************************************
 * Accessors
 ****************************************/

inline float
network::get_momentum () const
{
  return momentum;
}

inline float
network::get_learning_rate () const
{
  return learning_rate;
}

inline int
network::get_no_of_inputs () const
{
  return input_layer->no_of_neurons;
}

inline int
network::get_no_of_outputs () const
{
  return output_layer->no_of_neurons;
}

inline int
network::get_no_of_layers () const
{
  return no_of_layers;
}

inline int
network::get_no_of_patterns () const
{
  return no_of_patterns;
}


inline int
network::get_activation () const
{
  return activation;
}

inline float
network::get_output_error () const
{
  return global_error;
}

inline bool 
network::is_ssab_active () const
{
  return (nus != NULL);
}



inline float
network::get_max_learning_rate ()
{
  return maxnu;
}

inline float
network::get_min_learning_rate ()
{
  return minnu;
}



inline float
network::get_ssab_up_factor ()
{
  return nuup;
}

inline float
network::get_ssab_down_factor ()
{
  return nudown;
}


/****************************************
 * Mutators
 ****************************************/

inline void
network::set_learning_rate (float the_learning_rate)
{
  learning_rate = the_learning_rate;
}


inline void
network::set_momentum (float the_momentum)
{
  momentum = the_momentum;
}


inline void
network::set_ssab_up_factor (float factor)
{
  nuup = factor;
}

inline void
network::set_ssab_down_factor (float factor)
{
  nudown = factor;
}

#endif /* NETWORK_H */

---