Простая задача, но сеть уходит в континуум

0,4994      0,999
0,4975      0,993
0,4861      0,96
0,4345      0,828
0,3154      0,581
0,222       0,395
0,1928      0,301
0,1856      0,252
0,1838      0,225
0,1832      0,209
0,183       0,199
0,183       0,192
0,1831      0,188
0,1831      0,185
0,1831      0,183
...................................

const iLayersCount = 5;
const iDendrCount = 10;
const double dLearnStep = 0.01;
const double dHighValueErr = 0.12;
const iUotputCount = 1;
const double dImpulse = 0.5;
const int iIterations = 100;
//5 слоёв, включая 1 входной; выходной слой из одного нейрона (класс описан отдельно)
 
//Нейрон---------------------------------------------------------------------------------------
class TNeuron{
 public:
 double dSumm;
 double dDendr[iDendrCount];
 double dWeights[iDendrCount];
 double dExtremum[iDendrCount];
 double dDemWeights[iDendrCount];//"история" изменения весов
 double dSigma;
 
 TNeuron(){
   dSumm = 0;
   dSigma = 0;
   for ( int i = 0; i<iDendrCount; i++)
       dWeights[i] =  = (double)(rand()%200)/200.000;
   for ( int i = 0; i<iDendrCount; i++) dExtremum[i] = 1;
   for ( int i = 0; i<iDendrCount; i++) dDendr[i] = 0;
   for ( int i = 0; i<iDendrCount; i++) dDemWeights[i] = dWeights[i];
 }
 
  double _Func(){//acson
  dSumm = 0;
  for ( int i = 0; i < iDendrCount; i++){
        dSumm += dDendr[i]*dWeights[i];
      }
  return RoundingTo( 1/( 1 + exp(-1.1*dSumm)), -3);
 }
 
};
 
//Нейрон выходного слоя---------------------------------------------------------------
class TDecision{
 public:
 double dSumm;
 double dWeights[iDendrCount];
 double dDemWeights[iDendrCount];
 double dDendr[iDendrCount];
 double dSigma;
 TDecision(){
  dSumm = 0;
  dSigma = 0;
  for ( int i = 0; i<iDendrCount; i++)
      {
      double dd = (double)(rand()%200)/200.000;
      dWeights[i] = dd;
      }
  for ( int i = 0; i<iDendrCount; i++) dDendr[i] = 0;
  for ( int i = 0; i<iDendrCount; i++) dDemWeights[i] = dWeights[i];
 }
 
  double _Func(){//acson
  dSumm = 0;
  for ( int i = 0; i < iDendrCount; i++)
      {
        dSumm += dDendr[i]*dWeights[i];
      }
  return RoundingTo( 1/( 1 + exp(-1.1*dSumm)), -3);
 }
 
};
 
//класс слоя сети------------------------------------------------------------------------------
class TLayer{
 public:
 TNeuron *Neurones[iDendrCount];
 double dSigma;
 TLayer(){
  dSigma = 0;
  for ( int i = 0; i<iDendrCount; i++)
      Neurones[i] = new TNeuron();
 }
};
 
//класс сеть----------------------------------------------------------------------------
class TNetwork{
 public:
 TLayer *layers[iLayersCount];
 TDecision *dDec[iUotputCount];
 TNetwork(){
  for ( int i = 0; i<iLayersCount; i++){
        layers[i] = new TLayer();
      }
  for ( int i = 0; i<iUotputCount; i++){
        dDec[i] = new TDecision;
      }
 }
};
TNetwork* Net;

double _fastcall CalcSigmasOnLayer( int iLayer, int idxW)//сигмы внутренних слоёв
{
 double dSum = 0;
 if ( iLayer == iLayersCount)//это последний скрытый слой
    {
      for ( int N = 0; N < iUotputCount; N++)
          dSum += Net->dDec[N]->dSigma * Net->dDec[N]->dWeights[idxW];//сигма_выхода* вес_нейрона
    }
    else
    for ( int N = 0; N<iDendrCount; N++)//остальные внутренние слои
     {
       dSum += Net->layers[iLayer]->Neurones[N]->dSigma * Net->layers[iLayer]->Neurones[N]->dWeights[idxW];
     }
 return dSum;
}
 
//----------------------------------------------------------------------------------------------
double _fastcall CalcSigmasOnDec( double dY)//сигма выходного слоя
{
 double dSum = 0;   
 double dOut = Net->dDec[idxW]->_Func();//у сети всего один нейрон на выходном слое
 Net->dDec[idxW]->dSigma = dOut*(1-dOut)*(dY-dOut);
 return Net->dDec[idxW]->dSigma;
}
 
//----------------------------------------------------------------------------------------------
void CalcSigmasOnNeuron()//Сигма по нейронам скрытых слоёв
{
 for ( int N = 0; N<iDendrCount; N++)//последний скрытый слой
     {
       double dOut = Net->layers[iLayersCount-1]->Neurones[N]->_Func();//значение выхода нейрона слоя
       double dSigmaOnLayer = CalcSigmasOnLayer(iLayersCount, N);//сигма выходного слоя
       Net->layers[iLayersCount-1]->Neurones[N]->dSigma = dOut*(1-dOut)*(dSigmaOnLayer);
     }
 
 for ( int L = iLayersCount-2; L>0; L--)//внутренние слои, кроме последнего
     {
       for ( int N = 0; N<iDendrCount; N++)
           {
             double dOut = Net->layers[L]->Neurones[N]->_Func();
             Net->layers[L]->Neurones[N]->dSigma = dOut*(1-dOut)*CalcSigmasOnLayer(L+1, N);
           }
     }
}

void CorrectNetWeights()//корректировка весов сети
{
 for ( int N = 0; N < iUotputCount; N++)//выходной слой
     {
       for ( int i = 0; i<iDendrCount; i++) {
             Net->dDec[N]->dDemWeights[i] = dLearnStep*Net->dDec[N]->dSigma + dImpulse*Net->dDec[N]->dDemWeights[i];
             Net->dDec[N]->dWeights[i] = Net->dDec[N]->dWeights[i] + Net->dDec[N]->dDemWeights[i];
           }
     }
 
for ( int L = iLayersCount-1; L>0; L--) {
     for ( int N = 0; N<iDendrCount; N++) {
         for ( int i = 0; i <iDendrCount; i++) {
                   Net->layers[L]->Neurones[N]->dDemWeights[i] = dLearnStep * Net->layers[L]->Neurones[N]->dSigma +
                                                                 dImpulse * Net->layers[L]->Neurones[N]->dDemWeights[i];
                   Net->layers[L]->Neurones[N]->dWeights[i] = Net->layers[L]->Neurones[N]->dWeights[i] +
                                                              Net->layers[L]->Neurones[N]->dDemWeights[i];
             }
         }
     }
 
}

//Запуск обучения
String sInput[] = { "10010110111",//7
                     "11010110111",//8
                     "10010110000",//4
                     "10010110000",//4
                     "10010100000",//3
                     "10100110000",//4
                     "10000100000",//2
                     "10010111101",//7
                     "11010111101",//8
                     "01000101100"//4
                   };//обучающая выборка
 
while ( dErr_Current>dHighValueErr)
 {
 dErr_Current = 0;
 
 int iSz = sizeof(sInput)/4;//колво элементов в обучающей выборке
 
 for ( int Y = 0; Y<iSz; Y++)
       {
         sAwaited = sInput[Y][10];//ожидаемое значение выхода
 
         int iSzR = sInput[Y].Length();
         for ( int i = 0; i<iSzR; i++) {
               Net->layers[0]->Neurones[0]->dDendr[i] = String(sInput[Y][i+1]).ToInt();//подали сигналы на вход
             }
 
         //расчёт сети==============================================
          for ( int L = 1; L<iLayersCount; L++)//текущий слой
              {
                 for ( int N = 0; N < iDendrCount; N++)//нейроны текущего слоя
                     {
                       for ( int D = 0; D<iDendrCount; D++)//дендриты текущего нейрона текущего слоя
                           {
                             Net->layers[L]->Neurones[N]->dDendr[D] = Net->layers[L-1]->Neurones[D]->_Func();
                             double fff = Net->layers[L]->Neurones[N]->dDendr[D];
                           }
                     }
              }
 
           for ( int O = 0; O < iUotputCount; O++){
                 for ( int D = 0; D<iDendrCount; D++){
                       double dT = Net->layers[iLayersCount-1]->Neurones[D]->_Func();
                       Net->dDec[O]->dDendr[D] = dT;
                     }
               }
 
         double dOutput = Net->dDec[0]->_Func();
 
         //завершение расчёта сети======================================
 
         double dA_ = 0;//ожидаемые значения
 
         if ( sAwaited == "1")
            dA_ = 1;
 
         CalcSigmasOnDec( dA_);//расчёт сигмы на нейронах(-оне) выходного слоя
         CalcSigmasOnNeuron();//сигмы скрытых слоёв
         CorrectNetWeights();//корректировка весов
 
         double dEsum = fabs( pow(dOutput-dA_, 2)) * 0.5;
       }//for
 
   dErr_Current = (dErr_Current+1)/iSz;
 }