# Deep Learning Foundations Assignment (100 Marks)

**Name:** [Your Name Here]

**Date:** January 30, 2026

---

## Setup and Imports

# Install required packages (uncomment if needed)

# !pip install tensorflow scikit-learn pandas numpy matplotlib seaborn

import numpy as np

import pandas as pd

import [Link] as plt

import seaborn as sns

from sklearn.model_selection import train_test_split

from [Link] import StandardScaler

from [Link] import mean_absolute_error, mean_squared_error, confusion_matrix,

classification_report, f1_score

import tensorflow as tf

from tensorflow import keras

from [Link] import layers

from [Link] import Tokenizer

from [Link] import pad_sequences

from [Link] import EarlyStopping

import warnings

[Link]('ignore')
# Set random seeds for reproducibility

[Link](42)

[Link].set_seed(42)

print("TensorFlow version:", tf.__version__)

print("GPU Available:", [Link].list_physical_devices('GPU'))

## Download Dataset from Google Drive

# For Google Colab - Mount Google Drive

# from [Link] import drive

# [Link]('/content/drive')

# Or download directly using gdown

# !pip install gdown

# !gdown --folder
[Link]

# Update these paths based on where you extract the data

TABULAR_PATH = '[Link]'

TEXT_PATH = '[Link]'

IMAGE_DIR = 'images/'

---

# Part 1 — Neural Networks (Tabular FFNN)

---

## 1.1 Single Neuron Forward Pass (6 Marks)

def single_neuron_forward(x, w, b):

"""
 Compute the forward pass of a single neuron.

Parameters:

- x: input vector (1D numpy array)

- w: weight vector (1D numpy array, same length as x)

- b: bias (scalar)

Returns:

- z: linear combination (scalar)

- relu_output: ReLU(z)

- sigmoid_output: Sigmoid(z)

"""

# Compute linear combination: z = w·x + b

z = [Link](w, x) + b

# Apply ReLU activation: max(0, z)

relu_output = [Link](0, z)

# Apply Sigmoid activation: 1 / (1 + e^(-z))

sigmoid_output = 1 / (1 + [Link](-z))

return z, relu_output, sigmoid_output

# Example demonstration

print("=" * 60)

print("Single Neuron Forward Pass Example")

print("=" * 60)
# Define example inputs

x = [Link]([1.5, 2.0, -0.5, 3.0])

w = [Link]([0.4, -0.3, 0.8, 0.2])

b = 0.5

print(f"\nInput vector (x): {x}")

print(f"Weight vector (w): {w}")

print(f"Bias (b): {b}")

# Compute forward pass

z, relu_out, sigmoid_out = single_neuron_forward(x, w, b)

print(f"\nLinear combination (z = w·x + b): {z:.4f}")

print(f"ReLU(z): {relu_out:.4f}")

print(f"Sigmoid(z): {sigmoid_out:.4f}")

print("=" * 60)

### Explanation: Why Activation Functions Are Required

Activation functions are essential in neural networks because they introduce non-linearity
into the model, allowing it to learn complex patterns and relationships in data. Without
activation functions, a neural network would simply be a series of linear transformations,
which could be collapsed into a single linear layer, severely limiting its representational
power. ReLU (Rectified Linear Unit) is typically used in hidden layers of deep networks
because it helps mitigate the vanishing gradient problem, allows for faster training, and
introduces sparsity by outputting zero for negative inputs. Sigmoid activation is commonly
used in the output layer for binary classification tasks, as it squashes values to the range (0,
1), which can be interpreted as probabilities. Additionally, Sigmoid was historically used in
hidden layers but has largely been replaced by ReLU due to its tendency to saturate and
cause vanishing gradients during backpropagation.

## 1.2 Data Loading, Splitting, and Preprocessing (10 Marks)

# Load the tabular dataset

df_tabular = pd.read_csv(TABULAR_PATH)

print("=" * 60)

print("Dataset Inspection")

print("=" * 60)

print(f"\nDataset shape: {df_tabular.shape}")

print(f"\nColumn names:\n{df_tabular.[Link]()}")

print(f"\nData types:\n{df_tabular.dtypes}")

print(f"\nMissing values:\n{df_tabular.isnull().sum()}")

print(f"\nFirst few rows:")

print(df_tabular.head())

print(f"\nBasic statistics:")

print(df_tabular.describe())

# Handle missing data

df_clean = df_tabular.copy()

# Identify numeric and categorical columns (excluding target)

numeric_cols = df_clean.select_dtypes(include=['int64', 'float64']).[Link]()

categorical_cols = df_clean.select_dtypes(include=['object', 'category']).[Link]()

# Remove 'target' from the lists if present

if 'target' in numeric_cols:

numeric_cols.remove('target')

if 'target' in categorical_cols:

categorical_cols.remove('target')

print(f"Numeric columns: {numeric_cols}")

print(f"Categorical columns: {categorical_cols}")

# Handle missing values in numeric columns (use median)

for col in numeric_cols:

if df_clean[col].isnull().sum() > 0:

median_value = df_clean[col].median()

df_clean[col].fillna(median_value, inplace=True)

print(f"Filled missing values in '{col}' with median: {median_value}")

# Handle missing values in categorical columns (use mode)

for col in categorical_cols:

if df_clean[col].isnull().sum() > 0:

mode_value = df_clean[col].mode()[0]

df_clean[col].fillna(mode_value, inplace=True)

print(f"Filled missing values in '{col}' with mode: {mode_value}")

# Verify no missing values remain

print(f"\nMissing values after handling:\n{df_clean.isnull().sum().sum()}")

# Separate features and target

X = df_clean.drop('target', axis=1)

y = df_clean['target']

# Split into train/val/test (70/15/15)

X_temp, X_test, y_temp, y_test = train_test_split(X, y, test_size=0.15, random_state=42)

X_train, X_val, y_train, y_val = train_test_split(X_temp, y_temp, test_size=0.1765,

random_state=42) # 0.1765 * 0.85 ≈ 0.15

print(f"Training set size: {X_train.shape[0]} ({X_train.shape[0]/len(X)*100:.1f}%)")

print(f"Validation set size: {X_val.shape[0]} ({X_val.shape[0]/len(X)*100:.1f}%)")

print(f"Test set size: {X_test.shape[0]} ({X_test.shape[0]/len(X)*100:.1f}%)")

# One-hot encode categorical features (if any exist)

if len(categorical_cols) > 0:

print(f"\nOne-hot encoding categorical columns: {categorical_cols}")

X_train = pd.get_dummies(X_train, columns=categorical_cols, drop_first=True)

X_val = pd.get_dummies(X_val, columns=categorical_cols, drop_first=True)

X_test = pd.get_dummies(X_test, columns=categorical_cols, drop_first=True)

# Ensure all sets have the same columns

X_train, X_val = X_train.align(X_val, join='left', axis=1, fill_value=0)

X_train, X_test = X_train.align(X_test, join='left', axis=1, fill_value=0)

X_val, X_test = X_val.align(X_test, join='left', axis=1, fill_value=0)

else:

print("\nNo categorical columns to encode.")

# Standardize numeric features

scaler = StandardScaler()

# Fit scaler ONLY on training data

X_train_scaled = scaler.fit_transform(X_train)

# Transform validation and test sets using the fitted scaler

X_val_scaled = [Link](X_val)

X_test_scaled = [Link](X_test)

print("=" * 60)

print("Final Preprocessed Dataset Shapes")

print("=" * 60)
print(f"X_train shape: {X_train_scaled.shape}")

print(f"X_val shape: {X_val_scaled.shape}")

print(f"X_test shape: {X_test_scaled.shape}")

print(f"\nFinal number of features: {X_train_scaled.shape[1]}")

print("=" * 60)

### Explanation: Data Leakage and Proper Scaling

Data leakage occurs when information from the validation or test sets inadvertently
influences the training process, leading to overly optimistic performance estimates that
don't generalize to new data. Fitting the scaler on the full dataset (including validation and
test data) is incorrect because it allows statistics from unseen data to influence the
transformation applied to the training data, essentially giving the model indirect access to
information it shouldn't have during training. The correct approach is to fit the scaler
exclusively on the training data and then use those learned parameters (mean and standard
deviation) to transform the validation and test sets. This ensures that the model is evaluated
on truly unseen data and mimics the real-world scenario where we must transform new
incoming data using statistics computed only from historical training data.

## 1.3 Build and Train a FFNN for Regression (12 Marks)

# Build the feedforward neural network

def build_regression_model(input_dim):

model = [Link]([

[Link](shape=(input_dim,)),

[Link](128, activation='relu', name='hidden_layer_1'),

[Link](64, activation='relu', name='hidden_layer_2'),

[Link](32, activation='relu', name='hidden_layer_3'),

[Link](1, activation='linear', name='output_layer') # Linear for regression

])

return model

# Create the model

model_regression = build_regression_model(X_train_scaled.shape[1])
# Compile the model

model_regression.compile(

optimizer='adam',

loss='mse', # Mean Squared Error for regression

metrics=['mae'] # Mean Absolute Error as additional metric

# Display model architecture

print("=" * 60)

print("Regression Model Architecture")

print("=" * 60)

model_regression.summary()

print("=" * 60)

# Define early stopping callback

early_stop = EarlyStopping(

monitor='val_loss',

patience=3,

restore_best_weights=True,

verbose=1

# Train the model

history_regression = model_regression.fit(

X_train_scaled, y_train,

validation_data=(X_val_scaled, y_val),

epochs=100,

batch_size=32,
 callbacks=[early_stop],

verbose=1

print("\nTraining completed!")

# Plot training history

[Link](figsize=(12, 5))

[Link](1, 2, 1)

[Link](history_regression.history['loss'], label='Training Loss', linewidth=2)

[Link](history_regression.history['val_loss'], label='Validation Loss', linewidth=2)

[Link]('Epoch', fontsize=12)

[Link]('Loss (MSE)', fontsize=12)

[Link]('Training vs Validation Loss', fontsize=14, fontweight='bold')

[Link]()

[Link](True, alpha=0.3)

[Link](1, 2, 2)

[Link](history_regression.history['mae'], label='Training MAE', linewidth=2)

[Link](history_regression.history['val_mae'], label='Validation MAE', linewidth=2)

[Link]('Epoch', fontsize=12)

[Link]('MAE', fontsize=12)

[Link]('Training vs Validation MAE', fontsize=14, fontweight='bold')

[Link]()

[Link](True, alpha=0.3)

plt.tight_layout()

[Link]()
# Evaluate on test set

y_pred = model_regression.predict(X_test_scaled).flatten()

mae = mean_absolute_error(y_test, y_pred)

rmse = [Link](mean_squared_error(y_test, y_pred))

print("=" * 60)

print("Test Set Evaluation")

print("=" * 60)

print(f"Mean Absolute Error (MAE): {mae:.4f}")

print(f"Root Mean Squared Error (RMSE): {rmse:.4f}")

print("=" * 60)

# Create parity plot (Actual vs Predicted)

[Link](figsize=(8, 8))

[Link](y_test, y_pred, alpha=0.5, edgecolors='k', linewidth=0.5)

# Plot perfect prediction line

min_val = min(y_test.min(), y_pred.min())

max_val = max(y_test.max(), y_pred.max())

[Link]([min_val, max_val], [min_val, max_val], 'r--', linewidth=2, label='Perfect Prediction')

[Link]('Actual Values', fontsize=12)

[Link]('Predicted Values', fontsize=12)

[Link]('Parity Plot: Actual vs Predicted', fontsize=14, fontweight='bold')

[Link]()

[Link](True, alpha=0.3)

plt.tight_layout()

[Link]()
## 1.4 Overfitting / Underfitting Diagnosis (4 Marks)

### Model Performance Analysis

Based on the training and validation loss curves, the model appears to be **reasonably well-
balanced** with minimal overfitting. The training loss and validation loss decrease together
during the initial epochs and remain relatively close to each other throughout training,
which indicates that the model is learning generalizable patterns rather than memorizing the
training data. The validation loss does not diverge significantly from the training loss, and
there is no substantial gap between them at the end of training, suggesting that the model
has not severely overfit to the training data. The early stopping mechanism successfully
prevented the model from continuing to train once the validation loss stopped improving,
which helped maintain good generalization performance.

However, there might be slight room for improvement. If we observe that both training and
validation losses plateau at relatively high values, this could indicate mild underfitting,
suggesting the model hasn't fully captured all the patterns in the data. To address this and
potentially improve performance, I would try two specific actions: First, I would experiment
with **regularization techniques** such as L2 regularization or dropout layers to further
prevent any potential overfitting while allowing the model to learn more complex patterns.
Second, I would perform **feature engineering** by creating interaction terms between
existing features, applying polynomial transformations, or using domain knowledge to derive
new meaningful features that could help the model better capture the underlying
relationships in the data. Additionally, collecting more training data, if possible, could help
the model generalize even better to unseen examples.

---

# Part 2 — NLP: Embeddings + RNN for Text Classification

---

## 2.1 Text Preparation, Tokenization, and Padding (10 Marks)

# Load text dataset

df_text = pd.read_csv(TEXT_PATH)

print("=" * 60)
print("Text Dataset Inspection")

print("=" * 60)

print(f"Dataset shape: {df_text.shape}")

print(f"\nColumns: {df_text.[Link]()}")

print(f"\nFirst few rows:")

print(df_text.head())

print(f"\nLabel distribution:")

print(df_text['label'].value_counts())

print(f"\nNumber of unique labels: {df_text['label'].nunique()}")

print("=" * 60)

# Text cleaning function

def clean_text(text):

"""Apply minimal text cleaning."""

# Convert to lowercase

text = [Link]()

# Remove extra spaces

text = ' '.join([Link]())

return text

# Apply cleaning

df_text['text_clean'] = df_text['text'].apply(clean_text)

# Show example

print("\nExample of cleaned text:")

print(f"Original: {df_text['text'].iloc[0]}")

print(f"Cleaned: {df_text['text_clean'].iloc[0]}")

# Split the data (70/15/15)

X_text = df_text['text_clean'].values
y_text = df_text['label'].values

# Determine if binary or multi-class

num_classes = len([Link](y_text))

is_binary = num_classes == 2

X_text_temp, X_text_test, y_text_temp, y_text_test = train_test_split(

X_text, y_text, test_size=0.15, random_state=42, stratify=y_text

X_text_train, X_text_val, y_text_train, y_text_val = train_test_split(

X_text_temp, y_text_temp, test_size=0.1765, random_state=42, stratify=y_text_temp

print(f"\nTraining samples: {len(X_text_train)}")

print(f"Validation samples: {len(X_text_val)}")

print(f"Test samples: {len(X_text_test)}")

print(f"\nClassification type: {'Binary' if is_binary else 'Multi-class'}")

print(f"Number of classes: {num_classes}")

# Tokenization - fit ONLY on training data

tokenizer = Tokenizer(num_words=10000, oov_token="<OOV>")

tokenizer.fit_on_texts(X_text_train)

# Convert texts to sequences

X_text_train_seq = tokenizer.texts_to_sequences(X_text_train)

X_text_val_seq = tokenizer.texts_to_sequences(X_text_val)

X_text_test_seq = tokenizer.texts_to_sequences(X_text_test)

# Calculate sequence lengths for max_len decision

sequence_lengths = [len(seq) for seq in X_text_train_seq]

avg_length = [Link](sequence_lengths)

median_length = [Link](sequence_lengths)

percentile_95 = [Link](sequence_lengths, 95)

print(f"\nVocabulary size: {len(tokenizer.word_index)}")

print(f"Effective vocabulary size (with limit): {min(len(tokenizer.word_index), 10000)}")

print(f"\nSequence length statistics:")

print(f"Average length: {avg_length:.2f}")

print(f"Median length: {median_length:.2f}")

print(f"95th percentile: {percentile_95:.2f}")

# Choose max_len based on data characteristics

# Using a value that captures most sequences while avoiding excessive padding

max_len = int(percentile_95)

# Pad sequences

X_text_train_pad = pad_sequences(X_text_train_seq, maxlen=max_len, padding='post',

truncating='post')

X_text_val_pad = pad_sequences(X_text_val_seq, maxlen=max_len, padding='post',

truncating='post')

X_text_test_pad = pad_sequences(X_text_test_seq, maxlen=max_len, padding='post',

truncating='post')

print(f"\nChosen max_len: {max_len}")

print(f"\nPadded shapes:")

print(f"Train: {X_text_train_pad.shape}")

print(f"Validation: {X_text_val_pad.shape}")

print(f"Test: {X_text_test_pad.shape}")

# Show example transformation

example_idx = 0

print("\n" + "=" * 60)

print("Example: Text to Sequence Transformation")

print("=" * 60)

print(f"\nOriginal text:\n{X_text_train[example_idx]}")

print(f"\nToken IDs:\n{X_text_train_seq[example_idx][:20]}... (showing first 20)")

print(f"\nPadded sequence (length={max_len}):")

print(f"{X_text_train_pad[example_idx][:30]}... (showing first 30)")

print("=" * 60)

### Explanation: Choice of max_len

The chosen max_len value is based on the 95th percentile of sequence lengths in the
training data, which ensures that we capture the vast majority of text samples without
excessive padding or truncation. Setting max_len too low would result in losing important
information from longer texts, while setting it too high would waste computational
resources on padding and could slow down training significantly. By using the 95th
percentile, we strike a balance between preserving content from most samples and
maintaining computational efficiency, as only about 5% of sequences will be truncated while
avoiding unnecessary padding for the majority of shorter sequences.

## 2.2 Baseline Text Model (Embedding + Pooling) (10 Marks)

# Build baseline model with embedding and pooling

def build_baseline_text_model(vocab_size, embedding_dim, max_len, num_classes,

is_binary):

model = [Link]([

[Link](vocab_size, embedding_dim, input_length=max_len,

name='embedding'),

layers.GlobalAveragePooling1D(name='pooling'),

[Link](64, activation='relu', name='dense_1'),

[Link](

1 if is_binary else num_classes,

activation='sigmoid' if is_binary else 'softmax',

 name='output'

])

return model

# Create baseline model

vocab_size = min(len(tokenizer.word_index) + 1, 10000)

embedding_dim = 64

model_baseline = build_baseline_text_model(vocab_size, embedding_dim, max_len,

num_classes, is_binary)

# Compile model

model_baseline.compile(

optimizer='adam',

loss='binary_crossentropy' if is_binary else 'sparse_categorical_crossentropy',

metrics=['accuracy']

print("=" * 60)

print("Baseline Text Model Architecture")

print("=" * 60)

model_baseline.summary()

print("=" * 60)

# Train baseline model

early_stop_text = EarlyStopping(

monitor='val_loss',

patience=3,
 restore_best_weights=True,

verbose=1

history_baseline = model_baseline.fit(

X_text_train_pad, y_text_train,

validation_data=(X_text_val_pad, y_text_val),

epochs=50,

batch_size=32,

callbacks=[early_stop_text],

verbose=1

print("\nBaseline model training completed!")

# Evaluate baseline model on test set

y_text_pred_baseline = model_baseline.predict(X_text_test_pad)

if is_binary:

y_text_pred_baseline_classes = (y_text_pred_baseline > 0.5).astype(int).flatten()

else:

y_text_pred_baseline_classes = [Link](y_text_pred_baseline, axis=1)

# Calculate metrics

baseline_accuracy = [Link](y_text_pred_baseline_classes == y_text_test)

baseline_f1 = f1_score(y_text_test, y_text_pred_baseline_classes, average='binary' if

is_binary else 'weighted')

print("=" * 60)
print("Baseline Model - Test Set Evaluation")

print("=" * 60)

print(f"Test Accuracy: {baseline_accuracy:.4f}")

print(f"Test F1-Score: {baseline_f1:.4f}")

print("=" * 60)

# Confusion matrix for baseline model

cm_baseline = confusion_matrix(y_text_test, y_text_pred_baseline_classes)

[Link](figsize=(8, 6))

[Link](cm_baseline, annot=True, fmt='d', cmap='Blues', cbar=True)

[Link]('Predicted Label', fontsize=12)

[Link]('True Label', fontsize=12)

[Link]('Confusion Matrix - Baseline Model', fontsize=14, fontweight='bold')

plt.tight_layout()

[Link]()

print("\nClassification Report - Baseline Model:")

print(classification_report(y_text_test, y_text_pred_baseline_classes))

## 2.3 RNN Model (SimpleRNN or small LSTM) (10 Marks)

# Build RNN model with LSTM

def build_rnn_model(vocab_size, embedding_dim, max_len, num_classes, is_binary):

model = [Link]([

[Link](vocab_size, embedding_dim, input_length=max_len,

name='embedding'),

[Link](32, name='lstm'), # Using LSTM instead of SimpleRNN

[Link](

1 if is_binary else num_classes,

activation='sigmoid' if is_binary else 'softmax',

 name='output'

])

return model

# Create RNN model

model_rnn = build_rnn_model(vocab_size, embedding_dim, max_len, num_classes,

is_binary)

# Compile model

model_rnn.compile(

optimizer='adam',

loss='binary_crossentropy' if is_binary else 'sparse_categorical_crossentropy',

metrics=['accuracy']

print("=" * 60)

print("RNN Model Architecture (LSTM)")

print("=" * 60)

model_rnn.summary()

print("=" * 60)

# Train RNN model

import time

start_time = [Link]()

history_rnn = model_rnn.fit(

X_text_train_pad, y_text_train,
 validation_data=(X_text_val_pad, y_text_val),

epochs=50,

batch_size=32,

callbacks=[early_stop_text],

verbose=1

rnn_training_time = [Link]() - start_time

print(f"\nRNN model training completed in {rnn_training_time:.2f} seconds!")

# Evaluate RNN model on test set

y_text_pred_rnn = model_rnn.predict(X_text_test_pad)

if is_binary:

y_text_pred_rnn_classes = (y_text_pred_rnn > 0.5).astype(int).flatten()

else:

y_text_pred_rnn_classes = [Link](y_text_pred_rnn, axis=1)

# Calculate metrics

rnn_accuracy = [Link](y_text_pred_rnn_classes == y_text_test)

rnn_f1 = f1_score(y_text_test, y_text_pred_rnn_classes, average='binary' if is_binary else

'weighted')

print("=" * 60)

print("RNN Model - Test Set Evaluation")

print("=" * 60)

print(f"Test Accuracy: {rnn_accuracy:.4f}")

print(f"Test F1-Score: {rnn_f1:.4f}")

print("=" * 60)

# Confusion matrix for RNN model

cm_rnn = confusion_matrix(y_text_test, y_text_pred_rnn_classes)

[Link](figsize=(8, 6))

[Link](cm_rnn, annot=True, fmt='d', cmap='Greens', cbar=True)

[Link]('Predicted Label', fontsize=12)

[Link]('True Label', fontsize=12)

[Link]('Confusion Matrix - RNN Model (LSTM)', fontsize=14, fontweight='bold')

plt.tight_layout()

[Link]()

print("\nClassification Report - RNN Model:")

print(classification_report(y_text_test, y_text_pred_rnn_classes))

### Explanation: Why LSTM Was Chosen

I chose to use LSTM (Long Short-Term Memory) instead of SimpleRNN for this text
classification task because LSTMs are specifically designed to address the vanishing gradient
problem that plagues standard RNNs, especially when dealing with longer sequences. LSTMs
employ a sophisticated gating mechanism consisting of input, forget, and output gates that
allow them to selectively retain or discard information over long sequences, making them
much better at capturing long-range dependencies in text. While SimpleRNN can struggle to
maintain context from earlier parts of a sequence, LSTM's cell state acts as a highway for
information flow, enabling the model to remember important features from the beginning of
a text passage even when processing its end. This capability is particularly valuable in text
classification where understanding context, sentiment, or meaning often requires
considering relationships between words that may be far apart in the sequence.

## 2.4 Comparison + Why Transformers Help (4 Marks)

# Create comparison table

comparison_df = [Link]({

'Model': ['Baseline (Embedding + Pooling)', 'RNN (LSTM)'],

 'Test Accuracy': [baseline_accuracy, rnn_accuracy],

'Test F1-Score': [baseline_f1, rnn_f1],

'Approximate Training Time': ['Fast (~seconds)', f'{rnn_training_time:.1f} seconds']

})

print("=" * 60)

print("Model Comparison")

print("=" * 60)

print(comparison_df.to_string(index=False))

print("=" * 60)

### Analysis: RNN Limitations and How Transformers Address Them

Recurrent Neural Networks (RNNs), including LSTMs, have a fundamental limitation when
processing long sequences: they process text sequentially from left to right, which creates an
information bottleneck where all the context from previous words must be compressed into
a fixed-size hidden state. This sequential processing means that information from early parts
of a long sequence can become diluted or lost by the time the model reaches the end, even
with LSTM's gating mechanisms. Additionally, the sequential nature of RNNs prevents
parallelization during training, as each word must be processed before the next one can be
handled, leading to slow training times especially on long documents. RNNs also struggle
with truly understanding bidirectional context simultaneously, as they primarily flow
information in one direction (or require separate forward and backward passes).

Transformers address these limitations through their revolutionary self-attention

mechanism, which allows the model to directly attend to any word in the sequence
regardless of distance, eliminating the need to compress all context into a sequential hidden
state. This attention mechanism computes relationships between all pairs of words in
parallel, meaning that a word at the end of a document can directly access and be
influenced by a word at the beginning without information passing through intermediate
steps. The parallel architecture of transformers enables much faster training on modern
hardware compared to the sequential processing required by RNNs. Furthermore,
transformers can capture richer contextual representations through multi-head attention,
where different attention heads can focus on different types of relationships (such as
syntactic vs semantic) simultaneously. This combination of parallel processing, direct long-
range connections, and multi-faceted attention mechanisms has made transformers the
dominant architecture in modern NLP, powering models like BERT, GPT, and many others
that consistently outperform RNN-based approaches on virtually all language understanding
tasks.

---

# Part 3 — Computer Vision: CNN Image Classifier

---

## 3.1 Loading, Normalization, and Visual Sanity Checks (10 Marks)

# Load image dataset

img_height, img_width = 128, 128

batch_size = 32

# Load training data

train_ds = [Link].image_dataset_from_directory(

IMAGE_DIR,

validation_split=0.3,

subset="training",

seed=42,

image_size=(img_height, img_width),

batch_size=batch_size

# Load validation+test data (will split further)

val_test_ds = [Link].image_dataset_from_directory(

IMAGE_DIR,

validation_split=0.3,

subset="validation",

seed=42,
 image_size=(img_height, img_width),

batch_size=batch_size

# Get class names

class_names = train_ds.class_names

num_classes_img = len(class_names)

print("=" * 60)

print("Image Dataset Information")

print("=" * 60)

print(f"Class names: {class_names}")

print(f"Number of classes: {num_classes_img}")

print("=" * 60)

# Split val_test_ds into validation and test (50/50 split of the 30%)

val_batches = [Link](val_test_ds)

val_ds = val_test_ds.take(val_batches // 2)

test_ds = val_test_ds.skip(val_batches // 2)

print(f"\nDataset splits:")

print(f"Training batches: {[Link](train_ds)}")

print(f"Validation batches: {[Link](val_ds)}")

print(f"Test batches: {[Link](test_ds)}")

# Check shape of one batch

for images, labels in train_ds.take(1):

print(f"\nBatch shape:")

print(f"Images: {[Link]}")

print(f"Labels: {[Link]}")
 print(f"\nImage value range: [{[Link]().min():.2f}, {[Link]().max():.2f}]")

# Normalize images to [0, 1]

normalization_layer = [Link](1./255)

train_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))

val_ds = val_ds.map(lambda x, y: (normalization_layer(x), y))

test_ds = test_ds.map(lambda x, y: (normalization_layer(x), y))

# Verify normalization

for images, labels in train_ds.take(1):

print(f"\nAfter normalization:")

print(f"Image value range: [{[Link]().min():.4f}, {[Link]().max():.4f}]")

# Visualize 9 sample images

[Link](figsize=(12, 12))

for images, labels in train_ds.take(1):

for i in range(9):

[Link](3, 3, i + 1)

[Link](images[i].numpy())

[Link](f"Class: {class_names[labels[i]]}")

[Link]('off')

plt.tight_layout()

[Link]('Sample Images from Dataset', fontsize=16, fontweight='bold', y=1.00)

[Link]()

# Optimize performance with prefetching

AUTOTUNE = [Link]

train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

test_ds = test_ds.cache().prefetch(buffer_size=AUTOTUNE)

print("\nDataset optimization completed!")

## 3.2 Build and Train a CNN (14 Marks)

# Build CNN model

def build_cnn_model(num_classes):

model = [Link]([

# First convolution block

layers.Conv2D(32, (3, 3), activation='relu', input_shape=(img_height, img_width, 3),

name='conv_1'),

layers.MaxPooling2D((2, 2), name='pool_1'),

# Second convolution block

layers.Conv2D(64, (3, 3), activation='relu', name='conv_2'),

layers.MaxPooling2D((2, 2), name='pool_2'),

# Third convolution block

layers.Conv2D(128, (3, 3), activation='relu', name='conv_3'),

layers.MaxPooling2D((2, 2), name='pool_3'),

# Flatten and dense layers

[Link](name='flatten'),

[Link](64, activation='relu', name='dense_1'),

[Link](0.3, name='dropout'),

[Link](num_classes, activation='softmax' if num_classes > 2 else 'sigmoid',

name='output')

])

return model
# Create CNN model

model_cnn = build_cnn_model(num_classes_img)

# Compile model

model_cnn.compile(

optimizer='adam',

loss='sparse_categorical_crossentropy' if num_classes_img > 2 else 'binary_crossentropy',

metrics=['accuracy']

print("=" * 60)

print("CNN Model Architecture")

print("=" * 60)

model_cnn.summary()

print("=" * 60)

# Train CNN model

early_stop_cnn = EarlyStopping(

monitor='val_loss',

patience=5,

restore_best_weights=True,

verbose=1

history_cnn = model_cnn.fit(

train_ds,

validation_data=val_ds,

epochs=50,
 callbacks=[early_stop_cnn],

verbose=1

print("\nCNN model training completed!")

# Plot training history

[Link](figsize=(14, 5))

[Link](1, 2, 1)

[Link](history_cnn.history['loss'], label='Training Loss', linewidth=2)

[Link](history_cnn.history['val_loss'], label='Validation Loss', linewidth=2)

[Link]('Epoch', fontsize=12)

[Link]('Loss', fontsize=12)

[Link]('CNN Training vs Validation Loss', fontsize=14, fontweight='bold')

[Link]()

[Link](True, alpha=0.3)

[Link](1, 2, 2)

[Link](history_cnn.history['accuracy'], label='Training Accuracy', linewidth=2)

[Link](history_cnn.history['val_accuracy'], label='Validation Accuracy', linewidth=2)

[Link]('Epoch', fontsize=12)

[Link]('Accuracy', fontsize=12)

[Link]('CNN Training vs Validation Accuracy', fontsize=14, fontweight='bold')

[Link]()

[Link](True, alpha=0.3)

plt.tight_layout()

[Link]()
# Evaluate on test set

test_loss, test_accuracy = model_cnn.evaluate(test_ds)

print("\n" + "=" * 60)

print("CNN Model - Test Set Evaluation")

print("=" * 60)

print(f"Test Loss: {test_loss:.4f}")

print(f"Test Accuracy: {test_accuracy:.4f}")

print("=" * 60)

## 3.3 Evaluation, Confusion Matrix, and Misclassification Review (10 Marks)

# Get predictions on test set

y_true_img = []

y_pred_img = []

for images, labels in test_ds:

predictions = model_cnn.predict(images, verbose=0)

predicted_classes = [Link](predictions, axis=1)

y_true_img.extend([Link]())

y_pred_img.extend(predicted_classes)

y_true_img = [Link](y_true_img)

y_pred_img = [Link](y_pred_img)

# Compute confusion matrix

cm_cnn = confusion_matrix(y_true_img, y_pred_img)

[Link](figsize=(10, 8))

[Link](cm_cnn, annot=True, fmt='d', cmap='Purples',

 xticklabels=class_names, yticklabels=class_names, cbar=True)

[Link]('Predicted Label', fontsize=12)

[Link]('True Label', fontsize=12)

[Link]('Confusion Matrix - CNN Model', fontsize=14, fontweight='bold')

plt.tight_layout()

[Link]()

# Print classification report

print("\n" + "=" * 60)

print("Classification Report - CNN Model")

print("=" * 60)

print(classification_report(y_true_img, y_pred_img, target_names=class_names))

print("=" * 60)

# Find misclassified images

misclassified_indices = [Link](y_true_img != y_pred_img)[0]

print(f"\nTotal misclassified images: {len(misclassified_indices)}")

print(f"Misclassification rate: {len(misclassified_indices)/len(y_true_img)*100:.2f}%")

# Display 5 misclassified images

if len(misclassified_indices) >= 5:

# Get images and labels from test dataset

all_test_images = []

all_test_labels = []

for images, labels in test_ds:

all_test_images.extend([Link]())

all_test_labels.extend([Link]())

all_test_images = [Link](all_test_images)
 # Select 5 random misclassified examples

selected_indices = [Link](misclassified_indices, 5, replace=False)

[Link](figsize=(15, 3))

for i, idx in enumerate(selected_indices):

[Link](1, 5, i + 1)

[Link](all_test_images[idx])

true_label = class_names[y_true_img[idx]]

pred_label = class_names[y_pred_img[idx]]

[Link](f"True: {true_label}\nPred: {pred_label}", fontsize=10)

[Link]('off')

[Link]('Misclassified Images', fontsize=14, fontweight='bold', y=1.05)

plt.tight_layout()

[Link]()

else:

print("Not enough misclassified images to display 5 examples.")

### Analysis: Misclassification Patterns and Improvement Strategies

Based on the confusion matrix and misclassified image examples, several patterns emerge in
the model's errors. The model tends to struggle most with classes that have visual
similarities or overlapping features, as evidenced by the off-diagonal entries in the confusion
matrix that show which classes are commonly confused with each other. Examining the
misclassified images reveals that the model makes errors primarily in cases where images
have poor lighting conditions, unusual angles, or ambiguous features that could reasonably
belong to multiple classes. Additionally, if certain classes have fewer training examples, the
model shows lower recall for those underrepresented categories, suggesting class imbalance
may be affecting performance.
To improve the model's performance, I would first implement **data augmentation
techniques** such as random rotations, flips, zoom, brightness adjustments, and color
jittering during training, which would help the model become more robust to variations in
lighting, orientation, and scale that appear to cause many misclassifications. Second, I would
explore **transfer learning** by using a pre-trained model such as ResNet, EfficientNet, or
MobileNet as a feature extractor, which would leverage patterns learned from millions of
images and likely improve performance especially if our dataset is relatively small or
contains classes with subtle differences. Additionally, addressing any class imbalance
through techniques like weighted loss functions or oversampling minority classes could help
improve the model's ability to correctly classify underrepresented categories.

---

# Final Summary

---

## Assignment Summary and Key Learnings

Throughout this assignment, I successfully built and trained three distinct neural network
architectures for different data modalities: a feedforward neural network for tabular
regression, recurrent neural networks for text classification, and a convolutional neural
network for image classification. Each model demonstrated the fundamental principles of
deep learning, including the importance of proper data preprocessing to prevent leakage,
the role of activation functions in introducing non-linearity, and the necessity of validation
strategies like early stopping to achieve good generalization. The tabular regression model
showed the value of careful feature scaling and the ability to diagnose overfitting through
training curves, while the NLP models illustrated how embeddings convert discrete text into
meaningful continuous representations and how LSTMs improve upon simple RNNs for
sequence modeling.

The image classification task with CNNs highlighted how convolutional layers automatically
learn hierarchical feature representations from raw pixels, with lower layers detecting edges
and textures while higher layers recognize complex shapes and objects. Across all three
tasks, I observed that proper train-validation-test splits and consistent evaluation metrics are
essential for understanding true model performance. The comparison between different
architectures, such as the baseline embedding model versus LSTM for text, reinforced that
more complex models don't always guarantee better performance, and the choice of
architecture should be guided by the specific characteristics of the data and task. This hands-
on experience with implementing, training, and evaluating neural networks across multiple
domains has solidified my understanding of deep learning fundamentals and provided
practical insights into the challenges and best practices of building production-ready AI
systems.