This is the moment the whole module has been building toward. You know what a perceptron is and why layers get stacked (02-01), which activation goes where (02-02), how the network learns with forward and backpropagation (02-03), and which loss and optimizer to choose (02-04). Today we assemble it all into a project from start to finish: building, training and evaluating in Keras a dense network that recognizes handwritten digits using MNIST, the discipline's classic dataset. We follow the TecnoMarket methodology introduced in module 1 — prototype on public datasets → application to fictional TecnoMarket data: before attempting to classify product photos, the team validates the complete workflow on a standard test bench. That workflow (load → explore → preprocess → define → train → evaluate → predict → save) is identical in any real project, and from today on it's yours.

1. The project and the dataset: why MNIST
2. Loading and exploring the data
3. Preprocessing: normalization and splits
4. Defining the model (justifying every choice)
5. Training and reading the loss/accuracy curves
6. Evaluating on test and making individual predictions
7. Saving the model in tecnomarket-dl/
8. The prototype's limits: why real photos will demand another architecture

MNIST contains 70,000 grayscale images of 28×28 pixels with handwritten digits (0–9), already split into 60,000 for training and 10,000 for test. It's the "hello world" of deep learning for three practical reasons: it downloads with one line, trains in minutes without a GPU, and is hard enough for the concepts to matter yet easy enough for everything to work on the first try.

The TecnoMarket fit: the vision team's end goal is to classify product photos into categories (laptop, coffee maker, vacuum cleaner…). MNIST is their test bench: same type of problem (multiclass image classification), manageable size, known outcome. If the workflow works here, migrating to the real photos will be a matter of architecture (module 3) and data, not methodology.

Work where you prepared the environment in module 1: a notebook in tecnomarket-dl/notebooks/ (or Colab, if you chose that route).

Never train on data you haven't looked at. It's the first rule of any project.

Reading the exploration: each image is a 28×28 matrix of integers 0–255 (0 = black, 255 = white), the labels are integers 0–9, and the ten classes are reasonably balanced (between 5,400 and 6,700 examples each) — important, because a class with very few examples would be learned poorly. Let's look at some images with their labels:

Spend a minute looking at them: you'll see sevens with and without a crossbar, slanted ones, nines that almost look like fours. That variability is exactly what the network will have to absorb.

Three transformations separate raw data from ready data:

1. Flatten. Our dense network expects one vector per example, not a matrix: we convert each 28×28 image into a vector of 784 values. (Yes, this destroys the spatial structure; we'll return to that wound in section 8.)

2. Normalize. We scale the pixels from 0–255 to 0–1. Why? Because of what we learned in 02-03: gradients depend on the magnitude of the inputs, and with inputs up to 255 the weighted sums would be enormous, would saturate activations, and would force minuscule learning rates. Inputs around [0, 1] keep the training in the comfortable zone.

3. Set aside validation. From the 01-04 vocabulary: train to adjust weights, validation to monitor progress on data the network doesn't use for learning, test for the final exam, one single time. MNIST already comes with the test split; we now reserve 10% of the train set as validation.

We leave the labels as integers 0–9: in 02-04 we saw that sparse_categorical_crossentropy accepts them directly, without one-hot conversion.

We build a dense 784 → 128 → 64 → 10 network. Each decision comes out of a lesson in this module:

Do the check you already did with the 29-parameter 3-4-2-1 network in 01-04, now at scale: $784 \times 128 + 128 = 100480$; $128 \times 64 + 64 = 8256$; $64 \times 10 + 10 = 650$. A total of 109,386 parameters — weights and biases that backpropagation will adjust. The same counting as always, three orders of magnitude up.

Each epoch is $54000 / 64 \approx 844$ mini-batch updates of the 109,386 parameters, each with its forward pass, its backward pass and its Adam step: all of 02-03 and 02-04 spinning inside. The history object stores the per-epoch metrics; plotting them is mandatory:

How to read the curves:

• Both losses drop together at first: the network is learning general patterns. Good.
• Around epoch 5–7 they separate: the train loss keeps falling (down to 0.01) but the validation loss stalls and even rises slightly (0.086 → 0.101). The network is starting to memorize quirks of the train set that don't generalize: this is overfitting. At this magnitude it's mild (val_accuracy holds at ≈ 97.7%), but the signal is unmistakable: training for more epochs no longer improves anything useful.
• Practical rule: the curve that matters is the validation one. The techniques to fight overfitting (regularization, dropout, early stopping) have their own lesson in module 5; for now, it's enough to know how to detect it and not to overtrain.

The test set is touched one single time, at the end, to get the honest figure you would report to the TecnoMarket team:

97.7% with a simple dense network: about 230 images missed out of 10,000. Now, individual predictions — which is how the model would be used in production:

predict returns the softmax's 10 probabilities per image; argmax picks the most likely class. Even more instructive is looking at the errors:

You'll see that many misses are genuinely ambiguous digits (fours that look like nines, twisted sevens) where even a human would hesitate. Analyzing specific errors — not just the global metric — is a professional habit that will reappear in every project in module 7.

A model that lives only in the notebook's memory is lost when the session closes. We save the 109,386 weights, the architecture and the compile configuration in a single file, inside the folder structure we created in 01-05:

The .keras format is Keras's modern native one, and a single load_model is enough to recover the entire model, ready to predict or keep training. This is all you need for now: serious versioning, alternative formats and the real deployment of models (serving them in production for TecnoMarket's website) have their own lesson in module 6.

The prototype is validated; can the team dive straight into classifying TecnoMarket's product photos with this same network? No, and understanding why is the best transition to the next module:

• Flattening destroys the spatial structure. By converting 28×28 into 784 values, the network doesn't know that pixel 30 sits directly below pixel 2. It learns by statistical brute force, which is viable with centered 28×28 digits, but not with 224×224 photos where the coffee maker can appear in any corner.
• No position invariance. If you shift a digit three pixels to the right, to the dense network it's a completely different vector — every pixel lands on a different input with different weights. Real product photos vary in position, scale, angle and lighting.
• Parameter explosion. With 224×224 color photos (150,528 inputs), the first 128-neuron dense layer alone would have 19 million parameters. Unfeasible and inefficient.

The solution is convolutional neural networks (CNNs): layers that look at the image in patches, share weights and respect the spatial structure. They are exactly the subject of module 3.

• Forgetting the normalization. With 0–255 pixels the network can still train, but worse and more slowly (typical accuracy several points lower). If your results are suspiciously bad, check the input range before anything else: X.min(), X.max().
• Normalizing train and test with different criteria. Every transformation is defined on the train set and applied identically to the test set. Here it's trivial (dividing by 255), but the principle will save you from serious mistakes with tabular data.
• Evaluating on test many times while tuning. If you try ten architectures while watching the test set and keep the best one, the test has stopped being an honest exam: you've fitted to it. Validation is for iterating; the test is the final grade.
• Looking only at the train accuracy. 99.6% on train with 97.7% on validation is overfitting, not success. The figure that counts is always the validation/test one.
• Forgetting to flatten/preprocess at prediction time. The model expects exactly the format it was trained with: a vector of 784 floats in [0, 1], with shape (n, 784) (even for a single image: (1, 784), not (784,)!).
• Extra epochs "just in case". When the validation curve has been flat or rising for several epochs, further training only increases the overfitting. Stop and keep the good zone.

1. Fashion-MNIST, same workflow. Repeat the complete project with keras.datasets.fashion_mnist (same shapes: 28×28, 10 classes, but clothing items: t-shirts, sneakers, bags — a test bench even closer to TecnoMarket's products). What test accuracy do you get? Why do you think it's lower than on MNIST?
2. Size matters (or does it?). On MNIST, train three variants: (a) no hidden layers (784 → 10 softmax, a multiclass logistic regression), (b) one hidden layer of 32, (c) the network from the text (128 + 64). Compare validation accuracy and parameter count of each in a small table. Is each size jump worth it?
3. Confidence report. Write a function predict_with_confidence(model, image) that returns the predicted class, its probability, and the second most likely class with its probability; test it on 3 correctly classified images and 3 misclassified ones from the test set. What do you observe about the confidence on the misses?

Exercise 1. The code is identical, changing the loading line to keras.datasets.fashion_mnist.load_data(). The typical test accuracy hovers around 88–90%, versus ~98% on MNIST. The reason: the clothing classes look much more alike (t-shirt vs. shirt vs. coat share a silhouette) than digits do, and fine texture/shape matters more — a difficulty that foreshadows real product photos and motivates module 3's CNNs even further.

Exercise 2. Typical results (yours will vary somewhat due to the randomness of initialization):

The first jump (adding a hidden layer) contributes the most: it goes from a linear model to a non-linear one, +4 points. The second jump quadruples the parameters to gain ~1 point: diminishing returns. Lesson: bigger helps, but less and less, and the qualitative leap comes from non-linearity (as you've known since 02-02).

Exercise 3.

On correctly classified images the confidence usually exceeds 0.99 and the second option stays below 0.01. On misses it's common to see lower confidences (0.5–0.9) with a strong second option that often is the correct class (true 4, pred 9 at 0.55, second 4 at 0.42). The moral for TecnoMarket: the softmax's probabilities enable "human review if confidence is low" policies, just like the fraud detector's adjustable threshold.

You've just completed your first deep learning project from start to finish: you explored MNIST, normalized and partitioned it, defined a dense 784-128-64-10 network justifying every piece with the module's lessons (ReLU in hidden layers, softmax + categorical cross-entropy at the output, Adam as optimizer, mini-batches of 64), trained while watching the curves and detecting the onset of overfitting, obtained an honest ~97.7% on test, examined individual errors, and saved the versioned model in tecnomarket-dl/models/. The workflow you followed is the same one you'll use in every remaining project in the course; only the data and the architectures will change.

And architectures are precisely what the next step is about. We've seen that the dense network treats the image as a flat list of pixels: it barely managed with 28×28 digits and would struggle much more with Fashion-MNIST's clothing — and it would be unfeasible with TecnoMarket's real product photos. In module 3 you'll meet convolutional neural networks (CNNs), the architecture that understands images as what they are: spatial structures where position, edges and shapes matter.