red neuronal de convolución CNN (Tensorflow 2.1)

Se metafísico, sin modificación de los parámetros, la exactitud de la prueba sobre la pluralidad cambió de 99,1% a 98% de

conexión de referencia: " simple y Tensorflow crudo ", bravatas

tensorflow importación AS TF 
importación numpy AS NP 

clase MNISTLoader (): 
    DEF la __init __ (self): 
        MNIST = tf.keras.datasets.mnist 
        (self.train_data, self.train_label), (self.test_data, self.test_label) = MNIST. load_data () 
        # MNIST la uint8 predeterminada de la imagen ( 0 -255 número). El código siguiente del mismo a 0- normalizado de punto flotante número entre 1 y se añade al final como un canal de color-dimensional 
        self.train_data = np.expand_dims (self.train_data.astype (np.float32) / 255,0 , Axis = - 1 ) # [ 60000 , 28 , 28 , 1 ]
        self.test_data = np.expand_dims (self.test_data.astype (np.float32) / 255,0 , Axis = - . 1 ) # [ 10000 , 28 , 28 , 1. ] 
        self.train_label = self.train_label.astype (np.int32) # [ 60000 ] 
        self.test_label = self.test_label.astype (np.int32) # [ 10000 ] 
        self.num_train_data, self.num_test_data = self.train_data.shape [ 0 ], self.test_data.shape [ 0 ] 

    get_batch DEF ( Ser, batch_size): 
        # concentrada elementos batch_size tomadas al azar de los datos y devuelve el 
        índice= Np.random.randint ( 0 , np.shape (self.train_data) [ 0 ], batch_size)
         retorno self.train_data [índice,:], self.train_label [Índice] 


# tf.keras.layers.Conv2D ( 
# filtros , kernel_size, pasos = ( 1 , 1 ), relleno = ' válida ' , data_format = Ninguno, 
# dilation_rate = ( 1 , 1 ), activación = ninguno, use_bias = Verdadero, 
# kernel_initializer = ' glorot_uniform ' , bias_initializer = ' ceros '  ,
# kernel_regularizer = ninguno, bias_regularizer = Ninguno, activity_regularizer = Ninguno, 
# kernel_constraint = Ninguno, bias_constraint = Ninguno, ** kwargs 
#) 
# Filtros: Entero, la dimensionalidad del espacio La salida (Output es decir, el número de filtros en la convolución). 
# kernel_size: Integer campos receptivos o tupla Una / Lista de 2 números enteros que especifican la altura y la anchura de convolución 2D de la ventana. 
# pasos: paso vertical y horizontal 
# relleno: válida: no representa la convolución kernel de tamaño de bloque se descarta; representa una convolución kernel el tamaño de la misma no es suficiente para compensar el bloque 0, la salida y la entrada de la misma forma 

clase CNN (tf.keras.Model): 
    DEF la __init __ (Self): 
        super () __ .__ el init () 
        self.conv1 =tf.keras.layers.Conv2D ( 
            Filtros = 32 , # neurona convolución (convolución) Número 
            kernel_size = [ . 5 , . 5 ], # tamaño del campo receptivo 
            relleno = ' Same ' , # política de relleno (o vaild SAMe) 
            activación = tf.nn.relu # activación de la función 
        ) 
        self.pool = tf.keras.layers.MaxPool2D (pool_size = [ 2 , 2 ], Strides = 2 ) 
        self.conv2 = tf.keras.layers.Conv2D ( 
            Filtros = 64 ,
            kernel_size = [5 , 5 ], 
            relleno = ' misma ' , 
            activación = tf.nn.relu 
        ) 
        self.flatten = tf.keras.layers.Reshape (target_shape = ( 7 * 7 * 64 ,)) 
        self.dense1 = tf.keras. layers.Dense (unidades = 1024 , la activación = tf.nn.relu) 
        self.dense2 = tf.keras.layers.Dense (unidades = 10 ) 

    def llamar (self, entradas): 
        x = self.conv1 (entradas) # [ batch_size, 28 ,28 , 32 ] 
        x = self.pool (x) # [batch_size, 14 , 14 , 32 ] 
        x = self.conv2 (x) # [batch_size, 14 , 14 , 64 ] 
        x = self.pool (x) # [ batch_size, 7 , 7 , 64 ] 
        x = self.flatten (x) # [batch_size, 7 * 7 * 64 ] 
        x= Self.dense1 (x) # [batch_size, 1024 ] 
        x = self.dense2 (x) # [batch_size, 10 ] 
        de salida = tf.nn.softmax (x)
         de retorno de salida 

num_epochs = 5 
batch_size = 50 
learning_rate = 0,001 

modelo = CNN () 
data_loader = MNISTLoader () 
optimizador = tf.keras.optimizers.Adam (learning_rate = learning_rate) 

num_batches = int (data_loader.num_train_data //* num_epochs la batch_size) 
para batch_index en Rango (num_batches): 
    X-, Y = data_loader.get_batch (la batch_size) # seleccionados al azar parte del conjunto de datos a partir de los datos 
    con tf.GradientTape () AS cinta: 
        y_pred = Model (X-) para dar un # valor de predicción 
        pérdida tf.keras.losses.sparse_categorical_crossentropy = (Y = y_true, y_pred = y_pred) # calcula Pérdida 
        Pérdida = tf.reduce_mean (pérdida) 
        de impresión ( " BATCH% D: Pérdida% F " % (batch_index, loss.numpy ())) 
    GrADS = = tape.gradient (Pérdida), model.variables GrADS #calc
    optimizer.apply_gradients (grads_and_vars ZIP (graduados, model.variables)) #update GrADS 

# tf.keras.metrics.SparseCategoricalAccuracy un estimador 
# no entienden por qué el lote valor de predicción de verificación 
sparse_categorical_accuracy = tf.keras.metrics.SparseCategoricalAccuracy () 
num_batches = int (data_loader.num_test_data // el batch_size) 
para batch_index en Rango (num_batches): 
    start_index, END_INDEX = batch_index la batch_size *, (+ batch_index . 1 ) * la batch_size 
    # de entrada de datos de prueba model.predict, y da salida a un resultado de predicción 
    y_pred = model.predict (data_loader.test_data [start_index: END_INDEX])
    sparse_categorical_accuracy.update_state (y_true = data_loader. test_label [start_index: END_INDEX], y_pred =y_pred) 
de impresión ( " prueba de precisión:% f " % sparse_categorical_accuracy.result ())