neuralNetwork.h

Go to the documentation of this file.

 
#ifndef NEURALNETWORK_H
#define NEURALNETWORK_H
 
#include <vector>
#include "baseModel.h"
 
#ifndef EMSCRIPTEN
#include "../dependencies/json/json.h"
#endif
 
template<typename T>
class neuralNetwork final : public baseModel<T>
{
public:
    neuralNetwork(const size_t& num_inputs,
        const std::vector<size_t>& which_inputs,
        const size_t& num_hidden_layers,
        const size_t& num_hidden_nodes,
        const std::vector<T>& weights,
        const std::vector<T>& wHiddenOutput,
        const std::vector<T>& inRanges,
        const std::vector<T>& inBases,
        const T& outRange,
        const T& outBase);
 
    neuralNetwork(const size_t& num_inputs,
        const std::vector<size_t>& which_inputs,
        const size_t& num_hidden_layer,
        const size_t& num_hidden_nodes);
 
    ~neuralNetwork();
 
    T run(const std::vector<T>& inputVector) const override;
 
    void reset() override;
 
    size_t getNumInputs() const override;
    std::vector<size_t> getWhichInputs() const override;
 
    size_t getNumHiddenLayers() const;
    void setNumHiddenLayers(size_t num_hidden_layers);
 
    size_t getNumHiddenNodes() const;
    void setNumHiddenNodes(size_t num_hidden_nodes);
 
    size_t getEpochs() const;
    void setEpochs(const size_t& epochs);
 
    std::vector<T> getWeights() const;
    std::vector<T> getWHiddenOutput() const;
 
    std::vector<T> getInRanges() const;
    std::vector<T> getInBases() const;
    T getOutRange() const;
    T getOutBase() const;
 
#ifndef EMSCRIPTEN
    void getJSONDescription(Json::Value& currentModel) override;
#endif
 
 
private:
    size_t numInputs;
    std::vector<size_t> whichInputs;
    size_t numHiddenLayers;
    size_t numHiddenNodes;
 
    std::vector<T> inputLayer;
    std::vector<std::vector<T> > hiddenLayers;
    T outputNeuron;
 
    std::vector<std::vector<std::vector<T> > > weights;
    std::vector<T> wHiddenOutput;
 
    std::vector<T> inRanges;
    std::vector<T> inBases;
    T outRange;
    T outBase;
 
    inline T activationFunction(T) const;
 
 
public:
    void train(const std::vector<trainingExampleTemplate<T> >& trainingSet) override;
 
    void train(const std::vector<trainingExampleTemplate<T> >& trainingSet, const std::size_t whichOutput) override;
 
    size_t getCurrentEpoch() const;
 
private:
    T learningRate { 0.3 };
    T momentum { 0.2 };
    size_t numEpochs { 500 };
    size_t currentEpoch { 0 };
 
    std::vector<std::vector< std::vector<T> > > deltaWeights;
    std::vector<T> deltaHiddenOutput;
 
    T outputErrorGradient;
    inline T getHiddenErrorGradient(size_t layer, size_t neuron);
 
    void initTrainer();
 
    void runInternal(const std::vector<T>& inputVector, std::vector<T>& inputLayer, std::vector<std::vector<T>>& hiddenLayers, T& outputNeuron) const;
    void backpropagate(const T& desiredOutput);
 
    void updateWeights();
};
 
#endif