Introduction

MNIST remains a strong beginner dataset for learning image classification with Keras because the workflow is small enough to run quickly but complete enough to teach good habits. A solid MNIST solution still needs the same steps as a larger vision problem: load the data, normalize it, shape it for the model, validate during training, and inspect errors rather than staring only at the final accuracy number.

Load and Normalize the Data

Keras includes MNIST directly, so the first task is preprocessing rather than data collection. The official Keras examples normalize pixel values into the 0 to 1 range and reshape the data so a convolutional model can see the channel dimension.

1import keras
2import numpy as np
3
4(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
5
6x_train = x_train.astype("float32") / 255.0
7x_test = x_test.astype("float32") / 255.0
8
9x_train = np.expand_dims(x_train, -1)
10x_test = np.expand_dims(x_test, -1)
11
12print(x_train.shape, y_train.shape)

That final reshape turns each image from (28, 28) into (28, 28, 1), which is what Conv2D expects. Skipping this step is one of the most common shape mistakes in beginner code.

Build a Small Convolutional Network

For MNIST, a compact CNN is usually the best baseline because the data is image-like and local patterns matter. Keras' official MNIST convnet example uses a short Sequential model with two convolution-plus-pooling stages followed by a dense output layer.

1from keras import layers
2
3num_classes = 10
4
5model = keras.Sequential(
6    [
7        keras.Input(shape=(28, 28, 1)),
8        layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
9        layers.MaxPooling2D(pool_size=(2, 2)),
10        layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
11        layers.MaxPooling2D(pool_size=(2, 2)),
12        layers.Flatten(),
13        layers.Dropout(0.5),
14        layers.Dense(num_classes, activation="softmax"),
15    ]
16)
17
18model.summary()

This model is not large, but it is enough to learn MNIST well while still training quickly on ordinary hardware.

Compile and Train with Validation

The compile step should match the label format you are using. Here the labels are integer class IDs, so sparse categorical loss is appropriate.

1model.compile(
2    optimizer="adam",
3    loss="sparse_categorical_crossentropy",
4    metrics=["accuracy"],
5)
6
7callbacks = [
8    keras.callbacks.EarlyStopping(
9        monitor="val_accuracy",
10        patience=2,
11        restore_best_weights=True,
12    )
13]
14
15history = model.fit(
16    x_train,
17    y_train,
18    batch_size=128,
19    epochs=15,
20    validation_split=0.1,
21    callbacks=callbacks,
22    verbose=2,
23)

Validation matters even on a simple dataset. It tells you whether the model is improving in a way that generalizes or merely memorizing the training set.

Evaluate and Inspect Errors

After training, check the held-out test set and then look at the mistakes.

1test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=0)
2print(f"Test accuracy: {test_accuracy:.4f}")
3
4probabilities = model.predict(x_test, verbose=0)
5predictions = probabilities.argmax(axis=1)
6wrong = np.where(predictions != y_test)[0]
7
8print("Misclassified examples:", len(wrong))
9print("First few mismatches:", wrong[:5])

This second step is the habit that matters. Accuracy alone hides whether the network is confusing similar digits such as 4 and 9, or whether preprocessing introduced a systematic bug.

Save the Model as Part of the Workflow

Training is only useful if the artifact can be reused. Saving and reloading should be part of the normal workflow, even in a tutorial-sized project.

1model.save("mnist_cnn.keras")
2reloaded = keras.models.load_model("mnist_cnn.keras")
3
4sample = reloaded.predict(x_test[:3], verbose=0).argmax(axis=1)
5print(sample)

That quick reload check confirms the model can leave the training session and still be used for inference.

Common Pitfalls

• Forgetting to normalize pixel values before training.
• Feeding (28, 28) images into a convolutional model without adding the channel dimension.
• Using a label format that does not match the chosen loss function.
• Judging the model only by one final accuracy number and never looking at mistakes.
• Scaling the architecture up immediately instead of first establishing a clean baseline.

Summary

• MNIST is a good small dataset for learning the full Keras image-classification workflow.
• Normalize images and add a channel axis before training a CNN.
• A compact convolutional network is enough for a strong baseline.
• Use validation and early stopping instead of guessing the right epoch count.
• Evaluate, inspect errors, and save the trained model as part of the normal workflow.