Написал простую нейронную сеть 3-9-3. Работает. Но есть проблема

#include <cmath>
#include <iostream>
// y=1/(1+pow(e,-x));сигмоида
const float e=2.718281828;
//простая нейронная сеть 3-9-3
// на вход подается набор от 000 до 111 , на выходе необходимо получить инвертированные значения
 
const int n_input=3; // кол-во входных нейронов
const int n_vnut=9; // кол-во внутренних нейронов (1 слой)
const int n_out=3; // кол-во выходных нейронов
const int var_comb=pow(2,n_input); /// war_comb=8 при n_input=3// war_comb=32 при n_input=5
 
using namespace std;
 
int main()
{
    float target[n_out]={0};
    float ar_data[8][3]={{0,0,0},{0,0,1},{0,1,0},{0,1,1},{1,0,0},{1,0,1},{1,1,0},{1,1,1}}; // входные значения
    //float arr_out[8][3]={{0,1,1},{0,1,0},{1,1,1},{1,0,0},{0,1,1},{1,1,0},{0,0,1},{0,1,0}}; // выходные значения (случайные)
    float arr_out[8][3]={{1,1,1},{1,1,0},{1,0,1},{1,0,0},{0,1,1},{0,1,0},{0,0,1},{0,0,0}}; // выходные значения (инвертирование)
    float N_inp[n_input] = {0}; // содержимое входных нейронов
    // 3 строки, 9 столбцов, столбцы количество внутренних нейронов
    float W_inp[n_vnut][n_input]={{0.3, 0.55, 0.4},{0.22, 0.4, 0.33},{0.33, 0.25, 0.18},{0.11, 0.35, 0.2},
    {0.13, 0.38, 0.25},{0.09, 0.31, 0.261},{0.19, 0.24, 0.15},{0.24, 0.17, 0.32},{0.41, 0.15, 0.16}};
 
    float N_vn[n_vnut]={0}; //значения 9 внутренних нейронов обнуляем.
 
    // 3 столбца по 9 строк, 9 внутренних нейронов 27 весов
    float W_out[n_out][n_vnut]={{0.23, 0.32, 0.2, 0.21, 0.2, 0.32, 0.15, 0.24, 0.22},
    {0.33, 0.12, 0.2, 0.21, 0.4, 0.31, 0.16, 0.23, 0.22}, {0.235, 0.3, 0.24, 0.26, 0.19, 0.28, 0.10, 0.25, 0.21}};
    float N_out[n_out]={0}; // содержимое 3 выходных нейронов
 
    float weight_delta[n_out]={0};
    float weight_deltaNvn[n_vnut]={0};
    float error_Nvn[n_vnut]={0};
    float error_out[n_out]={0};
    float sigmx_dxN[n_out]={0}; // производная сиг функции
    float sigmx_dxNvn[n_vnut]={0}; // производная сиг функции внутр нейронов
    float learning_rate=0.1;
 
    float counti=2000;
 
    for (int i = 0; i <counti; i++)
    {
    cout << "++++++++++counti= " << i<<endl;
// цикл опроса входных значений
    for (int var = 0; var <var_comb; var++) // var_comb=8
    {
        N_inp[0]=ar_data [var][0]+0.1;
        N_inp[1]=ar_data [var][1]+0.1;
        N_inp[2]=ar_data [var][2]+0.1;
            target[0]=arr_out [var][0];
            target[1]=arr_out [var][1];
            target[2]=arr_out [var][2];
//////        cout << "N_inp[0]= " << N_inp[0]<<endl;
//////        cout << "N_inp[1]= " << N_inp[1]<<endl;
//////        cout << "N_inp[2]= " << N_inp[2]<<endl;
        cout << "target 0= " << target[0]<<endl;
        cout << "target 1= " << target[1]<<endl;
        cout << "target 2= " << target[2]<<endl;
 
 
    // прямое вычисление 9 внутренних нейронов
    for (int i = 0; i <n_vnut; i++)
    {
    N_vn[i]=0; // попробовать откл и усложнить вых данные
    for (int j = 0; j <n_input; j++)
 
        {
            N_vn[i]=N_vn[i]+N_inp[j]*W_inp[i][j];
        }
///        cout <<"N_vn["<< i <<"]= " << N_vn[i]<<endl; //
    }
 
    // вычисление сигмоиды внутренних нейронов
    for (int i = 0; i <n_vnut; i++)
    {
        N_vn[i]=1/(1+exp(-N_vn[i]));
 
///        cout <<"N_vnSigm["<<i<<"]= " << N_vn[i]<<endl; //
    }
 
    // прямое вычисление 3 выходных нейронов при 9 внутренних нейронов
     for (int j = 0; j <n_out; j++)
           {
            N_out[j]=0;
                        for (int i = 0; i <n_vnut; i++)
                    {
                        N_out[j]=N_out[j]+N_vn[i]*W_out[j][i];
                    }
///        cout << "N_out["<<j<<"]= " <<N_out[j]<<endl;
           }
 
    // вычисление сигмоиды выходных нейронов
    for (int i = 0; i <n_out; i++)
    {
        N_out[i]=1/(1+pow(e,-N_out[i]));
        cout << "Sigm Nout["<<i<<"]= " << N_out[i]<<endl;
    }
    cout << "var= " << var<<endl;
 
    // Начало вычислений и обратного распространения ошибок
    // для обучения
 
                      // цикл вычисления ошибок, сигмоиды и weight_delta выходных нейронов
            for (int i = 0; i <n_out; i++)
                  {
            // вычисление ошибок выходных нейронов
            error_out[i]=N_out[i]-target[i];
///         cout << "error_out[i]= " << error_out[i]<<endl; //
 
            // вычисление производной сигмоиды выходного нейрона
            sigmx_dxN[i]=N_out[i]*(1-N_out[i]);
///         cout << "sigmx_dxN["<<i<<"]= " << sigmx_dxN[i]<<endl; //
            // вычисление производной weight_delta
            weight_delta[i]=error_out[i]*sigmx_dxN[i];
//////            cout << "weight_delta["<<i<<"]= " << weight_delta[i]<<endl; //
                  }
 
            // перерасчет выходных весов для любого количества выходных нейронов
            for (int j = 0; j <n_out; j++)
            {
                        for (int i = 0; i <n_vnut; i++)
                {
///        cout << "W_out[i]["<<i<<"]= " << W_out[0][i]<<endl; //
        W_out[j][i]=W_out[j][i]-(N_vn[i]*weight_delta[j]*learning_rate);
 
/// cout << "W_out_new["<<j<<"]["<<i<<"]= " << W_out[j][i]<<endl; //
                }
            // cout << "W_out_new["<<j<<"]["<<i<<"]= " << W_out[j][i]<<endl; //
            }
 
            // нахождение ошибок для каждого внутреннего нейрона
            for (int i = 0; i <n_vnut; i++)
                {
                error_Nvn[i]=0;
                        for (int j = 0; j <n_out; j++)
                        {
                        error_Nvn[i]=error_Nvn[i]+W_out[j][i]*weight_delta[j];
///        cout << "error_vnN["<<i<<"]= " << error_vnN[i]<<endl; //
                        }
                }
 
                    /// нахождение нового значения для каждого внутреннего нейрона с учетом ошибки
            for (int i = 0; i <n_vnut; i++)
                    {
        N_vn[i]= N_vn[i]-error_Nvn[i];
 ///       cout << "N_vn_new["<<i<<"]= " << N_vn[i]<<endl;
                    }
 
                        for (int i = 0; i <n_vnut; i++)
                {
 
             // вычисление производной сигмоиды и weight_delta для внутренних нейронов
        sigmx_dxNvn[i]=N_vn[i]*(1-N_vn[i]);
///            cout << "sigmx_dxN["<<i<<"]= " << sigmx_dxNvn[i]<<endl; //
        weight_deltaNvn[i]=error_Nvn[i]*sigmx_dxNvn[i];
///            cout << "weight_delta["<<i<<"]= " << weight_delta[i]<<endl; //
                  }
 
 
                         // перерасчет 9 массивов входных весов из 3 нейронов (3 слойный пирог 9 кусочков)
            for (int j = 0; j <n_input; j++)
                {
                    for (int i = 0; i <n_vnut; i++)
                    {
        W_inp[i][j]=W_inp[i][j]-N_inp[j]*weight_deltaNvn[i]*learning_rate;
                    }
 
                }
        } // окончание цикла задания значений N_inp
        } // окончание цикла counti
 
                         // 5. Вывести массив W_inp[i][j] для проверки
  cout << endl << "W_inp[i][j]:" << endl;
  for (int i = 0; i < n_vnut; i++)
  {
    for (int j = 0; j < n_input; j++)
      cout << W_inp[i][j] << '\t';
    cout << endl;
  }
cout << "warcomb= " << var_comb<<endl; //
 
 
   return 0;
}