KERAS and MNIST#

We’ll apply the ideas we just learned to a neural network that does character recognition using the MNIST database. This is a set of handwritten digits (0–9) represented as a 28×28 pixel grayscale image.

There are 2 datasets, the training set with 60,000 images and the test set with 10,000 images.

import keras

import matplotlib.pyplot as plt
import numpy as np
2024-07-26 12:48:34.083463: I external/local_xla/xla/tsl/cuda/cudart_stub.cc:32] Could not find cuda drivers on your machine, GPU will not be used.
2024-07-26 12:48:34.086626: I external/local_xla/xla/tsl/cuda/cudart_stub.cc:32] Could not find cuda drivers on your machine, GPU will not be used.
2024-07-26 12:48:34.095446: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered
2024-07-26 12:48:34.109319: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered
2024-07-26 12:48:34.113435: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered
2024-07-26 12:48:34.125067: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.
To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
2024-07-26 12:48:34.968929: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT

This notebook uses keras and the tensorflow backend to do character recognition on the MNIST digits.

Important

You need to have the keras and tensorflow packages installed.

For visualization of the network, you need to have pydot installed.

We follow the example for setting up the network: Vict0rSch/deep_learning

The MNIST data#

The keras library can download the MNIST data directly and provides a function to give us both the training and test images and the corresponding digits. This is already in a format that Keras wants, so we don’t use the classes that we defined earlier.

from keras.datasets import mnist
(X_train, y_train), (X_test, y_test) = mnist.load_data()
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
       0/11490434 ━━━━━━━━━━━━━━━━━━━━ 0s 0s/step

  352256/11490434 ━━━━━━━━━━━━━━━━━━━━ 1s 0us/step

 5849088/11490434 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step

11490434/11490434 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step

The training set consists of 60000 digits represented as a 28x28 array (there are no color channels, so this is grayscale data). They are also integer data.

X_train.shape
(60000, 28, 28)
X_train.dtype
dtype('uint8')

Let’s look at the first digit and the “y” value (target) associated with it—that’s the correct answer.

plt.imshow(X_train[0], cmap="gray_r")
print(y_train[0])
5
../_images/a8aeb26d54eb384c9acc4023768550ffd0a9d68d141cafca141d744406220d8f.png

Preparing the Data#

The neural network takes a 1-d vector of input and will return a 1-d vector of output. We need to convert our data to this form.

We’ll scale the image data to fall in [0, 1) and the numerical output to be categorized as an array. Finally, we need the input data to be one-dimensional, so we fill flatten the 28x28 images into a single 784 vector.

X_train = X_train.astype('float32')/255
X_test = X_test.astype('float32')/255

X_train = np.reshape(X_train, (60000, 784))
X_test = np.reshape(X_test, (10000, 784))
X_train[0]
array([0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.01176471, 0.07058824, 0.07058824,
       0.07058824, 0.49411765, 0.53333336, 0.6862745 , 0.10196079,
       0.6509804 , 1.        , 0.96862745, 0.49803922, 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.11764706, 0.14117648, 0.36862746, 0.6039216 ,
       0.6666667 , 0.99215686, 0.99215686, 0.99215686, 0.99215686,
       0.99215686, 0.88235295, 0.6745098 , 0.99215686, 0.9490196 ,
       0.7647059 , 0.2509804 , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.19215687, 0.93333334,
       0.99215686, 0.99215686, 0.99215686, 0.99215686, 0.99215686,
       0.99215686, 0.99215686, 0.99215686, 0.9843137 , 0.3647059 ,
       0.32156864, 0.32156864, 0.21960784, 0.15294118, 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.07058824, 0.85882354, 0.99215686, 0.99215686,
       0.99215686, 0.99215686, 0.99215686, 0.7764706 , 0.7137255 ,
       0.96862745, 0.94509804, 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.3137255 , 0.6117647 , 0.41960785, 0.99215686, 0.99215686,
       0.8039216 , 0.04313726, 0.        , 0.16862746, 0.6039216 ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.05490196,
       0.00392157, 0.6039216 , 0.99215686, 0.3529412 , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.54509807,
       0.99215686, 0.74509805, 0.00784314, 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.04313726, 0.74509805, 0.99215686,
       0.27450982, 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.13725491, 0.94509804, 0.88235295, 0.627451  ,
       0.42352942, 0.00392157, 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.31764707, 0.9411765 , 0.99215686, 0.99215686, 0.46666667,
       0.09803922, 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.1764706 ,
       0.7294118 , 0.99215686, 0.99215686, 0.5882353 , 0.10588235,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.0627451 , 0.3647059 ,
       0.9882353 , 0.99215686, 0.73333335, 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.9764706 , 0.99215686,
       0.9764706 , 0.2509804 , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.18039216, 0.50980395,
       0.7176471 , 0.99215686, 0.99215686, 0.8117647 , 0.00784314,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.15294118,
       0.5803922 , 0.8980392 , 0.99215686, 0.99215686, 0.99215686,
       0.98039216, 0.7137255 , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.09411765, 0.44705883, 0.8666667 , 0.99215686, 0.99215686,
       0.99215686, 0.99215686, 0.7882353 , 0.30588236, 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.09019608, 0.25882354, 0.8352941 , 0.99215686,
       0.99215686, 0.99215686, 0.99215686, 0.7764706 , 0.31764707,
       0.00784314, 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.07058824, 0.67058825, 0.85882354,
       0.99215686, 0.99215686, 0.99215686, 0.99215686, 0.7647059 ,
       0.3137255 , 0.03529412, 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.21568628, 0.6745098 ,
       0.8862745 , 0.99215686, 0.99215686, 0.99215686, 0.99215686,
       0.95686275, 0.52156866, 0.04313726, 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.53333336, 0.99215686, 0.99215686, 0.99215686,
       0.83137256, 0.5294118 , 0.5176471 , 0.0627451 , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.        ], dtype=float32)

We will use categorical data–this means that we want to represent the result from the network as one of several possibilities.

Keras includes routines to categorize data. In our case, since there are 10 possible digits, we want to put the output into 10 categories (represented by 10 neurons).

from keras.utils import to_categorical

y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

Now let’s look at the target for the first training digit. We know from above that it was ‘5’. Here we see that there is a 1 in the index corresponding to 5 (remember we start counting at 0 in python).

y_train.shape
(60000, 10)
y_train[0]
array([0., 0., 0., 0., 0., 1., 0., 0., 0., 0.])

Build the Neural Network#

Now we’ll build the neural network. We will have 2 hidden layers, and the number of neurons will look like:

784 → 500 → 300 → 10

Layers#

Let’s start by setting up the layers. For each layer, we tell keras the number of output neurons. It infers the number of inputs from the previous layer (with the exception of the input layer, where we need to tell it what to expect as input).

Properties on the layers:

from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation

model = Sequential()
model.add(Dense(500, input_dim=784, activation="relu"))
model.add(Dropout(0.4))
model.add(Dense(300, activation="relu"))
model.add(Dropout(0.4))
model.add(Dense(10, activation="softmax"))
/opt/hostedtoolcache/Python/3.11.9/x64/lib/python3.11/site-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
  super().__init__(activity_regularizer=activity_regularizer, **kwargs)

Let’s look at the network

from keras.utils import plot_model
plot_model(model, show_shapes=True, show_layer_names=True, dpi=100)
../_images/ba5cb8369af74ff622f894fad76823a9fe06410f6ed0c4cf3ce210f89a6f7f9d.png

Loss function#

We need to specify what we want to optimize and how we are going to do it.

Recall: the loss (or cost) function measures how well our predictions match the expected target. Previously we were using the sum of the squares of the error.

For categorical data, like we have, the “cross-entropy” metric is often used. See here for an explanation: https://jamesmccaffrey.wordpress.com/2013/11/05/why-you-should-use-cross-entropy-error-instead-of-classification-error-or-mean-squared-error-for-neural-network-classifier-training/

Optimizer#

We also need to specify an optimizer. This could be gradient descent, as we looked at in our discussion before. Here’s a list of the optimizers supoprted by keras: https://keras.io/api/optimizers/ We’ll use RMPprop, which builds off of gradient descent and includes some momentum.

Finally, we need to specify a metric that is evaluated during training and testing. We’ll use "accuracy" here. This means that we’ll see the accuracy of our model reported as we are training and testing.

More details on these options is here: https://keras.io/api/models/model/

from tensorflow.keras.optimizers import RMSprop

rms = RMSprop()
model.compile(loss='categorical_crossentropy',
              optimizer=rms, metrics=['accuracy'])

Train#

For training, we pass in the inputs and target and the number of epochs to run and it will optimize the network by adjusting the weights between the nodes in the layers.

The number of epochs is the number of times the entire data set is passed forward and backward through the network. The batch size is the number of training pairs you pass through the network at a given time. You update the parameter in your model (the weights) once for each batch. This makes things more efficient and less noisy.

epochs = 20
batch_size = 256
model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size,
          validation_data=(X_test, y_test), verbose=2)
Epoch 1/20
235/235 - 2s - 10ms/step - accuracy: 0.8843 - loss: 0.3766 - val_accuracy: 0.9485 - val_loss: 0.1582
Epoch 2/20
235/235 - 2s - 7ms/step - accuracy: 0.9533 - loss: 0.1598 - val_accuracy: 0.9710 - val_loss: 0.0929
Epoch 3/20
235/235 - 2s - 7ms/step - accuracy: 0.9646 - loss: 0.1188 - val_accuracy: 0.9747 - val_loss: 0.0786
Epoch 4/20
235/235 - 2s - 7ms/step - accuracy: 0.9710 - loss: 0.0969 - val_accuracy: 0.9747 - val_loss: 0.0827
Epoch 5/20
235/235 - 3s - 11ms/step - accuracy: 0.9742 - loss: 0.0829 - val_accuracy: 0.9793 - val_loss: 0.0679
Epoch 6/20
235/235 - 2s - 7ms/step - accuracy: 0.9779 - loss: 0.0707 - val_accuracy: 0.9791 - val_loss: 0.0689
Epoch 7/20
235/235 - 2s - 7ms/step - accuracy: 0.9803 - loss: 0.0641 - val_accuracy: 0.9808 - val_loss: 0.0641
Epoch 8/20
235/235 - 2s - 7ms/step - accuracy: 0.9817 - loss: 0.0580 - val_accuracy: 0.9825 - val_loss: 0.0608
Epoch 9/20
235/235 - 2s - 7ms/step - accuracy: 0.9832 - loss: 0.0533 - val_accuracy: 0.9839 - val_loss: 0.0556
Epoch 10/20
235/235 - 3s - 11ms/step - accuracy: 0.9845 - loss: 0.0483 - val_accuracy: 0.9836 - val_loss: 0.0614
Epoch 11/20
235/235 - 2s - 7ms/step - accuracy: 0.9857 - loss: 0.0443 - val_accuracy: 0.9843 - val_loss: 0.0585
Epoch 12/20
235/235 - 2s - 7ms/step - accuracy: 0.9871 - loss: 0.0405 - val_accuracy: 0.9854 - val_loss: 0.0562
Epoch 13/20
235/235 - 2s - 7ms/step - accuracy: 0.9875 - loss: 0.0388 - val_accuracy: 0.9851 - val_loss: 0.0587
Epoch 14/20
235/235 - 2s - 7ms/step - accuracy: 0.9877 - loss: 0.0379 - val_accuracy: 0.9834 - val_loss: 0.0636
Epoch 15/20
235/235 - 2s - 7ms/step - accuracy: 0.9888 - loss: 0.0343 - val_accuracy: 0.9846 - val_loss: 0.0593
Epoch 16/20
235/235 - 2s - 7ms/step - accuracy: 0.9892 - loss: 0.0333 - val_accuracy: 0.9855 - val_loss: 0.0595
Epoch 17/20
235/235 - 2s - 7ms/step - accuracy: 0.9896 - loss: 0.0323 - val_accuracy: 0.9832 - val_loss: 0.0652
Epoch 18/20
235/235 - 2s - 7ms/step - accuracy: 0.9898 - loss: 0.0307 - val_accuracy: 0.9862 - val_loss: 0.0559
Epoch 19/20
235/235 - 2s - 7ms/step - accuracy: 0.9912 - loss: 0.0277 - val_accuracy: 0.9843 - val_loss: 0.0632
Epoch 20/20
235/235 - 2s - 7ms/step - accuracy: 0.9909 - loss: 0.0277 - val_accuracy: 0.9862 - val_loss: 0.0585
<keras.src.callbacks.history.History at 0x7fdad316bb90>

Test#

keras has a routine, evaluate() that can take the inputs and targets of a test data set and return the loss value and accuracy (or other defined metrics) on this data.

Here we see we are > 98% accurate on the test data—this is the data that the model has never seen before (and was not trained with).

loss_value, accuracy = model.evaluate(X_test, y_test, batch_size=16)
print(accuracy)
  1/625 ━━━━━━━━━━━━━━━━━━━━ 8s 13ms/step - accuracy: 1.0000 - loss: 1.4255e-04

 65/625 ━━━━━━━━━━━━━━━━━━━━ 0s 788us/step - accuracy: 0.9923 - loss: 0.0476   

128/625 ━━━━━━━━━━━━━━━━━━━━ 0s 792us/step - accuracy: 0.9875 - loss: 0.0672

191/625 ━━━━━━━━━━━━━━━━━━━━ 0s 793us/step - accuracy: 0.9853 - loss: 0.0751

254/625 ━━━━━━━━━━━━━━━━━━━━ 0s 794us/step - accuracy: 0.9842 - loss: 0.0788

316/625 ━━━━━━━━━━━━━━━━━━━━ 0s 799us/step - accuracy: 0.9836 - loss: 0.0801

379/625 ━━━━━━━━━━━━━━━━━━━━ 0s 798us/step - accuracy: 0.9834 - loss: 0.0797

443/625 ━━━━━━━━━━━━━━━━━━━━ 0s 797us/step - accuracy: 0.9833 - loss: 0.0788

507/625 ━━━━━━━━━━━━━━━━━━━━ 0s 795us/step - accuracy: 0.9835 - loss: 0.0772

571/625 ━━━━━━━━━━━━━━━━━━━━ 0s 794us/step - accuracy: 0.9838 - loss: 0.0754

625/625 ━━━━━━━━━━━━━━━━━━━━ 1s 794us/step - accuracy: 0.9840 - loss: 0.0739
0.9861999750137329

Predicting#

Suppose we simply want to ask our neural network to predict the target for an input. We can use the predict() method to return the category array with the predictions. We can then use np.argmax() to select the most probable.

np.argmax(model.predict(np.array([X_test[0]])))
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step

1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step
7
y_test[0]
array([0., 0., 0., 0., 0., 0., 0., 1., 0., 0.])

Now let’s loop over the test set and print out what we predict vs. the true answer for those we get wrong. We can also plot the image of the digit.

wrong = 0
max_wrong = 10

for n, (x, y) in enumerate(zip(X_test, y_test)):
    try:
        res = model.predict(np.array([x]), verbose=0)
        if np.argmax(res) != np.argmax(y):
            print(f"test {n}: prediction = {np.argmax(res)}, truth is {np.argmax(y)}")
            plt.imshow(x.reshape(28, 28), cmap="gray_r")
            plt.show()
            wrong += 1
            if (wrong > max_wrong-1):
                break
    except KeyboardInterrupt:
        print("stopping")
        break
test 247: prediction = 2, truth is 4
../_images/bf1793aa4f35052273154b4975838ad08fa0ccd2c7112408cb13de751fb4c1e3.png
test 321: prediction = 7, truth is 2
../_images/e2dce7d963b561c2276cd2a3303e2ccde53ae8dc278a2d3791c2b5e922f52c01.png
test 445: prediction = 0, truth is 6
../_images/d4487eed0a846e2f1c4f61a19c8198a0100ad4c4c5ee4688f3fe9fd935cd8806.png
test 495: prediction = 2, truth is 8
../_images/a759b3eee031acc79d5ef363aebc46d0bab89df82adec5a1e660b1e9741d8f78.png
test 582: prediction = 2, truth is 8
../_images/3ad8cf6d0f7bbeaee3bf9340b7f96a514162b11c796a997a6df311ca5e3eee05.png
test 619: prediction = 8, truth is 1
../_images/c99df25dd28518b599a44538d72391c872e12fdf18865bbeefd55535f6ec0a7a.png
test 659: prediction = 7, truth is 2
../_images/13891911fd4d9062fe7b7c3ee7e1e89910aded666b79bb3697f7551971174fb3.png
test 684: prediction = 3, truth is 7
../_images/a6df25d06728177ceb7d7727b8a80ca31b4d92a9008e12625a61c6797828eeb6.png
test 691: prediction = 4, truth is 8
../_images/7bce75e8e4dd11d666bb11ac4a4408b269ab11ac791cbf3f26f91e298c874848.png
test 720: prediction = 8, truth is 5
../_images/77458f75f5e4435c0a4a6e85d836152e3cd15bb9dd8a2cfc73a8b7fcdf1ff2b5.png

Experimenting#

There are a number of things we can play with to see how the network performance changes:

  • batch size

  • adding or removing hidden layers

  • changing the dropout

  • changing the activation function

Callbacks#

Keras allows for callbacks each epoch to store some information. These can allow you to, for example, plot of the accuracy vs. epoch by adding a callback. Take a look here for some inspiration:

https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/History

Going Further#

Convolutional neural networks are often used for image recognition, especially with larger images. They use filter to try to recognize patterns in portions of images (A tile). See this for a keras example:

https://www.tensorflow.org/tutorials/images/cnn