perceptron implementation changed + perceptronLearningAlgorithm and tests

CMakeLists.txt

@@ -50,6 +50,7 @@ set (LIBRARY_SOURCES
 
 	src/NeuralNetwork/Learning/BackPropagation.cpp
 	src/NeuralNetwork/Learning/QuickPropagation.cpp
+	src/NeuralNetwork/Learning/PerceptronLearning.cpp
 
 	src/NeuralNetwork/BasisFunction/Linear.cpp
 	src/NeuralNetwork/FeedForward/Layer.cpp
@@ -96,7 +97,11 @@ set_property(TEST optical_backpropagation PROPERTY LABELS unit)
 add_test(quickpropagation tests/quickpropagation)
 set_property(TEST quickpropagation PROPERTY LABELS unit)
 
+add_test(perceptron tests/perceptron)
+set_property(TEST perceptron PROPERTY LABELS unit)
 
+add_test(perceptron_learning tests/perceptron_learning)
+set_property(TEST perceptron_learning PROPERTY LABELS unit)
 
 add_test(feedforward_perf tests/feedforward_perf)
 set_property(TEST feedforward_perf PROPERTY LABELS perf)

include/NeuralNetwork/FeedForward/Perceptron.h

@@ -13,7 +13,15 @@ namespace FeedForward {
 
 			using Network::computeOutput;
 			using Network::randomizeWeights;
-			using Network::operator[];
+
+			inline std::size_t size() const {
+				return layers[1]->size();
+			}
+
+			inline NeuronInterface& operator[](const std::size_t& neuron) {
+				return layers[1]->operator[](neuron);
+			}
+
 		protected:
 	};
 }

include/NeuralNetwork/Learning/PerceptronLearning.h

@@ -3,19 +3,18 @@
 #include <vector>
 #include <cmath>
 
-#include <NeuralNetwork/FeedForward/Network.h>
-#include "CorrectionFunction/Linear.h"
+#include <NeuralNetwork/FeedForward/Perceptron.h>
 
 namespace NeuralNetwork {
 	namespace Learning {
 
-		/** @class BackPropagation
-		 * @brief
+		/** @class PerceptronLearning
+		 * @brief Basic algorithm for learning Perceptron
 		 */
 		class PerceptronLearning {
 
 		public:
-			inline PerceptronLearning(FeedForward::Network &feedForwardNetwork): network(feedForwardNetwork), learningCoefficient(0.4) {
+			inline PerceptronLearning(FeedForward::Perceptron &perceptronNetwork): perceptron(perceptronNetwork), learningCoefficient(0.1) {
 			}
 
 			virtual ~PerceptronLearning() {
@@ -30,7 +29,7 @@ namespace NeuralNetwork {
 
 		protected:
 
-			FeedForward::Network &network;
+			FeedForward::Perceptron &perceptron;
 
 			float learningCoefficient;
 		};

src/NeuralNetwork/Learning/PerceptronLearning.cpp

@@ -0,0 +1,15 @@
+#include <NeuralNetwork/Learning/PerceptronLearning.h>
+
+void NeuralNetwork::Learning::PerceptronLearning::teach(const std::vector<float> &input, const std::vector<float> &output) {
+	std::vector<float> computedOutput=perceptron.computeOutput(input);
+
+	std::size_t outputSize = output.size();
+
+	for(std::size_t i=0; i<outputSize; i++) {
+		perceptron[i+1].weight(0)+=learningCoefficient*(output[i]-computedOutput[i])*1;
+		for(std::size_t inputIndex=0; inputIndex<input.size(); inputIndex++) {
+			float delta = learningCoefficient*(output[i]-computedOutput[i])*2*(input[inputIndex]-0.5);
+			perceptron[i+1].weight(inputIndex+1)+=delta;
+		}
+	}
+}

tests/CMakeLists.txt

@@ -25,6 +25,12 @@ target_link_libraries(feedforward_perf NeuralNetwork)
 add_executable(optical_backpropagation optical_backpropagation.cpp)
 target_link_libraries(optical_backpropagation NeuralNetwork)
 
+add_executable(perceptron perceptron.cpp)
+target_link_libraries(perceptron NeuralNetwork)
+
+add_executable(perceptron_learning perceptron_learning.cpp)
+target_link_libraries(perceptron_learning NeuralNetwork)
+
 add_executable(recurrent recurrent.cpp)
 target_link_libraries(recurrent NeuralNetwork)
 

tests/perceptron.cpp

@@ -0,0 +1,16 @@
+#include <NeuralNetwork/FeedForward/Perceptron.h>
+
+#include <assert.h>
+#include <iostream>
+
+int main() {
+	NeuralNetwork::FeedForward::Perceptron p(2,1);
+
+	p[1].weight(0)=-1.0;
+	p[1].weight(1)=1.001;
+
+	assert(p.computeOutput({1,1})[0] == 1.0);
+	p[1].weight(1)=0.999;
+
+	assert(p.computeOutput({1,1})[0] == 0.0);
+}

tests/perceptron_learning.cpp

@@ -0,0 +1,41 @@
+#include <NeuralNetwork/Learning/PerceptronLearning.h>
+
+#include <cassert>
+#include <iostream>
+
+int main() {
+	{	// XOR problem
+		NeuralNetwork::FeedForward::Perceptron n(2,1);
+
+		n.randomizeWeights();
+
+		NeuralNetwork::Learning::PerceptronLearning learn(n);
+
+		for(int i=0;i<10;i++) {
+			learn.teach({1,0},{1});
+			learn.teach({1,1},{1});
+			learn.teach({0,0},{0});
+			learn.teach({0,1},{1});
+		}
+
+		{
+			std::vector<float> ret =n.computeOutput({1,1});
+			assert(ret[0] > 0.9);
+		}
+
+		{
+			std::vector<float> ret =n.computeOutput({0,1});
+			assert(ret[0] > 0.9);
+		}
+
+		{
+			std::vector<float> ret =n.computeOutput({1,0});
+			assert(ret[0] > 0.9);
+		}
+
+		{
+			std::vector<float> ret =n.computeOutput({0,0});
+			assert(ret[0] < 0.1);
+		}
+	}
+}