Нейросети-этот мудренный backprop,новая версия кода

 grads_out_nn=delta_out*self.nonlin(self.e2,deriv=True)*\
 self.e2 # Вот этого не было,ошибка иногда росла,иногда уменьшалась

import matplotlib.pyplot as plt
 
from math import sqrt
 
# Зерно для генератора
np.random.seed(150) 
class NN:
 
  def nonlin(self,sygnals,deriv=False):
  
     if deriv:
           return sygnals*(1-sygnals)
 
     return 1 / (1+np.exp(-sygnals))
   
  def __init__(self):
 
     self.e1=None # Взвешенная сумма сигналов на первой прослойке
     self.e2=None # Взвешенная сумма сигналов на второй прослойке 
   
     self.hidden1=None # активированное состояние нейронов на первой прослойке
     self.hidden2=None # активированное состояние нейронов на второй прослойке
 
     self.learning_rate=0.001
  
     self.init_net()
  
  def  init_net(self):
    
     """
       Трехслойный перпецетрон
       1слой-2 нейрона.
       2слой-4 нейрона.
       3слой-1 нейрон.
 
 
               o
 
        ->  o  o
                   o->
        ->  o  o
 
               o
  
     """
   
     #self.in_layer1=np.random.normal(0,1,(4,2)) 
     #self.in_layer2=np.random.normal(0,1,(1,4))
     # Говорят так лучше инициализировать веса,под дробью параметр-количество
     # дендритов-сигналов
     self.in_layer1=np.random.randn(4,2)*sqrt(2.0/2)
     self.in_layer2=np.random.randn(1,4)*sqrt(2.0/4)
     
    
  def direct_motion(self,_vector:list):
 
      
     self.e1=np.dot(self.in_layer1,_vector.T)
     self.hidden1=self.nonlin(self.e1)
     
     self.e2=np.dot(self.in_layer2,self.hidden1)
     self.hidden2=self.nonlin(self.e2)
 
     return self.hidden2
 
  
  def calculate_minimal_square_error(self,val):
 
     return np.mean(np.square(val))
   
 
  def back_propagate(self,vector:list, target:list):
  
      """
         Прямой проход
      """
      out_NN=self.direct_motion(vector)
 
      """
           Расчет ошибки 
      """
      delta_out=abs(target.T-out_NN)
      grads_out_nn=delta_out*self.nonlin(self.e2,deriv=True)*\
      self.e2 # Вот этого не было,ошибка иногда росла,иногда уменьшалась  
 
      # Взвешиваем ошибку
 
      grads_on_lay2=np.dot(grads_out_nn.T,self.in_layer2)*self.nonlin(self.e1.T,deriv=True)
 
      grads_on_lay1=np.dot(grads_on_lay2,self.in_layer1)
 
      """
         Коррекция ошибки
      """
     
      self.in_layer1+=( vector*grads_on_lay1*self.learning_rate)
     
      self.in_layer2+=(self.e1.T*grads_on_lay2*self.learning_rate)
 
      return self.calculate_minimal_square_error(delta_out)
    
  def plot_graphic_by_x_and_y(self,x,y):
      plt.plot(x,y)
      plt.show()    
 
  def learn(self,epocha:int,etta:float,train_set:list):
    
     error=0.0
 
     iteration:int=0
     n_epochs=[]
     n_mse=[]
     while(iteration< epocha):
      
       for vector,target in train_set:
            """
              Переберет все случаи train set-а, затем начнется новая эпоха
            """
            assert (isinstance((vector,target),tuple))
            assert (isinstance(vector,list))
            assert (isinstance(target,list))
 
 
            error=self.back_propagate(np.array(vector),np.array(target))
       if iteration % 1==0:
 
          print(error)
          n_epochs.append(iteration)
          n_mse.append(error)
           
 
       iteration+=1
     self.plot_graphic_by_x_and_y(n_epochs,n_mse)
     
 
def create_nn()->NN:
 
  return NN()     
def test():
 
   NN=create_nn()
   train_set=[([[0,0]],[[0]]),([[1,1]],[[1]]),([[0,1]],[[1]]),([[1,0]],[[1]])]
 
   NN.learn(100,0.07,train_set)  
 
if __name__=='__main__':
   test()