---

fixedwtregion.h

Go to the documentation of this file.

#ifndef __FIXEDWTREGION_H__
#define __FIXEDWTREGION_H__

#include <assert.h>
#include <algorithm>
#include <vector>
#include <functional>
//#include <unistd.h> // Temporary; for sync()

#include "genericalgs.h"
#include "robj.h"
#include "neuralregion.h"
#include "matrix.h"
#include "ipc.h" // 020614 TEMPORARY!


/******************************************************************************/
/* General-purpose utility functions                                          */
/******************************************************************************/

template <class MatrixK, class MatrixI, class MatrixO>
void convolve(const MatrixK& kernel, const MatrixI& in, MatrixO& out,
              const typename MatrixO::value_type size_scale=1.0,
              const bool overwrite=true)
{
  typedef typename MatrixK::size_type  SubscriptK;
  typedef typename MatrixI::size_type  SubscriptI;
  typedef typename MatrixO::size_type  SubscriptO;
  
  for (SubscriptO r=0; r < out.nrows(); r++)
    for (SubscriptO c=0; c < out.ncols(); c++){
      /* The min is just for safety when rounding certain non-integer size_scales */
      const SubscriptI  rp = std::min(SubscriptI(r*size_scale),SubscriptI(in.nrows()-kernel.nrows()));
      const SubscriptI  cp = std::min(SubscriptI(c*size_scale),SubscriptI(in.ncols()-kernel.ncols()));
      typename MatrixO::value_type sum=0;
      
      for (SubscriptK k=0; k < kernel.nrows(); k++)
        for (SubscriptK l=0; l < kernel.ncols(); l++)
          sum += kernel[k][l]*in[rp+k][cp+l];
      if (overwrite)
        out[r][c]  = sum;
      else
        out[r][c] += sum;
    }
}



template <class MatrixK, class MatrixI, class MatrixO>
void dense_convolve(const MatrixK& kernel, const MatrixI& in, MatrixO& out,
                    const typename MatrixO::value_type size_scale=1.0,
                    const bool overwrite=true)
{
  typedef typename MatrixK::size_type  SubscriptK;
  typedef typename MatrixI::size_type  SubscriptI;
  typedef typename MatrixO::size_type  SubscriptO;
  typedef typename MatrixK::value_type ValueK;
  typedef typename MatrixI::value_type ValueI;
  typedef typename MatrixO::value_type ValueO;

  const SubscriptK knr   = kernel.nrows();
  const SubscriptK knc   = kernel.ncols();
  const SubscriptI rpmin = SubscriptI(in.nrows()-knr);
  const SubscriptI cpmin = SubscriptI(in.ncols()-knc);

  for (SubscriptO r=0; r < out.nrows(); r++) {
    ValueK* oc=&(out[r][0]);
    for (SubscriptO c=0; c < out.ncols(); c++,oc++){
      /* The min is just for safety when rounding certain non-integer size_scales */
      const SubscriptI  rp = std::min(SubscriptI(r*size_scale),rpmin);
      const SubscriptI  cp = std::min(SubscriptI(c*size_scale),cpmin);
      typename MatrixO::value_type sum=0;
      
      for (SubscriptK k=0; k < knr; k++) {
        const ValueK* kl=&(kernel[k][0]);
        const ValueK* kbound=kl+knc;
        const ValueI* il=&(in[rp+k][cp]);

        /* This is a time-critical loop; make sure the compiler unrolls it */
        for (; kl<kbound; kl++,il++)
          sum += (*kl)*(*il);
      }
      if (overwrite)
        (*oc)  = sum;
      else
        (*oc) += sum;
    }
  }
}

  

/******************************************************************************/
/* NeuralRegion classes                                                       */
/******************************************************************************/


class FixedWtRegion : public InternalNeuralRegion {
public:
  FixedWtRegion(string name_i, Dimensions dims, ActivationFunction* actfn_=0)
    : InternalNeuralRegion(name_i, dims), actfn(actfn_),
    xo(dims.xoffset), yo(dims.yoffset) {  }
  
  virtual ~FixedWtRegion() {  Generic::delete_contents(inputs);  }
  
  virtual void add_input(const string& name, NeuralRegion& upstream_region,
                         WeightFunction& fn, Length size_scale=1.0) {
    WeightMatrix kernel = (fn)(size_scale);
    /* Kernel height and width must be odd */
    assert(kernel.nrows()%2==1);
    assert(kernel.ncols()%2==1);
    
    Generic::insert_named(inputs,name,new Input(name,kernel,&upstream_region,size_scale));
  }

  virtual Dimensions input_dimensions(WeightFunction& fn, Length size_scale=1.0) {
    WeightMatrix kernel = (fn)(size_scale);
    return Dimensions(Subscript(size_scale*output.nrows()+kernel.nrows()-1),
                      Subscript(size_scale*output.ncols()+kernel.ncols()-1),
                      Length(xo-Subscript(kernel.nrows()/2)),
                      Length(yo-Subscript(kernel.nrows()/2)));
  }

  virtual void activate(bool=false,bool=false,bool activate=false) {
    /* Activate each input */
    int num=0;
    for (inputs_type::const_iterator i=inputs.begin(); i!=inputs.end(); i++, num++) {
#ifdef SPARSE_MATRICES
      convolve
#else
      dense_convolve
#endif
        ((*i)->kernel,(*i)->input->const_activity(),output,(*i)->size_scale,i==inputs.begin());
    }
    
    /* Normalize the result to be independent of the number of inputs */
    if (num>1) output *= 1.0/num;
    if (actfn && activate)
      (*actfn)(output,output);
    else {
      /* Even if no activation function, still need to threshold at zero */
      typedef SequenceTransform::Threshold<ActivityMatrix,ActivityMatrix> TActfn;
      const double zero=0.0;
      TActfn makepositive(&zero);
      (makepositive)(output,output);
    }
  }

  virtual void backproject () { 

    // clean upstream bp and residual
    for (inputs_type::iterator i=inputs.begin();i != inputs.end(); ++i) {
      if (String::non_numeric_basename_matches<string>((*i)->name(),"Afferent")){
        NeuralRegion* inp = dynamic_cast<NeuralRegion*>(get_input((*i)->name()));
        int nr = inp->bp.nrows(), nc = inp->bp.ncols();
        for (int x=0; x<nr; ++x) 
          for (int y=0; y<nc; ++y) {
            inp->bp[x][y] = 0.0;
            inp->residual[x][y] = 0.0;
          }
      }
    }

    // backproject current bp to upstream bp matrix
    for (inputs_type::iterator i=inputs.begin();i != inputs.end(); ++i){
      if(String::non_numeric_basename_matches<string>((*i)->name(),"Afferent")){

        InternalNeuralRegion::backproject((*i)->name());

      }
    }

    // calculate error and residual
    for (inputs_type::iterator i=inputs.begin();i != inputs.end(); ++i){
      if(String::non_numeric_basename_matches<string>((*i)->name(),"Afferent")){

        NeuralRegion* inp=dynamic_cast<NeuralRegion*>(get_input((*i)->name()));

        double err = 0.0, err_tmp=0.0, bp_tmp, output_tmp;
        int nr = inp->bp.nrows(), nc = inp->bp.ncols();

        for (int x=0; x<nr; ++x) 
          for (int y=0; y<nc; ++y) {
            bp_tmp        = inp->bp[x][y];
            output_tmp    = inp->output[x][y];
            err_tmp       = output_tmp - bp_tmp;
            err          += err_tmp * err_tmp;
            inp->residual[x][y]   += err_tmp;
          }
        
        // Temporary
        ipc_log(IPC_ONE,"sqrt(sum err sqr) = %f\n", sqrt(err));
        //sync();
      }
      
    }

  }

  virtual NeuralRegion* get_input(const string& name) { 
    Input* i = Generic::find_named<Input>(inputs,name);
    return (i? i->input: 0);

  }

  virtual const WeightMatrix get_weights(const string& name, int=0,int=0) const {
    const Input* i = Generic::find_named_const<Input>(inputs,name);
    //if (!i) ... /* Error -- weights not found */
    return (i? i->kernel : WeightMatrix());
  }

  WeightBounds* get_weights_bounds(const string& name, int ui=0, int uj=0) const
  {
    const Input* i = Generic::find_named_const<Input>(inputs,name);
    //if (!i) ... /* Error -- weights not found */
    if (!i) return new NeuralRegion::Bounds(); /* Dummy infinite bounds */
    
    WeightMatrix wts = i->kernel;
    assert (wts.nrows()==wts.ncols()); /* Assumption */
    
    const int radius=wts.nrows()/2;
    const Boundary::AARBoundingBox<int,int> r(input_row(*i,ui),input_col(*i,uj),radius);
    const NeuralRegion::Bounds b=i->input->bounds();
    return new Boundary::Intersection<int,int,double,
                                      Boundary::AARBoundingBox<int,int>,
                                      NeuralRegion::Bounds>(r,b);
  }

  virtual bool is_plastic() const  {  return false;  }

  double size_connection_bytes()   const
    {  return Generic::accumulate(ISEQ(inputs),0.0,std::mem_fun(&Input::size_bytes));  }
  
  double size_unique_connections() const 
    {  return Generic::accumulate(ISEQ(inputs),0.0,std::mem_fun(&Input::size_conns));  }

protected:
  const OwningPointer<ActivationFunction> actfn;

  struct Input {
    Input(const string& name_i, const WeightMatrix& kernel_i,
          NeuralRegion* input_i, const Length size_scale_i)
      : name_str(name_i), kernel(kernel_i), input(input_i), size_scale(size_scale_i) { }
    const string& name() const {  return name_str;  }

    const double size_bytes() const {  return mat::size(kernel)*sizeof(WeightMatrix::value_type);  }
    const double size_conns() const {  return mat::size(kernel);  }
    
    string name_str;              
    WeightMatrix kernel;          
    NeuralRegion* input;    
    Length size_scale;            
  };

  inline Subscript input_row(const Input& input, Subscript row) const
    {  return Subscript(row*(input.size_scale)+(input.kernel.nrows()/2.0));  }
         
  inline Subscript input_col(const Input& input, Subscript col) const
    {  return Subscript(col*(input.size_scale)+(input.kernel.ncols()/2.0));  }
         
  typedef std::vector<Input*> inputs_type;

  const Activity xo,yo; 
  inputs_type            inputs;
};


#endif /* __FIXEDWTREGION_H__ */

---