multilayerffnn.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Robot Group Leipzig                             *
 *    martius@informatik.uni-leipzig.de                                    *
 *    fhesse@informatik.uni-leipzig.de                                     *
 *    der@informatik.uni-leipzig.de                                        *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************
 *                                                                         *
 *  DESCRIPTION                                                            *
 *                                                                         *
 *   $Log: multilayerffnn.h,v $
 *   Revision 1.8  2006/12/21 11:44:17  martius
 *   commenting style for doxygen //< -> ///<
 *   FOREACH and FOREACHC are macros for collection iteration
 *
 *   Revision 1.7  2006/11/23 08:43:46  martius
 *   bugfix in store and restore
 *
 *   Revision 1.6  2006/07/27 15:22:18  martius
 *   activations stored (processing must preceed learning and reponse calculation)
 *
 *
 *                                                                 *
 ***************************************************************************/
#ifndef __MULTILAYERFFNN_H
#define __MULTILAYERFFNN_H

#include <vector>

#include "feedforwardnn.h"
#include "invertablemodel.h"

class Layer : public Storeable {
public:
  Layer(int size, double factor_bias=0.1, 
        ActivationFunction actfun = FeedForwardNN::linear, 
        ActivationFunction dactfun = FeedForwardNN::dlinear)
    : size(size), factor_bias(factor_bias), actfun(actfun), dactfun(dactfun) {}

  /***STOREABLE ******/
  /// stores the layer binary into file stream
  bool store(FILE* f) const;
  /// restores the layer binary from file stream
  bool restore(FILE* f);

  int size;
  double factor_bias;
  ActivationFunction actfun;  ///< callback activation function
  ActivationFunction dactfun; ///< first derivative of the activation function  

  // prints the Layer data-structure
  friend std::ostream& operator<<(std::ostream& , const Layer&);
};

/// multi layer neural network with configurable activation functions
class MultiLayerFFNN : public FeedForwardNN, public InvertableModel {
public: 
  /**
     @param eps learning rate
     @param layers Layer description (the input layer is not specified (always linear))
  */
  MultiLayerFFNN(double eps, const std::vector<Layer>& layers)
    : eps(eps), layers(layers) { 
    
    initialised = false;  
  }
  virtual ~MultiLayerFFNN(){ }

  /// initialisation of the network with the given number of input and output units
  virtual void init(unsigned int inputDim, unsigned  int outputDim, double unit_map = 0.0); 

  /// passive processing of the input
  virtual const matrix::Matrix process (const matrix::Matrix& input); 

  /** performs learning and returns the network output before learning 
      (process should be called before) */
  virtual const matrix::Matrix learn (const matrix::Matrix& input, 
                                      const matrix::Matrix& nom_output, 
                                      double learnRateFactor = 1);

  /** \see InvertableModel::response
      (process should be called before)
   */
  virtual const matrix::Matrix response(const matrix::Matrix& input) const;

  /// returns the number of input neurons
  virtual unsigned int getInputDim() const { 
    return weights[0].getN(); 
  }
  /// returns the number of output neurons
  virtual unsigned int getOutputDim() const { 
    return (weights.rbegin())->getM(); 
  }

  /// damps the weights and the biases by multiplying (1-damping)
  virtual void damp(double damping);

  
  /**************  STOREABLE **********************************/
  /// stores the layer binary into file stream
  bool store(FILE* f) const;
  /// restores the layer binary from file stream
  bool restore(FILE* f);


  /************** CONFIGURABLE INTERFACE ************************/
  virtual paramkey getName() const {
    return std::string("multilayerffnn");
  }

  virtual paramval getParam(const paramkey& key) const {
    if(key == "epsM") return eps;
    else return 0.0;
  }
  
  virtual bool setParam(const paramkey& key, paramval val){
    if( key == "epsM") { 
      eps = val;
      return true;
    } else return false;
  }

  virtual paramlist getParamList() const{
    paramlist l;
    l.push_back(std::pair<paramkey, paramval> ("epsM", eps));
    return l;
  }

  virtual const Layer& getLayer(unsigned int layer) const {
    assert(layer < layers.size());
    return layers[layer];
  }

  virtual const matrix::Matrix& getWeights(unsigned int to_layer) const {
    assert(to_layer < weights.size());
    return weights[to_layer];
  }

  virtual const matrix::Matrix& getBias(unsigned int of_layer) const {
    assert(of_layer < bias.size());
    return bias[of_layer];
  }

protected:
  double eps;
  std::vector<Layer> layers;
  std::vector<matrix::Matrix> weights;
  std::vector<matrix::Matrix> bias;

  std::vector<matrix::Matrix> ys; // activations
  std::vector<matrix::Matrix> zs; // potentials

  bool initialised;
};

#endif

---