Level 2 · Masterclass · DLM

Deep Learning Masterclass

Neural networks in action: ANNs, CNNs for computer vision, and RNNs for NLP — with TensorFlow, Keras and PyTorch.

40 hours 5 lessons Prerequisite: CDSP Leads to: CGAIP

Your progress 0 / 5

01Deep Learning

Deep Learning Foundations

Deep learning is machine learning with neural networks that learn their own features. Before the networks, meet the tools and when to reach for them.

9 min read

When to go deep

Classic ML (like XGBoost) usually wins on tabular data. Deep learning shines on unstructured data — images, audio, text — where it learns useful features automatically instead of you hand-engineering them. More data and more compute is what makes it pay off.

The frameworks

TensorFlow + Keras — Keras is the friendly high-level API; great to start.
PyTorch — flexible and research-favorite; now dominant in the field.
Google Colab — free GPUs in the browser, so you can train without local hardware.

Why GPUs

Neural networks are mostly matrix multiplications. A GPU does thousands of these in parallel, training models tens to hundreds of times faster than a CPU. That hardware shift is a big reason deep learning took off.

Test yourself You have 3,000 rows of tabular customer data. Deep learning or XGBoost first?

XGBoost. On modest, structured/tabular data it typically beats deep learning and is faster to train and tune. Reach for deep learning when you have lots of unstructured data (images/text/audio).

Key takeaways

Deep learning wins on unstructured data by learning features automatically.
Start with Keras; PyTorch dominates research; Colab gives free GPUs.
GPUs parallelize the matrix math, making training vastly faster.

Try it Gradient descent

Training minimizes a loss curve. Pick a starting point and press “Descend” — each step moves downhill by the slope × learning rate until it settles at the minimum.

Start x: -3.0

loss –

Practice this in the interactive lab

02Deep Learning

Artificial Neural Networks

A neural network is layers of simple units that together learn complex patterns. Understand one neuron and backprop, and you understand deep learning.

12 min read

From neuron to network

A neuron multiplies its inputs by weights, adds a bias, and passes the result through an activation function. Stack neurons into layers — input, hidden, output — and connect them, and the network can approximate almost any function. This is a Multi-Layer Perceptron (MLP).

Activation functions add the nonlinearity

Without a nonlinear activation, stacking layers just gives another linear model. ReLU (keep positives, zero out negatives) is the default for hidden layers — simple and effective. The output layer uses sigmoid for yes/no, or softmax to turn scores into class probabilities.

How it learns: backpropagation

The network makes a prediction, a loss function measures how wrong it is, and backpropagation computes how much each weight contributed to that error. Gradient descent then nudges every weight to reduce the loss. Repeat over many epochs and the network learns.

A tiny Keras classifier

from tensorflow import keras
model = keras.Sequential([
    keras.layers.Dense(64, activation="relu"),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation="softmax"),
])
model.compile(optimizer="adam", loss="categorical_crossentropy",
              metrics=["accuracy"])
model.fit(X_train, y_train, epochs=10, validation_split=0.1)

Test yourself Why must hidden layers use a nonlinear activation like ReLU?

Because stacking purely linear layers collapses into a single linear transformation — no matter how many, it can't model curves or complex patterns. Nonlinearity is what lets deep networks learn rich functions.

Models & techniques — what, when & why

ReLU Activation Building block

Keeps positive values and zeroes out negatives, adding nonlinearity to a layer.

The default activation for hidden layers in almost every modern network.

Simple, fast, and avoids the vanishing gradients that plagued older activations.

Example: Dense(64, activation='relu') in Keras.

Dropout Regularization

Randomly disables a fraction of neurons during each training step.

When a network overfits (great on train, poor on validation).

Forces the network not to over-rely on any single neuron, improving generalization.

Example: Dropout(0.2) drops 20% of activations each step.

Softmax Output Output layer

Turns raw scores into a set of class probabilities that sum to 1.

The final layer for multi-class classification.

Gives an interpretable probability per class for the prediction.

Example: Digit classifier outputs [0.01,…,0.95,…] over 10 classes.

Key takeaways

An MLP is layers of neurons (weights + bias + activation) that approximate functions.
ReLU adds nonlinearity in hidden layers; softmax/sigmoid shape the output.
Backprop + gradient descent adjust weights; dropout/batchnorm curb overfitting.

Try it Inside a neuron

A neuron multiplies each input by a weight, adds a bias, then squashes the sum with an activation. Move the weights, watch the output — then press “Train step” to let gradient descent nudge them toward the target.

w₁: 0.8 w₂: -0.5 bias: 0.0

Output 0.50 · Target 0.90

Practice this in the interactive lab

03Deep Learning

CNNs & Computer Vision

Convolutional neural networks see. They power image classification, detection and recognition by learning visual features from pixels up.

11 min read

Why not a plain network for images?

A 200×200 color image is 120,000 numbers — a fully-connected network would need billions of weights and ignore that nearby pixels are related. CNNs exploit image structure: they scan small patches and reuse the same filters everywhere, so they learn efficiently.

Convolution + pooling

A convolution slides a small filter across the image, detecting a feature (an edge, a texture) wherever it appears. Early layers find edges; deeper layers combine them into shapes, then objects. Pooling downsamples between layers, shrinking the data and keeping the strongest signals.

Transfer learning: don't start from scratch

Training a CNN from zero needs huge data and compute. Instead, take a model already trained on millions of images (VGG, ResNet, Inception) and fine-tune its last layers on your task. You get excellent results with a few hundred images — the single most practical technique in computer vision.

Test yourself You need a mask-detection model but only have 400 labeled photos. Best approach?

Transfer learning — start from a pretrained CNN (e.g. ResNet) and fine-tune its top layers on your 400 images. Training from scratch would badly overfit such a small dataset.

Models & techniques — what, when & why

Convolution Layer Feature detector

Slides small filters across an image to detect features (edges, textures) anywhere.

The core layer of any image model.

Shared filters mean far fewer weights and exploit that nearby pixels relate.

Example: Early layers learn edges; deeper ones combine them into shapes and objects.

Pooling Downsampling

Shrinks the feature map between conv layers, keeping the strongest signals.

Between convolution blocks to reduce size and computation.

Cuts compute and adds a little translation-robustness.

Example: 2×2 max-pooling halves width and height.

Transfer Learning Pretrained model

Takes a CNN pretrained on millions of images and fine-tunes its top layers on your task.

Almost always in vision — especially with limited labeled data.

Reuses learned visual features, giving strong results from a few hundred images.

Example: Fine-tune ResNet/VGG for mask or defect detection.

Key takeaways

CNNs exploit image structure with shared filters — far fewer weights than a dense net.
Convolution detects features; pooling downsamples; depth builds edges→shapes→objects.
Transfer learning fine-tunes a pretrained model — great results from little data.

The idea How a CNN sees an image

A small filter slides across the image, multiplying and summing pixels to build a feature map — detecting edges, then shapes, then objects, layer by layer.

Practice this in the interactive lab

04Deep Learning

RNNs & NLP

Language and time-series are sequences where order matters. RNNs and their successors read sequences to classify sentiment, translate, and summarize.

11 min read

Text → numbers

First, tokenize text into words or sub-words, then map each token to an embedding — a dense vector that captures meaning. Classic features like TF-IDF also work for simpler tasks, but embeddings let models understand that 'great' and 'excellent' are close.

RNNs, LSTMs and GRUs

A Recurrent Neural Network reads a sequence one step at a time, carrying a memory of what came before. Plain RNNs forget long-range context, so LSTM and GRU add gates that decide what to remember and forget — enabling them to track meaning across long sentences.

What you can build

Sentiment analysis — classify reviews or tweets as positive/negative.
Text generation & summarization — produce or condense text.
Translation and named-entity recognition — sequence-to-sequence tasks.

Test yourself Why do LSTMs handle long sentences better than a plain RNN?

Their gates explicitly control what to keep and drop in memory, so important context from early in a sentence survives to the end. Plain RNNs suffer vanishing gradients and forget long-range dependencies.

Models & techniques — what, when & why

Word Embeddings Text → numbers

Maps each token to a dense vector where similar meanings sit close together.

Any NLP model that should understand meaning, not just spelling.

Captures semantics (king–man+woman≈queen) that raw word counts miss.

Example: Word2Vec / GloVe embeddings feed a sentiment classifier.

LSTM / GRU Sequence model

Recurrent networks with gates that decide what to remember and forget across a sequence.

Ordered data — text, time-series — with meaningful long-range context.

Gates preserve important early context, avoiding the forgetting of plain RNNs.

Example: Sentiment on long reviews; next-word suggestion.

Transformer (Attention) State of the art

Reads a whole sequence at once, weighing how every token relates to every other.

Modern NLP — translation, summarization, and all LLMs.

Attention captures long-range links and parallelizes, so it scales far better than RNNs.

Example: The architecture behind GPT, BERT and today's chat models.

Key takeaways

Tokenize then embed text so models grasp meaning, not just spelling.
RNNs carry memory across a sequence; LSTM/GRU gates handle long context.
Transformers superseded RNNs for NLP and underpin today's LLMs.

Practice this in the interactive lab

05Engineering

Deploying Deep Learning Models

A trained deep model is a large file of weights. Deploying it means serving predictions efficiently — and shrinking the model so it's fast and affordable.

8 min read

Save, then serve

Export the trained network (Keras .h5/SavedModel, or PyTorch state_dict). Then wrap it in an API (FastAPI/Flask) or a Streamlit/Gradio app that loads the model once and answers requests. For images, preprocessing (resize, normalize) must match exactly what training used.

Make it small and fast

Quantization stores weights in lower precision (e.g. 8-bit) — smaller and faster with tiny accuracy loss.
Pruning removes redundant connections; distillation trains a small model to mimic a big one.
ONNX / TensorFlow Lite export models to run on servers, mobile, or the edge.

Serve on the right hardware

Inference can run on CPU for small models, but heavy vision/NLP models often need a GPU to answer quickly. Batch requests together for throughput, and containerize (Docker) so the exact environment ships with the model.

Test yourself Your image classifier is accurate but too slow and large for a phone app. What techniques help?

Quantization and pruning to shrink and speed it up, distillation into a smaller student model, and export via TensorFlow Lite/ONNX to run efficiently on-device. Together they trade a tiny bit of accuracy for big size/speed gains.

Key takeaways

Export the weights, then serve via an API or Gradio/Streamlit app.
Quantization, pruning and distillation shrink models for speed and cost.
Match inference hardware to model size; containerize for reproducibility.