Deep Learning | 23IT5141B

Unit I • 12 Periods

Introduction to Deep Learning & CNNs

Historical trends, DL frameworks, Convolutional Neural Networks, pooling, activation functions, popular architectures (VGG, GoogLeNet, ResNet), dropout, normalization, and data augmentation.

Historical Trends in DL

Evolution from perceptrons to modern deep learning. Key milestones including AlexNet (2012), ResNet (2015).

Why DL is Growing

Big data, GPU computing, open-source frameworks, and breakthroughs in accuracy driving DL adoption.

DL Frameworks

TensorFlow/Keras for production, PyTorch for research. Comparison of syntax, ecosystem, and use-cases.

CNN Introduction

Convolutional Neural Networks for spatial data. Applications in image classification, detection, segmentation.

CNN Architecture

Conv layers, pooling layers, flattening, and fully connected layers forming the standard CNN pipeline.

Pooling Layers

Max pooling, average pooling, global average pooling — spatial dimension reduction techniques.

Activation Functions

ReLU, Sigmoid, Tanh, Leaky ReLU, Softmax — introducing non-linearity at each layer.

Popular Architectures

VGGNet (deep + simple), GoogLeNet (Inception modules), ResNet (skip connections).

Regularization

Dropout randomly disables neurons. Batch normalization stabilizes learning and speeds convergence.

Data Augmentation

Flipping, rotation, cropping, color jitter to increase effective dataset size and improve generalization.

🎯Learning Outcomes

Explain the basic concepts, architecture, and working principles of CNNs and their applications in computer vision.

Describe the role of activation functions, pooling layers, dropout, normalization, and data augmentation in CNN performance.

Apply CNN models using TensorFlow by implementing convolution, pooling, and training procedures for image classification.

🕐 Historical Trends in Deep Learning

The Rise of Deep Learning

Deep Learning emerged from Artificial Neural Networks (ANNs), tracing roots to the 1940s–50s with McCulloch & Pitts neurons and Rosenblatt's Perceptron. The field went through two "AI winters" before resurging in the 2000s–2010s.

1986: Backpropagation popularized by Rumelhart, Hinton & Williams — enabled training of multi-layer networks.
1998: LeNet-5 by LeCun — first practical CNN for digit recognition (MNIST).
2006: Hinton's deep belief networks — showed unsupervised pre-training could initialize deep networks.
2012: AlexNet wins ImageNet with 15.3% error (vs 26.2%) — the "ImageNet moment" that triggered the DL revolution.
2014: GANs introduced by Goodfellow. VGGNet, GoogLeNet compete in ImageNet.
2015: ResNet (152 layers) achieves superhuman performance (3.57% error on ImageNet).
2017: Transformer architecture introduced — "Attention Is All You Need".
2018–2023: BERT, GPT series, Vision Transformers transform NLP and CV.

Key insight: DL revival was driven by 3 factors — availability of big data, GPU computing power, and algorithmic improvements (ReLU, dropout, batch norm).

Why Deep Learning is Growing

Big Data: Internet-scale datasets (ImageNet, Common Crawl, YouTube) provide supervision signals impossible a decade ago.
GPU Computing: Parallel matrix operations on NVIDIA GPUs reduce training time from months to hours.
Open-Source Frameworks: TensorFlow (2015), PyTorch (2016) democratized research.
Transfer Learning: Pre-trained models allow fine-tuning on small datasets.
Algorithmic Improvements: Better optimizers (Adam), activation functions (ReLU), and regularization (dropout, batch norm).

🛠️ Deep Learning Frameworks

TensorFlow / Keras

Developed by Google Brain (2015). Uses static computation graphs (TF1) and eager execution (TF2). Keras is the high-level API that runs on top of TensorFlow.

model = tf.keras.Sequential([ tf.keras.layers.Conv2D(32, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(), tf.keras.layers.Flatten(), tf.keras.layers.Dense(10, activation='softmax') ])

Best for production deployment (TF Serving, TF Lite, TF.js)
Rich ecosystem: TensorBoard, TF Hub, TF Datasets
Supports distributed training natively

PyTorch

Developed by Facebook AI Research (2016). Uses dynamic computation graphs — define-by-run approach. Preferred in academic research for its Pythonic style and flexibility.

class CNN(nn.Module): def __init__(self): super().__init__() self.conv = nn.Conv2d(1, 32, 3) self.fc = nn.Linear(32*26*26, 10) def forward(self, x): return self.fc(F.relu(self.conv(x)).flatten(1))

Dynamic graphs enable easier debugging with standard Python tools
PyTorch Lightning, Hugging Face use PyTorch
ONNX export for deployment

📐 Convolutional Neural Networks (CNN)

Introduction & Motivation

Standard fully-connected networks do not scale to images — a 224×224 RGB image has 150,528 inputs, and full connectivity explodes parameters. CNNs exploit spatial structure through three key ideas:

Local connectivity: Each neuron connects only to a small region (receptive field) of the input
Parameter sharing: The same filter weights are used across all spatial positions
Translational invariance: Features detected anywhere in the image activate the same filter

CNNs achieve state-of-the-art performance in image classification, object detection, face recognition, medical imaging, and autonomous driving.

CNN Architecture

Standard CNN Pipeline

Input Image→ Conv + ReLU→ Pooling→ Conv + ReLU→ Pooling→ Flatten→ FC Layers→ Softmax Output

Convolutional Layer: Applies learnable filters (kernels) across the input. A filter of size k×k slides with stride s and produces a feature map.

Output size = ⌊(W - K + 2P) / S⌋ + 1 W=input size, K=kernel size, P=padding, S=stride

Feature Maps: Each filter learns to detect a specific pattern (edges, corners, textures). Deeper layers capture more complex features (eyes, faces, objects).

Types of Pooling Layers

Pooling reduces spatial dimensions, providing translation invariance and reducing computation.

Max Pooling: Takes the maximum value in each window. Preserves dominant features. Most commonly used (2×2, stride 2 halves spatial dims).
Average Pooling: Takes the average. Smoother representation, used in some architectures for final spatial averaging.
Global Average Pooling (GAP): Averages entire feature map to a single value per channel. Used in GoogLeNet, ResNet to replace FC layers — reduces parameters dramatically.
Min Pooling: Takes minimum value. Rarely used in practice.

Max pooling is preferred as it retains the most activated (important) features and provides robustness to small translations.

Activation Functions

ReLU (Rectified Linear Unit): f(x) = max(0, x). Most popular — computationally simple, avoids vanishing gradient for positive inputs, sparse activation. Suffers from "dying ReLU" (neurons stuck at 0).
Leaky ReLU: f(x) = max(αx, x), α≈0.01. Fixes dying ReLU by allowing small negative gradients.
Sigmoid: f(x) = 1/(1+e⁻ˣ). Output in (0,1) — used in binary classification output. Saturates at extremes causing vanishing gradients.
Tanh: f(x) = (eˣ−e⁻ˣ)/(eˣ+e⁻ˣ). Output in (−1,1). Zero-centered — better than sigmoid for hidden layers but still saturates.
Softmax: Converts raw scores to probability distribution. Used in final layer for multi-class classification.
ELU / GELU / Swish: Modern alternatives with smoother gradients, used in newer architectures.

🏛️ Popular CNN Architectures

VGGNet (2014) — Oxford Visual Geometry Group

Key innovation: use only small 3×3 convolution filters throughout (stacking two 3×3 convs = one 5×5 receptive field, but fewer parameters). VGG-16 has 16 weight layers.

Architecture: 5 conv blocks (increasing depth: 64→128→256→512→512) + 3 FC layers
Very deep but simple and uniform — easy to understand and transfer-learn
Problem: 138M parameters — very memory intensive

VGG showed that depth with small filters is key to representation power.

GoogLeNet / Inception (2014) — Google

Introduced the Inception module: performs 1×1, 3×3, 5×5 convolutions and 3×3 max pooling in parallel at each layer, concatenating results. This captures multi-scale features simultaneously.

1×1 convolutions used as bottlenecks to reduce channel dimensions (computational efficiency)
Global Average Pooling replaces FC layers → only 5M parameters (vs. VGG's 138M)
Auxiliary classifiers during training help with gradient flow in very deep networks
Later versions: Inception v2,v3,v4 improved modules progressively

ResNet (2015) — Microsoft Research

Introduced Residual / Skip Connections to train very deep networks (50, 101, 152 layers) without degradation. Won ImageNet 2015 with 3.57% top-5 error.

Output = F(x) + x F(x) = learned residual mapping, x = skip connection (identity shortcut)

Skip connections allow gradients to flow directly — solves vanishing gradient in very deep nets
Each residual block learns only the difference from the identity mapping (easier to optimize)
Batch Normalization after each conv layer
Bottleneck blocks (1×1 → 3×3 → 1×1) in ResNet-50+ for efficiency

ResNet's skip connections are one of the most influential ideas in deep learning — adopted in virtually every modern architecture.

🛡️ Regularization & Optimization Techniques

Dropout

During training, randomly set a fraction p (typically 0.5) of neuron outputs to zero. At test time, scale outputs by (1−p). Forces the network to learn redundant representations — acts like ensemble of many networks.

Prevents co-adaptation of neurons — each neuron must work independently
Most effective in fully-connected layers; less effective in conv layers (spatial correlation)
Modern alternative: DropBlock (drops entire spatial blocks for conv layers)

Batch Normalization

Normalizes layer inputs to zero mean and unit variance for each mini-batch, then applies learnable scale (γ) and shift (β).

BN(x) = γ · (x − μ_batch) / √(σ²_batch + ε) + β

Allows higher learning rates — accelerates convergence
Reduces sensitivity to weight initialization
Acts as a regularizer — often reduces the need for dropout
Applied after conv/FC layers, before activation function

Data Augmentation

Artificially expands training set by applying label-preserving transformations to existing images.

Geometric: Horizontal flip, rotation (±15°), random crop, zoom, shear
Photometric: Brightness, contrast, saturation, hue adjustment; adding Gaussian noise
Advanced: Cutout (masking patches), Mixup (blending two images), CutMix, AutoAugment (learned policies)
Applied on-the-fly during training using data generators (Keras ImageDataGenerator, torchvision.transforms)

Data augmentation is essential when labeled data is scarce. It regularizes the model by ensuring it sees diverse views of each sample.

Unit I Quiz — Deep Learning & CNNs

10 multiple-choice questions • Select one answer per question

Question 1 of 10

Which landmark event in 2012 is widely credited with reigniting interest in deep learning?

The release of TensorFlow by Google AlexNet winning ImageNet classification challenge with a large margin Introduction of the Transformer architecture Publication of the GAN paper by Goodfellow

Question 2 of 10

What is the primary advantage of using small 3×3 filters repeatedly (as in VGG) over a single large filter?

Larger filters always produce better accuracy Small filters are faster to compute on CPUs only Same receptive field with fewer parameters and more non-linearity Small filters prevent overfitting by reducing feature map size

Question 3 of 10

What is the key innovation introduced by ResNet that enables training of very deep networks?

Skip (residual) connections that allow gradient to bypass layers Use of Inception modules at each layer Replacing all pooling layers with strided convolutions Applying dropout after every convolutional layer

Question 4 of 10

Which activation function is most commonly used in hidden layers of CNNs and helps mitigate the vanishing gradient problem?

Sigmoid Tanh Softmax ReLU

Question 5 of 10

What does Max Pooling do in a CNN?

Applies a learnable filter to detect edges Selects the maximum value from each pooling window, reducing spatial dimensions Normalizes feature maps to zero mean and unit variance Randomly sets neurons to zero during training

Question 6 of 10

What is Dropout's primary purpose in neural network training?

To speed up forward pass computation To increase the number of trainable parameters To prevent overfitting by randomly deactivating neurons during training To normalize activations between layers

Question 7 of 10

Batch Normalization is primarily used to:

Stabilize and accelerate training by normalizing layer inputs Reduce the number of convolutional layers needed Replace the need for activation functions in hidden layers Generate augmented training samples on the fly

Question 8 of 10

GoogLeNet's Inception module applies which of the following at each layer?

Only 3×3 convolutions at varying depths Residual connections followed by batch normalization A sequence of dropout and pooling layers Parallel 1×1, 3×3, 5×5 convolutions and max pooling, concatenated

Question 9 of 10

Data augmentation helps deep learning models by:

Reducing training time by compressing datasets Increasing effective dataset size and improving generalization to unseen data Removing noisy labels from the training set automatically Replacing batch normalization during training

Question 10 of 10

Given an input of size 32×32 with a 3×3 kernel, padding=1, and stride=1, what is the output feature map size?

30×30 34×34 32×32 16×16

Unit I Case Study · L4 Analyze

AI-Based Pneumonia Detection from Chest X-Rays

Scenario: A healthcare company is developing an AI system to detect pneumonia from chest X-ray images. The initial model suffers from overfitting and poor accuracy on the validation set despite high training accuracy.

Problem Analysis

The model memorizes training data but fails to generalize — a classic overfitting scenario. Causes include limited medical imaging data, insufficient regularization, and possibly an architecture not suited for subtle pathology patterns in X-rays.

CNN-Based Solution Strategy

Architecture Choice: Use a pre-trained ResNet-50 or DenseNet-121 (trained on ImageNet) as the backbone. Fine-tune the last few layers on the X-ray dataset — transfer learning from natural images helps detect low-level features (edges, textures) relevant to lung patterns.
Convolution & Feature Extraction: Early CNN layers detect edges and lung boundaries; deeper layers capture pneumonia-specific opacity patterns and consolidations.
Pooling: Max pooling preserves the most prominent features (opacities) while reducing spatial noise from X-ray artifacts.
Dropout (p=0.5): Applied before final classification layers to prevent co-adaptation on the small medical dataset.
Batch Normalization: Applied after each conv block to stabilize training across varying X-ray exposure levels.
Data Augmentation: Horizontal flips, random rotations (±10°), zoom (0.9–1.1×), and brightness variation simulate different patient positions and imaging conditions. This effectively multiplies a 5,000-image dataset.
Class Imbalance: Use weighted loss (pneumonia cases are fewer) or SMOTE on features.

Expected Outcome

With these strategies, the model should achieve >90% AUC-ROC on held-out test data — comparable to radiologist-level performance for pneumonia detection, as demonstrated in the CheXNet paper (Rajpurkar et al., 2017).

Key Takeaway

CNNs with transfer learning + augmentation + regularization (dropout, batch norm) form the gold standard for medical image analysis tasks where labeled data is scarce and overfitting is the primary risk.

Unit II • 9 Periods

Recurrent Neural Networks (RNN)

Introduction to RNNs, Backpropagation Through Time (BPTT), Vanishing Gradient Problem, Gradient Clipping, Long Short-Term Memory (LSTM) Networks, and Gated Recurrent Units (GRU).

Introduction to RNNs

Recurrent connections allow networks to process sequential data with temporal dependencies.

BPTT

Backpropagation Through Time — unrolling RNN across time steps to compute gradients.

Vanishing Gradient

Gradients become exponentially small as they propagate back through many time steps.

Gradient Clipping

Limiting gradient norm to prevent exploding gradients during RNN training.

LSTM Networks

Long Short-Term Memory: cell state with input, forget, and output gates for long-range dependencies.

Gated Recurrent Units

Simplified version of LSTM with reset and update gates — fewer parameters, similar performance.

🎯Learning Outcomes

Explain RNN fundamentals, BPTT working principles, and the vanishing gradient problem in sequential data analysis.

Describe LSTM, GRU architectures and gradient clipping for improving training stability.

Apply RNN/LSTM models to sequential data problems for prediction or classification tasks.

🔄 Introduction to Recurrent Neural Networks

What Makes RNNs Different?

Feedforward networks (including CNNs) assume inputs are independent and fixed-size. Sequential data — text, speech, time series, video — has temporal dependencies where the current output depends on past inputs. RNNs address this with a recurrent connection that passes hidden state from one time step to the next.

RNN Unrolled Across Time Steps

x₁→ h₁→ x₂→ h₂→ x₃→ h₃→ ŷ

hₜ = tanh(Wₕ · hₜ₋₁ + Wₓ · xₜ + b) ŷₜ = Wᵧ · hₜ + bᵧ

Shared weights: Wₕ, Wₓ, Wᵧ are the same at every time step — enables processing variable-length sequences
Hidden state hₜ: A "memory" of all past inputs, summarized into a fixed-size vector
Applications: Language modeling, machine translation, speech recognition, sentiment analysis, stock price prediction

RNNs process one token at a time, maintaining state — unlike FFNNs which take the entire input at once.

⏳ Backpropagation Through Time (BPTT)

How BPTT Works

To train an RNN, we unroll it across T time steps and apply backpropagation on the resulting computational graph. The total loss is the sum of losses at each time step.

L = Σₜ L(ŷₜ, yₜ) ∂L/∂Wₕ = Σₜ ∂Lₜ/∂hₜ · Σₖ≤ₜ (∂hₜ/∂hₖ) · ∂hₖ/∂Wₕ

The term ∂hₜ/∂hₖ is a product of Jacobians across time steps — this is where the vanishing/exploding gradient issue arises.

Truncated BPTT: For long sequences, unroll only k steps to limit computational cost and memory
Full BPTT: Unroll the entire sequence — accurate but memory-intensive for long sequences

⚠️ Vanishing & Exploding Gradient Problems

Vanishing Gradient Problem

When backpropagating through many time steps, gradients are multiplied by the weight matrix Wₕ repeatedly. If the largest eigenvalue of Wₕ is < 1, gradients shrink exponentially → early time steps receive near-zero gradient updates → the network cannot learn long-range dependencies.

∂hₜ/∂h₁ = ∏ᵢ₌₂ᵗ (∂hᵢ/∂hᵢ₋₁) ≈ Wₕᵗ → 0 when |λmax(Wₕ)| < 1

Vanishing gradient makes vanilla RNNs nearly useless for sequences longer than ~10–20 steps. LSTMs and GRUs were designed to solve this.

Exploding Gradient Problem

Conversely, if |λmax(Wₕ)| > 1, gradients grow exponentially → weight updates become NaN (network diverges). This is the exploding gradient problem.

Gradient Clipping

A simple but effective solution to exploding gradients: if the gradient norm exceeds a threshold θ, rescale the gradient to have norm θ.

if ||∇|| > θ: ∇ ← θ · ∇/||∇|| Typically θ = 1.0 or 5.0

Clips the gradient direction is preserved, only magnitude is reduced
Does NOT solve vanishing gradients — only exploding
Implemented in PyTorch as: torch.nn.utils.clip_grad_norm_(params, max_norm=1.0)

🧠 Long Short-Term Memory (LSTM)

LSTM Architecture

Introduced by Hochreiter & Schmidhuber (1997). LSTM adds a cell state Cₜ (a separate memory highway) alongside the hidden state hₜ. Three gating mechanisms regulate information flow.

LSTM Cell — Information Flow

Forget Gate→ Input Gate→ Cell State Cₜ→ Output Gate→ hₜ

Forget Gate (fₜ): Decides what to erase from cell state. fₜ = σ(Wf · [hₜ₋₁, xₜ] + bf). Output ∈ (0,1) per cell — 0 = forget completely.
Input Gate (iₜ): Decides what new info to store. iₜ = σ(Wi · [hₜ₋₁, xₜ] + bi). Candidate values C̃ₜ = tanh(Wc · [hₜ₋₁, xₜ] + bc).
Cell State Update: Cₜ = fₜ ⊙ Cₜ₋₁ + iₜ ⊙ C̃ₜ (⊙ = element-wise product).
Output Gate (oₜ): Controls what part of cell state goes to hidden state. oₜ = σ(Wo · [hₜ₋₁, xₜ] + bo). hₜ = oₜ ⊙ tanh(Cₜ).

The cell state Cₜ acts like a conveyor belt — information can flow unchanged across many time steps, solving the vanishing gradient problem through additive gradient flow.

⚡ Gated Recurrent Units (GRU)

GRU Architecture

Introduced by Cho et al. (2014). GRU simplifies LSTM by merging cell state and hidden state, and using only two gates. Fewer parameters — often matches LSTM performance with less computation.

Reset Gate: rₜ = σ(Wr · [hₜ₋₁, xₜ]) Update Gate: zₜ = σ(Wz · [hₜ₋₁, xₜ]) Candidate: h̃ₜ = tanh(W · [rₜ ⊙ hₜ₋₁, xₜ]) Output: hₜ = (1 − zₜ) ⊙ hₜ₋₁ + zₜ ⊙ h̃ₜ

Reset gate (rₜ): Controls how much past hidden state influences candidate — allows forgetting past context
Update gate (zₜ): Balances how much old vs. new hidden state to keep — analogous to LSTM's forget+input gate combined
GRU vs LSTM: GRU trains faster with fewer parameters. LSTM slightly better for very long sequences needing precise memory control.

GRU is preferred when computational resources are limited or sequences are moderately long; LSTM is preferred for complex language modeling tasks.

Unit II Quiz — RNN, LSTM & GRU

10 multiple-choice questions

Question 1 of 10

What fundamental property distinguishes RNNs from standard feedforward neural networks?

RNNs use convolutional filters for feature extraction RNNs have recurrent connections that pass hidden state between time steps, enabling sequential processing RNNs require fixed-length inputs and outputs RNNs use attention mechanisms to weight input sequences

Question 2 of 10

Backpropagation Through Time (BPTT) is used to train RNNs by:

Unrolling the RNN across all time steps and applying standard backpropagation on the unrolled graph Applying gradient descent separately at each time step without sharing weights Using a forward-only pass to update weights directly without computing gradients Only computing gradients at the final time step

Question 3 of 10

The vanishing gradient problem in RNNs occurs because:

The learning rate is set too high during training Batch normalization removes too much variance from hidden states Gradients are multiplied by the weight matrix repeatedly across time steps, causing exponential shrinkage The RNN forgets to update the forget gate during backpropagation

Question 4 of 10

Gradient clipping addresses which specific problem in RNN training?

Vanishing gradients in very long sequences Overfitting on small sequential datasets Slow convergence due to saddle points Exploding gradients that cause weight updates to become NaN

Question 5 of 10

What is the purpose of the Forget Gate in an LSTM cell?

To generate the output hidden state from the cell state To decide what information to erase from the cell state at each time step To compute candidate values to add to the cell state To normalize the cell state before passing it forward

Question 6 of 10

How does LSTM's cell state solve the vanishing gradient problem?

The cell state uses additive updates (not multiplicative), allowing gradients to flow unchanged over many steps The cell state uses larger weight matrices than vanilla RNN The cell state applies dropout to prevent gradient shrinkage The cell state clips gradients automatically at each time step

Question 7 of 10

How many gating mechanisms does a GRU have compared to LSTM?

GRU has 3 gates (same as LSTM) GRU has 4 gates (one more than LSTM) GRU has 2 gates (reset and update), fewer than LSTM's 3 GRU has 1 gate (a single combined gate)

Question 8 of 10

Which application is MOST naturally suited for RNN/LSTM models?

Image classification from static photographs Clustering unstructured tabular data Object detection in single frames Time series forecasting and sequential text generation

Question 9 of 10

In the GRU's update gate zₜ, what does a value close to 1 indicate?

The network should completely reset and forget the previous hidden state The new candidate hidden state h̃ₜ should mostly replace the previous hidden state hₜ₋₁ The cell state should be zeroed out and restarted All gates should be deactivated for that time step

Question 10 of 10

Which statement about Truncated BPTT is TRUE?

It computes exact gradients across the full sequence but clips them at a threshold It trains only the output layer weights, keeping recurrent weights frozen It limits backpropagation to k steps, reducing memory cost at the cost of long-range gradient accuracy It eliminates vanishing gradients completely by truncating early time steps

Unit II Case Study · L4 Analyze

Stock Trend Prediction Using RNN/LSTM

Scenario: A financial firm wants to predict stock price trends using historical sequential data. Standard feedforward networks failed to capture temporal dependencies — today's price depends heavily on the past 30–60 days of market behavior.

Why Feedforward Networks Fail

FFNNs treat each time step independently. A window-based approach loses ordering information and struggles with variable-length dependencies. They also cannot model non-stationarity in financial time series.

RNN/LSTM Solution

Input sequence: Sliding window of past 60 days of OHLCV data (Open, High, Low, Close, Volume) → input shape (batch, 60, 5).
LSTM layers: 2–3 stacked LSTM layers (128→64→32 units) capture short-term momentum, weekly patterns, and monthly trends at different abstraction levels.
Vanishing gradient mitigation: LSTM's cell state allows gradient to flow unchanged across 60 time steps — critical for capturing seasonal trends (e.g., end-of-quarter reporting effects).
BPTT: Full BPTT used for 60-step windows with Adam optimizer (lr=0.001).
Gradient clipping (θ=5): Prevents weight explosion during volatile market periods (e.g., earnings announcements) where loss spikes suddenly.
Output: Dense layer predicts next-day closing price or binary trend (up/down).

Results & Insights

LSTM typically achieves 5–15% lower RMSE than ARIMA models on financial time series. GRU can be preferred for faster training in production pipelines with near-identical accuracy. The model captures mean-reversion patterns and momentum shifts that simple statistical models miss.

III

Unit III • 8 Periods

Generative Adversarial Networks (GANs)

Generative models, GAN concept and principles, generator-discriminator architecture, comparison with discriminative models, and real-world applications of GANs.

Generative Models

Models that learn the data distribution P(X) to generate new samples similar to training data.

GAN Concept & Principles

Two-player minimax game: generator tries to fool discriminator; discriminator tries to detect fakes.

Generator Network

Maps random noise z to synthetic data samples. Learns to produce realistic outputs.

Discriminator Network

Binary classifier that distinguishes real data from generator's fakes. Provides training signal.

Discriminative vs Generative

Discriminative: learns P(Y|X). Generative: learns P(X) or P(X,Y) to model full data distribution.

Applications of GANs

Image synthesis, style transfer, super-resolution, data augmentation, video generation, drug discovery.

🎯Learning Outcomes

Explain generative models and the fundamental principles and architecture of GANs, including generator and discriminator networks.

Differentiate between discriminative and generative models and describe GAN working mechanisms and applications.

Apply GAN frameworks to generate synthetic data or images using basic generator–discriminator models.

🧩 Generative vs. Discriminative Models

Discriminative Models

Learn the conditional distribution P(Y|X) — given input X, predict label Y. They draw decision boundaries between classes but do NOT learn to generate new samples.

Examples: Logistic Regression, SVM, CNN classifiers, Decision Trees
Efficient for classification tasks with labeled data
Cannot generate new data samples

Generative Models

Learn the joint distribution P(X, Y) or the marginal P(X). They model how data is generated, enabling sampling of new examples.

Examples: Naive Bayes, GMMs, VAEs, GANs, Diffusion Models
Can generate new realistic samples (images, text, audio)
Enable data augmentation, anomaly detection, creative AI

Discriminative models ask "Is this a cat?" — Generative models ask "What does a cat look like?" and can create one.

🎭 Generative Adversarial Networks (GANs)

Core Concept — The Adversarial Game

Introduced by Ian Goodfellow et al. (2014). A GAN consists of two neural networks trained simultaneously in a minimax game:

GAN Architecture

Random Noise z ~ N(0,I)→ Generator G→ Fake Data G(z)→ Discriminator D→ Real / Fake?

The Generator G maps a noise vector z to a synthetic sample G(z). The Discriminator D outputs the probability that its input is real (from training data). They are optimized in a minimax game:

min_G max_D V(D,G) = E[log D(x)] + E[log(1 − D(G(z)))] x ~ p_data (real), z ~ p_z (noise prior)

Generator Network

Input: A random noise vector z (typically 100-dimensional Gaussian)
Goal: Generate G(z) so realistic that D(G(z)) ≈ 1 (discriminator thinks it's real)
Architecture: Transposed convolutions (ConvTranspose2D) to upsample noise → full image. Batch Norm + ReLU in hidden layers, Tanh at output.
Training signal: Receives gradient from D — the generator is trained to maximize log(D(G(z))), i.e., fool the discriminator.

Discriminator Network

Input: Either a real image x or a fake image G(z)
Goal: Classify correctly: D(x) → 1 for real, D(G(z)) → 0 for fake
Architecture: Standard CNN with strided convolutions (no pooling in modern GANs). LeakyReLU activations, Sigmoid at output.
Training signal: Binary cross-entropy with true labels (real=1, fake=0)

Training Algorithm

GAN training alternates between updating D and G:

For each mini-batch: 1. Sample m real examples {x¹,...,xᵐ} from training data 2. Sample m noise vectors {z¹,...,zᵐ} from p_z 3. Update D: maximize [log D(xⁱ) + log(1 − D(G(zⁱ)))] 4. Update G: minimize [log(1 − D(G(zⁱ)))] ≡ maximize [log D(G(zⁱ))]

At Nash equilibrium, G generates the true data distribution and D outputs 0.5 for every input — it can no longer distinguish real from fake.

GAN Training Challenges

Mode Collapse: Generator learns to produce only a few types of outputs (e.g., always one digit), ignoring other modes of the data distribution.
Training Instability: D can become too powerful early on, giving G near-zero gradient → "discriminator wins and training stops."
Non-convergence: Generator and discriminator oscillate without reaching equilibrium.
Evaluation Difficulty: Hard to measure generated image quality — Fréchet Inception Distance (FID) and Inception Score (IS) are standard metrics.

Solutions: Wasserstein GAN (WGAN), spectral normalization, progressive growing (ProGAN), and label smoothing.

Applications of GANs

Image Synthesis: StyleGAN2 generates photorealistic human faces indistinguishable from real ones (thispersondoesnotexist.com)
Image-to-Image Translation: Pix2Pix (sketch → photo, satellite → map). CycleGAN (unpaired domain transfer — horse ↔ zebra)
Super-Resolution: SRGAN upscales low-resolution images to 4× resolution
Data Augmentation: Generate rare medical images (tumors, rare diseases) to balance datasets
Video Synthesis: DeepFake technology, video prediction
Drug Discovery: Molecular structure generation for pharmaceutical research

Unit III Quiz — GANs

10 multiple-choice questions

Question 1 of 10

What is the primary goal of the Generator in a GAN?

To classify input data as real or fake with high accuracy To compress real images into a lower-dimensional latent space To generate synthetic samples that fool the discriminator into classifying them as real To directly minimize reconstruction error between input and output images

Question 2 of 10

In GAN training, what does Nash Equilibrium represent?

The generator produces the true data distribution and the discriminator outputs 0.5 for all inputs The discriminator achieves 100% accuracy classifying real vs. fake The generator loss reaches zero and training stops Both networks converge to identical weight matrices

Question 3 of 10

What is "Mode Collapse" in GAN training?

The discriminator's loss collapses to zero during training The GAN fails to initialize and produces random noise The network collapses when batch size is too large The generator produces only a limited variety of outputs, ignoring the full data distribution

Question 4 of 10

Which key difference distinguishes generative models from discriminative models?

Generative models always achieve higher classification accuracy Generative models learn the data distribution P(X) and can synthesize new samples; discriminative models learn P(Y|X) for classification only Discriminative models require more training data than generative models Generative models cannot be trained using gradient descent

Question 5 of 10

What is the input to the Generator network in a standard GAN?

A real image from the training dataset A class label specifying what to generate A random noise vector sampled from a prior distribution (e.g., Gaussian) The discriminator's predicted probability from the previous step

Question 6 of 10

CycleGAN is specifically designed for:

Unpaired image-to-image translation (e.g., horse to zebra without paired training images) Generating high-resolution images from low-resolution inputs Training GANs with cyclic learning rate schedules Generating video from a series of text descriptions

Question 7 of 10

In a GAN's minimax objective, what does the Discriminator D try to maximize?

The probability that all inputs are classified as fake The diversity of generated samples from the generator The L2 reconstruction error between real and generated images log D(x) + log(1 − D(G(z))) — correctly identifying real as real and fake as fake

Question 8 of 10

Which metric is commonly used to evaluate the quality and diversity of GAN-generated images?

Mean Squared Error (MSE) between generated and real images Fréchet Inception Distance (FID) Cross-entropy loss of the discriminator on the test set Accuracy of the generator in classifying its own outputs

Question 9 of 10

Which architectural component is commonly used in the Generator to upsample noise to full image resolution?

Max pooling layers Standard convolution with stride 2 Transposed convolution (ConvTranspose2D) Recurrent LSTM cells for sequential upsampling

Question 10 of 10

Wasserstein GAN (WGAN) was proposed primarily to address:

Training instability and mode collapse by using Wasserstein distance instead of JS divergence Slow image generation speed by replacing the discriminator with a smaller network Overfitting of the generator on small datasets Adding class-conditional generation to unconditional GANs

Unit III Case Study · L4 Analyze

Synthetic Face Generation for Virtual Avatars

Scenario: A startup wants to generate realistic synthetic face images for virtual avatars without using real people's photos — avoiding privacy concerns while maintaining photorealistic quality.

Generator Role

The generator receives a 512-dimensional noise vector z ~ N(0,I) and progressively upsamples it through transposed convolution blocks (4×4 → 8×8 → ... → 256×256 pixels). It learns to map abstract noise to photorealistic face features (eyes, skin, hair). StyleGAN2's architecture adds style vectors at each resolution level, controlling separate aspects (low-res: pose/shape, high-res: texture/color).

Discriminator Role

A CNN-based discriminator downsamples the input image from 256×256 → 1 scalar probability. It's trained on real CelebA-HQ faces (real=1) and generated faces (fake=0). It provides the adversarial training signal to G.

Training Challenges & Solutions

Mode Collapse: Mitigated via minibatch standard deviation (forces G to produce diverse outputs) and progressive growing (start at 4×4, gradually increase to 256×256).
Instability: Use WGAN-GP (gradient penalty) instead of standard GAN loss for more stable training curves.
Quality Metric: Monitor FID score — lower is better (StyleGAN2 achieves FID of ~2–3 on FFHQ dataset vs. ~50+ for vanilla GAN).

Outcome

With StyleGAN2, the startup can generate thousands of unique, photorealistic avatar faces on demand — no real person's likeness used, fully usable for virtual reality, game characters, and profile pictures.

Unit IV • 8 Periods

Auto-Encoders

Auto-encoder concept and architecture (encoder/decoder), training for data compression and reconstruction, relationship with GANs, and Encoder-Decoder GAN hybrid models.

Auto-Encoder Concept

Unsupervised neural network that learns a compressed latent representation by reconstructing its own input.

Encoder

Maps high-dimensional input to a lower-dimensional latent code z. Learns most salient features.

Decoder

Maps latent code z back to the original input space. Trained to minimize reconstruction error.

Training for Compression

Minimize reconstruction loss (MSE/BCE) using gradient descent. The bottleneck forces efficient representation.

Autoencoders & GANs

Both learn data distributions. Can be combined for more powerful generative models.

Encoder-Decoder GANs

Hybrid models using autoencoder structure within GAN framework for image translation tasks.

🎯Learning Outcomes

Explain the concept, architecture, and components of auto-encoders including encoder and decoder roles in representation learning.

Describe autoencoder training for compression and reconstruction and their relationship with GANs and hybrid encoder-decoder models.

Apply auto-encoder models for data compression, reconstruction tasks, and implement basic encoder-decoder hybrid models.

🗜️ Auto-Encoders — Core Concepts

What is an Auto-Encoder?

An auto-encoder is an unsupervised neural network trained to reconstruct its input. It consists of an Encoder that compresses the input into a low-dimensional latent code (z), and a Decoder that reconstructs the original input from z. The bottleneck dimension forces the model to learn the most essential features.

Auto-Encoder Architecture

Input x (784d)→ Encoder→ Latent z (32d)→ Decoder→ Reconstructed x̂

Encoder: z = f_θ(x) [e.g., dense/conv layers with ReLU] Decoder: x̂ = g_φ(z) [mirror of encoder, upsample back] Loss: L = ||x − x̂||² (MSE for continuous) or BCE (binary)

The key constraint: z has far fewer dimensions than x. For MNIST, input is 784-d but z might be 32-d. This forces the encoder to learn a meaningful compressed representation.

Encoder Network

Purpose: Feature extraction and dimensionality reduction
Architecture: Stack of Dense layers (for tabular data) or Conv layers (for images), each reducing spatial/feature dimensions
Output: Latent vector z — a compressed, dense representation of the input
Analogy: The encoder acts like a "summary writer" — it extracts the essential information while discarding noise
Learned features: For face images, z might encode age, gender, expression, lighting implicitly

Decoder Network

Purpose: Reconstructs the original input from the compressed latent code
Architecture: Mirror of encoder — expands z back to original dimensions. Uses transposed conv for images.
Output: Reconstruction x̂ of the same shape as input x
Bottleneck constraint: Decoder must reconstruct faithfully from limited information → forces encoder to preserve the most important features
Activation: Sigmoid at output for pixel values in [0,1]; no activation for continuous values

🎓 Types of Auto-Encoders

Vanilla Auto-Encoder

Standard encoder-decoder with MSE reconstruction loss. Used for dimensionality reduction, visualization, and basic feature learning. The latent space is not regularized — similar inputs may map to distant z values.

Denoising Auto-Encoder (DAE)

Input is deliberately corrupted (Gaussian noise, masking, salt-and-pepper) and the network is trained to reconstruct the clean original. Forces robust representations that capture true data structure, not noise artifacts.

L = ||x_clean − g_φ(f_θ(x_noisy))||²

Application: Image denoising, robust feature learning for downstream classification tasks.

Sparse Auto-Encoder

Adds a sparsity constraint (L1 penalty or KL divergence) on the latent activations — most neurons in z should be near zero at any time. Learns disentangled, interpretable features even without bottleneck dimensionality constraint.

Variational Auto-Encoder (VAE)

Instead of encoding x to a point z, the encoder outputs distribution parameters μ and σ. Latent code is sampled: z ~ N(μ, σ²). Loss = Reconstruction Loss + KL divergence (regularizes latent space to ~ N(0,I)).

L = E[||x − x̂||²] + KL(N(μ,σ²) || N(0,I)) (Reconstruction loss + Regularization loss)

VAEs produce a smooth, structured latent space that enables interpolation between data points and controlled generation of new samples.

🔗 Relationship Between Autoencoders and GANs

Similarities

Both learn compressed data representations (GANs: generator's input space; AEs: latent bottleneck)
Both enable generation of new data samples from a lower-dimensional space
Both use neural networks trained with gradient descent

Key Differences

Training signal: AE uses reconstruction loss (MSE/BCE). GAN uses adversarial loss (discriminator feedback)
Generation quality: GAN-generated images are typically sharper. AE reconstructions can be blurry (averaging effect of MSE)
Latent structure: AE latent space may be irregular; VAE enforces Gaussian structure; GAN's latent space is learned implicitly

Hybrid Models: Encoder-Decoder GANs

Combining the reconstruction fidelity of autoencoders with the sharpness of GANs creates powerful hybrid architectures:

Pix2Pix: Uses a U-Net (encoder-decoder with skip connections) as the generator, and a PatchGAN discriminator. Trained with L1 + adversarial loss. Enables paired image-to-image translation (sketches → photos, aerial → maps).
BEGAN (Boundary Equilibrium GAN): Uses autoencoders as the discriminator. The discriminator tries to reconstruct real images; the generator tries to produce images that fool this autoencoder discriminator.
VAE-GAN: Combines VAE's structured latent space with GAN's discriminator for high-quality generation with disentangled controls.
BiGAN / ALI: Jointly learns the encoder (inference network) alongside the GAN generator — enables both generation and inference in one framework.

Encoder-Decoder GANs are state-of-the-art for image-to-image translation, video generation, and domain adaptation tasks.

⚙️ Training an Auto-Encoder

Training Process

1. Forward pass: z = Encoder(x), x̂ = Decoder(z) 2. Compute loss: L = MSE(x, x̂) = (1/N)Σ||xᵢ − x̂ᵢ||² 3. Backpropagate: ∂L/∂θ and ∂L/∂φ 4. Update weights: θ ← θ − η∇_θL, φ ← φ − η∇_φL

Optimizer: Adam is standard (lr=1e-3)
Batch training: Mini-batches of 64–256 samples
Convergence: Monitor validation reconstruction loss; stop when stable
Regularization: Weight decay, dropout in encoder layers to prevent trivial identity mapping

Applications

Dimensionality Reduction: Alternative to PCA — non-linear compression of high-dimensional data for visualization (t-SNE of AE latent codes)
Anomaly Detection: Train on normal data; high reconstruction error → anomaly (fraud, network intrusions, manufacturing defects)
Image Denoising: Denoising AE removes noise from corrupted images
Recommendation Systems: Collaborative filtering with AE for user-item interaction patterns
Feature Learning: Pre-train encoder, then fine-tune for downstream supervised tasks

Unit IV Quiz — Auto-Encoders

10 multiple-choice questions

Question 1 of 10

What is the primary purpose of an auto-encoder's bottleneck (latent layer)?

To apply dropout regularization at the midpoint of the network To force the network to learn a compressed, efficient representation of the most important features in the input To add batch normalization between encoder and decoder To separate gradient flow between the encoder and decoder networks

Question 2 of 10

What loss function is typically minimized when training a standard auto-encoder on image data?

Adversarial loss from a discriminator network Cross-entropy between class labels and softmax output Reconstruction loss (MSE or BCE) between the input and the decoded output KL divergence between the latent distribution and a target prior

Question 3 of 10

A Denoising Auto-Encoder is trained by:

Feeding corrupted/noisy input and training the network to reconstruct the original clean version Adding Gaussian noise to the latent code z and reconstructing without noise Training with a discriminator that penalizes noisy reconstructions Using sparse regularization to force most latent activations to zero

Question 4 of 10

How does a Variational Auto-Encoder (VAE) differ from a standard auto-encoder?

VAE replaces the decoder with a GAN discriminator VAE does not use backpropagation — it uses evolutionary algorithms VAE encodes images into a fixed-size vector without any stochastic component VAE encodes to distribution parameters (μ, σ) and samples z ~ N(μ,σ²), enabling controlled generation

Question 5 of 10

Auto-encoders are particularly effective for anomaly detection because:

They use class labels to identify anomalous samples during inference When trained on normal data, anomalous inputs produce high reconstruction error since the model hasn't learned to encode them They apply sigmoid threshold to latent vectors to detect outliers Anomalies always produce very low reconstruction error compared to normal inputs

Question 6 of 10

In Pix2Pix (an Encoder-Decoder GAN), what architecture is typically used as the generator?

A standard VGGNet with fully connected output layers A stack of LSTM cells for sequential image generation A U-Net (encoder-decoder with skip connections between corresponding encoder and decoder layers) A ResNet with global average pooling and a single linear output layer

Question 7 of 10

The skip connections in U-Net (used in Pix2Pix) serve what purpose?

They pass fine-grained spatial details from encoder layers directly to corresponding decoder layers, preventing loss of spatial information They allow the discriminator to access intermediate feature maps from the generator They speed up training by bypassing non-critical layers during backpropagation They implement residual connections between the latent code and output image

Question 8 of 10

A key limitation of using MSE loss in vanilla auto-encoders for image reconstruction is:

MSE causes the encoder to learn class labels instead of compressed features MSE makes training unstable and causes mode collapse MSE cannot be computed for high-dimensional image data efficiently MSE produces blurry reconstructions because it averages over plausible outputs, losing high-frequency details

Question 9 of 10

Which combination of losses is used in a VAE-GAN hybrid model?

Only adversarial loss from the GAN discriminator, applied to both encoder and decoder Reconstruction loss + KL divergence loss + adversarial loss from a discriminator Cross-entropy classification loss + L2 regularization on latent weights Triplet loss for metric learning in the latent space

Question 10 of 10

Auto-encoders can be used for dimensionality reduction — how do they compare to PCA?

PCA can learn non-linear manifolds; auto-encoders can only perform linear projections Auto-encoders and PCA are mathematically identical when using linear activation functions Auto-encoders can learn non-linear manifolds through their activation functions; PCA is restricted to linear projections only PCA always outperforms auto-encoders because it finds globally optimal projections

Unit IV Case Study · L4 Analyze

Network Intrusion Anomaly Detection with Auto-Encoders

Scenario: A cybersecurity organization needs to detect anomalous network traffic patterns (intrusions, DDoS, data exfiltration) using limited labeled attack data. Traditional supervised approaches fail due to the scarcity of labeled attack samples and the constantly evolving nature of threats.

Why Auto-Encoders?

Auto-encoders excel in anomaly detection without requiring labeled attack data. By training only on normal traffic, the model learns to compress and reconstruct legitimate network behavior. Novel attack patterns — never seen during training — produce high reconstruction error because the model doesn't know how to encode them efficiently.

Auto-Encoder Architecture for Network Traffic

Input: Feature vector of network flow statistics — packet size, inter-arrival times, protocol type, port numbers, connection duration (e.g., 41 features from NSL-KDD dataset)
Encoder: Dense(41) → Dense(16) → Dense(8) with ReLU activation — compresses 41 features to 8-dimensional latent code
Bottleneck: 8-dimensional z — forces model to encode only essential patterns of normal traffic behavior
Decoder: Dense(8) → Dense(16) → Dense(41) — reconstructs original feature vector
Training: Only on normal traffic samples. MSE reconstruction loss. Adam optimizer (lr=1e-3), 50 epochs.
Detection: At inference, compute reconstruction error for each flow. Set threshold τ at 95th percentile of training errors. Flows with error > τ flagged as anomalies.

Hybrid Encoder-Decoder GAN Enhancement

A VAE-GAN hybrid improves detection: the VAE component provides a structured latent space for interpolating between normal patterns, while the GAN discriminator sharpens the boundary between normal and anomalous. This reduces false positive rate by ~30% compared to standalone AE, particularly for subtle low-and-slow attacks that only slightly deviate from normal behavior.

Results

AE-based anomaly detection achieves ~95% detection rate on known attack types and ~70–80% on novel zero-day attacks, with no labeled attack data needed during training — a significant advantage over supervised classifiers that require thousands of labeled attack samples per category.

Unit V • 8 Periods

Transformers & Attention Mechanisms

Limitations of RNNs/LSTMs, Attention Mechanism, Self-Attention, Scaled Dot-Product Attention, Multi-Head Attention, Positional Encoding, Transformer Encoder-Decoder, BERT, GPT, Vision Transformers, and applications.

RNN/LSTM Limitations

Sequential processing bottleneck, difficulty with very long-range dependencies, non-parallelizable training.

Attention Mechanism

Weighted sum of values — network learns which parts of the input to attend to for each output position.

Self-Attention

Each position in the sequence attends to all other positions in the same sequence to build context-aware representations.

Scaled Dot-Product

Attention(Q,K,V) = softmax(QKᵀ/√dₖ)·V. Scaled to prevent gradient saturation with large key dimensions.

Multi-Head Attention

Multiple attention operations in parallel on different projections — captures diverse relationships in different subspaces.

Positional Encoding

Sinusoidal encodings injected at input — adds position information since self-attention is permutation-invariant.

Transformer Architecture

Encoder stack processes input; Decoder stack generates output auto-regressively. Each block: attention + FFN + LayerNorm.

Pre-trained Models

BERT (bidirectional encoder for understanding), GPT (autoregressive decoder for generation), ViT (patches as tokens).

🎯Learning Outcomes

Explain Transformer architecture: attention mechanisms, self-attention, multi-head attention, positional encoding, and limitations of RNNs/LSTMs.

Apply Transformer encoder-decoder and pre-trained models (BERT, GPT, ViT) for NLP, computer vision, and chatbot problems.

Demonstrate Transformer-based models for real-world AI applications involving language and vision tasks.

⚠️ Limitations of RNNs / LSTMs

Why Transformers Were Needed

Sequential Processing: RNNs process tokens one-at-a-time — step t depends on t-1. GPUs excel at parallelism; sequential computation wastes this advantage.
Long-Range Dependencies: Even LSTM struggles with dependencies spanning 500+ tokens. The hidden state is a fixed-size bottleneck — distant context gets compressed and lost.
Training Speed: Long sequences take proportionally longer; no parallelism across time steps.

Transformers solve all three: fully parallel computation, O(1)-distance connections between any two positions, and context scales with model size.

👁️ Attention & Self-Attention

Scaled Dot-Product Attention

Attention(Q, K, V) = softmax( Q·Kᵀ / √dₖ ) · V Q = Queries (what am I looking for?) K = Keys (what do I contain?) V = Values (what do I return when matched?)

Scaling by √dₖ: For large key dimensions, dot products grow large → softmax saturates → near-zero gradients. Scaling keeps values numerically stable.

Self-Attention

Q, K, V all derived from the same input sequence X via learned projections Wq, Wk, Wv. Every position attends to every other position — O(1) path length between any two tokens regardless of distance.

Example: "The animal didn't cross the street because it was too tired." — Self-attention resolves that "it" refers to "animal" in one operation, something an LSTM must propagate through many steps.

Multi-Head Attention

MultiHead(Q,K,V) = Concat(head₁,...,headₕ) · Wᴼ headᵢ = Attention(Q·Wᵢq, K·Wᵢk, V·Wᵢv) Typical: h=8 heads, dmodel=512 → each head dₖ=64

Different heads learn complementary patterns simultaneously: one captures syntactic dependencies, another semantic relationships, another coreference resolution. Results are concatenated and linearly projected.

Positional Encoding

Self-attention is permutation-invariant — it treats input as a set. Positional encodings add order information to embeddings:

PE(pos, 2i) = sin(pos / 10000^(2i/dmodel)) PE(pos, 2i+1) = cos(pos / 10000^(2i/dmodel))

Modern alternatives: learned positional embeddings (BERT), Rotary Position Embedding / RoPE (LLaMA, GPT-NeoX), ALiBi (linear attention bias).

🏗️ Transformer Encoder-Decoder Architecture

Architecture Overview

Full Transformer (Vaswani et al., 2017)

Input + PE→ N× Encoder Block
Self-Attn → Add&Norm → FFN → Add&Norm→ Encoder K,V

Target + PE→ N× Decoder Block
Masked Self-Attn → Cross-Attn → FFN→ Linear + Softmax

Encoder Block: Multi-Head Self-Attention → Add & LayerNorm → Feed-Forward Network (2 linear + ReLU) → Add & LayerNorm
Decoder Block: Masked Multi-Head Self-Attention → Cross-Attention on encoder output → Feed-Forward
Masked attention in decoder ensures each output position only sees previous tokens (causal/autoregressive)
Layer Normalization + residual connections around every sub-layer for stable deep training

🤖 Pre-trained Transformer Models

BERT — Bidirectional Encoder Representations from Transformers (Google, 2018)

Architecture: Encoder-only (12 or 24 Transformer blocks)
Pre-training tasks: Masked Language Modeling (MLM) — predict 15% randomly masked tokens using bidirectional context; Next Sentence Prediction (NSP)
Bidirectional: Sees both left AND right context — unlike GPT which only sees left context
Fine-tuning: Add task head → SOTA on question answering (SQuAD), NER, sentiment, NLI with minimal extra architecture
Variants: RoBERTa, ALBERT, DistilBERT, domain-specific BioBERT, LegalBERT

BERT is best for understanding tasks: classification, extraction, reading comprehension. Not for generation.

GPT — Generative Pre-trained Transformer (OpenAI)

Architecture: Decoder-only with causal (masked) self-attention
Pre-training: Next-token prediction (language modeling) — learn P(xₜ | x₁,...,xₜ₋₁)
Autoregressive generation: Generate one token at a time, feeding output back as next input
Scale: GPT-1 (117M) → GPT-2 (1.5B) → GPT-3 (175B, in-context learning) → GPT-4 (multimodal)
ChatGPT: GPT-3.5/4 + RLHF (Reinforcement Learning from Human Feedback) for helpful, harmless alignment

GPT is best for generation tasks: text completion, summarization, code generation, conversational AI.

Vision Transformer (ViT — Google, 2020)

Applies Transformer directly to images. Image split into 16×16 patches → each flattened and linearly projected to a token embedding → sequence of patch tokens fed to standard Transformer Encoder.

224×224 image → 196 patches (16×16 each) Each patch: 16×16×3 = 768 dims → linear projection → token + [CLS] token + Positional Embeddings → 12-layer Transformer Encoder → [CLS] output → MLP head → class label

Self-attention provides global context from the first layer — each patch sees all others immediately
Outperforms CNNs when pre-trained on large datasets (JFT-300M, ImageNet-21k)
Variants: DeiT (data-efficient), Swin Transformer (hierarchical shifted windows), DINO (self-supervised)

Applications Summary

NLP: Machine translation (MarianMT), summarization (BART, T5), Q&A (BERT), chatbots (ChatGPT, Claude)
Computer Vision: Classification (ViT), object detection (DETR), segmentation (SAM — Segment Anything)
Multimodal: CLIP (vision+language alignment), DALL-E (text → image), GPT-4V (image understanding)
Science: AlphaFold 2 (protein structure with Transformer attention), drug discovery, genomics

Unit V Quiz — Transformers & Attention

10 multiple-choice questions

Question 1 of 10

Which limitation of RNNs/LSTMs do Transformers primarily overcome?

RNNs cannot handle text; Transformers work with any modalityRNNs require more GPU memory for equivalent model sizesRNNs process sequences sequentially (non-parallelizable); Transformers process all positions in parallel enabling faster training and better long-range dependenciesRNNs cannot be trained with gradient descent

Question 2 of 10

In Scaled Dot-Product Attention, why is the score scaled by 1/√dₖ?

For large dₖ, dot products become very large and push softmax into saturation with near-zero gradients; scaling prevents thisScaling reduces the quadratic complexity of attention from O(n²d) to O(n√d)Scaling ensures attention weights sum to dₖ instead of 1Scaling prevents Q and K from becoming identical during training

Question 3 of 10

What distinguishes Self-Attention from cross-attention?

Self-attention only attends to adjacent tokensSelf-attention uses a single head; cross-attention uses multiple headsSelf-attention does not require the Value matrixIn self-attention, Q, K, and V all come from the same sequence, so every position relates to all others in the same sequence

Question 4 of 10

What is the purpose of Positional Encoding in Transformers?

To normalize input embeddings before attention layersTo inject sequence order information — self-attention is permutation-invariant and has no inherent notion of positionTo add classification tokens at specific positions for fine-tuningTo encode the semantic category of each token based on vocabulary position

Question 5 of 10

Multi-Head Attention improves on single-head attention by:

Increasing sequence length the model can process without quadratic memoryReplacing softmax with a more stable sigmoid functionRunning multiple attention operations in parallel on different projections, allowing the model to jointly attend from multiple representation subspaces simultaneouslyCaching previously computed attention weights across different sequences

Question 6 of 10

BERT's Masked Language Modeling (MLM) pre-training enables:

Bidirectional understanding — the model sees both left and right context when predicting masked tokensLeft-to-right autoregressive text generation similar to GPTImage-text alignment by masking image patches and predicting them from textSemi-supervised learning by masking 50% of training labels

Question 7 of 10

GPT uses a Decoder-only Transformer. What does "autoregressive generation" mean?

The model generates all output tokens simultaneously in one forward passTokens are sampled randomly from the vocabulary without conditioning on prior tokensThe model uses encoder-decoder cross-attention to generate output from inputEach token is generated one at a time, conditioned on all previously generated tokens using causal (masked) self-attention

Question 8 of 10

How does Vision Transformer (ViT) adapt Transformers for image classification?

ViT replaces self-attention with 2D convolution in each Transformer blockViT splits images into fixed-size patches, flattens and linearly projects each patch to an embedding, and feeds the sequence of patch embeddings to a standard Transformer EncoderViT applies recurrent connections between image rows, treating each row as one time stepViT uses the Transformer Decoder to generate class labels from image pixels one at a time

Question 9 of 10

In the Transformer Decoder, why is "masked" (causal) self-attention used?

To prevent the decoder from attending to low-confidence encoder representationsTo mask padding tokens in variable-length input sequencesTo prevent the decoder from attending to future tokens — each position can only attend to past positions, preserving the autoregressive property during trainingTo mask encoder output during the first few training steps for curriculum learning

Question 10 of 10

RLHF (Reinforcement Learning from Human Feedback) is used in ChatGPT to:

Fine-tune the model to produce helpful, harmless, and honest responses by learning from human preference rankings on model outputsPre-train the model on human-labeled text corpora to learn language structureReplace Transformer's self-attention with a reinforcement learning value function for faster inferenceEnable the model to interact with external APIs without additional training

Unit V Case Study · L4 Analyze

Multilingual Ed-Tech Chatbot Using Transformer Models

Scenario: An ed-tech company is building a multilingual chatbot to answer student queries in English, Hindi, Telugu, and French — with coherent multi-turn conversation and pedagogically accurate answers.

Why RNNs Fall Short

LSTMs struggle with: (1) long conversation histories beyond ~200 tokens; (2) multilingual modeling where different language embeddings interfere; (3) slow retraining on new course content due to sequential training.

Transformer Architecture for the Chatbot

Base Model: XLM-R (robustly optimized multilingual pre-trained model supporting 100+ languages) — handles all four languages from a single model.
Self-Attention for Multi-turn Context: All tokens in the conversation history are attended to simultaneously. Long context (1,024–4,096 tokens with modern models) handled natively — no hidden state bottleneck.
Multi-Head Attention roles: Different heads learn to track subject-matter references across turns, pronoun coreference ("explain it more"), and language switches mid-conversation.
Positional Encoding: Segment embeddings distinguish conversation turns; custom position encodings mark speaker roles (student vs. assistant).
BERT (Understanding): Used to classify the student's question — subject area detection, language identification, intent parsing. Bidirectional context is crucial for parsing ambiguous queries.
GPT (Generation): Generates the chatbot's response auto-regressively, producing fluent multi-sentence explanations in the target language. Fine-tuned with RLHF on preferred educational explanations.

Outcome

The Transformer-based multilingual chatbot achieves 85%+ user satisfaction across all four languages, handles 10+ turn conversations with coherent context tracking, and can be updated with new course content through fine-tuning in hours rather than weeks.