Обучение нейронной сети - алгоритм обратного распространения ошибки(learning_tree)

struct SAcson
{
    int l,c; // строка, столбец
    float x; // заряд
};
struct SSinapc
{
    int l,c; // строка, столбец
};
struct SNeiron
{
    float w; // весы
    float c; // заряд
    vector <SAcson> a; // аксон
    vector <SSinapc> s; // синапс
    inline bool operator== (SNeiron * n) {return (n == this) ? true : false;}
};
class SNetAI
{
protected:
    float cw;
    float cx;
    vector<vector <SNeiron>> neirons; //  нейроны
    vector <bool> r; // реле ответов
    void initSinaps();
    void void_charge();
    void bypass(vector<SAcson* > &ns,  vector<SNeiron* > &nw ,vector <SNeiron> :: iterator n);
    void delete_duplicate_neiron(vector<SNeiron* > &nw, unsigned int size_not_delete);
public:
    friend SNeiron;
    SNetAI ();
    void create(char *с);
    void launc_signal(vector <unsigned int> m);
    vector <bool> & get_result();
    void learning(bool err);
    void learning_tree(vector <bool> &r, unsigned int type_l);
    void save(char *с);
 
};

void  SNetAI::delete_duplicate_neiron(vector<SNeiron* > &nw, unsigned int size_not_delete)
 {
    for (unsigned int i = size_not_delete; i < nw.size() ; i++)
    {
        for (unsigned int j = size_not_delete; j < nw.size() ; j++)
        {
            if(i == j)
                continue;
            if( nw[i] == nw[j])
            {
                vector<SNeiron* > ::iterator del_nw = nw.begin() + j;
                nw.erase(del_nw);
                j--;
            }
        }
 
    }
 };
 void SNetAI::learning_tree(vector <bool> &r , unsigned int type_l)
     {
         vector <SAcson*> nsp;
         vector <SAcson*> nsm;
         vector <SNeiron*> nwp;
         vector <SNeiron*> nwm;
 
         vector <vector <SNeiron>> :: iterator i2 = neirons.end() - 1;
         for (vector <SNeiron> :: iterator i =  i2->begin() ; i < i2->end() ; i++)
         {
             int size_nwp = nwp.size();
             int size_nwm = nwm.size();
             if (r[distance(i2->begin(), i)])
             {
 
                 bypass(nsp, nwp,i);
                 delete_duplicate_neiron(nwp, size_nwp);
             }
             else
             {
                 bypass(nsm, nwm,i);
                 delete_duplicate_neiron(nwm, size_nwm);
             }
         }
         switch(type_l)
         {
         case 1:
             for ( unsigned int i = 0; i < nsp.size(); i ++)
             {
                 nsp[i]->x += cx;
             }
             for ( unsigned int i = 0; i < nsm.size(); i ++)
             {
                 nsm[i]->x -= cx;
             }
             break;
 
         case 2:
             for ( unsigned int i = 0; i < nwp.size(); i ++)
             {
                 nwp[i]->w += cw;
             }
             for ( unsigned int i = 0; i < nwm.size(); i ++)
             {
                 nwm[i]->w -= cw;
             }
             break;
 
         case 3:
             for ( unsigned int i = 0; i < nsp.size(); i ++)
             {
                 nsp[i]->x += cx;
             }
             for ( unsigned int i = 0; i < nsm.size(); i ++)
             {
                 nsm[i]->x -= cx;
             }
             for ( unsigned int i = 0; i < nwp.size(); i ++)
             {
                 nwp[i]->w += cw;
             }
             for ( unsigned int i = 0; i < nwm.size(); i ++)
             {
                 nwm[i]->w -= cw;
             }
             break;
         };
 }
 void SNetAI::bypass(vector<SAcson* > &ns,  vector<SNeiron* > &nw ,vector <SNeiron> :: iterator n)
 {
    
    for (vector <SSinapc> ::iterator i = n->s.begin() ; i < n->s.end(); i++)
    {
        for (vector <SAcson> ::iterator j = neirons[i->c][i->l].a.begin(); j < neirons[i->c][i->l].a.end(); j++)
        {
            vector <SNeiron> :: iterator n2 = neirons[j->c].begin() + j->l;
            if (n2 == n)
            {
                ns.push_back(&j[0]);
                nw.push_back(&n2[0]);
                break;
            }
        }
        vector <SNeiron> :: iterator n2 = neirons[i->c].begin() + i->l;
        bypass(ns, nw,  n2);
    }
            
 }