Rprop implementation

src/NeuralNetwork/Learning/RProp.cpp

@@ -0,0 +1,103 @@
+#include <NeuralNetwork/Learning/RProp.h>
+
+void NeuralNetwork::Learning::RProp::teach(const std::vector<float> &input, const std::vector<float> &expectation) {
+	network.computeOutput(input);
+	resize();
+	computeSlopes(expectation);
+
+	computeDeltas(input);
+	if(++currentBatchSize >= batchSize) {
+		updateWeights();
+		endBatch();
+		currentBatchSize=0;
+	}
+}
+
+void NeuralNetwork::Learning::RProp::computeSlopes(const std::vector<float> &expectation) {
+	auto& outputLayer=network[network.size()-1];
+	for(std::size_t j=1;j<outputLayer.size();j++) {
+		auto& neuron = outputLayer[j];
+		slopes[network.size()-1][j]=correctionFunction->operator()( expectation[j-1], neuron.output())*
+									neuron.getActivationFunction().derivatedOutput(neuron.value(),neuron.output());
+	}
+
+	for(int layerIndex=static_cast<int>(network.size()-2);layerIndex>0;layerIndex--) {
+		auto &layer=network[layerIndex];
+
+		for(std::size_t j=1;j<layer.size();j++) {
+			float deltasWeight = 0;
+
+			for(std::size_t k=1;k<network[layerIndex+1].size();k++) {
+				deltasWeight+=slopes[layerIndex+1][k]* network[layerIndex+1][k].weight(j);
+			}
+
+			slopes[layerIndex][j]=deltasWeight*layer[j].getActivationFunction().derivatedOutput(layer[j].value(),layer[j].output());
+		}
+	}
+}
+
+void NeuralNetwork::Learning::RProp::computeDeltas(const std::vector<float> &input) {
+	for(std::size_t layerIndex=1;layerIndex<network.size();layerIndex++) {
+		auto &layer=network[layerIndex];
+		auto &prevLayer=network[layerIndex-1];
+
+		std::size_t prevLayerSize=prevLayer.size();
+		std::size_t layerSize=layer.size();
+
+		for(std::size_t j=1;j<layerSize;j++)  {
+			float update = slopes[layerIndex][j];
+			for(std::size_t k=0;k<prevLayerSize;k++) {
+				float inputValue = 0.0;
+				if(layerIndex==1 && k!=0) {
+					inputValue = input[k-1];
+				} else {
+					inputValue= prevLayer[k].output();
+				}
+				if(currentBatchSize == 0) {
+					gradients[layerIndex][j][k] = update * inputValue;
+				} else {
+					gradients[layerIndex][j][k] += update * inputValue;
+				}
+			}
+		}
+	}
+}
+
+void NeuralNetwork::Learning::RProp::updateWeights() {
+
+	for(std::size_t layerIndex=1;layerIndex<network.size();layerIndex++) {
+		auto &layer = network[layerIndex];
+		auto &prevLayer = network[layerIndex - 1];
+
+		std::size_t prevLayerSize = prevLayer.size();
+		std::size_t layerSize = layer.size();
+
+		for(std::size_t j = 1; j < layerSize; j++) {
+			for(std::size_t k = 0; k < prevLayerSize; k++) {
+				float gradient = gradients[layerIndex][j][k];
+				float lastGradient = lastGradients[layerIndex][j][k];
+
+				lastGradients[layerIndex][j][k] = gradient;
+
+				float weightChangeDelta = lastWeightChanges[layerIndex][j][k];
+
+				if(gradient * lastGradient > 0) {
+					weightChangeDelta = std::min(weightChangeDelta*weightChangePlus,maxChangeOfWeights);
+				} else if (gradient * lastGradient < 0) {
+					weightChangeDelta = std::max(weightChangeDelta*weightChangeMinus,minChangeOfWeights);
+				} else {
+					weightChangeDelta = lastWeightChanges[layerIndex][j][k];
+				}
+
+				lastWeightChanges[layerIndex][j][k] = weightChangeDelta;
+
+				if(gradient > 0) {
+					layer[j].weight(k) += weightChangeDelta;
+				} else if (gradient < 0){
+					layer[j].weight(k) -= weightChangeDelta;
+				} else {
+				}
+			}
+		}
+	}
+}