FFLayer.h

// Copyright (C) 2001 Jean-Marc Valin
#ifndef FFLAYER_H
#define FFLAYER_H

#include "Object.h"
#include <math.h>
#include <iostream>
#include <stdlib.h>
#include "functions.h"

namespace FD {

class FFLayer : public Object {
  public:
   void (*func) (float *, float *, int);

   void (*deriv_func) (float *, float *, int);

  protected:
   int nbNeurons;

   int nbInputs;

   float *weights;

   /*type of activation function (tansig, sigmoid, lin)*/
   std::string funcType;

   int weightOffset;

   int neuronOffset;

   float derivOffset;

  public:
   FFLayer() 
      : derivOffset(0) 
   {}

   //FFLayer(float *_weights) : weights(_weights) {};

   FFLayer(int _nbNeurons, int _nbInputs, float *_weights, int _weightOffset, int _neuronOffset, std::string type = "tansig");

   FFLayer(const FFLayer &layer) {std::cerr << "I wouldn't do that if I were you\n";}
   
   void setupAfterRead(float *_weights, int _weightOffset, int _neuronOffset);

   ~FFLayer() 
   {
   }

   void update(const float *previous, float *value, float *deriv=NULL)
   {
      for (int i=0;i<nbNeurons;i++)
      {
         float *w=weights + i*(nbInputs+1);              
         value[i] = vec_inner_prod(w, previous, nbInputs) + w[nbInputs];

      }

      if (func == tansig)
      {
         tansig(value, value, nbNeurons);
         if (deriv)
            deriv_tansig(value, deriv, nbNeurons);
      } else if (func == lin)
      {
         //lin(value, value, nbNeurons);
         if (deriv)
            deriv_lin(value, deriv, nbNeurons);
      } else if (func == sigmoid)
      {
         sigmoid(value, value, nbNeurons);
         if (deriv)
            deriv_sigmoid(value, deriv, nbNeurons);
      } else {
         std::cerr << "unknown\n";
         func(value, value, nbNeurons);
         if (deriv)
            deriv_func(value, deriv, nbNeurons);
      }
      if (deriv)
         vec_add_scal(derivOffset, deriv, deriv, nbNeurons);
   }

   int size() {return nbNeurons;}

   int getNbWeights() {return nbNeurons*(nbInputs+1);}

   int getNeuronWeightOffset(int i) {return weightOffset+i*(nbInputs+1);}

   int getWeightOffset() {return weightOffset;}

   int getNeuronOffset() {return neuronOffset;}

   void init(float minmax);

   void init(double *mean, double *std);

   void setBias(double *minmax);

   float *getWeights(int i) {return weights + i*(nbInputs+1);}

   void printOn(std::ostream &out) const;

   void readFrom (std::istream &in);

   void setDerivOffset(float d) {derivOffset=d;}
};

std::istream &operator >> (std::istream &in, FFLayer &layer);

}//namespace FD


#endif

---