neuralNetwork.h

Go to the documentation of this file.

 
#pragma once
 
#include "baseModel.h"
#ifndef EMSCRIPTEN
#include "../dependencies/json/json.h"
#endif
 
#include <optional>
#include <vector>
 
template<typename T>
class neuralNetwork final : public baseModel<T>
{
  public:
  neuralNetwork(const std::optional<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 std::optional<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) const 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();
};