Нейронная сеть. Растет ошибка только на последнем сете обучающей выборки

Посмотрите, у меня на Python(можно конвертировать) такая функция вспомогательная:

ready = False
y = 0
def operations(op, x, nn_params: Nn_params):
    global ready, y
    alpha_leaky_relu = nn_params.alpha_leaky_relu
    alpha_sigmoid = nn_params.alpha_sigmoid
    alpha_tan = nn_params.alpha_tan
    beta_tan = nn_params.beta_tan
    if op == RELU:
        if (x <= 0):
            return 0
        else:
            return x
    elif op == RELU_DERIV:
        if (x <= 0):
            return 0
        else:
            return 1
    elif op == TRESHOLD_FUNC:
        if (x > 0.5):
            return 1
        else:
            return 0
    elif op == TRESHOLD_FUNC_DERIV:
        return 1
    elif op == LEAKY_RELU:
        if (x <= 0):
            return alpha_leaky_relu
        else:
            return 1
    elif op == LEAKY_RELU_DERIV:
        if (x <= 0):
            return alpha_leaky_relu
        else:
            return 1
    elif op == SIGMOID:
        y = 1 / (1 + math.exp(- alpha_sigmoid * x))
        return y
    elif op == SIGMOID_DERIV:
        return (alpha_sigmoid * y * (1 - y))
    elif op == SOFTMAX_DERIVATE:
        return 1
    elif op == INIT_W_MY:
        if ready:
            ready = False
            return -0.567141530112327
        ready = True
        return 0.567141530112327
    elif op == INIT_W_RANDOM:
        return random.random()
    elif op == TAN:
        f = alpha_tan * math.tanh(beta_tan * x)
        return f
    elif op == TAN_DERIV:
        return beta_tan / alpha_tan * (alpha_tan * alpha_tan - y * y)
    elif op == INIT_W_CONST:
        return 0.567141530112327
    elif op == INIT_RANDN:
        return np.random.randn()
    else:
        print("Op or function does not support ", op)

Справа op это enum, попробуйте инициализацию, возьмите одну OR/AND или XOR, простые операции мне помогли TRESHOLD_FUNC и INIT_W_MY(так даже для "нерешаемой" XOR)

У вас оказывается довольно большая конфигурируемая сеть(не 3 слоя), и мне стала непонятна архитектура, поэтому предлагаю сначала изменить код так(более логично):

struct NeuralNetwork
{
private:
    
    

    struct Lay
    {
        int _in;
        int _out;
        Matrix<double_t> *matrix;  // веса
        Vector<double_t> *hidden; // вектор после функции активации
        Vector<double_t> *errors; // вектор ошибок
        

    double_t getRandomWeight() { return (double_t)(rand()) / RAND_MAX - 0.5; };  

    public:
        Lay(int in, int out) : _in(in), _out(out) // 1 слой
        {

            matrix = new Matrix<double_t>(_in, _out); // Создание матрицы весов

            srand(time(NULL));
            for (int row = 0; row < _out; row++) // ее заполнение
                for (int elem = 0; elem < _in; elem++)
                    matrix[row][elem] = getRandomWeight();

            hidden = new Vector<double_t>(out);
            errors = new Vector<double_t>(out);
        }
    };

    
    Vector<Lay> *net; // сеть как стек Слоев
    size_t count_layers;

    double_t E;
    double_t a;

    //Функция активации
    double_t (*activationFunc)(const double_t value) = [](const double_t value) {
        return value > 0.5 ? (double_t)1 : 0;
    };
    //Производная функции активации
    double_t (*derivativeFunc)(const double_t value) = [](const double_t value) {
        return (double_t)1;
    };

public:
    NeuralNetwork(const size_t *dimensions, const size_t size,
                  const double_t E = 0.5, const double_t a = 0.5)
    {

        this->count_layers = size;
        this->net = new Vector<Lay>(this->count_layers);
        for (size_t i = 0; i < this->count_layers; i++)
            this->net[i]=new Lay(dimensions[i + 1], dimensions[i]);
        
        this->E = E;
        this->a = a;
        
    };
...
}