HopfieldNetwork.h

Go to the documentation of this file.

#ifndef HOPFIELDNETWORK_H
#define HOPFIELDNETWORK_H

#include "Network.h"
#include "Matrix.h"
#include <vector>

namespace annie {

real isPositive(real x);

/*abstract*/ class HopfieldBase : public Network    {
protected:
    bool _bipolar;

    int _nPatterns;
    int _time;

    HopfieldBase() : Network(0,0), _neurons(0) {}

    struct  NData {
        Vector _biases;
        //      Vector _activations;
        Vector _outputs;
        ActivationFunction _function;   //one for all
        void setSize(uint size) {
            _biases.resize(size); _outputs.resize(size);
        }
        NData(uint size, ActivationFunction f=signum) : _biases(size), _outputs(size), _function(f) {}
    } _neurons;
    
    int real2int(real r) const;
    typedef uint Nid;
    real _getBias(Nid i);
    void _setBias(Nid i, real bias);
    void _setNeuronOutput(Nid n, real a) { _neurons._outputs[n] = a; }
    real _getNeuronOutput(Nid n) const  { return _neurons._outputs[n]; }
public:
    /*virtual void setActivation(Nid n, real a) = 0;
    virtual real getOutput(Nid n, real a) = 0;*/

    virtual real getWeight(uint from, uint to) const = 0;
    virtual void setWeight(uint from, uint to, real weight) = 0;    

    HopfieldBase(uint size, bool bias=false, bool bipolar=true);

    virtual ~HopfieldBase() {}

    virtual void save(const std::string &filename) { throw Exception("Not implemented"); }

    virtual real getEnergy();

    virtual real getEnergy(int pattern[]);

    virtual uint getSize() const;

    virtual void step();
    
    virtual int getTime();

    void randomize();

    virtual const char* getClassName() const;


    /* Given an input pattern, keeps iterating through time till the network
      * output converges. Ofcourse, it is possible that this never happens
      * and hence a timeout has to be specified.
      * \todo Implement this!
      * @param pattern The initial input pattern given to the network
      * @param updateAll Determines type of updating (synchronous, asynchronous)
      * @param timeout The maximum number of iteration to try convergence for
         * @return false if the network output didn't converge till the timeout, true otherwise
      */
    //virtual bool converge(int pattern[], bool updateAll, int timeout);

    virtual real getBias(uint i);

    virtual void setBias(uint i, real bias);

    virtual void setInput(int pattern[]);

    virtual void setInput(const std::vector<int> &pattern);

    virtual void setInput(const Vector &pattern);

    virtual Vector getOutput() const;

    std::vector<int> getOutputInt() const;

    virtual Vector getNextOutput();

    virtual Vector getOutput(const Vector &input);

    virtual bool propagate(int pattern[], uint timeout);

    virtual bool propagate(const std::vector<int> &pattern, uint timeout);

    virtual bool HopfieldBase::propagate(const Vector &pattern, uint timeout);
};

class HopfieldNetwork : public HopfieldBase {
protected:
    Matrix *_weightMatrix;

    virtual real getWeight(uint from, uint to) const;
public:
    HopfieldNetwork(uint size, bool bias=false, bool bipolar=true);

    HopfieldNetwork(const char *filename);
    
    ~HopfieldNetwork();

    virtual void save(const std::string &filename);

    virtual void setWeight(uint i, uint j, real weight);

    virtual Matrix getWeightMatrix();

    virtual void addPattern(int pattern[]);

    virtual uint getPatternCount();
};


}
; //namespace annie
#endif // define _HOPFIELDNETWORK_H

---