esn.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef AURESERVOIR_ESN_H__
#define AURESERVOIR_ESN_H__

#include <iostream>
#include <map>
#include <algorithm>

#include "utilities.h"
#include "activations.h"
#include "init.h"
#include "simulate.h"
#include "train.h"

namespace aureservoir
{

template <typename T = float>
class ESN
{
 public:

  typedef std::map<InitParameter,T> ParameterMap;

  typedef typename SPMatrix<T>::Type SPMatrix;
  typedef typename DEMatrix<T>::Type DEMatrix;
  typedef typename DEVector<T>::Type DEVector;

  ESN();

  ESN(const ESN<T> &src);

  const ESN& operator= (const ESN<T>& src);

  ~ESN();



  void init()
    throw(AUExcept)
  { init_->init(); }

  double adapt(const DEMatrix &in)
    throw(AUExcept);

  inline void train(const DEMatrix &in, const DEMatrix &out, int washout)
    throw(AUExcept)
  { train_->train(in, out, washout); }

  inline void simulate(const DEMatrix &in, DEMatrix &out)
  { sim_->simulate(in, out); }

  void resetState()
  {
    std::fill_n( x_.data(), x_.length(), 0 );
    std::fill_n( sim_->last_out_.data(), outputs_, 0 );
  }




  double adapt(T *inmtx, int inrows, int incols) throw(AUExcept);

  inline void train(T *inmtx, int inrows, int incols,
                    T *outmtx, int outrows, int outcols,
                    int washout) throw(AUExcept);

  inline void simulate(T *inmtx, int inrows, int incols,
                       T *outmtx, int outrows, int outcols) throw(AUExcept);

  inline void simulateStep(T *invec, int insize, T *outvec, int outsize)
    throw(AUExcept);





  void setBPCutoff(const DEVector &f1, const DEVector &f2) throw(AUExcept);

  void setBPCutoff(T *f1vec, int f1size, T *f2vec, int f2size)
    throw(AUExcept);

  void setIIRCoeff(const DEMatrix &B, const DEMatrix &A, int series=1)  
    throw(AUExcept);

  void setIIRCoeff(T *bmtx, int brows, int bcols,
                   T *amtx, int arows, int acols,
                   int series=1) throw(AUExcept);




  void post();

  int getSize() const { return neurons_; };
  int getInputs() const { return inputs_; };
  int getOutputs() const { return outputs_; };
  double getNoise() const { return noise_; }

  T getInitParam(InitParameter key) { return init_params_[key]; }

  InitAlgorithm getInitAlgorithm() const
  { return static_cast<InitAlgorithm>(net_info_.at(INIT_ALG)); }
  TrainAlgorithm getTrainAlgorithm() const
  { return static_cast<TrainAlgorithm>(net_info_.at(TRAIN_ALG)); }
  SimAlgorithm getSimAlgorithm() const
  { return static_cast<SimAlgorithm>(net_info_.at(SIMULATE_ALG)); }

  ActivationFunction getReservoirAct() const
  { return static_cast<ActivationFunction>(net_info_.at(RESERVOIR_ACT)); }
  ActivationFunction getOutputAct() const
  { return static_cast<ActivationFunction>(net_info_.at(OUTPUT_ACT)); }




  const DEMatrix &getWin() { return Win_; }
  const SPMatrix &getW() { return W_; }
  const DEMatrix &getWback() { return Wback_; }
  const DEMatrix &getWout() { return Wout_; }
  const DEVector &getX() { return x_; }
  DEMatrix getDelays() throw(AUExcept) { return sim_->getDelays(); }




  void getWin(T **mtx, int *rows, int *cols);
  void getWback(T **mtx, int *rows, int *cols);
  void getWout(T **mtx, int *rows, int *cols);
  void getX(T **vec, int *length);
  void getW(T *wmtx, int wrows, int wcols) throw(AUExcept);
  void getDelays(T *wmtx, int wrows, int wcols) throw(AUExcept);




  void setInitAlgorithm(InitAlgorithm alg=INIT_STD)
    throw(AUExcept);
  void setTrainAlgorithm(TrainAlgorithm alg=TRAIN_PI)
    throw(AUExcept);
  void setSimAlgorithm(SimAlgorithm alg=SIM_STD)
    throw(AUExcept);

  void setSize(int neurons=10) throw(AUExcept);
  void setInputs(int inputs=1) throw(AUExcept);
  void setOutputs(int outputs=1) throw(AUExcept);

  void setNoise(double noise) throw(AUExcept);

  void setInitParam(InitParameter key, T value=0.);

  void setReservoirAct(ActivationFunction f=ACT_TANH) throw(AUExcept);
  void setOutputAct(ActivationFunction f=ACT_LINEAR) throw(AUExcept);

//   void setParameter(string param, string value) throw(AUExcept);




  void setWin(const DEMatrix &Win) throw(AUExcept);
  void setW(const DEMatrix &W) throw(AUExcept);
  void setWback(const DEMatrix &Wback) throw(AUExcept);
  void setWout(const DEMatrix &Wout) throw(AUExcept);
  void setX(const DEVector &x) throw(AUExcept);

  void setLastOutput(const DEVector &last) throw(AUExcept);




  void setWin(T *inmtx, int inrows, int incols) throw(AUExcept);

  void setW(T *inmtx, int inrows, int incols) throw(AUExcept);

  void setWback(T *inmtx, int inrows, int incols) throw(AUExcept);

  void setWout(T *inmtx, int inrows, int incols) throw(AUExcept);

  void setX(T *invec, int insize) throw(AUExcept);

  void setLastOutput(T *last, int size) throw(AUExcept);


 protected:

  InitBase<T> *init_;

  TrainBase<T> *train_;

  SimBase<T> *sim_;


  DEMatrix Win_;

  SPMatrix W_;

  DEMatrix Wback_;

  DEMatrix Wout_;

  DEVector x_;


  void (*reservoirAct_)(T *data, int size);

  void (*outputAct_)(T *data, int size);

  void (*outputInvAct_)(T *data, int size);


  int neurons_;
  int inputs_;
  int outputs_;

  double noise_;


  ParameterMap init_params_;

  enum NetInfo
  {
    RESERVOIR_ACT,  
    OUTPUT_ACT,     
    INIT_ALG,       
    TRAIN_ALG,      
    SIMULATE_ALG    
  };
  typedef std::map<NetInfo, int> InfoMap;

  InfoMap net_info_;

  string getActString(int act);
  string getInitString(int alg);
  string getSimString(int alg);
  string getTrainString(int alg);



  friend class InitBase<T>;
  friend class InitStd<T>;
  friend class TrainBase<T>;
  friend class TrainPI<T>;
  friend class TrainLS<T>;
  friend class TrainRidgeReg<T>;
  friend class TrainDSPI<T>;
  friend class SimBase<T>;
  friend class SimStd<T>;
  friend class SimSquare<T>;
  friend class SimLI<T>;
  friend class SimBP<T>;
  friend class SimFilter<T>;
  friend class SimFilter2<T>;
  friend class SimFilterDS<T>;
};

} // end of namespace aureservoir

#include <aureservoir/esn.hpp>
#include <aureservoir/init.hpp>
#include <aureservoir/simulate.hpp>
#include <aureservoir/train.hpp>

#endif // AURESERVOIR_ESN_H__

---