refactored propagation

include/NeuralNetwork/FeedForward/Layer.h

@@ -67,6 +67,15 @@ namespace FeedForward {
 				return *neurons[neuron];
 			}
 
+			/**
+			 * @brief This is a virtual function for selecting neuron
+			 * @param neuron is position in layer
+			 * @returns Specific neuron
+			 */
+			const NeuronInterface& operator[](const std::size_t& neuron) const {
+				return *neurons[neuron];
+			}
+
 			void solve(const std::vector<float> &input, std::vector<float> &output);
 
 			/**

include/NeuralNetwork/Learning/BackPropagation.h

@@ -1,10 +1,6 @@
 #pragma once
 
-#include <vector>
-#include <cmath>
-
-#include <NeuralNetwork/FeedForward/Network.h>
-#include "CorrectionFunction/Linear.h"
+#include "BatchPropagation.h"
 
 namespace NeuralNetwork {
 namespace Learning {
@@ -12,23 +8,17 @@ namespace Learning {
 	/** @class BackPropagation
 	 * @brief 
 	 */
-	class BackPropagation {
+	class BackPropagation : public BatchPropagation {
 
 		public:
-			inline BackPropagation(FeedForward::Network &feedForwardNetwork, CorrectionFunction::CorrectionFunction *correction = new CorrectionFunction::Linear()):
-									network(feedForwardNetwork), correctionFunction(correction),learningCoefficient(0.4), slopes() {
+			BackPropagation(FeedForward::Network &feedForwardNetwork, std::shared_ptr<CorrectionFunction::CorrectionFunction> correction = std::make_shared<CorrectionFunction::Linear>()):
+				BatchPropagation(feedForwardNetwork,correction), learningCoefficient(0.4) {
 				resize();
 			}
 
-			virtual ~BackPropagation() {
-				delete correctionFunction;
-			}
-
 			BackPropagation(const BackPropagation&)=delete;
 			BackPropagation& operator=(const NeuralNetwork::Learning::BackPropagation&) = delete;
 
-			void teach(const std::vector<float> &input, const std::vector<float> &output);
-
 			inline virtual void setLearningCoefficient (const float& coefficient) { learningCoefficient=coefficient; }
 
 			float getMomentumWeight() const {
@@ -48,75 +38,22 @@ namespace Learning {
 				weightDecay=wd;
 			}
 
-			std::size_t getBatchSize() const {
-				return batchSize;
-			}
-
-			void setBatchSize(std::size_t size) {
-				batchSize = size;
-			}
-
 		protected:
 
-			virtual inline void resize() {
-				if(slopes.size()!=network.size())
-					slopes.resize(network.size());
-
-				for(std::size_t i=0; i < network.size(); i++) {
-					if(slopes[i].size()!=network[i].size())
-						slopes[i].resize(network[i].size());
-				}
-
-				if(deltas.size() != network.size())
-					deltas.resize(network.size());
-
-				bool resized = false;
-
-				for(std::size_t i = 0; i < network.size(); i++) {
-					if(deltas[i].size() != network[i].size()) {
-						deltas[i].resize(network[i].size());
-						resized = true;
-
-						if(i > 0) {
-							for(std::size_t j = 0; j < deltas[i].size(); j++) {
-								deltas[i][j].resize(network[i - 1].size());
-								std::fill(deltas[i][j].begin(),deltas[i][j].end(),0.0);
-							}
-						}
-					}
-				}
-
-				if(momentumWeight > 0.0 && (resized || lastDeltas.size() != deltas.size())) {
-					lastDeltas = deltas;
+			virtual inline void resize() override {
+				BatchPropagation::resize();
+				if(momentumWeight > 0.0) {
+					_lastDeltas = _gradients;
 				}
 			}
 
-			virtual void computeDeltas(const std::vector<float> &input);
-
-			void updateWeights();
-
-			virtual void computeSlopes(const std::vector<float> &expectation);
-
-			virtual void endBatch() {
-
-			}
-
-			FeedForward::Network &network;
-
-			CorrectionFunction::CorrectionFunction *correctionFunction;
+			virtual void updateWeightsAndEndBatch() override;
 
 			float learningCoefficient;
-
 			float momentumWeight = 0.0;
-
 			float weightDecay = 0.0;
 
-			std::size_t batchSize = 1;
-			std::size_t currentBatchSize = 0;
-
-			std::vector<std::vector<float>> slopes;
-			std::vector<std::vector<std::vector<float>>> deltas = {};
-			std::vector<std::vector<std::vector<float>>> lastDeltas = {};
+			std::vector<std::vector<std::vector<float>>> _lastDeltas = {};
 
 	};
 }

include/NeuralNetwork/Learning/BatchPropagation.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <NeuralNetwork/FeedForward/Network.h>
+
+#include "CorrectionFunction/Linear.h"
+
+#include <vector>
+#include <memory>
+
+namespace NeuralNetwork {
+namespace Learning {
+	class BatchPropagation {
+		public:
+			BatchPropagation(FeedForward::Network &ffn, std::shared_ptr<CorrectionFunction::CorrectionFunction> correction) : _network(ffn), _correctionFunction(correction) {
+
+			}
+
+			virtual ~BatchPropagation() {
+
+			}
+
+			void teach(const std::vector<float> &input, const std::vector<float> &output);
+
+			void finishTeaching();
+
+			std::size_t getBatchSize() const {
+				return _batchSize;
+			}
+
+			void setBatchSize(std::size_t size) {
+				_batchSize = size;
+			}
+		protected:
+			virtual void updateWeightsAndEndBatch() = 0;
+			virtual void resize();
+
+			FeedForward::Network &_network;
+			std::shared_ptr<CorrectionFunction::CorrectionFunction> _correctionFunction;
+
+			std::size_t _batchSize = 1;
+			std::size_t _currentBatchSize = 0;
+
+			std::vector<std::vector<float>> _slopes = {};
+			std::vector<std::vector<std::vector<float>>> _gradients = {};
+
+			bool init = false;
+		private:
+			void computeSlopes(const std::vector<float> &expectation);
+			void computeDeltas(const std::vector<float> &input);
+	};
+}
+}

include/NeuralNetwork/Learning/OpticalBackPropagation.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include "./BackPropagation.h"
-#include "./CorrectionFunction/Optical.h"
-
-namespace NeuralNetwork {
-namespace Learning {
-
-	/** @class OpticalBackPropagation
-	 * @brief 
-	 */
-	class OpticalBackPropagation : public BackPropagation {
-
-		public:
-			OpticalBackPropagation(FeedForward::Network &feedForwardNetwork): BackPropagation(feedForwardNetwork,new CorrectionFunction::Optical()) {
-
-			}
-
-			virtual ~OpticalBackPropagation() {
-			}
-	};
-}
-}

include/NeuralNetwork/Learning/QuickPropagation.h

@@ -15,46 +15,24 @@ namespace NeuralNetwork {
 		class QuickPropagation : public BackPropagation {
 
 		public:
-			inline QuickPropagation(FeedForward::Network &feedForwardNetwork, CorrectionFunction::CorrectionFunction *correction = new CorrectionFunction::Linear()):
-				BackPropagation(feedForwardNetwork,correction),previousSlopes() {
-				resize();
+			inline QuickPropagation(FeedForward::Network &feedForwardNetwork, std::shared_ptr<CorrectionFunction::CorrectionFunction> correction = std::make_shared<CorrectionFunction::Linear>()):
+				BackPropagation(feedForwardNetwork,correction) {
 			}
 
 			virtual ~QuickPropagation() {
 			}
 
 		protected:
+
 			float _maxChange=1.75;
 			float _epsilon=0.5;
 
 			virtual inline void resize() override {
-				if(slopes.size()!=network.size())
-					slopes.resize(network.size());
-
-				for(std::size_t i=0; i < network.size(); i++) {
-					if(slopes[i].size()!=network[i].size())
-						slopes[i].resize(network[i].size());
-				}
-
-				if(deltas.size()!=network.size())
-					deltas.resize(network.size());
-
-				for(std::size_t i=0; i < network.size(); i++) {
-					if(deltas[i].size()!=network[i].size())
-						deltas[i].resize(network[i].size());
-
-					for(std::size_t j=0; j < previousSlopes[i].size(); j++) {
-						deltas[i][j]=1.0;
-					}
-				}
-				weightChange= deltas;
+				BackPropagation::resize();
+				_previousSlopes = _slopes;
 			}
 
-			virtual void updateWeights(const std::vector<float> &input) override;
-
-			std::vector<std::vector<float>> previousSlopes ={};
-			std::vector<std::vector<float>> deltas ={};
-			std::vector<std::vector<float>> weightChange ={};
+			std::vector<std::vector<float>> _previousSlopes ={};
 		};
 	}
 }

include/NeuralNetwork/Learning/RProp.h

@@ -1,10 +1,7 @@
 #pragma once
 
-#include <vector>
-#include <cmath>
 
-#include <NeuralNetwork/FeedForward/Network.h>
-#include "CorrectionFunction/Linear.h"
+#include "BatchPropagation.h"
 
 namespace NeuralNetwork {
 	namespace Learning {
@@ -12,122 +9,48 @@ namespace NeuralNetwork {
 		/** @class Resilient Propagation
 		 * @brief
 		 */
-		class RProp {
+		class RProp : public BatchPropagation {
 
 			public:
-				RProp(FeedForward::Network &feedForwardNetwork, CorrectionFunction::CorrectionFunction *correction = new CorrectionFunction::Linear()):
-					network(feedForwardNetwork), correctionFunction(correction) {
-					resize();
-				}
-
-				virtual ~RProp() {
-					delete correctionFunction;
+				RProp(FeedForward::Network &feedForwardNetwork, std::shared_ptr<CorrectionFunction::CorrectionFunction> correction = std::make_shared<CorrectionFunction::Linear>()):
+					BatchPropagation(feedForwardNetwork, correction) {
 				}
 
 				RProp(const RProp&)=delete;
 				RProp& operator=(const NeuralNetwork::Learning::RProp&) = delete;
 
-				void teach(const std::vector<float> &input, const std::vector<float> &output);
-
-				std::size_t getBatchSize() const {
-					return batchSize;
+				void setInitialWeightChange(float initVal) {
+					initialWeightChange=initVal;
 				}
+				void setLearningCoefficient(float) {
 
-				void setBatchSize(std::size_t size) {
-					batchSize = size;
-				}
-
-				void setInitialWeightChange(float init) {
-					initialWeightChange=init;
 				}
 			protected:
 
-				virtual inline void resize() {
-					if(slopes.size()!=network.size())
-						slopes.resize(network.size());
+				virtual inline void resize() override {
+					BatchPropagation::resize();
 
-					for(std::size_t i=0; i < network.size(); i++) {
-						if(slopes[i].size()!=network[i].size())
-							slopes[i].resize(network[i].size());
-					}
+					_lastGradients =_gradients;
 
-					if(gradients.size() != network.size())
-						gradients.resize(network.size());
-
-					bool resized = false;
-
-					for(std::size_t i = 0; i < network.size(); i++) {
-						if(gradients[i].size() != network[i].size()) {
-							gradients[i].resize(network[i].size());
-							resized = true;
-
-							if(i > 0) {
-								for(std::size_t j = 0; j < gradients[i].size(); j++) {
-									gradients[i][j].resize(network[i - 1].size());
-									std::fill(gradients[i][j].begin(),gradients[i][j].end(),0.0);
-								}
-							}
+					_changesOfWeightChanges = _lastGradients;
+					for(std::size_t i = 1; i < _network.size(); i++) {
+						for(std::size_t j = 0; j < _changesOfWeightChanges[i].size(); j++) {
+							std::fill(_changesOfWeightChanges[i][j].begin(),_changesOfWeightChanges[i][j].end(),initialWeightChange);
 						}
 					}
-
-					if(resized) {
-						lastGradients = gradients;
-
-						if(changesOfWeightChanges.size() != network.size())
-							changesOfWeightChanges.resize(network.size());
-
-						for(std::size_t i = 0; i < network.size(); i++) {
-							if(changesOfWeightChanges[i].size() != network[i].size()) {
-								changesOfWeightChanges[i].resize(network[i].size());
-								if(i > 0) {
-									for(std::size_t j = 0; j < changesOfWeightChanges[i].size(); j++) {
-										changesOfWeightChanges[i][j].resize(network[i - 1].size());
-										std::fill(changesOfWeightChanges[i][j].begin(),changesOfWeightChanges[i][j].end(),initialWeightChange);
-									}
-								}
-							}
-						}
-					}
-
-					if(resized) {
-						if(lastWeightChanges.size() != network.size())
-							lastWeightChanges.resize(network.size());
-
-						for(std::size_t i = 0; i < network.size(); i++) {
-							if(lastWeightChanges[i].size() != network[i].size()) {
-								lastWeightChanges[i].resize(network[i].size());
-								if(i > 0) {
-									for(std::size_t j = 0; j < lastWeightChanges[i].size(); j++) {
-										lastWeightChanges[i][j].resize(network[i - 1].size());
-										std::fill(lastWeightChanges[i][j].begin(),lastWeightChanges[i][j].end(),0.1);
-									}
-								}
-							}
+					_lastWeightChanges = _lastGradients;
+					for(std::size_t i = 1; i < _network.size(); i++) {
+						for(std::size_t j = 0; j < _lastWeightChanges[i].size(); j++) {
+							std::fill(_lastWeightChanges[i][j].begin(),_lastWeightChanges[i][j].end(),0.1);
 						}
 					}
 				}
 
-				virtual void computeSlopes(const std::vector<float> &expectation);
-				virtual void computeDeltas(const std::vector<float> &input);
+				void updateWeightsAndEndBatch() override;
 
-				void updateWeights();
-
-				virtual void endBatch() {
-
-				}
-
-				FeedForward::Network &network;
-
-				CorrectionFunction::CorrectionFunction *correctionFunction;
-
-				std::vector<std::vector<float>> slopes;
-				std::vector<std::vector<std::vector<float>>> gradients = {};
-				std::vector<std::vector<std::vector<float>>> lastGradients = {};
-				std::vector<std::vector<std::vector<float>>> lastWeightChanges = {};
-				std::vector<std::vector<std::vector<float>>> changesOfWeightChanges = {};
-
-				std::size_t batchSize = 1;
-				std::size_t currentBatchSize = 0;
+				std::vector<std::vector<std::vector<float>>> _lastGradients = {};
+				std::vector<std::vector<std::vector<float>>> _lastWeightChanges = {};
+				std::vector<std::vector<std::vector<float>>> _changesOfWeightChanges = {};
 
 				float maxChangeOfWeights = 50;
 				float minChangeOfWeights = 0.0001;

include/NeuralNetwork/Neuron.h

@@ -108,7 +108,7 @@ namespace NeuralNetwork
 			/**
 			 * @brief getter for activation function of neuron
 			 */
-			virtual ActivationFunction::ActivationFunction& getActivationFunction() =0;
+			virtual const ActivationFunction::ActivationFunction& getActivationFunction() const =0;
 
 			virtual void setBasisFunction(const BasisFunction::BasisFunction& basisFunction) =0;
 
@@ -167,7 +167,7 @@ namespace NeuralNetwork
 				return *basis;
 			}
 
-			virtual ActivationFunction::ActivationFunction& getActivationFunction() override {
+			virtual const ActivationFunction::ActivationFunction& getActivationFunction() const override {
 				return *activation;
 			}
 
@@ -216,7 +216,7 @@ namespace NeuralNetwork
 				throw usageException("basis function");
 			}
 
-			virtual ActivationFunction::ActivationFunction& getActivationFunction() override {
+			virtual const ActivationFunction::ActivationFunction& getActivationFunction() const override {
 				throw usageException("biasNeuron - activation function");
 			}
 
@@ -267,7 +267,7 @@ namespace NeuralNetwork
 				throw usageException("basis function");
 			}
 
-			virtual ActivationFunction::ActivationFunction& getActivationFunction() override {
+			virtual const ActivationFunction::ActivationFunction& getActivationFunction() const override {
 				throw usageException("input neuron - activation function");
 			}