🤖Course Curriculum

Deep Learning & Neural Networks

AI & Machine Learning· Advanced· Ages 16–18· 40 Hours

Course At a Glance

Program Outcomes

By the end of this course, students will be able to:

1
Understand neural network architecture and deep learning principles.
2
Build and train deep learning models using modern AI frameworks (TensorFlow/Keras).
3
Evaluate and optimise model performance using advanced techniques including regularisation, callbacks, and Grad-CAM interpretability.
4
Develop an end-to-end AI project demonstrating professional-level understanding of deep learning workflows, ethical considerations, and model deployment.

Module 1

Foundations of Neural Networks

Students build deep understanding of neural networks from the ground up: perceptrons, activation functions, architecture, loss functions, gradient descent, backpropagation, and the Keras API.

Approx. 10 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Frameworks / Methods
1.1	From Machine Learning to Deep Learning	Review ML vs DL. Understand multi-layer networks, unstructured data applications (AlexNet, GPT), and GPU/Colab hardware requirements.	DL Landscape Map: Map 10 modern AI applications. Identify which require deep learning vs classical ML.	`Deep learning, unstructured data, GPU, Google Colab, neural network layers`
1.2	The Perceptron & Artificial Neurons	Understand the artificial neuron mathematically: output = activation(w·x + b). Learn the weight update rule and the XOR limitation.	Build: Implement a single Perceptron from scratch in NumPy. Train on AND gate. Demonstrate XOR failure.	`w·x + b, step/sigmoid activation, weight update, NumPy dot(), XOR limitation`
1.3	Activation Functions	Study Sigmoid, Tanh, ReLU, Leaky ReLU, and Softmax. Understand the vanishing gradient problem intuitively.	Activation Visualisation: Plot activation functions. Build a small NN and compare ReLU vs Sigmoid in hidden layers.	`sigmoid, tanh, ReLU=max(0,x), leaky ReLU, softmax, vanishing gradient`
1.4	Neural Network Architecture	Understand dense feedforward networks: input/hidden/output layers. Choose output neurons/activations for classification vs regression.	Architecture Design: Sketch a 3-layer fully-connected network for binary classification and calculate parameters.	`Dense layer, input_shape, output neurons, sigmoid vs softmax, parameter count`
1.5	Loss Functions & Gradient Descent	Understand Cross-Entropy and MSE. Understand gradient descent, learning rates, and optimisers (SGD, Adam).	Loss Landscape Demo: Explore 2D loss landscapes. Train networks using SGD vs Adam and compare convergence.	`binary_crossentropy, categorical_crossentropy, mse, Adam, SGD, learning_rate`
1.6	Backpropagation: Intuition & Chain Rule	Understand backpropagation using the chain rule. Learn how TensorFlow handles this via automatic differentiation.	Backprop by Hand: Trace forward and backward passes manually on a tiny network, then verify with GradientTape.	`Chain rule, GradientTape, automatic differentiation, forward/backward pass`
1.7	Building Your First Neural Network with Keras	Implement a fully-connected NN using Sequential API. Compile, fit, and evaluate. Plot loss/accuracy curves.	Build: 'First Keras Classifier' — train a 3-layer Dense network on Iris using Sequential API, achieving >90% accuracy.	`keras.Sequential, Dense, model.compile(), model.fit(validation_split=0.2), history`
1.8	Module 1 Project: Tabular Data Classifier	Build, train, and evaluate a fully-connected NN on tabular data. Compare against an sklearn RandomForest model.	Project: 'DL vs ML Comparison' — train a Keras network and a RandomForest on tabular data. Compare performance.	`Full Module 1 — Keras Sequential, Dense, compile/fit/evaluate, sklearn comparison`

Module 2

Deep Learning for Computer Vision

Students build convolutional neural networks: from filter visualisation through CNN architecture, data augmentation, transfer learning (MobileNetV2), object detection, and a CIFAR-10 classifier.

Approx. 10 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Frameworks / Methods
2.1	Image Data & Preprocessing	Understand image tensors (H×W×C). Preprocess images: /255 normalisation, resizing, and batching with ImageDataGenerator.	Image Data Lab: Load CIFAR-10. Visualise images, apply normalisation, and print tensor shapes at each stage.	`tf.keras.datasets, image shape (H,W,C), /255.0, ImageDataGenerator, plt.imshow()`
2.2	Convolutional Neural Networks: How They Work	Understand convolutional layers, kernels, stride, padding, and pooling. Learn what deep CNN layers detect.	Filter Visualisation: Apply edge-detection kernels to an image manually, then visualise VGG16 feature maps.	`Conv2D(filters, kernel_size, strides, padding='same'), MaxPooling2D, feature maps`
2.3	Building a CNN from Scratch	Implement a CNN: stacked Conv2D + MaxPooling2D → Flatten → Dense. Use BatchNormalization for stability.	Build: 'MNIST Digit Classifier' — train a CNN on MNIST targeting >99% accuracy. Compare parameters with a Dense network.	`Conv2D, MaxPooling2D, BatchNormalization, Flatten, Dense, model.summary()`
2.4	Data Augmentation	Prevent overfitting using random image transformations (flip, rotation, zoom) via Keras preprocessing layers.	Augmentation Lab: Train a CNN on a small dataset with and without augmentation. Compare learning curves.	`RandomFlip, RandomRotation, RandomZoom, ImageDataGenerator, augmented training`
2.5	Transfer Learning with Pre-trained Models	Use MobileNetV2 (ImageNet) for transfer learning. Practice feature extraction and fine-tuning with low learning rates.	Build: 'Cats vs Dogs Transfer Learner' — freeze MobileNetV2 base, add a custom head, train, and then fine-tune.	`tf.keras.applications.MobileNetV2, include_top=False, base_model.trainable=False, fine-tuning`
2.6	Object Detection Concepts	Understand bounding boxes and detection architectures (YOLO, Faster R-CNN). Introduce mAP metric.	Detection Demo: Run YOLOv8 inference on sample images. Display bounding boxes and analyse false positives.	`from ultralytics import YOLO, model.predict(), results.boxes, .names, mAP`
2.7	Image Classification Project: CIFAR-10	Build and optimise a complete CNN for CIFAR-10 applying augmentation, batch norm, and per-class evaluation.	Build: 'CIFAR-10 Classifier' — design a robust CNN, plot confusion matrix, and identify confused classes.	`3x Conv-Pool blocks, BatchNorm, Dropout, augmentation, classification_report`
2.8	Module 2 Project: Custom Image Classifier	Build a custom image classifier using transfer learning on a chosen dataset. Evaluate with confusion matrices.	Project: 'Custom Image Classifier' — apply MobileNetV2 transfer learning on a 3-5 class dataset. Achieve >85% val accuracy.	`Full Module 2 — CNN, BatchNorm, augmentation, transfer learning, fine-tuning`

Module 3

Model Optimisation & Evaluation

Students apply professional-grade optimisation: Dropout, L2, BatchNorm, Keras callbacks, Keras Tuner, Grad-CAM interpretability, multi-class metrics, and an introduction to LSTMs.

Approx. 10 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Frameworks / Methods
3.1	Regularisation: Dropout & L2	Constrain complexity using Dropout (zeroes neurons) and L2 (weight decay) to prevent severe overfitting.	Overfitting Experiment: Train an over-parametrised network, then apply Dropout and L2 to reduce the train/val gap.	`Dropout(rate=0.5), kernel_regularizer=l2(0.001), train vs val gap, learning curves`
3.2	Batch Normalisation & Optimisers	Understand BatchNorm for faster, stable training. Compare Adam, SGD+Momentum, and RMSprop optimisers.	Training Speed Experiment: Train CNNs with 4 different optimisers. Add BatchNorm to Adam and compare convergence.	`BatchNormalization(), Adam(lr=1e-3), SGD(momentum=0.9), RMSprop, convergence comparison`
3.3	Learning Rate Scheduling & Callbacks	Use callbacks: EarlyStopping, ModelCheckpoint, and ReduceLROnPlateau. Plot dynamic learning rates.	Build: 'Smart Training Loop' — train a CNN with multiple callbacks, automatically saving the best weights.	`EarlyStopping, ModelCheckpoint, ReduceLROnPlateau, TensorBoard, callbacks=[]`
3.4	Hyperparameter Tuning with Keras Tuner	Use Keras Tuner (Hyperband/Bayesian) to automatically search architecture and training parameter spaces.	Tuning Lab: Run a Hyperband tuner to find optimal layers, learning rate, and dropout rate for a CNN.	`keras_tuner.Hyperband, hp.Int(), hp.Float(), hp.Choice(), tuner.search(), get_best_hp()`
3.5	Model Interpretability: Grad-CAM	Implement Grad-CAM to produce heatmaps explaining which image regions influenced CNN predictions.	Grad-CAM Visualisation: Apply Grad-CAM to a trained model. Overlay heatmaps and identify model focus areas.	`Grad-CAM, GradientTape, last conv layer activations, heatmap overlay, tf-explain`
3.6	Advanced Evaluation: Multi-class Metrics	Use classification_report, multi-class ROC (OvR), calibration plots, and balanced accuracy.	Evaluation Deep Dive: Evaluate CIFAR-10 using per-class precision/recall, macro F1, and OvR ROC curves.	`classification_report, roc_auc_score(multi_class='ovr'), CalibrationDisplay, balanced_accuracy_score`
3.7	Introduction to Sequence Models (RNN/LSTM)	Understand sequential data and RNNs/LSTMs. Learn about gated cells that solve vanishing gradients in text.	Build: 'Sentiment Analyser' — train an Embedding + LSTM model on IMDB reviews and predict sentiment.	`Embedding(vocab_size, embed_dim), LSTM(units), pad_sequences(), binary_crossentropy`
3.8	Module 3 Project: Optimised Classifier	Apply Dropout, BatchNorm, Keras Tuner, and callbacks to fully optimise a custom image classifier.	Optimisation Report: Improve a baseline classifier systematically, documenting validation gains and Grad-CAM errors.	`Full Module 3 — Dropout, BatchNorm, callbacks, Keras Tuner, Grad-CAM, classification_report`

Module 4

AI Capstone Project

Students design, build, optimise, evaluate, and deploy a complete deep learning project. Integrates architecture design, Grad-CAM, deployment via Gradio, and Responsible AI reflection.

Approx. 10 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Frameworks / Methods
4.1	Capstone Briefing & Project Selection	Write a Project Proposal defining dataset, motivation, architecture plan, and chosen evaluation metrics.	Project Proposal: Submit a 1-page proposal outlining an end-to-end Deep Learning project for approval.	`Project scoping, dataset sourcing, architecture selection, metric justification`
4.2	Dataset Preparation & Augmentation Pipeline	Build a tf.data.Dataset pipeline with AUTOTUNE prefetching, stratification, and training augmentation.	Data Sprint: Prepare a pipeline. Visualise augmented grid, verify shapes, and ensure no validation augmentation.	`image_dataset_from_directory, .map(), .batch(), .prefetch(AUTOTUNE), stratified split`
4.3	Architecture Design & Baseline Model	Design a custom CNN or transfer learning model on paper. Code and establish a baseline accuracy.	Build Sprint: Train the baseline model for 20 epochs. Print model.summary() and document initial performance.	`model architecture diagram, base model selection, model.summary(), baseline accuracy`
4.4	Optimisation & Iterative Improvement	Systematically apply techniques (BatchNorm, callbacks, fine-tuning) via a documented Optimisation Log.	Optimisation Sprint: Complete ≥5 rounds of optimisation to improve validation accuracy by at least 5%.	`Optimisation log, fine-tuning, Dropout/BatchNorm/LR schedule, iterative improvement`
4.5	Final Evaluation & Model Analysis	Evaluate exactly once on the test set. Produce confusion matrices, per-class F1, and Grad-CAM error analysis.	Evaluation Sprint: Run full test set evaluation. Perform Grad-CAM on 5 errors and diagnose failure cases.	`Final test evaluation (once), Grad-CAM on errors, classification_report, confusion matrix`
4.6	Model Deployment: Saving & Inference	Save models in .keras/.h5. Build an inference script and deploy an interactive web demo using Gradio.	Deployment Build: Save the model and build a 2-line Gradio web interface for drag-and-drop image prediction.	`model.save(), tf.keras.models.load_model(), Gradio, gr.Interface(), TFLite (concept)`
4.7	Ethics, Bias & Responsible AI	Examine dataset representation and social implications. Study real-world AI biases in facial recognition.	Bias Audit: Write a Responsible AI Reflection identifying potential biases and harms in the custom model.	`Dataset bias audit, fairness metrics, responsible AI, representative training data`
4.8	Final AI Capstone Presentation Day	Present the project including the Gradio demo, Optimisation Log, Grad-CAM insights, and Ethical Reflection.	Final Demo: 6-minute live presentation of the end-to-end DL project and 3-minute Q&A. Certificates awarded.	`Full course — Keras, CNN, transfer learning, optimisation, Grad-CAM, Gradio, ethics`

Teaching Notes & Tips

Pacing Guidance

Each module contains 8 lessons (~65–75 mins), totalling ~40 hours. Plan GPU-intensive training to run during discussion. Google Colab GPU is essential. Module 4 has mandatory checkpoints at 4.2, 4.4, and 4.6.

Differentiation

Advanced students: Vision Transformers (ViT), GANs, HuggingFace Transformers, or reinforcement learning (OpenAI Gym). Students needing support should focus on pre-built Keras architectures and evaluation over custom code.

Assessment Criteria

Capstone assessed on: (1) Data Pipeline (efficient, balanced). (2) Architecture Justification. (3) Optimisation Rigour (≥5 rounds logged). (4) Evaluation Depth (Grad-CAM, per-class metrics). (5) Gradio Deployment. (6) Responsible AI.

Tools & Environment

Required: Google Colab (T4 GPU). TensorFlow 2.x + Keras. Libraries: numpy, pandas, matplotlib, seaborn, scikit-learn, ultralytics (YOLOv8), keras-tuner, gradio, tf-explain. Kaggle for datasets.

Capstone Project Tracks

Image Classification System (MobileNetV2), Face Mask Detection (binary), Plant Disease Classifier (38 classes), Wildlife Species Identifier, Medical Image Classifier (Pneumonia X-rays).

Prior Knowledge Expected

Students must be highly confident with Python OOP, pandas, scikit-learn, and matplotlib. A completed ML project with strong understanding of gradient descent and loss functions is assumed.

Enroll Your Child Now