Traffic Sign Recognition using CNN

Driver-assistance systems and autonomous vehicles both depend on one deceptively simple skill: reading the signs on the road. It is simple for humans and surprisingly hard for machines — the same stop sign appears blurred at speed, backlit at noon, rain-streaked at dusk, tilted, partially hidden by a branch, or faded after a decade in the sun. Worse, the dangerous confusions are between near-twins: a 30 and an 80 differ only in their digits. The German Traffic Sign Recognition Benchmark (GTSRB), introduced at IJCNN 2011, turned this into a rigorous academic task: 43 sign classes, over 50,000 cropped real-world images, with the messy variation baked in. This project builds the complete applied-deep-learning workflow on that benchmark — a custom CNN designed for small sign crops, an augmentation pipeline that simulates road conditions, a fully logged training experiment with honest error analysis, and a demo that classifies sign photos in seconds. It classifies cropped signs; finding signs inside full road scenes is documented as the extension, not the claim.

1. GTSRB images are loaded with their class labels; every crop is resized to 48×48 RGB and pixel values are normalized.
2. Training images pass through augmentation — rotation, brightness jitter, blur and shifts that mimic real road photography.
3. The custom CNN (three convolutional blocks with batch normalization and dropout, then dense layers) trains with the Adam optimizer and categorical cross-entropy.
4. After each epoch the notebook logs training and validation accuracy plus loss curves; early stopping keeps the best checkpoint.
5. The final model is evaluated on the held-out 12,630-image test split: accuracy, per-class F1 and the confusion matrix.
6. The demo app loads the exported weights, preprocesses any uploaded sign photo identically, and returns the top-3 ranked predictions.

Tech stack:

• Python 3.10, TensorFlow/Keras (CNN design, training, SavedModel export)
• OpenCV (image loading, resizing, augmentation support)
• NumPy, pandas (data handling, prediction tables)
• scikit-learn (per-class F1, confusion matrix)
• Matplotlib, Seaborn (accuracy curves, confusion heatmap)
• Flask demo app with sign-photo upload UI
• Jupyter notebook (buyer-run training and evaluation)

Dataset & model

• Dataset: GTSRB — German Traffic Sign Recognition Benchmark (IJCNN 2011 competition): 43 classes, 51,839 images total (39,209 train / 12,630 test), real German road photography with lighting, weather, occlusion and motion-blur variation.
• Model: custom convolutional network — input 48×48 RGB crop; three (Conv → BatchNorm → ReLU → MaxPool) blocks, dropout 0.5, dense head; 43-way softmax output.
• Prediction task: single-label classification of a cropped sign image. Metrics: accuracy, per-class precision/recall/F1, confusion matrix — all computed by the notebook on the held-out test split during your build. Design target: ~95%+ test accuracy — a target, not a measured claim.

• Custom CNN classifier designed for sign crops: stacked convolution → batch-norm → ReLU → max-pool blocks with dropout, ending in a 43-way softmax head
• Complete GTSRB data pipeline — 39,209 training and 12,630 test images across 43 classes, resized to 48×48 with normalization
• Road-condition augmentation: random rotation, brightness shifts, motion-blur simulation and translations applied during training
• Top-3 prediction output with confidence bars, so near-miss confusions are visible instead of hidden
• Demo upload UI: drop in a sign photo and get the ranked prediction in seconds
• Evaluation notebook logging accuracy, per-class F1 and the full confusion matrix on the held-out test split
• Misclassification gallery that collects the hardest confusions (speed-limit twins, faded signs) for the report's error analysis
• Exported SavedModel weights from the training run for the demo and viva demonstration

• Complete source code (data pipeline, augmentation, CNN model, training loop, evaluation, demo app)
• Jupyter training and evaluation notebook (buyer-run procedure: train on GTSRB, evaluate on the held-out split)
• Project report PDF (background, CNN design, augmentation strategy, results, error analysis)
• PPT presentation for final review
• Viva Q&A preparation document (convolutions, pooling, overfitting, GTSRB, augmentation, softmax)
• Setup guide (environment, GTSRB download, training your own model, running the demo)

• The model classifies cropped sign images — it does not detect or localize signs inside full road scenes; that detection stage is a documented extension, not part of the base build.
• GTSRB contains German signs: Indian road signs differ in design and language, so deployment here needs fine-tuning on locally photographed signs — the report states this plainly.
• Heavily occluded, vandalized or sun-faded signs fall outside what the training data represents and are the main documented failure cases.
• Near-identical classes (30 vs 50 vs 80 speed limits) are the top confusion pairs; the confusion matrix in the report shows this openly.
• Reported performance is whatever your training run measures on the held-out split — the ~95% figure is a design target, never a pre-claimed result.
• Real-time video inference needs frame-rate optimization the base notebook does not cover; the demo is upload-based.