nn_hebbian.h

Go to the documentation of this file.

#include "object.h"
#include "mimasexception.h"
#include "matrix_tool.h"
#include "values.h"

#ifndef NN_HEBBIAN_H
#define NN_HEBBIAN_H

namespace mimas {
  class nn_hebbian: public object
  {

    private:
      matrix_tool weights; 
      int trainingType; 
      double eta; 

    public:
      nn_hebbian(void); 
      ~nn_hebbian(void); 
      void init(int rows, int cols); 
      void setTrainingType(int type); 
      void setLearningRate(double lr); 
         void update(matrix_tool& pat, double targetval) throw (exception); 
         double recall(matrix_tool& pat) throw (exception); 
      void useWeights(matrix_tool& weight_matrix); 
      matrix_tool getWeights(void); 
  };


  nn_hebbian::nn_hebbian()
  {
    trainingType=0; // default training type
    eta=0.01;
  }

  void nn_hebbian::init(int rows, int cols)
  {
    if (weights.initialised()) weights.clear();
    weights.init(rows, cols);
  }

  void nn_hebbian::setTrainingType(int type)
  {
    trainingType=type;
  }

  void nn_hebbian::setLearningRate(double lr)
  {
    eta=lr;
  }

  // update the Hebbian weights given pattern pat
  void nn_hebbian::update(matrix_tool& pat, double targetval)
     throw (exception)
  {
     MMERROR( weights.getRows() ==pat.getRows() &&
              weights.getCols() == pat.getCols(),
              exception, , "nn_hebbian::update - weight and input "
              "matrices dimensions not equal" );

    for (int i=0; i<weights.getRows(); i++)
      for (int j=0; j<weights.getCols(); j++)
      {
        switch (trainingType)
        {
          // *post-not-pre* long term depression (LTD)
          case 1: weights(i,j) = weights(i,j) + eta * (2.0*pat(i,j)-1) * targetval;
              break;

              // *pre-not-post* long term depression (LTD)
          case 2: weights(i,j) = weights(i,j) + eta * pat(i,j) * (2 * targetval -1);
              break;

              // Long term potention (LTP)
          default: weights(i,j) = weights(i,j) + eta * pat(i,j) *targetval;
        }

      }

  }


  double nn_hebbian::recall(matrix_tool& pat) throw (exception)
  {
     MMERROR( weights.getRows() == pat.getRows() &&
              weights.getCols() == pat.getCols(), exception, ,
              "nn_hebbian::recall - weight and input matrices dimensions "
              "not equal" );

    double targetval=0.0;

    for (int i=0; i<weights.getRows(); i++)
      for (int j=0; j<weights.getCols(); j++)
        targetval=targetval + weights(i,j) * pat(i,j);

    return targetval;

  }


  // use the weights given by weight_matrix;
  void nn_hebbian::useWeights(matrix_tool& weight_matrix)
  {
    if (weights.initialised()) weights.clear();
    weights=weight_matrix;
  }


  // return the weights that are stored 
  matrix_tool nn_hebbian::getWeights(void)
  {
    matrix_tool temp=weights;

    return weights;
  }
}

#endif

---