Крутой код.Самодельная нейросеть работает с mnist

"""
   Трехслойный перпецетрон
"""
 
import numpy as np
import matplotlib.pyplot as plt
 
from math import sqrt
from keras.datasets import mnist
 
from keras.utils import np_utils
 
import hashlib as hsh
 
#np.set_printoptions(threshold=np.inf) для вывода матриц полностью
 
 
 
# Зерно для генератора
np.random.seed(42)
 
bias_val=1
class NN:
 
  def nonlin(self,sygnals,deriv=False):
    
     if deriv:
           return (sygnals*(1.0-sygnals))
 
     return (1.0 / (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):
    
   
     self.in_layer1=np.random.normal(0,2**-0.5,(40,784)) 
     self.in_layer2=np.random.normal(0,2**-0.5,(10,40))
     # Говорят так лучше инициализировать веса,под дробью параметр-количество
     # дендритов-сигналов
     #self.in_layer1=np.random.randn(40,784)\
       #*sqrt(2.0/784)
     #self.in_layer2=np.random.randn(10,40)\
       #*sqrt(2.0/10)
     print("lay1 %s \n lay2 %s"%(self.show_matrix_hash(self.in_layer1,self.in_layer2)[0],self.show_matrix_hash(self.in_layer1,self.in_layer2)[1]))
     
    
  def direct_motion(self,_vector):
 
      
     self.e1=np.dot(self.in_layer1,_vector.T)
     self.e1/=784
    
     self.hidden1=self.nonlin(self.e1
                              +bias_val
                              )
     self.hidden1/=784 # Здесь все нормализовал что бы не было больших чисел
                       # ведь идет сумма произведений,которые близки к единицы
                       # а их 784
     self.e2=np.dot(self.in_layer2,self.hidden1)
     self.e2/=40      # нормализовал
     self.hidden2=self.nonlin(self.e2
                              +bias_val
                              )
     self.hidden2/=40
     return self.hidden2
 
   # for debug
  def show_matrix_hash(self,*matr):
                hash_obj=hsh.sha256()
                matr_list=['']*len(matr)
                j=0
                #:matrix<R> 
                for i  \
                    in matr:   
                         hash_obj.update(str(matr).encode('ascii'))
                         matr_list[j]=hash_obj.hexdigest()
                         j+=1
                return matr_list      
 
  
  def calculate_minimal_square_error(self,val):
 
     return np.mean(np.square(val))
   
 
  def back_propagate(self,vector, target):
  
      """
         Прямой проход
      """
      out_NN=self.direct_motion(vector)
      #print("out %s",self.show_matrix_hash(out_NN)[0])
 
      """
           Расчет ошибки 
      """
      delta_out=abs(target.T-out_NN)
      grads_out_nn=delta_out*self.nonlin(self.e2,deriv=True)
     
 
      grads_on_lay2=np.dot(grads_out_nn.T,self.in_layer2)*self.nonlin(self.e1.T,deriv=True)*1/40 # Подправлям дифференциалы
      grads_on_lay1=np.dot(grads_on_lay2,self.in_layer1)*1/784  # Подправлям дифференциалы
 
      """
         Коррекция ошибки
      """
     
      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,l_r:float,train_set,target_set):
    
     error=0.0
     self.learning_rate=l_r
     iteration:int=0
     n_epochs=[]
     n_mse=[]
     while(iteration< epocha):
       
       for i in range(train_set.shape[0]):
           
            single_2D_array_train=np.array([train_set[i]])
            single_2D_array_target=np.array([target_set[i]])
            error=self.back_propagate(single_2D_array_train,single_2D_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():
   (X_train,y_train),(X_test,y_test)=mnist.load_data()
   
   X_train=X_train.astype('float32')
    
  
   X_train=X_train.reshape(60000,784)
  
   # Нормализация всей обучающей выборки
   X_train=X_train/255.0
   print('X_train',X_train[0])
   
   y_train=np_utils.to_categorical(y_train)    
 
   NN=create_nn()  
 
   NN.learn(100,0.7,X_train,y_train)  
#===========================
if __name__=='__main__':
   test()
#===========================