Robot Simulator of the Robotics Group for Self-Organization of Control: invertnchannelcontroller.h Source File

- Main Page
- Namespaces
- Classes
- Files
- Directories
- Related Pages
- Examples

- Search for |

- File List
- File Members

# invertnchannelcontroller.h

Go to the documentation of this file.

    00001 /***************************************************************************
    00002  *   Copyright (C) 2005 by Robot Group Leipzig                             *
    00003  *    martius@informatik.uni-leipzig.de                                    *
    00004  *    fhesse@informatik.uni-leipzig.de                                     *
    00005  *    der@informatik.uni-leipzig.de                                        *
    00006  *                                                                         *
    00007  *   ANY COMMERCIAL USE FORBIDDEN!                                         *
    00008  *   LICENSE:                                                              *
    00009  *   This work is licensed under the Creative Commons                      *
    00010  *   Attribution-NonCommercial-ShareAlike 2.5 License. To view a copy of   *
    00011  *   this license, visit http://creativecommons.org/licenses/by-nc-sa/2.5/ *
    00012  *   or send a letter to Creative Commons, 543 Howard Street, 5th Floor,   *
    00013  *   San Francisco, California, 94105, USA.                                *
    00014  *                                                                         *
    00015  *   This program is distributed in the hope that it will be useful,       *
    00016  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
    00017  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                  *
    00018  *                                            *
    00019  *                                                                         *
    00020  *   $Log: invertnchannelcontroller.h,v $
    00021  *   Revision 1.22  2009/10/23 12:39:03  martius
    00022  *   added description for inspectable elements
    00023  *
    00024  *   Revision 1.21  2008/05/30 11:58:27  martius
    00025  *   use cmath instead of math.h
    00026  *
    00027  *   Revision 1.20  2008/04/17 14:54:45  martius
    00028  *   randomGen added, which is a random generator with long period and an
    00029  *    internal state. Each Agent has an instance and passed it to the controller
    00030  *    and the wiring. This is good for
    00031  *   a) repeatability on agent basis,
    00032  *   b) parallel execution as done in ode_robots
    00033  *
    00034  *   Revision 1.19  2006/12/11 18:14:14  martius
    00035  *   delete for BNoise
    00036  *   delete of buffers
    00037  *
    00038  *   Revision 1.18  2006/08/02 09:31:34  martius
    00039  *   removed TODO
    00040  *
    00041  *   Revision 1.17  2006/07/20 17:14:35  martius
    00042  *   removed std namespace from matrix.h
    00043  *   storable interface
    00044  *   abstract model and invertablemodel as superclasses for networks
    00045  *
    00046  *   Revision 1.16  2006/07/14 12:23:58  martius
    00047  *   selforg becomes HEAD
    00048  *
    00049  *   Revision 1.14.6.4  2006/07/10 13:05:16  martius
    00050  *   NON-COMMERICAL LICENSE added to controllers
    00051  *
    00052  *   Revision 1.14.6.3  2006/07/10 11:59:24  martius
    00053  *   Matrixlib now in selforg
    00054  *   no namespace std in header files
    00055  *
    00056  *   Revision 1.14.6.2  2006/01/18 16:48:35  martius
    00057  *   stored and restore
    00058  *
    00059  *   Revision 1.14.6.1  2005/11/14 17:37:29  martius
    00060  *   moved to selforg
    00061  *
    00062  *   Revision 1.14  2005/10/27 15:46:38  martius
    00063  *   inspectable interface is expanded to structural information for network visualiser
    00064  *
    00065  *   Revision 1.13  2005/10/27 15:02:06  fhesse
    00066  *   commercial use added
    00067  *                                    *
    00068  *                                                                         *
    00069  ***************************************************************************/
    00070 #ifndef __INVERTNCHANNELCONTROLLER_H
    00071 #define __INVERTNCHANNELCONTROLLER_H
    00072
    00073 #include "invertcontroller.h"
    00074 #include "controller_misc.h"
    00075
    00076 #include <assert.h>
    00077 #include <cmath>
    00078
    00079 #include <selforg/matrix.h>
    00080
    00081 /**
    00082  * class for robot controller that uses the georg's matrixlib for
    00083  *  direct matrix inversion for n channels
    00084  * (simple one layer networks)
    00085  *
    00086  * Implements standart parameters: eps, rho, mu, stepnumber4avg, stepnumber4delay
    00087  */
    00088 class InvertNChannelController : public InvertController {
    00089
    00090 public:
    00091   InvertNChannelController(int _buffersize, bool _update_only_1=false);
    00092   virtual void init(int sensornumber, int motornumber, RandGen* randGen = 0);
    00093
    00094   virtual ~InvertNChannelController();
    00095
    00096   /// returns the name of the object (with version number)
    00097   virtual paramkey getName() const {return name; }
    00098   /// returns the number of sensors the controller was initialised with or 0 if not initialised
    00099   virtual int getSensorNumber() const { return number_channels; }
    00100   /// returns the mumber of motors the controller was initialised with or 0 if not initialised
    00101   virtual int getMotorNumber() const  { return number_channels; }
    00102
    00103   /// performs one step (includes learning).
    00104   /// Calulates motor commands from sensor inputs.
    00105   virtual void step(const sensor* , int number_sensors, motor* , int number_motors);
    00106
    00107
    00108   /// performs one step without learning. Calulates motor commands from sensor inputs.
    00109   virtual void stepNoLearning(const sensor* , int number_sensors,
    00110                               motor* , int number_motors);
    00111
    00112
    00113   /***** STOREABLE ****/
    00114   /** stores the controller values to a given file. */
    00115   virtual bool store(FILE* f) const;
    00116   /** loads the controller values from a given file. */
    00117   virtual bool restore(FILE* f);
    00118
    00119   // inspectable interface
    00120   virtual std::list<ILayer> getStructuralLayers() const;
    00121   virtual std::list<IConnection> getStructuralConnections() const;
    00122
    00123
    00124 protected:
    00125   unsigned short number_channels;
    00126   unsigned short buffersize;
    00127   bool update_only_1;
    00128
    00129   matrix::Matrix A; // Model Matrix
    00130   matrix::Matrix C; // Controller Matrix
    00131   matrix::Matrix h; // Controller Bias
    00132   matrix::Matrix L; // Jacobi Matrix
    00133   matrix::Matrix* x_buffer;
    00134   matrix::Matrix* y_buffer;
    00135   int t;
    00136   paramkey name;
    00137
    00138
    00139 /*   virtual void iteration(double *column, */
    00140 /*                       double dommy[NUMBER_CHANNELS][NUMBER_CHANNELS], */
    00141 /*                       double *improvment); */
    00142
    00143   virtual double calculateE(const matrix::Matrix& x_delay, const matrix::Matrix& y_delay);
    00144
    00145   /// learn values h,C
    00146   virtual void learn(const matrix::Matrix& x_delay, const matrix::Matrix& y_delay);
    00147
    00148   virtual void learnmodel( const matrix::Matrix& y_delay);
    00149
    00150   /// calculate delayed values
    00151   virtual matrix::Matrix calculateDelayedValues(const matrix::Matrix* buffer,
    00152                                         unsigned int number_steps_of_delay_);
    00153   virtual matrix::Matrix calculateSmoothValues(const matrix::Matrix* buffer,
    00154                                        unsigned int number_steps_for_averaging_);
    00155
    00156   matrix::Matrix calculateControllerValues(const matrix::Matrix& x_smooth);
    00157
    00158   // put new value in ring buffer
    00159   void putInBuffer(matrix::Matrix* buffer, const matrix::Matrix& vec);
    00160
    00161   /// neuron transfer function
    00162   static double g(double z)
    00163   {
    00164     return tanh(z);
    00165   };
    00166
    00167   ///
    00168   static double g_s(double z)
    00169   {
    00170     double k=tanh(z);
    00171     return 1.0 - k*k;
    00172     //    return 1.0 - tanh(z)*tanh(z);
    00173   };
    00174
    00175
    00176
    00177   /// squashing function, to protect against to large weight updates
    00178   static double squash(double z)
    00179   {
    00180     return clip(z,-0.1,0.1);
    00181     //    return z < -0.1 ? -0.1 : ( z > 0.1 ? 0.1 : z );
    00182     //return 0.1 * tanh(10.0 * z);
    00183   };
    00184 };
    00185
    00186 #endif
    00187
    00188