Evaluate Neural Networks

You've trained a neural network and it hits 98% accuracy on the training data — but the moment it faces real-world input, it falls apart. This is the classic overfitting trap, and it's exactly why you must evaluate neural networks on test data. In this lesson, you'll learn a disciplined, hands-on approach to measuring generalization — the single most important skill for deploying trustworthy models.

The problem this lesson solves

Training a neural network is only half the battle. The real question in applied AI engineering is: Does my model work on data it has never seen?

If you only evaluate on training data, you'll get falsely high metrics. The model may have memorized noise, outliers, or even specific sample order — a phenomenon called overfitting. Production systems are unforgiving: a fraud-detection model that shines in training but misses new fraud patterns costs real money. A medical image classifier with inflated training accuracy could cause dangerous misdiagnoses.

The core pain: You need a reliable way to estimate real-world performance before deployment. This lesson gives you the tools — holdout validation, test-set evaluation, and metric interpretation — to catch failures early and make confident decisions.

Core concept / mental model

Think of your dataset as a classroom. The training set is the textbook — your model studies it in depth. The validation set is a practice exam — you tune hyperparameters using it. The test set is the final exam — you touch it only once, after all studying is done.

This separation enforces intellectual honesty: if you tune your model based on test results, the test set becomes part of training, and you lose your unbiased performance estimate.

Key terms

• Training set — the data used to update weights via backpropagation.
• Validation set — held-out data used to compare model variants and early-stop training.
• Test set — fully held-out data evaluated exactly once at the end.
• Generalization gap — the difference between training performance and test performance. A large gap signals overfitting.

Pro tip: Never peek at the test set during model development. Every time you look, you leak information and inflate your final metrics.

How it works step by step

Here's the typical workflow for evaluating a neural network on test data:

1. Split your dataset — commonly 70/15/15 (train/validation/test) or 80/10/10. Use train_test_split with a fixed random_state for reproducibility.
2. Train on the training set — optionally using validation loss for early stopping.
3. Tune hyperparameters — using only the validation set (e.g., learning rate, number of layers, dropout).
4. Freeze the model — stop changing anything after tuning.
5. Run predictions on the test set — compute metrics like accuracy, precision, recall, F1, or loss.
6. Interpret results — compare test metrics to training metrics. If test accuracy is much lower, you're overfitting.
7. Repeat with different seeds — for low-variance estimates, run multiple train/test splits (k-fold cross-validation) and average.

Why a dedicated test set matters

• Unbiased estimate — the model has never seen this data, so metrics reflect true generalization.
• Trustworthy comparison — when comparing model A vs. B, a fixed test set gives a fair battlefield.
• Regulatory compliance — many domains (finance, healthcare) require documented test performance for audits.

Hands-on walkthrough

Let's implement a complete pipeline in Python using TensorFlow/Keras and scikit-learn. We'll train a simple feedforward network on the classic MNIST dataset and evaluate it properly.

Step 1: Load and split data

import numpy as np
from sklearn.model_selection import train_test_split
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# Load MNIST
(x_full, y_full), (x_test_, y_test_) = keras.datasets.mnist.load_data()

# Normalize pixel values to [0,1]
x_full = x_full.astype('float32') / 255.0
x_test_ = x_test_.astype('float32') / 255.0

# Reshape for a dense network (flatten 28x28 images)
x_full = x_full.reshape(-1, 784)
x_test_ = x_test_.reshape(-1, 784)

# Split the full training set (60k) into train (48k) and validation (12k)
x_train, x_val, y_train, y_val = train_test_split(
    x_full, y_full, test_size=0.2, random_state=42
)

# Store the original test set for final evaluation
x_test = x_test_
y_test = y_test_

print(f"Train: {x_train.shape}, Val: {x_val.shape}, Test: {x_test.shape}")

Expected output:

Train: (48000, 784), Val: (12000, 784), Test: (10000, 784)

Step 2: Build and train the model

# Simple Sequential model
model = keras.Sequential([
    layers.Dense(128, activation='relu', input_shape=(784,)),
    layers.Dropout(0.2),  # helps reduce overfitting
    layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Train with early stopping on validation loss
early_stop = keras.callbacks.EarlyStopping(
    monitor='val_loss', patience=3, restore_best_weights=True
)

history = model.fit(
    x_train, y_train,
    validation_data=(x_val, y_val),
    epochs=20,
    batch_size=128,
    callbacks=[early_stop]
)

Step 3: Evaluate on test data

# After training, evaluate exactly once on the test set
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
print(f"Test loss: {test_loss:.4f}")
print(f"Test accuracy: {test_acc:.4f}")

# Also get training accuracy for comparison
_, train_acc = model.evaluate(x_train, y_train, verbose=0)
print(f"Train accuracy: {train_acc:.4f}")
print(f"Generalization gap: {train_acc - test_acc:.4f}")

Expected output (varies by run):

Test loss: 0.0712
Test accuracy: 0.9789
Train accuracy: 0.9910
Generalization gap: 0.0121

A small gap (less than ~0.05) is healthy. If the gap were large (e.g., 0.2), you'd suspect overfitting and need to adjust.

Step 4: Inspect misclassifications

import numpy as np

# Predict on test set
predictions = model.predict(x_test)
predicted_classes = np.argmax(predictions, axis=1)

# Find indices where predictions are wrong
misclassified = np.where(predicted_classes != y_test)[0]
print(f"Number of misclassified samples: {len(misclassified)}")

# Show first 5 misclassified examples (index, true label, predicted)
for idx in misclassified[:5]:
    print(f"Index {idx}: true={y_test[idx]}, predicted={predicted_classes[idx]}")

Expected output (sample):

Number of misclassified samples: 211
Index 7: true=4, predicted=9
Index 12: true=1, predicted=7
Index 24: true=5, predicted=3
...

These error patterns help you decide if you need more data, more layers, or different features.

Compare options / when to choose what

Different evaluation strategies have distinct trade-offs. Here's a quick comparison:

Which to choose?

• For quick experiments — use a single 80/10/10 split.
• For final model selection — use 5-fold cross-validation on the training set, then evaluate the best model once on the test set.
• For production-critical systems — consider nested CV or bootstrap resampling to measure confidence intervals.

Pro tip: Always use a fixed random seed when splitting. This makes your experiments reproducible and your comparisons fair.

Troubleshooting & edge cases

1. Test accuracy is much lower than training accuracy

Symptom: Gap > 0.2 on classification tasks. Fix: Increase dropout, add weight regularization (L2), reduce model capacity, or get more data.

# Example: add L2 regularization
from tensorflow.keras import regularizers
model.add(layers.Dense(128, activation='relu',
                       kernel_regularizer=regularizers.l2(0.001)))

2. Test data comes from a different distribution

Symptom: Model works on validation but fails on test even with a small gap in validation. Fix: Check that your train/test split comes from the same distribution. If not, use stratified sampling or gather more representative test data.

from sklearn.model_selection import StratifiedShuffleSplit
splitter = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
for train_idx, val_idx in splitter.split(x_full, y_full):
    x_train, x_val = x_full[train_idx], x_full[val_idx]
    y_train, y_val = y_full[train_idx], y_full[val_idx]

3. You accidentally used the test set for hyperparameter tuning

Symptom: Your test accuracy looks too good compared to real-world performance. Fix: Re-split a new test set from your original data (or collect fresh data) and evaluate once more. Avoid this by never touching the test set until the very end.

4. Unbalanced classes

Symptom: Accuracy is high but your model always predicts the majority class. Fix: Use metrics like precision, recall, or F1 instead of accuracy alone.

from sklearn.metrics import classification_report
print(classification_report(y_test, predicted_classes))

What you learned & what's next

You now know how to evaluate neural networks on test data — the gold standard for measuring generalization. You can:

• Split data into train/validation/test sets correctly.
• Train a model without peeking at test data.
• Compute and interpret metrics like accuracy and generalization gap.
• Diagnose overfitting and fix it with regularization.
• Use appropriate evaluation strategies for different scenarios.

Next up: In the next lesson, you'll learn how to improve model performance by tuning hyperparameters systematically using the validation set — turning that 98% training accuracy into a 97% test accuracy you can trust.

Final thought: A model that performs well on test data is a model you can ship. Never skip this step.