void NeuralNet::learnBackpropagation(double* data, double* ans, double acs, double k) {  //data - массив обучающих данных, ans - массив ответов на обучающие данные, k - количество эпох обучения, acs- скорость обучения

for (uint32_t e = 0; e < k; e++) {
    double* errors = new double[neuronsInLayers[numLayers - 1]]; //объявим массив для хранения ошибок выходного слоя
                //Шуточное "Do_it" было заменено на "Forward"
    Forward(neuronsInLayers[0], data);//прогоним обучающую выборку через сеть
    getResult(neuronsInLayers[numLayers - 1], errors);//получаем выходные данные после обучающей выборки

for (uint16_t n = 0; n < neuronsInLayers[numLayers - 1]; n++) {
      neurons[n][2][numLayers - 1] = (ans[n] - neurons[n][1][numLayers - 1]) * (neurons[n][1][numLayers - 1]) * (1 - neurons[n][1][numLayers - 1]);
    }

for (uint8_t L = numLayers - 2; L > 0; L--) {
      for (uint16_t neu = 0; neu < neuronsInLayers[L]; neu++) {
        for (uint16_t lastN = 0; lastN < neuronsInLayers[L + 1]; lastN++) {
          neurons[neu][2][L] += neurons[lastN][2][L + 1] * weights[neu][lastN][L] * neurons[neu][1][L] * (1 - neurons[neu][1][L]);
          weights[neu][lastN][L] += neurons[neu][1][L] * neurons[lastN][2][L + 1] * acs;
        }
      }
    }

void NeuralNet::learnBackpropagation(double* data, double* ans, double acs, double k) {  //k - количество эпох обучения acs- скорость обучения
  for (uint32_t e = 0; e < k; e++) {
    double* errors = new double[neuronsInLayers[numLayers - 1]];
    Forward(neuronsInLayers[0], data);
    getResult(neuronsInLayers[numLayers - 1], errors);
    for (uint16_t n = 0; n < neuronsInLayers[numLayers - 1]; n++) {
      neurons[n][2][numLayers - 1] = (ans[n] - neurons[n][1][numLayers - 1]) * (neurons[n][1][numLayers - 1]) * (1 - neurons[n][1][numLayers - 1]);
    }
    for (uint8_t L = numLayers - 2; L > 0; L--) {
      for (uint16_t neu = 0; neu < neuronsInLayers[L]; neu++) {
        for (uint16_t lastN = 0; lastN < neuronsInLayers[L + 1]; lastN++) {
          neurons[neu][2][L] += neurons[lastN][2][L + 1] * weights[neu][lastN][L] * neurons[neu][1][L] * (1 - neurons[neu][1][L]);
          weights[neu][lastN][L] += neurons[neu][1][L] * neurons[lastN][2][L + 1] * acs;
        }
      }
    }
  }
}

#include <stdio.h>
#include "neuro.h"
int main()
{
    uint16_t neurons[3] = {16, 32, 10}; //в данном массиве содержится количество нейронов в каждом слое, кол-во нейронов на втором слое взято с потолка
/* каждый нейрон первого слоя воспринимает значение одного "пикселя" из матрицы
каждый нейрон последнего слоя обозначает одно из десятичных цифр
*/
    NeuralNet net(3, neurons);
    double teach[4 * 4] = {// создаём "рисунок" цифры "4" для обучения, кол-во пикселей: 4*4 = 16
        1,0,1,0,
        1,1,1,0,
        0,0,1,0,
        0,0,1,0,
    };
    double test[4 * 4] = {//рисуем цифру "4", но по-другому
        1,0,0,1,
        1,1,1,1,
        0,0,0,1,
        0,0,0,1,
    };
    double ans[10] = {0, 0, 0, 0, 1, 0, 0, 0, 0, 0,};// тут мы содержим ответы для обучающей выборки, "1" на пятом месте означает, что в тестовой выборке содержится цифра "4"
    double output[10] = { 0 };// массив для выгрузки данных из сети
    net.Forward(4*4, teach); // проверяем работу необученной сети
    net.getResult(10, output);
    for (uint8_t i = 0; i < 10; i++) printf("%d: %f \n", i, output[i]*100); //выводим результат работы
    net.learnBackpropagation(teach, ans, 0.50, 1000); //обучаем сеть на выборке "test", скорость обучения: 0.5
    printf("\n");
    net.Forward(4 * 4, test);// проверяем работу сети после обучения
    net.getResult(10, output);
    for (uint8_t i = 0; i < 10; i++) printf("%d: %f \n", i, output[i]*100);
    return 0;
}