FeedForwardNeuralNetwork.h

Go to the documentation of this file.

#ifndef _FEEDFORWARDNN_H
#define _FEEDFORWARDNN_H

#include "../Controller.h"
#include "../../utils/Matrix.h"
#include "../GenotypeDecoder.h"
#include <valarray>
#include <vector>
#include <ishtar/settings.h>

namespace Teem
{
    class FeedForwardNeuralNetwork : public Controller
    {
    public:
        FeedForwardNeuralNetwork(size_t inputCount, size_t outputCount, const std::string &root);
        virtual ~FeedForwardNeuralNetwork() { }
        
        // Controller overrides.
        virtual void setInput(unsigned index, double val);
        virtual double getInput(unsigned index) const { assert(index < inputCount); return input[index]; }
        virtual unsigned getInputCount() const { return inputCount; }
        virtual double getOutput(unsigned index);
        virtual void step();
        
        size_t layerNum() { return layerCount; }
        size_t layerSize(size_t layer) { return layerSizes[layer]; }
        size_t inputNum() { return inputCount; }
        size_t outputNum() { return outputCount; }
        
        void setWeight(size_t toLayer, size_t from, size_t to, double w) { weights[toLayer](from, to) = w; }
        double getWeight(size_t toLayer, size_t from, size_t to) const { return weights[toLayer](from, to); }
        
        void setBiasWeight(size_t toLayer, size_t to, double w) { biasWeights[toLayer][to] = w; }
        double getBiasWeight(size_t toLayer, size_t to) const { return biasWeights[toLayer][to]; }
        
        virtual void randomize(double from, double to);
    
    protected:
        
        typedef double (*ActivationFunction)(double x, double b);
    
        class ActivationFunctor;
        
        size_t inputCount; 
        size_t outputCount; 
        size_t layerCount; 
        Ishtar::Variable<unsigned> hiddenLayerCount;  
        std::vector<size_t> layerSizes;  
        Ishtar::Variable<double> biasValue;  
        Ishtar::Variable<std::string> activationFunction;  
        Ishtar::Variable<double> activationFunctionParameter;  
        
        std::vector<Matrix<double> > weights;  
        std::vector<std::valarray<double> > biasWeights;  
        std::vector<std::valarray<double> > activations;  
        std::vector<std::valarray<double> > outputs;  
        std::valarray<double> input;  
        ActivationFunction forwardActFunc;  
        
        static double TanhForwardActivationFunction(double x, double b)
        {
            return tanh(x * b);
        }
    };
    
    class FeedForwardNeuralNetwork::ActivationFunctor
    {
    protected:
        ActivationFunction function;  
        double b;  
        std::valarray<double>& result;  
        size_t pos;  
        
    public:
        ActivationFunctor(ActivationFunction func, std::valarray<double> &res, double b)
            : result(res)
        {
            this->function = func;
            this->pos = 0;
            this->b = b;
        }
        
        void operator()(double x)
        {
            result[pos++] = function(x, b);
        }
    };
    
    
    class RecurrentFeedForwardNeuralNetwork : public FeedForwardNeuralNetwork
    {
    public:
        RecurrentFeedForwardNeuralNetwork(size_t inputCount, size_t outputCount, const std::string &root);
        virtual ~RecurrentFeedForwardNeuralNetwork() { }
        
        virtual void step();
        virtual void randomize(double from, double to);
        
        void setRecursiveWeight(size_t layer, size_t from, size_t to, double w) { recursiveWeights[layer](from, to) = w; }
        double getRecursiveWeight(size_t layer, size_t from, size_t to) const { return recursiveWeights[layer](from, to); }
        bool isLayerRecursive(size_t layer) { return layerRecursive[layer]; }
    
    protected:
    
        Ishtar::Variable<bool> outputLayerRecursive; 
        std::vector<Matrix<double> > recursiveWeights; 
        std::vector<bool> layerRecursive; 
    };
    
    
    class BackPropFeedForwardNeuralNetwork : public FeedForwardNeuralNetwork
    {
    public:
        BackPropFeedForwardNeuralNetwork(size_t inputCount, size_t outputCount, const std::string &root);
        virtual ~BackPropFeedForwardNeuralNetwork() { }
        
        virtual void stepBackward();
        
        void setError(size_t index, double val)
        {
            assert(index < error.size());
            error[index] = val;
        }
        
        void setLearningRate(double rate) { learningRate = rate; }
        double getLearningRate() { return learningRate; }
    
    protected:
        
        Ishtar::Variable<double> learningRate;  
        std::valarray<double> error;  
        ActivationFunction backwardActFunc;  
        std::vector<std::valarray<double> > deltas;  
    
        static double TanhBackwardActivationFunction(double x, double b)
        {
            double t = tanh(x * b);
            return b * (1.0 - t * t);
        }
    };
    
    
    class FeedForwardNeuralNetworkGenotypeDecoder : public GenotypeDecoder
    {
    public:
        FeedForwardNeuralNetworkGenotypeDecoder(const std::string &root);
        virtual ~FeedForwardNeuralNetworkGenotypeDecoder() { }
        
        virtual Genome* createGenome();
        
        virtual Controller* decode(Genome *genome);
    
    protected:
    
        Ishtar::Variable<unsigned> hiddenLayerCount;  
        std::vector<size_t> hiddenLayerSizes;  
        Ishtar::Variable<bool> useBackProp; 
        Ishtar::Variable<bool> useRecursion; 
        Ishtar::Variable<double> weightRange; 
        std::vector<bool> layerRecursive; 
    };
}

#endif

---