RecurrentNeuralNetwork.h

//-------------------------------------------------------------------------------------------------------
// Copyright (C) Taylor Woll and panann contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for
// full license information.
//-------------------------------------------------------------------------------------------------------
 
#ifndef RECURRENTNEURALNETWORK_H__
#define RECURRENTNEURALNETWORK_H__
 
#include "Perceptron.h"
 
namespace panann {
 
class RecurrentNeuralNetwork : public Perceptron {
 protected:
  struct LongShortTermMemoryCell {
    size_t neuron_start_index;
 
    size_t neuron_count;
 
    size_t cell_state_start_index;
 
    size_t cell_state_count;
 
    size_t GetNeuronsPerGate() const;
    size_t GetForgetGateStartNeuronIndex() const;
    size_t GetInputGateStartNeuronIndex() const;
    size_t GetOutputGateStartNeuronIndex() const;
    size_t GetCandidateCellStateStartNeuronIndex() const;
    size_t GetOutputUnitStartNeuronIndex() const;
  };
 
  struct CellLayer {
    size_t cell_start_index;
 
    size_t cell_count;
  };
 
 public:
  RecurrentNeuralNetwork() = default;
  RecurrentNeuralNetwork(const RecurrentNeuralNetwork&) = delete;
  RecurrentNeuralNetwork& operator=(const RecurrentNeuralNetwork&) = delete;
  ~RecurrentNeuralNetwork() override = default;
 
  void SetCellMemorySize(size_t memory_size);
  size_t GetCellMemorySize() const;
 
  void RunForward(const std::vector<double>& input) override;
 
  std::vector<double>& GetCellStates();
 
  void AddHiddenLayer(size_t neuron_count) = delete;
 
  void AddHiddenLayer(size_t cell_count,
                      const std::vector<size_t>& cell_memory_sizes = {});
 
  void Construct() override;
 
 protected:
  void ConnectFully() override;
  void FixNeuronConnectionIndices() override;
  void InitializeHiddenNeurons() override;
 
  void AllocateCellStates();
  bool AreCellStatesAllocated() const;
 
  void UpdateCellState(const LongShortTermMemoryCell& cell);
 
  size_t AddCellMemoryStates(size_t count);
 
  size_t GetCellCount() const;
  LongShortTermMemoryCell& GetCell(size_t index);
  size_t GetCellLayerCount() const;
  CellLayer& GetCellLayer(size_t index);
 
  void InitializeCellNeurons(const LongShortTermMemoryCell& cell,
                             size_t input_connection_count,
                             size_t output_connection_count);
 
  void InitializeCellNeuronsOneGate(size_t neuron_start_index,
                                    size_t neurons_per_gate,
                                    ActivationFunctionType activation_function,
                                    size_t input_connection_count,
                                    size_t output_connection_count);
 
 private:
  static constexpr size_t DefaultCellMemorySize = 200;
 
  std::vector<CellLayer> layers_;
  std::vector<LongShortTermMemoryCell> cells_;
  std::vector<double> cell_states_;
  size_t cell_states_count_ = 0;
  size_t cell_memory_size_ = DefaultCellMemorySize;
  bool is_allocated_ = false;
};
 
}  // namespace panann
 
#endif  // RECURRENTNEURALNETWORK_H__