CSM422:DEEP LEARNING

L:2 T:0 P:2 Credits:3

Course Outcomes: Through this course students should be able to

CO1 :: identify neural network components/types, design perceptron for classification, analyze
parameter/hyperparameter impact, evaluate architectures/activation functions, and develop
comprehensive evaluation plans for neural network models.

CO2 :: demonstrate the information flow in artificial neural networks (ANNs) and the feedforward
process. Specify the dimensions, representations, and relationships of weight matrices, biases,
inputs, and outputs in various layers of ANNs for image recognit

CO3 :: apply backpropagation in neural networks, update parameters using the gradient descent
algorithm, and minimize loss functions
CO4 :: illustrate knowledge of CNNs and their widespread applications in computer vision,
including image classification and object detection tasks

CO5 :: analyze CNN models in Keras and Python for image classification, evaluate pooling
strategies, examine model performance, and select customized CNN architectures with specific
training plans
CO6 :: explain the knowledge of architecture of RNNs and their variants, including bidirectional
RNNs and LSTMs. Train RNNs by mitigating vanishing/exploding gradients and analyzing the
characteristics and structures of RNN cells such as GRU

Unit I
Introduction to Neural Networks : Neural Networks - Inspiration from the Human Brain,
Introduction to Perceptron, Binary Classification using Perceptron, Perceptrons - Training, Multiclass
Classification using Perceptrons, Working of a Neuron, Inputs and Outputs of a Neural Network,
Assumptions made to Simplify Neural Networks, Parameters and Hyperparameters of Neural
Networks, Activation Functions
Unit II
Applying Neural Networks : Flow of Information in Neural Networks - Between 2 Layers,
Information Flow - Image Recognition, Comprehension - Count of Pixels, Learning the Dimensions
Weight Matrices, Feedforward Algorithm, Vectorized Feedforward Implementation, Understanding
Vectorized Feedforward Implementation
Unit III
Training Neural Networks : What Does Training a Network Mean?, Complexity of the Loss Function,
Comprehension - Training a Neural Network, Updating the Weights and Biases, Sigmoid
Backpropagation, Batch in Backpropagation, Training in Batches
Unit IV
Introduction to Convolutional Neural networks : A Specialized Architecture for Visual Data,
Applications of CNNs, Understanding the Visual System of Mammals, Introduction to CNNs, Reading
Digital Images, Video Analysis, Understanding Convolutions, Stride and Padding, Important Formulas
Unit V
Applying Convolutional Neural Networks : Weights of a CNN, Feature Maps, Pooling, Putting the
Components Together, Building CNNs in Keras - MNIST, Comprehension - VGG16 Architecture, CIFAR-
10 Classification with Python
Unit VI
Recurrent neural Networks : What are Sequences?, What Makes the Network Recurrent,
Architecture of an RNN, Feeding Sequences to RNNs, Comprehension: RNN Architecture, Trainable
Parameters in RNN, Types of RNNs, Training RNNs, Vanishing and Exploding Gradients in RNNs,
Bidirectional RNNs, Long Short-term Memory Networks, Characteristics of an LSTM Cell, Structure of
an LSTM Cell, Gated Recurrent Unit (GRU)

List of Practicals / Experiments:

List of practicals
• Write a program to implement perceptron in multiclass classification.

• Write a program to evaluate the performance of a multiclass perceptron model.

Session 2024-25 Page:1/2

 • Write a program to access and modify the weights and biases of a neural network in Python using a
popular deep learning library like TensorFlow or PyTorch.
• Write a program to implement the feedforward algorithm for a simple single-layer perceptron (SLP) in
Python.
• Write a program to implement the feedforward algorithm for a multi-layer perceptron (MLP) with
multiple hidden layers in Python.
• Write a program to analyze how does the choice of activation functions affect the dimensions and
learning of weight matrices.
• Implement a simple batch gradient descent algorithm in Python for linear regression.

• Implement the backpropagation algorithm with sigmoid activation function for a single layer neural
network in Python.
• Write a program to implement padding in a 2D convolution using TensorFlow or PyTorch.

• Write a Python function to perform max pooling on a given input feature map, using a specified pool
size and stride.
• Write a program to implement common layers used in CNNs for MNIST classification, and how are
they configured in Keras.
• Write a program to implement the sigmoid, ReLU activation function in Python

• Write a program to Implement a convolutional neural network (CNN) to classify images from datasets
like CIFAR-10 or MNIST. Fine-tune a pre-trained model (e.g., VGG16, ResNet) on a new dataset.
Classify handwritten digits (0-9) from the MNIST dataset.
• Write a program to Apply deep learning to classify diseases from medical images (e.g., X-rays,
MRIs).Use segmentation models to identify tumours or other abnormalities. Implement the function
to calculate the number of feature maps in a convolutional layer given the input shape, kernel size,
and number of filters.
• Write a program to Implement a Generative Adversarial Network (GAN) to generate new images.
Train a Variational Autoencoder (VAE) for generating new samples from a dataset.
• Create a Python function that demonstrates the problem of exploding gradients in RNNs. The function
should create an RNN model, initialize its weights with large random values, and generate a sequence
of data that triggers the exploding gradients issue. The function should then print out the gradients of
the model's parameters before and after applying gradient clipping

Text Books:
1. BEGINNING WITH DEEP LEARNING USING TENSORFLOW by MOHAN KUMAR
SILAPARASETTY, BPB PUBLICATIONS
References:
1. DEEP LEARNING : by JOHN D. KELLEHER, MIT Press

2. APPLIED DEEP LEARNING by DR. RAJKUMAR TEKCHANDANI, DR. NEERAJ KUMAR, BPB
PUBLICATIONS

Session 2024-25 Page:2/2