I continue my series on a Python code for a simple multi-layer perceptron [MLP]. During the course of the previous articles we have built a Python class “ANN” with methods to import the MNIST data set and handle forward propagation as well as error backward propagation [EBP]. We also had a deeper look at the mathematics of gradient descent and EBP for MLP training.

A simple program for an ANN to cover the Mnist dataset – IX – First Tests

A simple program for an ANN to cover the Mnist dataset – VIII – coding Error Backward Propagation

A simple program for an ANN to cover the Mnist dataset – VII – EBP related topics and obstacles

A simple program for an ANN to cover the Mnist dataset – VI – the math behind the „error back-propagation“

A simple program for an ANN to cover the Mnist dataset – V – coding the loss function

A simple program for an ANN to cover the Mnist dataset – IV – the concept of a cost or loss function

A simple program for an ANN to cover the Mnist dataset – III – forward propagation

A simple program for an ANN to cover the Mnist dataset – II – initial random weight values

A simple program for an ANN to cover the Mnist dataset – I – a starting point

The code modifications in the last article enabled us to perform a first test on the MNIST dataset. This test gave us some confidence in our training algorithm: It seemed to converge and produce weights which did a relatively good job on analyzing the MNIST images.

We saw a slight tendency of overfitting. But an accuracy level of **96.5%** on the test dataset showed that the MLP had indeed “* learned*” something during training. We needed around 1000 epochs to come to this point.

However, there are a lot of parameters controlling our grid structure and the learning behavior. Such parameters are often called “**hyper-parameters**“. To get a better understanding of our MLP we must start playing around with such parameters. In this article we shall concentrate on the parameter for (regression) regularization (called Lambda2 in the parameter interface of our class ANN) and then start varying the node numbers on the layers.

But before we start new test runs we add a statistical element to the training – namely the variation of the composition of our mini-batches (see the last article).

General hint: In all of the test runs below we used 4 CPU cores with libOpenBlas on a Linux system with an I7 6700K CPU.

# Shuffling the contents of the mini-batches

Let us add some more parameters to the interface of class “ANN”:

shuffle_batches = True

print_period = 20

The first parameter

shall control whether we vary the composition of the mini-batches with each epoch. The second parameter controls for which period of the epochs we print out some intermediate data (costs, averaged error of last mini-batch).

def __init__(self, my_data_set = "mnist", n_hidden_layers = 1, ay_nodes_layers = [0, 100, 0], # array which should have as much elements as n_hidden + 2 n_nodes_layer_out = 10, # expected number of nodes in output layer my_activation_function = "sigmoid", my_out_function = "sigmoid", my_loss_function = "LogLoss", n_size_mini_batch = 50, # number of data elements in a mini-batch n_epochs = 1, n_max_batches = -1, # number of mini-batches to use during epochs - > 0 only for testing # a negative value uses all mini-batches lambda2_reg = 0.1, # factor for quadratic regularization term lambda1_reg = 0.0, # factor for linear regularization term vect_mode = 'cols', learn_rate = 0.001, # the learning rate (often called epsilon in textbooks) decrease_const = 0.00001, # a factor for decreasing the learning rate with epochs mom_rate = 0.0005, # a factor for momentum learning shuffle_batches = True, # True: we mix the data for mini-batches in the X-train set at the start of each epoch print_period = 20, # number of epochs for which to print the costs and the averaged error figs_x1=12.0, figs_x2=8.0, legend_loc='upper right', b_print_test_data = True ): ''' Initialization of MyANN Input: data_set: type of dataset; so far only the "mnist", "mnist_784" datsets are known We use this information to prepare the input data and learn about the feature dimension. This info is used in preparing the size of the input layer. n_hidden_layers = number of hidden layers => between input layer 0 and output layer n ay_nodes_layers = [0, 100, 0 ] : We set the number of nodes in input layer_0 and the output_layer to zero Will be set to real number afterwards by infos from the input dataset. All other numbers are used for the node numbers of the hidden layers. n_nodes_out_layer = expected number of nodes in the output layer (is checked); this number corresponds to the number of categories NC = number of labels to be distinguished my_activation_function : name of the activation function to use my_out_function : name of the "activation" function of the last layer which produces the output values my_loss_function : name of the "cost" or "loss" function used for optimization n_size_mini_batch : Number of elements/samples in a mini-batch of training data The number of mini-batches will be calculated from this n_epochs : number of epochs to calculate during training n_max_batches : > 0: maximum of mini-batches to use during training < 0: use all mini-batches lambda_reg2: The factor for the quadartic regularization term lambda_reg1: The factor for the linear regularization term vect_mode: Are 1-dim data arrays (vctors) ordered by columns or rows ? learn rate : Learning rate - definies by how much we correct weights in the indicated direction of the gradient on the cost hyperplane. decrease_const: Controls a systematic decrease of the learning rate with epoch number mom_const: Momentum rate. Controls a mixture of the last with the present weight corrections (momentum learning) shuffle_batches: True => vary composition of mini-batches with each epoch print_period: number of periods between printing out some intermediate data on costs and the averaged error of the last mini-batch figs_x1=12.0, figs_x2=8.0 : Standard sizing of plots , legend_loc='upper right': Position of legends in the plots b_print_test_data: Boolean variable to control the print out of some tests data ''' # Array (Python list) of known input data sets self._input_data_sets = ["mnist", "mnist_784", "mnist_keras"] self._my_data_set = my_data_set # X, y, X_train, y_train, X_test, y_test # will be set by analyze_input_data # X: Input array (2D) - at present status of MNIST image data, only. # y: result (=classification data) [digits represent categories in the case of Mnist] self._X = None self._X_train = None self._X_test = None self._y = None self._y_train = None self._y_test = None # relevant dimensions # from input data information; will be set in handle_input_data() self._dim_sets = 0 self._dim_features = 0 self._n_labels = 0 # number of unique labels - will be extracted from y-data # Img sizes self._dim_img = 0 # should be sqrt(dim_features) - we assume square like images self._img_h = 0 self._img_w = 0 # Layers # ------ # number of hidden layers self._n_hidden_layers = n_hidden_layers # Number of total layers self._n_total_layers = 2 + self._n_hidden_layers # Nodes for hidden layers self._ay_nodes_layers = np.array(ay_nodes_layers) # Number of nodes in output layer - will be checked against information from target arrays self._n_nodes_layer_out = n_nodes_layer_out # Weights # -------- # empty List for all weight-matrices for all layer-connections # Numbering : # w[0] contains the weight matrix which connects layer 0 (input layer ) to hidden layer 1 # w[1] contains the weight matrix which connects layer 1 (input layer ) to (hidden?) layer 2 self._li_w = [] # Arrays for encoded output labels - will be set in _encode_all_mnist_labels() # ------------------------------- self._ay_onehot = None self._ay_oneval = None # Known Randomizer methods ( 0: np.random.randint, 1: np.random.uniform ) # ------------------ self.__ay_known_randomizers = [0, 1] # Types of activation functions and output functions # ------------------ self.__ay_activation_functions = ["sigmoid"] # later also relu self.__ay_output_functions = ["sigmoid"] # later also softmax # Types of cost functions # ------------------ self.__ay_loss_functions = ["LogLoss", "MSE" ] # later also other types of cost/loss functions # the following dictionaries will be used for indirect function calls self.__d_activation_funcs = { 'sigmoid': self._sigmoid, 'relu': self._relu } self.__d_output_funcs = { 'sigmoid': self._sigmoid, 'softmax': self._softmax } self.__d_loss_funcs = { 'LogLoss': self._loss_LogLoss, 'MSE': self._loss_MSE } # Derivative functions self.__d_D_activation_funcs = { 'sigmoid': self._D_sigmoid, 'relu': self._D_relu } self.__d_D_output_funcs = { 'sigmoid': self._D_sigmoid, 'softmax': self._D_softmax } self.__d_D_loss_funcs = { 'LogLoss': self._D_loss_LogLoss, 'MSE': self._D_loss_MSE } # The following variables will later be set by _check_and set_activation_and_out_functions() self._my_act_func = my_activation_function self._my_out_func = my_out_function self._my_loss_func = my_loss_function self._act_func = None self._out_func = None self._loss_func = None # number of data samples in a mini-batch self._n_size_mini_batch = n_size_mini_batch self._n_mini_batches = None # will be determined by _get_number_of_mini_batches() # maximum number of epochs - we set this number to an assumed maximum # - as we shall build a backup and reload functionality for training, this should not be a major problem self._n_epochs = n_epochs # maximum number of batches to handle ( if < 0 => all!) self._n_max_batches = n_max_batches # actual number of batches self._n_batches = None # regularization parameters self._lambda2_reg = lambda2_reg self._lambda1_reg = lambda1_reg # parameter for momentum learning self._learn_rate = learn_rate self._decrease_const = decrease_const self._mom_rate = mom_rate self._li_mom = [None] * self._n_total_layers # shuffle data in X_train? self._shuffle_batches = shuffle_batches # epoch period for printing self._print_period = print_period # book-keeping for epochs and mini-batches # ------------------------------- # range for epochs - will be set by _prepare-epochs_and_batches() self._rg_idx_epochs = None # range for mini-batches self._rg_idx_batches = None # dimension of the numpy arrays for book-keeping - will be set in _prepare_epochs_and_batches() self._shape_epochs_batches = None # (n_epochs, n_batches, 1) # list for error values at outermost layer for minibatches and epochs during training # we use a numpy array here because we can redimension it self._ay_theta = None # list for cost values of mini-batches during training # The list will later be split into sections for epochs self._ay_costs = None # Data elements for back propagation # ---------------------------------- # 2-dim array of partial derivatives of the elements of an additive cost function # The derivative is taken with respect to the output results a_j = ay_ANN_out[j] # The array dimensions account for nodes and sampls of a mini_batch. The array will be set in function # self._initiate_bw_propagation() self._ay_delta_out_batch = None # parameter to allow printing of some test data self._b_print_test_data = b_print_test_data # Plot handling # -------------- # Alternatives to resize plots # 1: just resize figure 2: resize plus create subplots() [figure + axes] self._plot_resize_alternative = 1 # Plot-sizing self._figs_x1 = figs_x1 self._figs_x2 = figs_x2 self._fig = None self._ax = None # alternative 2 does resizing and (!) subplots() self.initiate_and_resize_plot(self._plot_resize_alternative) # *********** # operations # *********** # check and handle input data self._handle_input_data() # set the ANN structure self._set_ANN_structure() # Prepare epoch and batch-handling - sets ranges, limits num of mini-batches and initializes book-keeping arrays self._rg_idx_epochs, self._rg_idx_batches = self._prepare_epochs_and_batches() # perform training start_c = time.perf_counter() self._fit(b_print=True, b_measure_batch_time=False) end_c = time.perf_counter() print('\n\n ------') print('Total training Time_CPU: ', end_c - start_c) print("\nStopping program regularily")

Both parameters affect our method “_fit()” in the following way :

''' -- Method to set the number of batches based on given batch size -- ''' def _fit(self, b_print = False, b_measure_batch_time = False): ''' Parameters: b_print: Do we print intermediate results of the training at all? b_print_period: For which period of epochs do we print? b_measure_batch_time: Measure CPU-Time for a batch ''' rg_idx_epochs = self._rg_idx_epochs rg_idx_batches = self._rg_idx_batches if (b_print): print("\nnumber of epochs = " + str(len(rg_idx_epochs))) print("max number of batches = " + str(len(rg_idx_batches))) # loop over epochs for idxe in rg_idx_epochs: if (b_print and (idxe % self._print_period == 0) ): print("\n ---------") print("\nStarting epoch " + str(idxe+1)) # sinmple adaption of the learning rate self._learn_rate /= (1.0 + self._decrease_const * idxe) # shuffle indices for a variation of the mini-batches with each epoch if self._shuffle_batches: shuffled_index = np.random.permutation(self._dim_sets) self._X_train, self._y_train, self._ay_onehot = self._X_train[shuffled_index], self._y_train[shuffled_index], self._ay_onehot[:, shuffled_index] # loop over mini-batches for idxb in rg_idx_batches: if b_measure_batch_time: start_0 = time.perf_counter() # deal with a mini-batch self._handle_mini_batch(num_batch = idxb, num_epoch=idxe, b_print_y_vals = False, b_print = False) if b_measure_batch_time: end_0 = time.perf_counter() print('Time_CPU for batch ' + str(idxb+1), end_0 - start_0) if (b_print and (idxe % self._print_period == 0) ): print("\ntotal costs of mini_batch = ", self._ay_costs[idxe, idxb]) print("avg total error of mini_batch = ", self._ay_theta[idxe, idxb]) return None

# Results for shuffling the contents of the mini-batches

With shuffling we expect a slightly broader variation of the costs and the averaged error. But the accuracy should no change too much in the end. We start a new test run with the following parameters:

ay_nodes_layers = [0, 70, 30, 0], n_nodes_layer_out = 10, my_loss_function = "LogLoss", n_size_mini_batch = 500, n_epochs = 1500, n_max_batches = 2000, # small values only for test runs lambda2_reg = 0.1, lambda1_reg = 0.0, vect_mode = 'cols', learn_rate = 0.0001, decrease_const = 0.000001, mom_rate = 0.00005, shuffle_batches = True, print_period = 20, ...

If we look at the intermediate printout for the last mini-batch of some epochs and compare it to the results given in the last article, we see a stronger variation in the costs and averaged error. The reason is that the composition of last mini-batch of an epoch changes with every epoch.

number of epochs = 1500 max number of batches = 120 --------- Starting epoch 1 total costs of mini_batch = 1757.7650929607967 avg total error of mini_batch = 0.17086198431410954 --------- Starting epoch 61 total costs of mini_batch = 511.7001121819204 avg total error of mini_batch = 0.030287362041332373 --------- Starting epoch 121 total costs of mini_batch = 435.2513093033654 avg total error of mini_batch = 0.023445601362614754 ---------- Starting epoch 181 total costs of mini_batch = 361.8665831722295 avg total error of mini_batch = 0.018540003201911136 --------- Starting epoch 241 total costs of mini_batch = 293.31230634431023 avg total error of mini_batch = 0.0138237366634751 --------- Starting epoch 301 total costs of mini_batch = 332.70394217467936 avg total error of mini_batch = 0.017697548541363246 --------- Starting epoch 361 total costs of mini_batch = 249.26400606039937 avg total error of mini_batch = 0.011765164578232358 --------- Starting epoch 421 total costs of mini_batch = 240.0503762160913 avg total error of mini_batch = 0.011650843329895542 --------- Starting epoch 481 total costs of mini_batch = 222.89422430417295 avg total error of mini_batch = 0.011503859412784031 --------- Starting epoch 541 total costs of mini_batch = 200.1195962051405 avg total error of mini_batch = 0.009962020519104173 --------- tarting epoch 601 total costs of mini_batch = 206.74753168607685 avg total error of mini_batch = 0.01067995191155135 --------- Starting epoch 661 total costs of mini_batch = 171.14090717705736 avg total error of mini_batch = 0.0077091934178393105 --------- Starting epoch 721 total costs of mini_batch = 158.44967190977957 avg total error of mini_batch = 0.0070760922760890735 --------- Starting epoch 781 total costs of mini_batch = 165.4047453537401 avg total error of mini_batch = 0.008622788115637027 --------- Starting epoch 841 total costs of mini_batch = 140.52762105883642 avg total error of mini_batch = 0.0067360505574077766 --------- Starting epoch 901 total costs of mini_batch = 163.9117184790982 avg total error of mini_batch = 0.007431666926365192 --------- Starting epoch 961 total costs of mini_batch = 126.05539161877512 avg total error of mini_batch = 0.005982378079899406 --------- Starting epoch 1021 total costs of mini_batch = 114.89943308334199 avg total error of mini_batch = 0.005122976288751798 --------- Starting epoch 1081 total costs of mini_batch = 117.22051220670932 avg total error of mini_batch = 0.005185936692097749 --------- Starting epoch 1141 total costs of mini_batch = 140.88969853048422 avg total error of mini_batch = 0.007665464508660714 --------- Starting epoch 1201 total costs of mini_batch = 113.27223303239667 avg total error of mini_batch = 0.0059791015452599705 --------- Starting epoch 1261 total costs of mini_batch = 105.55343407063131 avg total error of mini_batch = 0.005000503315756879 --------- Starting epoch 1321 total costs of mini_batch = 130.48116668827038 avg total error of mini_batch = 0.006287118265324945 --------- Starting epoch 1381 total costs of mini_batch = 109.04042315247389 avg total error of mini_batch = 0.005874339148860562 --------- Starting epoch 1441 total costs of mini_batch = 121.01379412127089 avg total error of mini_batch = 0.0065105907117289944 --------- Starting epoch 1461 total costs of mini_batch = 103.08774822996196 avg total error of mini_batch = 0.005299079778792264 --------- Starting epoch 1481 total costs of mini_batch = 106.21334182056928 avg total error of mini_batch = 0.005343967730134955 ------- Total training Time_CPU: 1963.8792177759988

Note that the averaged error values result from averaging of the * absolute* values of the errors of all records in a batch! The small numbers are not due to a cancelling of positive by negative deviations. A contribution to the error at an output node is given by the absloute value of the difference between the predicted real output value and the encoded target output value. We then first calculate an average over all output nodes (=10) per record and then average these values over all records of a batch. Such an “averaged error” gives us a first indication of the accuracy level reached.

Note that this averaged error is not becoming a constant. The last values in the above list indicate that we do not get much better with the error than 0.0055 on the training data. Our approached minimum points on the various cost hyperplanes of the mini-batches obviously hop around the global minimum on the hyperplane of the total costs. One of the reasons is the varying composition of the mini-batches; another reason is that the cost hyperplanes of the various mini-batches themselves are different from the hyperplane of the total costs of ** all** records of the test data set. We see the effects of a mixture of “batch gradient descent” and “stochastic gradient descent” here; i.e., we do not get rid of stochastic elements even if we are close to a global minimum.

Still we observe an overall convergent behavior at around 1050 epochs. There our curves get relatively flat.

Accuracy values are:

**total accuracy for training data = 0.9914
total accuracy for test data = 0.9611**

So, this is pretty much the same as in our original run in the last article without data shuffling.

# Dropping regularization

In the above run we had used a quadratic from of the regularization (often called Ridge regularization). In the next test run we shall drop regularization completely (Lambda2 = 0, Lambda1 = 0) and find out whether this hampers the generalization of our MLP and the resulting accuracy with respect to the test data set.

Resulting data for the last epochs of the test run are

Starting epoch 1001 total costs of mini_batch = 67.98542512352101 avg total error of mini_batch = 0.007449654093429594 --------- nStarting epoch 1051 total costs of mini_batch = 56.69195783294443 avg total error of mini_batch = 0.0063384571747725415 --------- Starting epoch 1101 total costs of mini_batch = 51.81035466850738 avg total error of mini_batch = 0.005939699354987233 --------- Starting epoch 1151 total costs of mini_batch = 52.23157716632318 avg total error of mini_batch = 0.006373981433882217 --------- Starting epoch 1201 total costs of mini_batch = 48.40298652277855 avg total error of mini_batch = 0.005653856253701317 --------- Starting epoch 1251 total costs of mini_batch = 45.00623540189525 avg total error of mini_batch = 0.005245339176038497 --------- Starting epoch 1301 total costs of mini_batch = 36.88409532579881 avg total error of mini_batch = 0.004600719544961844 --------- Starting epoch 1351 total costs of mini_batch = 36.53543045554845 avg total error of mini_batch = 0.003993852242709943 --------- Starting epoch 1401 total costs of mini_batch = 38.80422469954769 avg total error of mini_batch = 0.00464620714991714 --------- Starting epoch 1451 total costs of mini_batch = 42.39371261881638 avg total error of mini_batch = 0.005294796697150631 ------ Total training Time_CPU: 2118.4527089519997

Note, by the way, that the absolute values of the costs depend on the regularization parameter; therefore we see somewhat lower values in the end than before. But the absolute cost values are not so important regarding the general convergence and the accuracy of the network reached.

We omit the plots and just give the accuracy values:

**total accuracy for training data = 0.9874
total accuracy for test data = 0.9514**

We get a slight drop in accuracy for the test data set – small (1%), but notable. It is interesting the even the accuracy on the training data became influenced.

# Why might it be interesting to check the impact of the regularization?

We learn from literature that regularization helps with overfitting. Another aspect discussed e.g. by Jörg Frochte in his book “Maschinelles Lernen” is, whether we have enough training data to determine the vast amount of weights in complicated networks. He suggests on page 190 of his book to consider the number of weights in an MLP and compare it with the number of available data points.

He suggests that one may run into trouble if the difference between the number of weights (number of degrees of freedom) and the number of data records (number of independent information data) becomes too big. However, his test example was a rather limited one and for regression not classification. He also notes that if the data are well distributed may not be as big as assumed. If one thinks about it, one may also come to the question whether the real amount of data provided by the records is not by a factor of 10 larger – as we use 10 output values per record ….

Anyway, I think it is worthwhile to have a look at regularization.

# Enlarging the regularization factor

We double the value of Lambda2: Lambda2 = 0.2.

Starting epoch 1251 total costs of mini_batch = 128.00827405482318 avg total error of mini_batch = 0.007276206815511017 --------- Starting epoch 1301 total costs of mini_batch = 107.62983581797556 avg total error of mini_batch = 0.005535653858885446 --------- Starting epoch 1351 total costs of mini_batch = 107.83630092292944 avg total error of mini_batch = 0. 005446805325519184 --------- Starting epoch 1401 total costs of mini_batch = 119.7648277329852 avg total error of mini_batch = 0.00729466852297802 --------- Starting epoch 1451 total costs of mini_batch = 106.74254206278933 avg total error of mini_batch = 0.005343124456075227

We get a slight improvement of the accuracy compared to our first run with data shuffling:

**total accuracy for training data = 0.9950
total accuracy for test data = 0.964**

So, regularization does have its advantages. I recommend to investigate the impact of this parameter closely, if you need to get the “last percentages” in generalization and accuracy for a given MLP-model.

# Enlarging node numbers

We have 60000 data records in the training set. In our example case we needed to fix around 784*70 + 70*30 + 30*10 = 57280 weight values. This is pretty close to the total amount of training data (60000). What happens if we extend the number of weights beyond the number of training records?

E.g. 784*100 + 100*50 + 50*10 = 83900. Do we get some trouble?

The results are:

Starting epoch 1151 total costs of mini_batch = 109.77341617599176 avg total error of mini_batch = 0.005494982077591186 --------- Starting epoch 1201 total costs of mini_batch = 113.5293680548904 avg total error of mini_batch = 0.005352117137100675 --------- Starting epoch 1251 total costs of mini_batch = 116.26371170820423 avg total error of mini_batch = 0.0072335516486698 --------- Starting epoch 1301 total costs of mini_batch = 99.7268420386945 avg total error of mini_batch = 0.004850817052601995 --------- Starting epoch 1351 total costs of mini_batch = 101.16579732551999 avg total error of mini_batch = 0.004831600835072556 --------- Starting epoch 1401 total costs of mini_batch = 98.45208584213253 avg total error of mini_batch = 0.004796133492821962 --------- Starting epoch 1451 total costs of mini_batch = 99.279344780807 avg total error of mini_batch = 0.005289728162205425 ------ Total training Time_CPU: 2159.5880855739997

Ooops, there appears a glitch in the data around epoch 1250. Such things happen! So, we should have a look at the graphs before we decide to take the weights of a special epoch for our MLP model!

But in the end, i.e. with the weights at epoch 1500 the accuracy values are:

**total accuracy for training data = 0.9962
total accuracy for test data = 0.9632**

So, we were NOT punished by extending our network, but we gained nothing worth the effort.

Now, let us go up with node numbers much more: 300 and 100 => 784*300 + 300*100 + 100*10 = 266200; ie. substantially more individual weights than training samples! **First with Lambda2 = 0.2**:

Starting epoch 1201 total costs of mini_batch = 104.4420759423322 avg total error of mini_batch = 0.0037985801450468246 --------- Starting epoch 1251 total costs of mini_batch = 102.80878647657674 avg total error of mini_batch = 0.003926855904089417 --------- Starting epoch 1301 total costs of mini_batch = 100.01189950545002 avg total error of mini_batch = 0.0037743225368465773 --------- Starting epoch 1351 total costs of mini_batch = 97.34294880936079 avg total error of mini_batch = 0.0035513092392408865 --------- Starting epoch 1401 total costs of mini_batch = 93.15432903284587 avg total error of mini_batch = 0.0032916082743134206 --------- Starting epoch 1451 total costs of mini_batch = 89.79127326241868 avg total error of mini_batch = 0.0033628384147655283 ------ Total training Time_CPU: 4254.479082876998

**total accuracy for training data = 0.9987
total accuracy for test data = 0.9630**

So , much CPU-time for no gain!

**Now, what happens if we set Lambda2 = 0?** We get:

**total accuracy for training data = 0.9955
total accuracy for test data = 0.9491**

This is a small change around 1.4%! I would say:

**In the special case of MNIST, a MLP-network with 2 hidden layers and a small learning rate we see neither a major problem regarding the amount of available data, nor a dramatic impact of the regularization. Regularization brings around a 1% gain in accuracy. **

# Reducing the node number on the hidden layers

Another experiment could be to reduce the number of nodes on the hidden layers. Let us go down to 40 nodes on L1 and 20 on L2, then to 30 and 20. Lambda2 is set to 0.2 in both runs. acc1 in the following listing means the accuracy for the training data, acc2 for the test data.

The results are:

40 nodes on L1, 20 nodes on L2, 1500 epochs => 1600 sec, acc1 = **0.9898**, acc2 = **0.9578**

30 nodes on L1, 20 nodes on L2, 1800 epochs => 1864 sec, acc1 = **0.9861**, acc2 = **0.9513**

We loose around 1% in accuracy!

The plot for 30, 20 nodes on layers L1, L2 shows that we got a convergence only beyond 1500 epochs.

# Working with just one hidden layer

To get some more indications regarding efficiency let us now turn to networks with just one layer.

We investigate three situations with the following node numbers on the hidden layer: 100, 50, 30

The plot for 100 nodes on the hidden layer; we get convergence at around 1050 epochs.

Interestingly the CPU time for 100 nodes is with 1850 secs not smaller than for the network with 70 and 30 nodes on the hidden layers. As the dominant matrices are the ones connecting layer L0 and layer L1 this is quite understandable. (Note the CPU time also depends on the consumption of other jobs on the system.

The plots for 50 and 30 nodes on the hidden layer; we get convergence at around 1450 epochs. The

CPU time for 1500 epochs goes down to 1500 sec and XXX sec, respectively.

**Plot for 50 nodes on the hidden layer**:

We get the following accuracy values:

100 nodes, 1950 sec (1500 epochs), acc1 = 0.9947, acc2 = **0.9619**,

50 nodes, 1600 sec (1500 epochs), acc1 = 0.9880, acc2 = **0.9566**,

30 nodes, 1450 sec (1500 epochs), acc1 = 0.9780, acc2 = **0.9436**

Well, now we see a drop in the accuracy by around 2% compared to our best cases. You have to decide yourself whether the gain in CPU time is worth it.

Note, by the way, that the accuracy value for 50 nodes is pretty close to the value S. Rashka got in his book “Python Machine Learning”. If you compare such values with your own runs be aware of the rather small learning rate (0.0001) and momentum rates (0.00005) I used. You can probably become faster with smaller learning rates. But then you may need another type of adaption for the learning rate compared to our simple linear one.

# Conclusion

We saw that our original guess of a network with 2 hidden layers with 70 and 30 nodes was not a bad one. A network with just one layer with just 50 nodes or below does not give us the same accuracy. However, we neither saw a major improvement if we went to grids with 300 nodes on layer L1 and 100 nodes on layer L2. Despite some discrepancy between the number of weights in comparison to the number of test records we saw no significant loss in accuracy either – with or without regularization.

We also learned that we should use regularization (here of the quadratic type) to get the last 1% to 2% bit of accuracy on the test data in our special MNIST case.

In the next article

A simple program for an ANN to cover the Mnist dataset – XI – confusion matrix

we shall have a closer look at those MNIST number images where our MLP got problems.