bp: refactored

src/NeuralNetwork/Learning/BackPropagation.cpp

@@ -4,47 +4,15 @@
 #include <immintrin.h>
 
 void NeuralNetwork::Learning::BackPropagation::teach(const std::vector<float> &input, const std::vector<float> &expectation) {
-
 	network.computeOutput(input);
-
 	resize();
-
 	computeSlopes(expectation);
 
-	updateWeights(input);
-
-	std::swap(deltas,lastDeltas);
-}
-
-
-void NeuralNetwork::Learning::BackPropagation::updateWeights(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 delta =slopes[layerIndex][j]*learningCoefficient;
-
-			//momentum
-			delta += momentumWeight * lastDeltas[layerIndex][j];
-
-			deltas[layerIndex][j]=delta;
-
-			layer[j].weight(0)+=delta - weightDecay *layer[j].weight(0);
-
-			for(std::size_t k=1;k<prevLayerSize;k++) {
-				if(layerIndex==1) {
-					layer[j].weight(k)+=delta*input[k-1] - weightDecay * layer[j].weight(k);
-				} else {
-					layer[j].weight(k)+=delta*prevLayer[k].output() - weightDecay * layer[j].weight(k);
-				}
-			}
-		}
+	computeDeltas(input);
+	if(++currentBatchSize >= batchSize) {
+		updateWeights();
+		endBatch();
+		currentBatchSize=0;
 	}
 }
 
@@ -71,4 +39,55 @@ void NeuralNetwork::Learning::BackPropagation::computeSlopes(const std::vector<f
 	}
 }
 
+void NeuralNetwork::Learning::BackPropagation::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) {
+					deltas[layerIndex][j][k] = update * inputValue;
+				} else {
+					deltas[layerIndex][j][k] += update * inputValue;
+				}
+			}
+		}
+	}
+}
+
+void NeuralNetwork::Learning::BackPropagation::updateWeights() {
+
+	bool enableMoments = momentumWeight > 0.0;
+
+	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 delta = deltas[layerIndex][j][k]*learningCoefficient - weightDecay * layer[j].weight(k);
+
+				if(enableMoments) {
+					delta += momentumWeight * lastDeltas[layerIndex][j][k];
+					lastDeltas[layerIndex][j][k]=delta;
+				}
+
+				layer[j].weight(k)+= delta;
+			}
+		}
+	}
+}