Neural Network doesn't seem to be working properly - c++

Question

I've been creating my own neural network by following a book called "Make Your Own Neural Network" by Tariq Rashid. After some theory, the book explains an example written in Python. Since I'm not into Python that much I tried implementing it in C++.
And yes, I did try existing libraries. But now I'd like to implement my own architecture I can tweak as I wish and use them with my Qt and AR projects.
Feeding forward the signals works as expected. I used the same sample values as given in the book and it all seems to be working fine.
The back-propagation however fails at solving the XOR problem. The output value is almost always the same. It's just a bit bigger when both input values are 0.0. The weights appear unusually big to me (often bigger than 7.0. Not sure if that's normal).
Indexing through all layers and transposing those that need to be, also works fine since otherwise, I'd get out of bounds errors.
The project consists of a namespace containing all matrix calculations and the NeuralNetwork class.
Perhaps someone knows what's causing the issue in my code.
Thanks
(EDIT: If you want to compile and run it on your own you can get the source from my Git repository)
AnnMaths.cpp
#include "AnnMaths.h"
vector<vector<double>> AnnMaths::transpose(vector<vector<double>>& x)
{
vector<vector<double>> y;
for (int col = 0; col < x[0].size(); ++col)
{
y.push_back(vector<double>());
for (int row = 0; row < x.size(); ++row)
{
y[col].push_back(x[row][col]);
}
}
return y;
}
vector<vector<double>> AnnMaths::multiply(vector<vector<double>>& x, vector<vector<double>>& y, bool useSigmoid)
{
vector<vector<double>> z;
for (int row = 0; row < x.size(); row++)
{
z.push_back(vector<double>());
for (int col = 0; col < y[0].size(); col++)
{
z[row].push_back(0);
for (int inner = 0; inner < x[0].size(); inner++)
{
z[row][col] += x[row][inner] * y[inner][col];
}
if (useSigmoid) { z[row][col] = sigmoid(z[row][col]); }
}
}
return z;
}
vector<vector<double>> AnnMaths::getOutputErrors(vector<vector<double>>& targets, vector<vector<double>>& output)
{
vector<vector<double>> errors;
for (int neuron = 0; neuron < targets.size(); ++neuron)
{
errors.push_back(vector<double>());
errors[neuron].push_back(/*pow(*/targets[neuron][0] - output[neuron][0]/*, 2)*/);
}
return errors;
}
vector<vector<double>> AnnMaths::getHiddenErrors(vector<vector<double>>& weightsT, vector<vector<double>>& errors)
{
vector<vector<double>> results = multiply(weightsT, errors);
return results;
}
vector<vector<double>> AnnMaths::applyErrors(vector<vector<double>>& errors, vector<vector<double>>& output)
{
vector<vector<double>> results;
for (int i = 0; i < errors.size(); ++i)
{
results.push_back(vector<double>());
results[i].push_back(errors[i][0] * output[i][0] * (1.0 - output[i][0]));
}
return results;
}
vector<vector<double>> AnnMaths::applyLearnrate(vector<vector<double>>& x, double lr)
{
vector<vector<double>> results;
for (int row = 0; row < x.size(); ++row)
{
results.push_back(vector<double>());
for (int col = 0; col < x[0].size(); ++col)
{
results[row].push_back(x[row][col] * lr);
}
}
return results;
}
vector<vector<double>> AnnMaths::add(vector<vector<double>>& x, vector<vector<double>>& y)
{
vector<vector<double>> results;
for (int row = 0; row < x.size(); ++row)
{
results.push_back(vector<double>());
for (int col = 0; col < x[0].size(); ++col)
{
results[row].push_back(x[row][col] + y[row][col]);
}
}
return results;
}
double AnnMaths::sigmoid(double val)
{
return 1 / (1 + pow(E, -val));
}
double AnnMaths::randomVal()
{
return ((double)rand() / (RAND_MAX) -0.5);
}
NeuralNetwork.cpp
#include "NeuralNetwork.h"
NeuralNetwork::NeuralNetwork(vector<int>& topology, vector<vector<double>>& input, vector<vector<double>>& targets, double lr)
{
this->topology = topology;
this->layers.clear();
this->weights.clear();
this->targets.clear();
this->targets = targets;
this->layers.resize(topology.size());
this->errors.resize(this->layers.size());
this->weights.resize(topology.size()-1);
this->learnrate = lr;
for (int layer = 0; layer < topology.size(); ++layer)
{
if (layer == 0)
{
this->layers[layer].push_back(vector<double>());
this->layers[layer] = input;
}
else
{
for (int neuron = 0; neuron < topology[layer]; ++neuron)
{
this->layers[layer].push_back(vector<double>());
this->layers[layer][neuron].push_back(/*AnnMaths::randomVal()*/0.0);
}
}
if (layer < (topology.size() - 1))
{
for (int row = 0; row < topology[layer+1]; ++row)
{
this->weights[layer].push_back(vector<double>());
for (int col = 0; col < topology[layer]; ++col)
{
this->weights[layer][row].push_back(AnnMaths::randomVal());
}
}
}
}
this->errors = this->layers;
}
void NeuralNetwork::feedForward()
{
for (int layer = 0; layer < weights.size(); ++layer)
{
layers[layer + 1] = AnnMaths::multiply(weights[layer], layers[layer], true);
}
}
void NeuralNetwork::setErrors()
{
for (int layer = layers.size() - 1; layer >= 0; --layer)
{
if (layer == layers.size() - 1)
{
this->errors[layer] = AnnMaths::getOutputErrors(this->targets, layers[layer]);
}
else
{
vector<vector<double>> weightsT = AnnMaths::transpose(this->weights[layer]);
vector<vector<double>> tmpErrors = AnnMaths::multiply(weightsT, this->errors[layer+1]);
this->errors[layer] = tmpErrors;
}
}
}
void NeuralNetwork::setInput(vector<vector<double>>& input)
{
this->layers[0] = input;
}
void NeuralNetwork::setTargets(vector<vector<double>>& target)
{
this->targets = targets;
}
void NeuralNetwork::backPropagation()
{
setErrors(); //compute all errors
for (int layer = layers.size() - 2; layer >= 0; --layer)
{
vector<vector<double>> prevOutputT = AnnMaths::transpose(layers[layer]); //get the transposed output of the previous layer
vector<vector<double>> appliedErrors = AnnMaths::applyErrors(this->errors[layer+1], layers[layer+1]); //apply errors to output of next layer
vector<vector<double>> deltaWeights = AnnMaths::multiply(appliedErrors, prevOutputT); //compute delta of weights by multiplying the applied output with the previous output
deltaWeights = AnnMaths::applyLearnrate(deltaWeights, learnrate); //add learning rate to delta weights
weights[layer] = AnnMaths::add(deltaWeights, weights[layer]); //add delta weights to the weights
}
}
main.cpp
#include"AnnMaths.h"
#include<iostream>
#include<vector>
#include"NeuralNetwork.h"
int main()
{
std::vector<std::vector<std::vector<double>>> input;
input.push_back(std::vector<std::vector<double>>());
input.push_back(std::vector<std::vector<double>>());
input.push_back(std::vector<std::vector<double>>());
input.push_back(std::vector<std::vector<double>>());
input[0].push_back(std::vector<double>());
input[0].push_back(std::vector<double>());
input[0][0].push_back(0.0);
input[0][1].push_back(0.0);
input[1].push_back(std::vector<double>());
input[1].push_back(std::vector<double>());
input[1][0].push_back(1.0);
input[1][1].push_back(0.0);
input[2].push_back(std::vector<double>());
input[2].push_back(std::vector<double>());
input[2][0].push_back(0.0);
input[2][1].push_back(1.0);
input[3].push_back(std::vector<double>());
input[3].push_back(std::vector<double>());
input[3][0].push_back(1.0);
input[3][1].push_back(1.0);
std::vector<std::vector<std::vector<double>>> targets;
targets.push_back(std::vector<std::vector<double>>());
targets.push_back(std::vector<std::vector<double>>());
targets.push_back(std::vector<std::vector<double>>());
targets.push_back(std::vector<std::vector<double>>());
targets[0].push_back(std::vector<double>());
targets[0][0].push_back(0.0);
targets[1].push_back(std::vector<double>());
targets[1][0].push_back(1.0);
targets[2].push_back(std::vector<double>());
targets[2][0].push_back(1.0);
targets[3].push_back(std::vector<double>());
targets[3][0].push_back(0.0);
std::vector<int> topology;
topology.push_back(input[0].size());
topology.push_back(3);
topology.push_back(targets[0].size());
NeuralNetwork nn(topology, input[0], targets[0], 0.3);
for (struct { int i = 0; int count = 0; } x; x.i < 10000; ++x.i, ++x.count)
{
if (x.count == 4) { x.count = 0; }
nn.setInput(input[x.count]);
nn.setTargets(targets[x.count]);
nn.feedForward();
nn.backPropagation();
if (x.i % 51 == 0 )
{
nn.printInput();
nn.printOutput();
}
}
return 0;
}
For better visibility I did not include test and print functions.