abstractmodel.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2011 LpzRobots development team                    *
 *    Georg Martius  <georg dot martius at web dot de>                     *
 *    Frank Guettler <guettler at informatik dot uni-leipzig dot de        *
 *    Frank Hesse    <frank at nld dot ds dot mpg dot de>                  *
 *    Ralf Der       <ralfder at mis dot mpg dot 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.             *
 *                                                                         *
 ***************************************************************************/
#ifndef __ABSTRACTMODEL_H
#define __ABSTRACTMODEL_H

#include "matrix.h"
#include "configurable.h"
#include "storeable.h"
#include "inspectable.h"
#include "randomgenerator.h"

/// abstract class (interface) for a model that can be used by a controller
class AbstractModel : public Configurable, public Storeable, public Inspectable {
 public:
  // 20110317, guettler: disabled default constructor since it is not needed and would cause difficulties
  //AbstractModel() {};
  AbstractModel(const std::string& name, const std::string& revision)
    : Configurable(name, revision), Inspectable(name) {}
  virtual ~AbstractModel(){};

  /** initialisation of the network with the given number of input and output units
      @param inputDim length of input vector
      @param outputDim length of output vector
      @param unit_map if 0 the parametes are choosen randomly. 
             Otherwise the model is initialised to represent a unit_map 
             with the given response strength.
      @param randGen pointer to random generator, if 0 an new one is used
   */
  virtual void init(unsigned int inputDim, unsigned  int outputDim, 
                    double unit_map = 0.0, RandGen* randGen = 0) = 0;

  /** passive processing of the input
     (this function is not constant since a recurrent network 
     for example might change internal states
  */
  virtual const matrix::Matrix process (const matrix::Matrix& input) = 0;

  /* performs learning and returns the network output before learning.
     Neural networks process the input before. (no need to call process before)
     \param learnRateFactor can be given to modify eps for this learning step.
  */
  virtual const matrix::Matrix learn (const matrix::Matrix& input, 
                                      const matrix::Matrix& nom_output, 
                                      double learnRateFactor = 1) = 0;

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

  /// returns the number of input neurons
  virtual unsigned int getInputDim() const = 0;
  /// returns the number of output neurons
  virtual unsigned int getOutputDim() const = 0;

};


#endif