---

neuralregion.h

Go to the documentation of this file.

#ifndef __NEURALREGION_H__
#define __NEURALREGION_H__

#include <utility>
#include <string>
using std::string;

#include "matrix.h"
#include "generic_stdlib.h"
#include "matrixadapter.h"
#include "boundingbox.h"
#include "weightset.h"
#include "bounded.h"
#include "pointermap.h"
#include "sequencetransform.h"



class NeuralRegion : public HasTable<mat::MatrixInterface<Bounded::Magnitude> > {
public:

  typedef Bounded::Magnitude Magnitude;

  typedef Magnitude Activity;

  typedef double Length;

  typedef MatrixType<Activity>::rectangular ActivityMatrix;

  typedef ActivityMatrix::size_type Subscript;

  typedef std::pair<Subscript,Subscript> SubscriptPair;

  typedef mat::MatrixInterface<Magnitude> MapBaseType;

  typedef mat::MatrixInterfaceAdapter<ActivityMatrix,Magnitude> ActivityAdapter;
  
  typedef Boundary::AARBoundingBox<int,int> Bounds;

  typedef SequenceTransform::OneD<ActivityMatrix,ActivityMatrix> ActivationFunction;

  struct Dimensions {
    Dimensions(Subscript h, Subscript w, Length xo=0.5, Length yo=0.5)
      : height(h), width(w), xoffset(xo), yoffset(yo) {  }
    Subscript height;   
    Subscript width;    
    Length    xoffset;  
    Length    yoffset;  
  };

  NeuralRegion(string name_i, Dimensions dims)
    : HasTable<mat::MatrixInterface<Bounded::Magnitude> >(),
      name_str(name_i), output(dims.height,dims.width), 
      bp(dims.height,dims.width),
      residual(dims.height,dims.width) { }
  
  NeuralRegion(const NeuralRegion& other) 
    : HasTable<mat::MatrixInterface<Bounded::Magnitude> >(),
      name_str(other.name_str), output(other.output), 
      bp(other.bp), residual(other.residual) { }
  
  virtual ~NeuralRegion() { }
  

  virtual void activate(bool learn=false, bool settle=true, bool activatefn=true) =0; 

  
  
  /*   activity(Subscript i, Subscript j) may need to be made non-virtual for speed.  */
  virtual Activity activity(Subscript i, Subscript j) const {  return output[i][j];  }
  virtual const ActivityMatrix& const_activity() const      {  return output;        }

  virtual const ActivityMatrix& backprojection() const      {  return bp;    }

  virtual const ActivityMatrix& residual_activity() const      {  return residual;    }

  //  virtual ActivityMatrix& activity()                        {  return output;        }


  const string& name() const {  return name_str;  }

  const int nrows() const {  return int(output.nrows());  }
  const int ncols() const {  return int(output.ncols());  }

  virtual bool is_internal() const  {  return false;  }
  
  virtual bool is_plastic() const  {  return true;  }

  virtual void save_state(const string&) { }
  
  virtual bool restore_state(const int, const string&) {  return true;  } 

  virtual void prune() {  }
  
  virtual double size_connection_bytes()   const=0;
  
  virtual double size_unique_connections() const=0;

  /* Backproject current activity. Must be implemented by derived classes. yschoe 
  virtual void backproject() = 0;
  */

private:
  const string name_str;

public:
  Bounds bounds() const {  return Bounds(0,0,output.ncols()-1,output.nrows()-1);  }

// yschoe: make this temporarily public; was protected:
public:
  ActivityMatrix output;
  ActivityMatrix bp;
  ActivityMatrix residual;
};



class InternalNeuralRegion : public NeuralRegion {
public:
  InternalNeuralRegion(string name_i, Dimensions dims)
    : NeuralRegion(name_i,dims) { }
  
  virtual ~InternalNeuralRegion() { }

  typedef ActivityMatrix WeightMatrix;

  typedef Generic::unary_virtual_function<double,WeightMatrix> WeightFunction;

  typedef Boundary::BoundingBox<int,int> WeightBounds;

  typedef WeightSet<WeightMatrix,WeightBounds,MapBaseType,mat::MatrixInterfaceAdapter<WeightMatrix,Magnitude> > Weights;

  
  virtual Dimensions input_dimensions(WeightFunction& fn, Length size_scale=1.0) =0;

  virtual bool is_internal() const  {  return true;  }
  
  virtual void add_input(const string& name, NeuralRegion& upstream_region,
                         WeightFunction& fn, Length size_scale) =0;

  virtual void backproject() = 0;

  virtual void backproject(const string& name, const double gammaaff=1.0) {

        // This function should be called by derived classes' 
        // backproject(noarg), which will know which map to call.
        // --- cout << " - " << name << endl;

        // 1. get named input (upstream's output). Cleaning up the 
        //    backprojection region should be done prior to calling this
        //    function, so it is omitted here.
        NeuralRegion* inp = dynamic_cast<NeuralRegion*>(get_input(name));
        if (!inp) {
          // Messaging not currently possible from this routine
          //cout << "Error: input region nonexistent" << endl;
                return;
        }

        // 2. Loop thorough all neurons in the current NeuralRegion bp 
        int nr = output.nrows(), nc = output.ncols();
        for (int i=0; i<nr; i++)
          for (int j=0; j<nc; j++) {

            double cur_output = bp[i][j];

            // 2.1 get named weights and bounds (upstream->downstream)
            const WeightMatrix  wmat = get_weights(name,i,j);
            const WeightBounds* wbounds = get_weights_bounds(name,i,j);

            // 2.2 get current activity (this map's output)
            //    output is the current ActivityMatrix;
            int xl = wbounds->aarectangle().corners().xl;
            int yl = wbounds->aarectangle().corners().yl;
            int xh = wbounds->aarectangle().corners().xh;
            int yh = wbounds->aarectangle().corners().yh;

            // 2.3 backproject loop
            for (int x=xl; x<=xh; ++x)
              for (int y=yl; y<=yh; ++y)
                (inp->bp[x][y]) += cur_output * wmat[x-xl][y-yl] / gammaaff;

            delete wbounds;

          }
        // 2. end

  };

  
#ifdef OBJ_LISSOM
  
  virtual void resp_to_residual() {};

  virtual void resp_to_residual(const string& name, const double gammaaff=1.0) {

        // This function should be called by derived classes' 
        // resp_to_residual(noarg), which will know which map to call.
        //
        // precondition: upstream "residual" must have been properly calculated
        // assumption: result will be ADDED to the current "output"
        //      so "output" should have been cleaned if this is the first time.

        // 1. propagation starts at the current "residual"

        // 2. Loop thorough all neurons in the current NeuralRegion residual
        NeuralRegion* inp = dynamic_cast<NeuralRegion*>(get_input(name));

        int nr = output.nrows(), nc = output.ncols();
        for (int i=0; i<nr; i++)
          for (int j=0; j<nc; j++) {

            // 2.1 get named weights and bounds (upstream->downstream)
            const WeightMatrix  wmat = get_weights(name,i,j);
            const WeightBounds* wbounds = get_weights_bounds(name,i,j);

            // 2.2 get current activity (this map's output)
            //    output is the current ActivityMatrix;
            int xl = wbounds->aarectangle().corners().xl;
            int yl = wbounds->aarectangle().corners().yl;
            int xh = wbounds->aarectangle().corners().xh;
            int yh = wbounds->aarectangle().corners().yh;

            // 2.3 backproject loop
            double sum = 0.0;

            for (int x=xl; x<=xh; ++x)
              for (int y=yl; y<=yh; ++y)
                sum += (inp->residual[x][y]) 
                              * wmat[x-xl][y-yl];

            output[i][j] += sum / gammaaff;

            delete wbounds;

          }
        // 2. end

  }

  virtual void train_obj_weights() {};

  virtual void randomize_lat_wts() {};
#endif /* OBJ_LISSOM */



  virtual const Weights weights(const string& name, int ui=0, int uj=0) const
  {  return Weights(new WeightMatrix(get_weights(name,ui,uj)),get_weights_bounds(name,ui,uj));  }


//private: /* Eventually */
  virtual const WeightMatrix get_weights(const string& name, int ui=0, int uj=0) const =0;

  virtual WeightBounds* get_weights_bounds(const string& name, int ui=0, int uj=0) const =0;



  virtual NeuralRegion* get_input(const string& name) = 0;

};


#endif /* __NEURALREGION_H__ */

---