Нейронная сеть направленная на распознавание рукописных цифр с картинки, после обучения выдает примерно примерно один и

#define _CRT_SECURE_NO_WARNINGS
//#include <opencv2/opencv.hpp> 
#include "opencv2/imgproc.hpp"
#include "opencv2/highgui.hpp"
#include <iostream> 
#include <time.h>
#include <omp.h>
#include <math.h>
#include <conio.h>
#include <Windows.h>
#include <string>
#include <vector>
#include <fstream>
#include <conio.h>
using namespace std;
using namespace cv;
 
const int kolPercNeurons[3] = { 784,196,10 };
const int kolLearningImages = 3;//Кол-во обучающих изображений
const long double baseLearnPercRate = 0.1;
long double PercLearningRate = baseLearnPercRate;
vector<vector<vector<long double>>> percWeights(2);//Веса переходов между слоями в персептроне 
vector<long double> neuralOut(kolPercNeurons[2]);//Результат работы нейронной сети 
vector<vector<long double>> percLvls(3);//Персептрон
//vector<vector<vector<long double>>> percErrors;//Матрица ошибок персептрона 
vector<vector<long double>> percErrors(3, vector<long double>(kolPercNeurons[0]));//ошибки для данного слоя перцептрона
vector<vector<long double>> trueAns(kolPercNeurons[2], vector<long double>(1));
vector<vector<long double>> listImage(1);//Текущее изображение
vector<int> orderImage(kolLearningImages, 0);
vector<vector<vector<long double>>> deltas(2, vector<vector<long double>>(kolPercNeurons[0], vector<long double>(kolPercNeurons[1])));
vector<vector<long double>> deltasBias(2, vector<long double>(kolPercNeurons[1]));
//int bias[2] = { 1,1 };
long double weightBias[2][196];
 
 
void LoadImg(int Num) {
    stringstream ss;
    ss << orderImage[Num];
    //cout << orderImage[Num-1] << endl;
    string name = ss.str();
    string name1 = ss.str();
    name += ".png";
    name1 += ".txt";
    name = "tr2/" + name;
    name1 = "txt1/" + name1;
    //cout << name;
    Mat img = imread(name, CV_LOAD_IMAGE_GRAYSCALE);
    //resize(img, img, Size(480, 480), 0, 0, INTER_CUBIC);
    //cout << img.rows << " " << img.cols;
    for (int iRead = 0; iRead < img.rows; iRead++) {
        for (int jRead = 0; jRead < img.cols; jRead++) {
            percLvls[0][iRead+jRead] = img.at<uchar>(iRead, jRead) /255;
            //cout<< percLvls[0][jRead+iRead] << " ";
            // listStartImageBGR[1][iRead][jRead] = img.at<Vec3b>(iRead, jRead)[1];
        //  listStartImageBGR[2][iRead][jRead] = img.at<Vec3b>(iRead, jRead)[2];
            //cout << listStartImageBGR[0][iRead][jRead] << " " << listStartImageBGR[1][iRead][jRead] << " " << listStartImageBGR[2][iRead][jRead] << endl;
        }
    }
    //cout << 1;
    img.release();
    ifstream file(name1);
    for (int iRead = 0; iRead < kolPercNeurons[2]; iRead++) {
        file >> trueAns[iRead][0];
        //cout << trueAns[iRead][0];
        //trueAns[iRead][0] = trueAns[iRead][0] / 100;
       // cout << trueAns[iRead][0]<<endl;
    }
    //cout << endl;
    file.close();
};
 
long double activateFunction(long double x) {
    //return (x <= 0) ? ((long double)(rand() % 5) / 100) : x;
    return 1.0 - 2.0 / (exp(2 * x) + 1);
}
 
long double activateFunctionDX(long double x) {
    return 1 - x * x;
}
 
long double sigm(long double x) {
    return 1 / (1 + exp(-x));
    //return 1 / (1 + pow(2.71828, -x));
}
 
//long double sigmDX(long double x) {
//  return x * (1 - x);
//}
long double sigmDX(long double x) {
    //return x * (1 - x);
    return exp(-x) / ((1 + exp(-x)) * (1 + exp(-x)));
    /*if ((fabs(x - 1) < 1e-9) || (fabs(x) < 1e-9)) return 0.0;
    double res = x * (1.0 - x);
    return res;*/
}
void percToNextLvl(vector<long double>& curLvl, int curNeroAmt, vector<long double>& succLvl, int succNeroAmt, vector<vector<long double>>& curWeights, int numOfLayer)
{
    for (int i = 0; i < curNeroAmt; i++) {
#pragma omp parallel for schedule(guided, succNeroAmt / flows)
        for (int j = 0; j < succNeroAmt; j++)
            succLvl[j] += curLvl[i] * curWeights[i][j];
    }//тут
    for (int i = 0; i < succNeroAmt; i++) {
        succLvl[i] += 1. * weightBias[numOfLayer][i];
    }
#pragma omp parallel for schedule(guided, succNeroAmt / flows)
    for (int j = 0; j < succNeroAmt; j++)
        succLvl[j] = sigm(succLvl[j]);
 
}
 
void learningPerc(vector<vector<long double>>& Errors, int percLvl, int amtNerous, int curImage) {
        if (percLvl == 2) {
            for (int i = 0; i < amtNerous; i++) {
#pragma omp parallel for schedule(guided, kolPercNeurons[percLvl] / flows)
                Errors[percLvl][i] = sigmDX(percLvls[percLvl][i]) * Errors[percLvl][i];
                //cout << Errors[percLvl][i] << " ";
            }
        }
        else {
            for (int i = 0; i < amtNerous; i++) {
#pragma omp parallel for schedule(guided, kolPercNeurons[percLvl] / flows)
                for (int j = 0; j < kolPercNeurons[percLvl + 1]; j++) {
                    Errors[percLvl][i] += percWeights[percLvl][i][j] * Errors[percLvl + 1][j];
                }
                Errors[percLvl][i] *= sigmDX(percLvls[percLvl][i]);
                //cout << Errors[percLvl][i]<<" ";
            }
        }
        for (int i = 0; i < kolPercNeurons[percLvl - 1]; i++) {
#pragma omp parallel for schedule(guided, kolPercNeurons[percLvl] / flows)
            for (int j = 0; j < kolPercNeurons[percLvl]; j++) {
                deltas[percLvl - 1][i][j] = PercLearningRate * Errors[percLvl][j] * percLvls[percLvl - 1][i]; //= PercLearningRate * Errors[percLvl][j] * percLvls[percLvl - 1][i];
                //percWeights[percLvl - 1][i][j] += delta;
            }
        }
        for (int i = 0; i < kolPercNeurons[percLvl]; i++) {
            //long double delta = PercLearningRate * Errors[percLvl][i];
            deltasBias[percLvl - 1][i]=PercLearningRate* Errors[percLvl][i];
            //weightBias[percLvl - 1][i] += delta;
        }
 
        if (percLvl-1 == 0) {
            return;
        }
        else learningPerc(Errors, percLvl - 1, kolPercNeurons[percLvl - 1], curImage);
}
 
void mixImage() {
//  for (int i = 0; i < kolLearningImages; i++) {
//      orderImage[i] = i + 1;
//  }
//  for (int i = 0; i < kolLearningImages; i++) {
//      swap(orderImage[i], orderImage[rand() % kolLearningImages]);
    //}
        for (int i = 0; i < kolLearningImages; i++) {
            //cout << orderImage[i] << endl;
            orderImage[i] = i;
        }
}
 
void fillWeight() {
    percLvls.assign(3, vector<long double>(kolPercNeurons[0]));
    percWeights[0].assign(kolPercNeurons[0], vector<long double>(kolPercNeurons[1]));
    percWeights[1].assign(kolPercNeurons[1], vector<long double>(kolPercNeurons[2]));
    for (int i = 0; i < percWeights[0].size(); i++) {
        for (int j = 0; j < percWeights[0][0].size(); j++) {
            percWeights[0][i][j] = ((long double)(rand() % 10001-5000)) / 30000;
        }
    }
    for (int i = 0; i < percWeights[1].size(); i++) {
        for (int j = 0; j < percWeights[1][0].size(); j++) {
            percWeights[1][i][j] = ((long double)(rand() % 10001 - 5000)) / 30000;
        }
    }
    for (int i = 0; i < kolPercNeurons[1]; i++) {
        weightBias[0][i] = ((long double)(rand() % 10001 - 5000)) / 30000;
    }
    for (int i = 0; i < kolPercNeurons[2]; i++) {
        weightBias[1][i] = ((long double)(rand() % 10001 - 5000)) / 30000;
    }
}
 
int main(int argc, char** argv)
{
    srand(time(0));
    mixImage();
    fillWeight();
    for (int epoch = 0; epoch < 50; epoch++) {
        mixImage();
        for (int num = 0; num < 3; num++) {
            LoadImg(num);
            for (int i = 0; i < 196; i++) {
                percLvls[1][i] = 0;
            }
            for (int i = 0; i < 10; i++) {
                percLvls[2][i] = 0;
            }
            percToNextLvl(percLvls[0], kolPercNeurons[0], percLvls[1], kolPercNeurons[1], percWeights[0], 0);
            percToNextLvl(percLvls[1], kolPercNeurons[1], percLvls[2], kolPercNeurons[2], percWeights[1], 1);
            percErrors[0].assign(kolPercNeurons[0], 0);
            percErrors[1].assign(kolPercNeurons[1], 0);
            percErrors[2].assign(kolPercNeurons[2], 0);
            for (int i = 0; i < kolPercNeurons[2]; i++) {
                percErrors[2][i] = trueAns[i][0] - percLvls[2][i];
                //percErrors[2][i + 1] = trueAns[i + 1][0] - percLvls[2][i + 1];
                //cout << perc[2][i] << " " << percErrors[2][i + 1] << " ";
            }
            learningPerc(percErrors, 2, kolPercNeurons[2], 0);
            for (int i = 0; i < kolPercNeurons[0]; i++) {
#pragma omp parallel for schedule(guided, kolPercNeurons[1] / flows)
                for (int j = 0; j < kolPercNeurons[1]; j++) {
                    percWeights[0][i][j] += deltas[0][i][j];
                }
            }
            for (int i = 0; i < kolPercNeurons[1]; i++) {
#pragma omp parallel for schedule(guided, kolPercNeurons[2] / flows)
                for (int j = 0; j < kolPercNeurons[2]; j++) {
                    percWeights[1][i][j] += deltas[1][i][j];
                }
            }
            for (int i = 0; i < kolPercNeurons[2]; i++) weightBias[1][i] += deltasBias[1][i];  for (int i = 0; i < kolPercNeurons[1]; i++) weightBias[0][i] += deltasBias[0][i];
 
            cout << "Time: " << clock() << ", " << "Number: " << epoch << ";"<<orderImage[num]<<" " << endl;
            cout << "True:" << trueAns[0][0] << " " << trueAns[1][0] << " " << trueAns[2][0] << endl;//" " << trueAns[3][0] << " " << trueAns[4][0] << " " << trueAns[5][0] << " " << trueAns[6][0] << " "
            //  << trueAns[7][0] << " " << trueAns[8][0] << " " << trueAns[9][0] << endl;
            cout << "Ans:" << percLvls[2][0] << " " << percLvls[2][1] << " " << percLvls[2][2] << endl;//" " << percLvls[2][3] << " " << percLvls[2][4] << " " << percLvls[2][5] << " " << percLvls[2][6] << " "
            //  << percLvls[2][7] << " " << percLvls[2][8] << " " << percLvls[2][9] << endl;
        }
    }
 
    cout << endl; cout << endl; cout << endl;
 
    LoadImg(0);
    percToNextLvl(percLvls[0], kolPercNeurons[0], percLvls[1], kolPercNeurons[1], percWeights[0], 0);
    percToNextLvl(percLvls[1], kolPercNeurons[1], percLvls[2], kolPercNeurons[2], percWeights[1], 1);
    cout << "True:" << trueAns[0][0] << " " << trueAns[1][0] << " " << trueAns[2][0] << endl;//" " << trueAns[3][0] << " " << trueAns[4][0] << " " << trueAns[5][0] << " " << trueAns[6][0] << " "
                //  << trueAns[7][0] << " " << trueAns[8][0] << " " << trueAns[9][0] << endl;
    cout << "Ans:" << percLvls[2][0] << " " << percLvls[2][1] << " " << percLvls[2][2] << endl;//" " << percLvls[2][3] << " " << percLvls[2][4] << " " << percLvls[2][5] << " " << percLvls[2][6] << " "
    //  << percLvls[2][7] << " " << percLvls[2][8] << " " << percLvls[2][9] << endl;
    LoadImg(1);
    percToNextLvl(percLvls[0], kolPercNeurons[0], percLvls[1], kolPercNeurons[1], percWeights[0], 0);
    percToNextLvl(percLvls[1], kolPercNeurons[1], percLvls[2], kolPercNeurons[2], percWeights[1], 1);
    cout << "True:" << trueAns[0][0] << " " << trueAns[1][0] << " " << trueAns[2][0] << endl;//" " << trueAns[3][0] << " " << trueAns[4][0] << " " << trueAns[5][0] << " " << trueAns[6][0] << " "
                //  << trueAns[7][0] << " " << trueAns[8][0] << " " << trueAns[9][0] << endl;
    cout << "Ans:" << percLvls[2][0] << " " << percLvls[2][1] << " " << percLvls[2][2] << endl; //" " << percLvls[2][3] << " " << percLvls[2][4] << " " << percLvls[2][5] << " " << percLvls[2][6] << " "
    //  << percLvls[2][7] << " " << percLvls[2][8] << " " << percLvls[2][9] << endl;
    return 0;
}