■ APPLIED AI & MACHINE LEARNING

MODULE 4

Deep Learning
ANN · CNN · RNN · Autoencoders · GPU Acceleration

A Complete Beginner-Friendly Lecture with Real-World Examples

Includes Jupyter Notebook Basics | Easy Language | Hands-On

Code

■ Course Applied AI & Machine Learning – CICU, Focal Point Ludhiana

■ Module 4 of 7 — Deep Learning

■ Duration ~4 Weeks | 20+ Hours of Hands-on Practice

■ Goal Build and understand Neural Networks from scratch — no heavy math needed!

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 1

 ■ Table of Contents
Ch 0 Jupyter Notebook Basics — Your Digital Lab Notebook Getting Started

Ch 1 What is Deep Learning? — Teaching Computers to Think Foundation

Ch 2 Artificial Neural Networks (ANN) — The Brain of AI Core Topic

Ch 3 Convolutional Neural Networks (CNN) — Eyes of AI Core Topic

Ch 4 Recurrent Neural Networks (RNN) — Memory of AI Core Topic

Ch 5 Autoencoders — AI's Secret Compressor Advanced

Ch 6 GPU Acceleration — Giving AI a Turbo Boost Tools

Ch 7 Real-World Projects & Case Studies Practice

Ch 8 Quick Revision Cheat Sheet Summary

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 2

 MODULE 4 CHAPTER 0

Jupyter Notebook Basics

Your Digital Lab Notebook — Before We Start Coding

■ ANALO Think of Jupyter Notebook like a Word document that can also run code. You
GY write Python code, press a button, and instantly see the result — all in one place!

■ How to Install & Open Jupyter

Terminal / Command Prompt
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# Step 1: Install Jupyter (one time only)

pip install jupyter notebook

# Step 2: Open Jupyter

jupyter notebook

# This opens your browser at: [Link]

# You will see a file explorer — click 'New' → 'Python 3'

■ Key Things to Know

Feature What It Does Shortcut

Cell A box where you type code or text —

Run Cell Executes the code in that cell Shift + Enter

Add Cell Below Inserts a new cell B

Delete Cell Removes the current cell D, D

Markdown Cell Write plain text / headings M

Code Cell Write and run Python code Y

Restart Kernel Clears all memory, start fresh Menu: Kernel → Restart

■ Your First Jupyter Cell

Cell 1 — Try This!
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# This is a comment — Python ignores it

print('Hello Deep Learning!')

# Simple math

result = 10 + 5

print('Result is:', result)

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 3

 # OUTPUT:

# Hello Deep Learning!

# Result is: 15

■ WATCH Always run cells from top to bottom! If you skip a cell and run a later one, Python won't
OUT know about variables defined in skipped cells.

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 4

 MODULE 4 CHAPTER 1

What is Deep Learning?

Teaching Computers to Think Like Humans

Deep Learning is a type of Machine Learning where we build systems that learn from examples —
just like how a child learns to recognize a cat by seeing many cats. The 'deep' part means many
layers of learning happening inside.

■ The Learning Ladder

Level Name Example

■ Level 1 Artificial Intelligence (AI) Any machine that can do smart things

■ Level 2 Machine Learning (ML) Machines that learn from data

■ Level 3 Deep Learning (DL) ML using many-layered neural networks

■ Why Does Industry Use Deep Learning?

■ Face Unlock on your phone — recognizes your face in milliseconds
■ YouTube / Spotify recommendations — knows what you'll like next
■ Medical Diagnosis — detects cancer in X-rays better than some doctors
■ Self-Driving Cars — detects pedestrians, traffic lights, lanes
■ Manufacturing — finds defects on a production line automatically
■ Customer Service Chatbots — understands and replies to questions

Analogy: Imagine teaching someone to recognize dogs. Instead of writing rules

('dogs have 4 legs, fur, tail...'), you show them 10,000 dog photos. They figure out

■ ANALO the pattern themselves. Deep Learning does exactly this — with data instead of
GY rules!

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 5

 MODULE 4 CHAPTER 2

Artificial Neural Networks (ANN)

The Brain of AI — Learning from Examples

■ What is a Neuron?
Your brain has about 86 billion neurons. Each neuron takes signals from other neurons, processes
them, and either fires a signal forward or not. An Artificial Neuron is a simple math version of this
— it takes numbers in, multiplies them by weights (importance), adds them up, and outputs a
number.

Imagine a hiring committee. They score a candidate on Skills (weight = 50%),

Experience (weight = 30%), Communication (weight = 20%). The final score =

■ ANALO (Skills × 0.5) + (Experience × 0.3) + (Communication × 0.2). If score > 70, candidate
GY is hired. This is exactly what one neuron does!

■■ Structure of an ANN
Layer What It Does Real-World Role

Input Layer Receives raw data Like your eyes/ears taking in information

Hidden Layer(s) Finds patterns in data Like your brain processing what you see

Output Layer Gives the final answer Like your mouth saying what you see

■ Key Terms Explained Simply

How important is this input? Higher weight = more important. The network learns
Weight
these automatically.

Bias A small adjustment — like a starting point. Helps the model be more flexible.

Activation Function Decides whether a neuron should 'fire' or not. Like a gate that opens/closes.

Epoch One complete pass through all your training data. More epochs = more learning.

Loss / Error How wrong is the model right now? Goal: make this number as small as possible.

Backpropagation The model looks at its mistakes and adjusts weights to do better next time.

How fast does the model correct itself? Too fast = overshoots. Too slow = takes
Learning Rate
ages.

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 6

 ■ Jupyter: Build Your First ANN
Cell 1 — Imports
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 1: Install & Import

# ============================================

# Run this first (one-time setup)

# !pip install tensorflow

import tensorflow as tf

from tensorflow import keras

import numpy as np

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

Cell 2 — Data
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 2: Real-World Example

# Predict if a student will PASS or FAIL

# based on Hours Studied and Previous Score

# ============================================

# Fake student data: [hours_studied, prev_score]

X = [Link]([

[1, 40], # studied 1 hr, prev score 40

[2, 50],

[5, 65],

[8, 75],

[10, 85],

[3, 55],

])

# Labels: 0 = Fail, 1 = Pass

y = [Link]([0, 0, 1, 1, 1, 0])

Cell 3 — Build Model

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 3: Build the ANN

# ============================================

model = [Link]([

[Link](8, activation='relu', input_shape=(2,)),

# ^ 8 neurons, relu = 'fire if positive'

[Link](4, activation='relu'),

# ^ another hidden layer with 4 neurons

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 7

 [Link](1, activation='sigmoid'),

# ^ output: probability between 0 and 1

])

[Link](

optimizer='adam', # adam = smart learning algorithm

loss='binary_crossentropy', # for yes/no problems

metrics=['accuracy']

[Link]() # See the network structure

Cell 4 — Train & Predict

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 4: Train & Predict

# ============================================

[Link](X, y, epochs=100, verbose=0) # Train!

print('Training done!')

# Predict for a new student:

# 6 hours studied, previous score 70

new_student = [Link]([[6, 70]])

prediction = [Link](new_student)[0][0]

if prediction > 0.5:

print(f'Student will likely PASS ({prediction:.0%} confidence)')

else:

print(f'Student might FAIL ({1-prediction:.0%} risk)')

■ Real Industry Use: Tata Steel uses ANN to predict whether a steel batch will pass
■ INDUST quality tests — based on temperature, chemical composition, and pressure readings.
RY This saves crores of rupees in defective batches!

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 8

 MODULE 4 CHAPTER 3

Convolutional Neural Networks (CNN)

The Eyes of AI — Understanding Images

■■ What is a CNN and Why Do We Need It?

A regular ANN treats every pixel of an image as a separate input. A 28×28 image = 784 inputs. A
1000×1000 image = 1,000,000 inputs! That's too much. A CNN is smarter — it looks at small
patches of the image at a time, finds local patterns, and builds up understanding gradually.

Imagine reading a newspaper. You don't look at every single letter individually

■ ANALO across the whole page. You scan small areas at a time, spot headlines, pictures,
GY and columns. CNN does the same with images!

■ CNN Layers Explained Simply

Layer Plain English Meaning Real Example

Convolution Layer Scans image with a small window to find features like
Detects
edges,the
corners
edge of a car door

ReLU Activation Keeps only useful (positive) signals, throws away noise
Ignores blank/dark areas

Pooling Layer Shrinks the image but keeps important features — reduces
Summarizing
data size
a photo

Flatten Layer Converts 2D image data into a 1D list of numbers Unrolling a matrix to a list

Dense (FC) Layer Regular ANN neurons make the final classification decision
Deciding: cat or dog?

■ Jupyter: Build a CNN to Classify Images

Cell 1 — Load Data
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 1: Load Famous MNIST Dataset

# 70,000 handwritten digit images (0-9)

# Used by banks to read cheque amounts!

# ============================================

import tensorflow as tf

from tensorflow import keras

import [Link] as plt

# Load data — automatically downloads

(X_train, y_train), (X_test, y_test) = [Link].load_data()

# Normalize: convert pixel values from 0-255 to 0-1

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 9

 X_train = X_train / 255.0

X_test = X_test / 255.0

# Reshape: CNN needs (height, width, channels)

X_train = X_train.reshape(-1, 28, 28, 1)

X_test = X_test.reshape(-1, 28, 28, 1)

print(f'Training samples: {X_train.shape[0]}')

print(f'Image size: 28x28 pixels')

Cell 2 — Visualize
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 2: Visualize a few digits

# ============================================

fig, axes = [Link](1, 5, figsize=(10, 2))

for i in range(5):

axes[i].imshow(X_train[i].reshape(28,28), cmap='gray')

axes[i].set_title(f'Label: {y_train[i]}')

axes[i].axis('off')

[Link]('Sample Handwritten Digits')

[Link]()

Cell 3 — Build CNN

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 3: Build CNN

# ============================================

model = [Link]([

# First: Scan for edges and simple shapes

[Link].Conv2D(32, (3,3), activation='relu',

input_shape=(28,28,1)),

[Link].MaxPooling2D(2,2), # Shrink image

# Second: Detect more complex patterns

[Link].Conv2D(64, (3,3), activation='relu'),

[Link].MaxPooling2D(2,2),

[Link](), # Unroll to 1D

[Link](128, activation='relu'), # Brain

[Link](10, activation='softmax'),# 10 digits

])

[Link](optimizer='adam',

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 10

 [Link]()

Cell 4 — Train & Evaluate

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 4: Train and Test

# ============================================

history = [Link](X_train, y_train,

epochs=5,

validation_split=0.1)

test_loss, test_acc = [Link](X_test, y_test)

print(f'Test Accuracy: {test_acc:.2%}')

# Should be around 99% — amazing!

# Plot accuracy over training

[Link]([Link]['accuracy'], label='Train')

[Link]([Link]['val_accuracy'], label='Validate')

[Link]('Model Accuracy Over Epochs')

[Link]('Epoch')

[Link]('Accuracy')

[Link]()

[Link]()

■ Industry Example: Amazon's warehouse robots use CNNs to identify products on

■ INDUST conveyor belts. Maruti Suzuki uses CNN-based quality cameras to spot paint defects on
RY car bodies — faster and more accurate than human inspectors!

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 11

 MODULE 4 CHAPTER 4

Recurrent Neural Networks (RNN)

The Memory of AI — Understanding Sequences

■ What Makes RNN Different?

ANN and CNN have no memory — they treat each input independently. But what about predicting
tomorrow's stock price? Or understanding a sentence? Order matters! RNN has a memory loop —
it remembers what it saw before and uses that to predict what comes next.

Imagine reading a novel. When you read 'The dog chased its ___', you know the
answer is 'tail' because you remember the context. A regular ANN only sees the last

■ ANALO word 'its' and has no idea. RNN remembers 'The dog chased' and can answer
GY correctly!

■ Where is RNN Used?

Stock Price Prediction Looks at past 30 days of prices to predict tomorrow

Weather Forecasting Uses past temperature/humidity patterns to forecast

Language Translation Understands full sentence context before translating

Voice Assistants Understands spoken words in sequence

Music Generation Learns patterns in notes to create new music

Predictive Text Suggests next words as you type on your phone

■ LSTM — Long Short-Term Memory (Better RNN)

Simple RNN forgets things after a while (like a goldfish!). LSTM is a smarter version that has 3
gates — a forget gate (what to erase), an input gate (what to store), and an output gate (what to
pass forward). This makes it excellent for long sequences.

■ Jupyter: Stock Price Prediction with LSTM

Cell 1 — Imports
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 1: Imports

# ============================================

import numpy as np

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 12

 import [Link] as plt

from tensorflow import keras

from [Link] import MinMaxScaler

Cell 2 — Stock Data

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 2: Create Fake Stock Data

# (In real life, use yfinance library!)

# ============================================

[Link](42)

days = 200

# Simulate stock price going up with noise

price = 100 + [Link]([Link](days) * 2)

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

[Link](price)

[Link]('Simulated Stock Price')

[Link]('Day')

[Link]('Price (Rs.)')

[Link]()

Cell 3 — Prepare Sequences

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 3: Prepare Sequences

# Use last 30 days to predict next day

# ============================================

scaler = MinMaxScaler() # Scale 0 to 1

price_scaled = scaler.fit_transform([Link](-1,1))

WINDOW = 30 # Look back 30 days

X, y = [], []

for i in range(WINDOW, len(price_scaled)):

[Link](price_scaled[i-WINDOW:i, 0]) # past 30 days

[Link](price_scaled[i, 0]) # next day

X = [Link](X).reshape(-1, WINDOW, 1)

y = [Link](y)

print(f'X shape: {[Link]}') # (samples, 30 days, 1 feature)

Cell 4 — LSTM Model

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 4: Build LSTM Model

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 13

 # ============================================

model = [Link]([

[Link](50, return_sequences=True,

input_shape=(WINDOW, 1)),

[Link](50, return_sequences=False),

[Link](25, activation='relu'),

[Link](1) # Output: next day price

])

[Link](optimizer='adam', loss='mse')

[Link](X, y, epochs=20, batch_size=16, verbose=1)

■ Industry Example: BSE (Bombay Stock Exchange) analysts use LSTM models to
■ INDUST detect unusual trading patterns. Weather apps like IMD use LSTM on historical
RY temperature/rainfall sequences to predict monsoon arrival dates.

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 14

 MODULE 4 CHAPTER 5

Autoencoders
AI's Secret Compressor — Compress and Reconstruct

■■ What is an Autoencoder?
An Autoencoder is a neural network that learns to compress data into a smaller form and then
reconstruct it back. It has two parts: an Encoder (compresses) and a Decoder (reconstructs). The
magic is in the middle — the compressed form called a Bottleneck or Latent Space.

Imagine a zip file. WinZip takes a 100MB folder, compresses it to 30MB (encoding),

■ ANALO and later you unzip it back to 100MB (decoding). An Autoencoder learns to do this
GY automatically — and whatever gets lost in compression reveals what's important!

■ Real-World Uses of Autoencoders

Use Case How It Works

Anomaly Detection Train on normal data. Unusual data reconstructs badly → flagged as anomaly

Image Denoising Feed noisy image in, clean image comes out

Data Compression Compress images/data for storage or transmission

Fraud Detection Normal transactions reconstruct well; fraud transactions don't

Recommendation Systems Compress user preferences into small vector, find similar users

■ Jupyter: Anomaly Detection with Autoencoder

Cell 1 — Simulate Factory Data
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# REAL WORLD: Detect Faulty Products in Factory

# Normal product: values between 0.4 - 0.6

# Faulty product: values are outliers (very high/low)

# ============================================

import numpy as np

import tensorflow as tf

from tensorflow import keras

import [Link] as plt

# Simulate sensor readings from a machine

# Normal operations: values near 0.5

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 15

 normal_data = [Link](0.5, 0.05, (1000, 10))

# A few faulty readings (anomalies)

faulty_data = [Link](0.9, 0.1, (50, 10))

print(f'Normal data shape: {normal_data.shape}')

print(f'Faulty data shape: {faulty_data.shape}')

Cell 2 — Train Autoencoder

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 2: Build Autoencoder

# ============================================

input_dim = 10 # 10 sensor readings

autoencoder = [Link]([

# ENCODER: compress 10 → 4

[Link](6, activation='relu', input_shape=(input_dim,)),

[Link](4, activation='relu'), # Bottleneck!

# DECODER: reconstruct 4 → 10

[Link](6, activation='relu'),

[Link](input_dim, activation='sigmoid'),

])

[Link](optimizer='adam', loss='mse')

[Link](normal_data, normal_data, # input = output

epochs=50, batch_size=32, verbose=0)

print('Training complete!')

Cell 3 — Detect Anomalies

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

# ============================================

# CELL 3: Detect Anomalies!

# ============================================

def get_reconstruction_error(data):

reconstructed = [Link](data, verbose=0)

errors = [Link]([Link](data - reconstructed), axis=1)

return errors

normal_errors = get_reconstruction_error(normal_data)

faulty_errors = get_reconstruction_error(faulty_data)

# Set threshold: if error > threshold → ANOMALY!

threshold = [Link](normal_errors, 95)

print(f'Normal avg error: {normal_errors.mean():.5f}')

print(f'Faulty avg error: {faulty_errors.mean():.5f}')

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 16

 print(f'Threshold: {threshold:.5f}')

print(f'Anomalies detected: {(faulty_errors > threshold).sum()}/{len(faulty_data)}')

■ Industry Example: Ludhiana-based bicycle part manufacturers use autoencoders on

CNC machine sensor data to detect anomalies before a machine breaks down —
■ INDUST preventing costly production halts. Banks use them to flag suspicious credit card
RY transactions in real-time.

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 17

 MODULE 4 CHAPTER 6

GPU Acceleration
Giving AI a Turbo Boost

■ CPU vs GPU — What's the Difference?

A CPU is like a single super-smart professor who does one task brilliantly but one
at a time. A GPU is like 10,000 average students all working simultaneously.

■ ANALO Training neural networks needs millions of simple math operations — perfect for
GY GPU's parallel power!

Feature CPU GPU

Cores 4-64 cores Thousands of cores (e.g., 10,496)

Best For Complex sequential tasks Massively parallel tasks

Speed for DL Baseline (1x) 50-100x faster!

Examples Intel i9, AMD Ryzen NVIDIA RTX 4090, Tesla V100

Cost Rs. 20,000-80,000 Rs. 80,000-10,00,000+

■■ Free GPU Options for Students

Platform Free GPU? How to Use Best For

Google Colab Yes (T4/V100) [Link] All projects

Kaggle Kernels Yes (30 hrs/week) [Link]/code Competitions

Paperspace Gradient Free tier [Link] Larger projects

Lightning AI Free tier [Link] PyTorch users

■ Check GPU in Jupyter / Colab

Cell — Check GPU
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

import tensorflow as tf

# Check if GPU is available

gpus = [Link].list_physical_devices('GPU')

if gpus:

print(f'GPU found: {gpus[0].name}')

print('Training will be FAST!')

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 18

 else:

print('No GPU found. Using CPU.')

print('Consider using Google Colab for GPU access!')

# In Google Colab, go to:

# Runtime → Change Runtime Type → GPU → Save

■ Pro Tip: For this course, Google Colab is perfect — it gives you FREE GPU access.
Just go to [Link], sign in with Gmail, and you're ready. All
■ TIP TensorFlow code in this module will work there!

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 19

 MODULE 4 CHAPTER 7

Real-World Projects & Case Studies

Apply What You've Learned

■ Industry Case Studies

■ Defect Detection in Manufacturing (CNN)
Ludhiana produces bicycle parts, hosiery, and auto components. A CNN model is trained on
thousands of images of good and defective parts. A camera on the production line takes photos,
the CNN classifies each part as PASS or FAIL, and rejects defective ones automatically —
replacing 3 human inspectors per shift.

■ Data: Product images (good vs bad)

■ Model: CNN (like our Module 4 example)
■ Output: PASS/FAIL + defect location
■ Impact: 40% reduction in defective shipments

■ Sales Forecasting (LSTM/RNN)

A textile company in Ludhiana wants to predict next month's fabric demand. An LSTM model is
trained on 3 years of past sales data (seasonal patterns, festivals). It predicts demand 30 days
ahead — helping the company order raw materials efficiently.

■ Data: Daily sales, festivals, weather

■ Model: LSTM (sequence data)
■ Output: Predicted demand per item
■ Impact: 25% reduction in inventory costs

■ Fraud Detection (Autoencoder)

A payment gateway processes lakhs of transactions daily. An autoencoder is trained only on
legitimate transactions. Fraudulent transactions have high reconstruction error and get flagged
within milliseconds.

■ Data: Transaction amount, time, location

■ Model: Autoencoder
■ Output: Anomaly score per transaction
■ Impact: Blocked 94% of fraudulent transactions

■ Module 4 Mini Project Ideas

Project 1: Build a digit recognizer using CNN on MNIST — wrap it in a simple web form using
Gradio

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 20

 Project 2: Train an LSTM to predict next day temperature using Indian city weather data
(Kaggle)
Project 3: Use Autoencoder to detect anomalies in manufacturing sensor data (simulate with
random data)
Project 4: Build a cat vs dog classifier using pre-trained VGG16 CNN (Transfer Learning)
Project 5: Create a handwriting identifier for your own name using CNN

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 21

 MODULE 4 CHAPTER 8

Quick Revision Cheat Sheet

Everything You Need to Remember — At a Glance

■ When to Use Which Network?

Network Best For Key Advantage Example

ANN Tabular / structured data Flexible, general purpose Predict loan default

CNN Images, spatial data Detects local patterns Product defect detection

RNN / LSTM Sequences, time series Has memory across time Stock prediction

Autoencoder Compression, anomaly detection Unsupervised learning Fraud detection

■ Key Vocabulary — Quick Reference

Term One-Line Explanation

Neuron Basic unit — takes inputs, does math, outputs a number

Layer Group of neurons working together

Weight How important an input is (learned automatically)

Epoch One full pass through all training data

Batch Size How many samples to process at once before updating weights

Overfitting Model memorizes training data but fails on new data

Dropout Randomly turn off some neurons during training to prevent overfitting

relu Activation: output = max(0, x) — most common hidden layer activation

sigmoid Activation: output between 0-1 — used for yes/no outputs

softmax Activation: outputs probabilities summing to 1 — multi-class classification

Loss Function Measures how wrong the model is — we minimize this

Adam Optimizer Smart algorithm that adjusts learning rate automatically

Transfer Learning Use a pre-trained model and fine-tune it for your task

■ Final Message: Deep Learning is not magic — it's just math with many layers. Start
with the code examples, run them in Jupyter/Colab, change numbers, observe what

■ MESSA happens. The best way to learn is by breaking things and fixing them. You've got this!
GE ■

CICU — Applied AI & Machine Learning Module 4: Deep Learning | Page 22