Perceptron.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 PERCEPTRON_H__
#define PERCEPTRON_H__
 
#include <vector>
 
#include "ActivationFunction.h"
#include "MultiLayerNeuralTopology.h"
#include "RandomWrapper.h"
 
namespace panann {
 
class TrainingData;
 
class Perceptron : public MultiLayerNeuralTopology {
 public:
  enum class ErrorCostFunction : uint8_t {
    MeanSquareError = 1,
    MeanAbsoluteError,
  };
 
  Perceptron() = default;
  Perceptron(const Perceptron&) = delete;
  Perceptron& operator=(const Perceptron&) = delete;
  ~Perceptron() override = default;
 
  void SetErrorCostFunction(ErrorCostFunction mode);
  ErrorCostFunction GetErrorCostFunction() const;
 
  void SetHiddenNeuronActivationFunctionType(ActivationFunctionType type);
  ActivationFunctionType GetHiddenNeuronActivationFunctionType() const;
 
  void SetOutputNeuronActivationFunctionType(ActivationFunctionType type);
  ActivationFunctionType GetOutputNeuronActivationFunctionType() const;
 
  void InitializeWeightsRandom(double min = -1.0, double max = 1.0);
 
  void InitializeWeights(const TrainingData& training_data);
 
  virtual void RunForward(const std::vector<double>& input);
 
  void RunBackward(const std::vector<double>& output);
 
  double GetError(const std::vector<double>& output);
 
  double GetError(const TrainingData& training_data);
 
  std::vector<double>& GetWeights();
 
  void SetWeights(const std::vector<double>& weights);
 
  void GetOutput(std::vector<double>* output) const;
 
  virtual void Construct();
 
  bool IsConstructed() const;
 
  void EnableErrorShaping();
  void DisableErrorShaping();
 
 protected:
  void AllocateWeights();
  bool AreWeightsAllocated() const;
 
  void InitializeNeurons();
 
  virtual void InitializeHiddenNeurons();
 
  void ComputeNeuronValue(size_t neuron_index);
  void ComputeNeuronValueRange(size_t neuron_start_index, size_t neuron_count);
  void ComputeNeuronError(size_t neuron_index);
 
  void ResetOutputLayerError();
  void CalculateOutputLayerError(const std::vector<double>& output);
 
  double GetError() const;
 
  RandomWrapper& GetRandom();
 
  size_t GetWeightCount() const;
  double& GetWeight(size_t index);
 
 private:
  std::vector<double> weights_;
  RandomWrapper random_;
 
  double error_sum_ = 0;
  double error_count_ = 0;
 
  ErrorCostFunction error_cost_function_ = ErrorCostFunction::MeanSquareError;
  ActivationFunctionType hidden_neuron_activation_function_type_ =
      ActivationFunctionType::Sigmoid;
  ActivationFunctionType output_neuron_activation_function_type_ =
      ActivationFunctionType::Sigmoid;
 
  bool should_shape_error_curve_ = false;
  bool is_constructed_ = false;
  bool is_allocated_ = false;
};
 
}  // namespace panann
 
#endif  // PERCEPTRON_H__