i

Deep Learning using TensorFlow

A Report on Virtual Internship facilitated by the APSCHE

Deep Learning using TensorFlow

Submitted in partial fulfilment of the requirements for the award of the degree of

BACHELOR OF TECHNOLOGY

IN

COMPUTER SCIENCE AND ENGINEERING

Submitted by

SATHISH SUNKARA

21A31A05J1

Under the Guidance of

Mrs D. Kanaka Mahalakshmi Devi
Associate Professor

DEPARTMENT OF CSE

PRAGATI ENGINEERING COLLEGE

(AUTONOMOUS)

(Approved by AICTE & Permanently Affiliated to JNTUK, Kakinada &Accredited by

NAAC) 1-378, ADB Road, Surampalem, E.G.Dist., A.P, Pin -533437.

2021-2025
i
Deep Learning using TensorFlow

PRAGATI ENGINEERING COLLEGE

(AUTONOMOUS)

(Approved by AICTE & Permanently Affiliated to JNTUK, Kakinada &Accredited by

NAAC)

1-378, ADB Road, Surampalem, E.G.Dist., A.P, Pin -533437.

DEPARTMENT OF CSE

CERTIFICATE

This is to certify that the report entitled ―Deep Learning using TensorFlow, that is being
submitted by Sathish Sunkara of IV Year II Semester bearing roll number (21A31A05IJ1,
in partial fulfilment for the award of the Degree of Bachelor of Technology in Computer
Science and Engineering, Pragati Engineering College is a record of bonafide work carried out
by him.

Supervisor Head of the Department

Mrs D. Kanaka Mahalakshmi Devi Dr. D. V. Manjula

Associate Professor Associate Professor & HOD
Department of CSE Department of CSE
ii
Deep Learning using TensorFlow

TABLE OF CONTENTS
Page Number

1. Abstract 6

2 Introduction 7–8

2.1 What is Deep Learning

2.2. Trends in Deep Learning
2.3. Python for Deep Learning

3 Foundations of Deep Learning

3.1. Neural Networks and perceptron 9 - 10

Problem Formulation
3.2. Forward and Backward Propagation
3.3. Loss Functions in Deep Learning
3.4 Activation Functions
4. Computer Vision with TensorFlow 11 - 13
4.1. Introduction to TensorFlow
4.2. Convolutional Neural Networks (CNNS)
4.3 Workflow for Image Classification
5. Activity Log
5.1. Week 1 14 -15
5.2. Week 2 16 - 17
5.3. Week 3 18 – 19
5.4. Week 4 20 - 21
5.5. Week 5 22 - 23
5.6. Week 6 24 - 25
5.7. Week 7 26 - 27
5.8. Week 8 28 -29
5.9. Week 9 30 - 31
5.10. Week 10 32 - 33
5.11. Week 11 34 - 35
5.12. Week 12 36 - 37
5.13. Week 13 38 - 39
5.14. Week 14 40 - 41
5.15. Week 15 42 - 43
5.16. Week 16 44 - 45
6. Conclusion 46

iii
Deep Learning using TensorFlow

ACKNOWLEDGEMENT

It gives me an immense pleasure to express a deep sense of gratitude to my Guide, Mrs D.

Kanaka Mahalakshmi Devi, Associate Professor in the Department of Computer Science &
Engineering because of his wholehearted and invaluable guidance throughout the report.
Without his sustained and sincere effort, this report would not have taken this shape. He
encouraged and helped me to overcome various difficulties that I have faced at various stages
of my report.

I would like to sincerely thank Mr. Sayantan Kar, Assistant Professor, and Department
Internship Coordinator of Computer Science & Engineering for providing all the necessary
facilities that led to the successful completion of my report.

I would like to sincerely thank Dr. D. V. Manjula, Associate Professor and HOD, Computer
Science & Engineering for providing all the necessary facilities that led to the successful
completion of my report.
I wish to express our special thanks to my beloved Dr. G. Naresh, Professor and Principal for
giving guidelines and encouragement.

I wish to express my special thanks to our beloved Dr. K. Satyanarayana, Professor and
Director (Academics)for giving guidelines and encouragement.

I wish to express sincere gratitude to our beloved and respected Dr. P. KRISHNARAO,
Chairman and Sri. M.V. HARANATHA BABU, Director (Management) and Sri M.
SATISH, Vice-President for their encouragement and blessings.

I am thankful to all the faculty members of the department for their valuable suggestions. My
sincere thanks are also extended to all the teaching and non-teaching staff of Pragati
Engineering College. I also thank my parents whose continuous support has helped in the
successful completion of the project.

Sunkara Sathish

4
Deep Learning using TensorFlow

21A31A05J1

APSCHE Domain Virtual Internship Certificate

5
Deep Learning using TensorFlow

6
Deep Learning using TensorFlow

ABSTRACT

Deep learning, a subset of machine learning, has emerged as a transformative technology for
solving complex problems across a wide range of domains, including computer vision,
natural language processing (NLP), and speech recognition. Leveraging artificial neural
networks, deep learning models are capable of automatically learning from vast amounts of
data, uncovering intricate patterns that traditional machine learning algorithms might miss.
TensorFlow, an open-source framework developed by Google, has become a leading tool in
the deep learning community, offering a comprehensive environment for building, training,
and deploying these sophisticated models.
It explores the foundational aspects of deep learning, with a particular focus on how
TensorFlow enables the implementation of neural networks such as Convolutional Neural
Networks (CNNs) and Recurrent Neural Networks (RNNs). TensorFlow’s capabilities,
including automatic differentiation, scalability across CPUs and GPUs, and optimization
tools, make it an ideal choice for developers and researchers. The framework’s flexibility
allows for the development of a wide variety of deep learning models, from image
classification and object detection to language translation and text generation.
Through practical examples, the study demonstrates TensorFlow’s core strengths, such as its
efficient handling of large datasets, ability to run on multiple processors, and its support for
deploying models on diverse platforms. The integration of tools like TensorFlow Lite for
mobile devices and TensorFlow Serving for real-time model deployment further underscores
the platform's versatility in production environments. The paper emphasizes TensorFlow’s
role in simplifying the model-building process while ensuring that the models remain highly
performant, making it a preferred choice in both academic research and industry applications.
TensorFlow provides an accessible yet powerful framework that supports a wide array of
deep learning tasks, making it a cornerstone of modern AI development. Its robust ecosystem
not only facilitates the creation of complex neural networks but also streamlines the
deployment process, ensuring that AI-driven solutions can be efficiently integrated into real-
world applications. This study highlights how TensorFlow empowers developers and
researchers to push the boundaries of artificial intelligence with greater ease and flexibility.

7
Deep Learning using TensorFlow

2. INTRODUCTION

Deep Learning, a subset of Machine Learning, focuses on artificial neural networks to model
complex patterns and decision-making processes. It powers applications in healthcare, finance,
autonomous systems, and more by learning from large datasets and making predictions with
minimal human intervention.

2.1 WHAT IS DEEP LEARNING?

Deep Learning uses multiple layers of artificial neural networks (ANNs) to extract high-level
features from raw data. It is particularly effective for tasks such as image recognition, natural
language processing (NLP), speech recognition, and medical diagnosis.

2.1.2 APPLICATIONS OF DEEP LEARNING

• HEALTHCARE: Medical imaging analysis, disease detection, and predictive diagnostics
using CNNs and RNNs.
• AUTONOMOUS SYSTEMS: Self-driving cars use deep learning for object detection,
navigation, and decision-making.
• FINANCE: Fraud detection, algorithmic trading, and risk assessment through deep learning
models.
• NATURAL LANGUAGE PROCESSING (NLP): Chatbots, sentiment analysis, and AI-
driven language models like GPT.
• COMPUTER VISION: Face recognition, object detection, and medical imaging
classification using convolutional neural networks (CNNs). DIFFERENCE BETWEEN
MACHINE LEARNING AND DEEP LEARNING

2.2 TRENDS IN DEEP LEARNING

• Transformers & Large Language Models (LLMs): The rise of models like GPT, BERT, and
Vision Transformers (ViTs).
• Self-Supervised Learning (SSL): Models that learn representations without labeled data.
• Edge AI: Deploying deep learning models on edge devices for real-time processing
. • Explainable AI (XAI): Improving transparency and interpretability of neural networks.

8
Deep Learning using TensorFlow

2. .2.2 DIFFERENCE BETWEEN MACHINE LEARNING AND DEEP LEARNING

• MACHINE LEARNING (ML): Traditional ML models (e.g., Decision Trees, SVM, Random
Forest) rely on feature engineering and structured data.
• DEEP LEARNING (DL): Utilizes neural networks (e.g., CNN, RNN, Transformer) to
automatically extract features from raw data and handle large-scale unstructured datasets. 18
TRENDS IN DEEP LEARNING
• Transformers & Large Language Models (LLMs): The rise of models like GPT, BERT, and
Vision Transformers (ViTs).
• Self-Supervised Learning (SSL): Models that learn representations without labeled data.
• Edge AI: Deploying deep learning models on edge devices for real-time processing.
• Explainable AI (XAI): Improving transparency and interpretability of neural networks.

2.3 PYTHON FOR DEEP LEARNING

Python is the primary language for Deep Learning development, providing powerful
frameworks like:
• TensorFlow & Keras: High-performance deep learning libraries for building, training, and
deploying models
• PyTorch: A flexible framework for deep learning research and experimentation.
• OpenCV & NumPy: Essential tools for image processing and numerical computation.

9
Deep Learning using TensorFlow

3. FOUNDATIONS OF DEEP LEARNING

3.1 Neural Networks and Perceptron Problem Formulation

• Deep learning models solve complex problems like image recognition, speech
processing, and disease prediction.
• The goal is to build models that learn patterns from data and make accurate
predictions.
• Example: Predicting whether a CT scan contains a tumor (binary classification).
Data- Driven Approach
• Neurons: The basic building blocks of neural networks. Each neuron receives
inputs, applies weights, and outputs an activation.
• Perceptron: The simplest form of a neural network with a single layer. It is a linear
classifier used for binary classification.
• Limitations of Perceptron: It can only solve linearly separable problems (e.g., NOT
XOR logic). 19 Mathematical Representation of a Neuron (Perceptron Model) o A
neuron computes the weighted sum of inputs and applies an activation function:
y=f(WX+b)y = f(WX + b)y=f(WX+b) where:
• XXX = Input features
• WWW = Weights
• bbb = Bias term
• fff = Activation function
3.2 Forward and Backward Propagation Forward Propagation
a. Inputs are multiplied by weights and biases.
b. The weighted sum is passed through an activation function.
c. The output is computed and compared to the true label.
d. Loss (error) is calculated using a loss function.
Example for a single neuron:
y=f(w1x1+w2x2+b)y = f(w_1x_1 + w_2x_2 + b)y=f(w1x1+w2x2+b)
Backward Propagation (Error Correction)
Adjusts weights using Gradient Descent to reduce error.
Calculates the gradient of the loss function with respect to each weight.
Uses partial derivatives to update weights in the opposite direction of the gradient.
Ensures the model improves over multiple training epochs.

10
Deep Learning using TensorFlow

3.3 Loss Functions in Deep Learning: Loss functions measure how well the model performs.
Types of Loss Functions
1. For Regression Problems:
o Mean Squared Error (MSE): MSE=1N∑i=1N(yi−y^i)2MSE = \frac{1}{N}
\sum_{i=1}^{N} (y_i - \hat{y}_i)^2MSE=N1i=1∑N(yi−y^i)2 o Mean Absolute Error
(MAE): MAE=1N∑i=1N∣yi−y^i∣MAE = \frac{1}{N}
\sum_{i=1}^{N} |y_i - \hat{y}_i|MAE=N1i=1∑N∣yi−y^i∣
2. For Classification Problems: o Binary Cross-Entropy (for 2 classes):
L=−1N∑i=1N[yilog⁡(y^i)+(1−yi)log⁡(1−y^i)]L = -\frac{1}{N} \sum_{i=1}^{N} [y_i \
log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i)]L=−N1i=1∑N
[yilog(y^i)+(1−yi)log(1−y^i)] o Categorical Cross-Entropy (for multiple classes):
L=−∑yilog⁡(y^i)L = -\sum y_i
\log(\hat{y}_i)L=−∑yilog(y^i)
3.3 Activation Functions
Activation functions introduce non-linearity, allowing neural networks to learn
complex patterns. Types of Activation Functions
1.Sigmoid Function (Used for binary classification)
f(x)=11+e−xf(x) = \frac{1}{1 + e^{-x}}f(x)=1+e−x1
o Output range: 000 to 111.
o Causes vanishing gradients (small updates for deep networks).
2.ReLU (Rectified Linear Unit) (Most widely used)
f(x)=max⁡(0,x)f(x) = \max(0, x)f(x)=max(0,x)
o Prevents vanishing gradients.
o Computationally efficient.
3.Tanh (Hyperbolic Tangent) Function
f(x)=ex−e−xex+e−xf(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}
f(x)=ex+e−xex−e−x
o Output range: −1-1−1 to 111, centered around zero.
4.Softmax (For multi-class classification)
f(xi)=exi∑exjf(x_i)=\frac{e^{x_i}}{\sum e^{x_j}}
f(xi)=∑exjexi
o Converts raw scores into probabilities.

11
Deep Learning using TensorFlow

4. COMPUTER VISION WITH TENSORFLOW

4.1 Introduction to Computer Vision

Problem Formulation
• Computer Vision focuses on enabling machines to interpret and understand visual
data.
• Problems include:
o Image Classification (e.g., Identifying whether a CT scan contains a tumor)
o Object Detection (e.g., Detecting cancerous regions in medical images) o
Segmentation (e.g., Identifying organ boundaries in MRI scans)
Data-Driven Approach
• Image data is represented as a matrix of pixel values (grayscale or RGB).
• Preprocessing techniques (resizing, normalization, augmentation) are crucial for
better model performance.

4.2 Convolutional Neural Networks (CNNs)

Why CNNs?
• Traditional ANNs cannot handle high-dimensional image data efficiently.
• CNNs use spatial hierarchies to detect patterns like edges, textures, and shapes.
CNN Architecture Components

1. Convolutional Layer:
• Extracts spatial features from an image using filters (kernels).
• Computes feature maps through convolution operations.
Mathematical Formula:
Y(i,j) = ∑m∑nX(i+m,j+n) K(m,n)Y(i, j) = \sum_{m}\sum_{n} X(i+m, j+n) \cdot K(m,
n)Y(i,j )= m∑n∑X(i+m,j+n) K(m,n)  where: o XXX = input image o KKK = kernel
o YYY = feature map o
2. Activation Function (ReLU):
 Introduces non-linearity to improve learning.
3. Pooling Layer (Max Pooling):
• Reduces spatial dimensions while preserving key features.

12
Deep Learning using TensorFlow

• Max Pooling takes the highest value in a region.

4. Fully Connected (FC) Layer:
 Maps extracted features to class labels.
5. Softmax Layer:
 Converts final outputs into probabilities.

4.3 Workflow for Image Classification with CNNs

1. Data Collection
• Gather labeled image datasets (e.g., Chest X-ray, CT scans).
• Example dataset: Lung Cancer CT Scans Dataset.
2. Data Preprocessing
• Resizing images to a standard size (e.g., 224x224 pixels).
• Normalization (scaling pixel values to [0,1] range).
• Data Augmentation to improve model generalization:
o Rotation, flipping, zooming, contrast adjustments.

Fig1: Model Development (CNN Architecture in TensorFlow)

13
Deep Learning using TensorFlow

4. Training and Optimization

Hyperparameter Tuning
• Batch size: Determines how many images are processed at a time.
• Learning rate: Controls the step size for weight updates.
• Epochs: Number of times the model sees the full dataset.
5. Model Evaluation and Validation
Evaluation Metrics
• Accuracy: Percentage of correctly classified images.
• Precision & Recall: Important for medical applications where false negatives can be
critical.
• Confusion Matrix: Visualizes model performance. 6. Transfer Learning for Improved
Performance Why Transfer Learning?
• CNNs trained from scratch need large datasets and high computing power.
• Transfer learning allows us to use pretrained models like VGG16, ResNet, Inception for
feature
7.Object Detection with TensorFlow What is Object
Detection?
• Identifies objects within an image and draws bounding boxes.
• Used in medical imaging, autonomous vehicles, security systems.
Popular Object Detection Models
• YOLO (You Only Look Once) – Real-time detection.
• Faster R-CNN – High accuracy, slower speed.
• SSD (Single Shot MultiBox Detector) – Balances speed and accuracy
8.Segmentation with U-Net (Medical Imaging
Applications) What is Image Segmentation?
• Pixel-wise classification to identify regions of interest.
• Used in tumor segmentation in CT/MRI scans.
U-Net Architecture
• Encoder (Feature Extraction)
• Bottleneck (Deep Feature Representation)
• Decoder (Reconstructs segmented output

14
Deep Learning using TensorFlow

ACTIVITY LOG FOR THE FIRST WEEK

WEEK 1: FROM: 18-11-2024 TO: 23-11-2024

Day Brief description of the daily activity Learning Outcome

Day 1 Platform setup, jupyter notebook, vscode Understanding key

setup, GPU, Intro of deeplearning
concepts and
implementation

Day 2 History and importance of deep learning

Understanding key concepts
and implementation

Day 3 Perceptron and multilayer perceptron Understanding key concepts

and implementation

Day 4 Forward propagation and backward Understanding key concepts and

propagation implementation

Day 5 Vanish Gradient problem Understanding key concepts

and implementation

Day 6 Vanish Gradient problem class -2 Understanding key concepts and

implementation

Signature of the Guide

WEEKLY REPORT

WEEK-1(FROM: 18-11-2024 TO: 23-11-2024)

Objective of the activity done in week 1: The first week focused on introducing participants
to the fundamentals of deep learning while ensuring they had a fully functional development

15
Deep Learning using TensorFlow

environment. The training covered the history, importance, and key concepts of deep learning,
including perceptron, multi-layer perceptron, forward and backward propagation, and the
vanishing gradient problem. Additionally, participants were guided through platform setup,
including Jupyter Notebook, VS Code, and GPU configuration for deep learning experiments.

Detailed Report of Week 1:

Platform Setup

The training began with setting up the development environment for deep learning projects.
Participants installed and configured Jupyter Notebook for interactive coding and model 42
experimentation, VS Code for writing Python scripts and debugging deep learning models, and
GPU setup with CUDA, cuDNN, and TensorFlow/PyTorch to enable GPU acceleration for
model training. Anaconda was used to set up a virtual environment to manage dependencies
effectively. This setup ensured that participants had a fully functional Python-based deep
learning workspace, capable of handling large-scale computations. The first week of training
laid a strong foundation in Deep Learning, starting with the Platform Setup, ensuring all
participants had Jupyter Notebook and VS Code properly configured. The session also covered
GPU Setup, emphasizing the need for powerful hardware to accelerate computations for deep
learning models. The introduction to Deep Learning traced its History, from early Artificial
Neural Networks (ANNs) to modern-day deep learning architectures. A core focus was on
Forward Propagation, where data moves from input through hidden layers to produce an
output. Participants learned about Weights, Biases, and Activation Functions, such as Sigmoid,
Tanh, and ReLU, which introduce non-linearity into neural networks, allowing them to learn
intricate patterns. The session emphasized how each neuron applies an activation function to
transform data, ensuring that the network can capture complex relationships within the input
features.

The week concluded with a practical Hands-on Implementation, where participants applied
Forward and Backward Propagation using a simple neural network model, observed how Loss
Functions evolve during training, and experimented with different Optimizers to enhance
model performance.
ACTIVITY LOG FOR THE SECOND WEEK

WEEK 2: FROM: 25-11-2024 TO: 30-11-2024

16
Deep Learning using TensorFlow

Day Brief description of the daily activity Learning Outcome

Day 1 Activation functions 1 Understanding key

concepts and
implementation

Day 2 Activation functions 2

Understanding key concepts
and implementation

Day 3 Loss functions Regression Understanding key concepts

and implementation

Day 4 Loss functions Classification Understanding key concepts and

implementation

Day 5 RMSprop advantages Understanding key concepts

and implementation

Day 6 Optimizers-1 Understanding key concepts and

implementation

Signature of the Guide

17
Deep Learning using TensorFlow

WEEKLY REPORT

WEEK-2 (FROM: 25-11-2024 TO: 30-11-2024)

Objective of the activity done in week 2: The second week aimed to enhance participants'
understanding of deep learning by focusing on Activation Functions, Loss Functions, and
Optimizers. The curriculum covered different types of activation functions, their significance,
regression and classification loss functions, and optimization techniques. This comprehensive
exploration was designed to improve participants' proficiency in training deep learning models
effectively.

Detailed Report of week 2:

Throughout the week, participants engaged in intensive training sessions that covered the role
of activation functions, loss functions, and optimizers in neural networks. The training began
with an introduction to Activation Functions-1, covering Sigmoid, Tanh, and ReLU (Rectified
Linear Unit). Participants learned that activation functions introduce non-linearity into neural
networks, enabling them to learn complex patterns. Sigmoid Activation was discussed in detail,
highlighting its role in compressing values between 0 and 1 but also its major drawback—the
vanishing gradient problem. Tanh Activation was explored as an improvement over Sigmoid,
mapping values between -1 and 1 but still suffering from similar gradient issues in deep
networks. The training then progressed to Activation Functions-2, where more advanced
activation functions such as Leaky ReLU, Parametric ReLU (PReLU), and Swish were
introduced. Leaky ReLU was highlighted for overcoming the dying ReLU problem by allowing
small gradients for negative values. Following the activation functions, the training transitioned
to Loss Functions for Regression, which are crucial for evaluating model performance.
Participants explored Mean Squared Error (MSE), Mean Absolute Error (MAE), and Huber
Loss, understanding their differences and use cases.

The week concluded with hands-on experiments where participants implemented and compared
different Activation Functions, Loss Functions, and Optimizers in training deep learning
models. By the end of the week, participants had gained a thorough understanding of how
activation functions affect learning, how loss functions measure model performance, and how
optimizers improve training efficiency, setting the foundation for more advanced topics in deep
learning.

18
Deep Learning using TensorFlow

ACTIVITY LOG FOR THE THIRD WEEK

WEEK 3: FROM: 2-12-2024 TO: 7-12-2024

Day Brief description of the daily activity Learning Outcome

Day 1 Optimizers-2 Understanding key

concepts and
implementation

Day 2 Project Structure on ANN for regression

Understanding key concepts
and implementation

Day 3 Car price prediction Understanding key concepts

and implementation

Day 4 Laptop price prediction Understanding key concepts and

implementation

Day 5 Project structure on ANN for classification Understanding key concepts

and implementation

Day 6 Project structure on ANN for classification Understanding key concepts and
implementation

Signature of the Guide

WEEKLY REPORT

WEEK-3 (FROM: 2-12-2024 TO: 7-12-2024)

19
Deep Learning using TensorFlow

Objective of the activity done in week 1: The third week aimed to strengthen participants'
knowledge of optimizers, artificial neural networks (ANNs) for regression and classification,
and practical implementations of deep learning models. The curriculum covered advanced
optimization techniques, structured ANN models for car price and laptop price prediction, and
classification tasks. This hands-on learning experience was designed to enhance participants'
ability to build and deploy ANN-based predictive models.

Detailed Report of week 3:

The training began with an advanced discussion on Optimizers-2, focusing on techniques such
as AdamW, Nadam, AdaDelta, and Lookahead Optimizer. AdamW, a weight-decay variant of
Adam, was introduced to address overfitting issues by incorporating proper L2 regularization.
Nadam (Nesterov-accelerated Adaptive Moment Estimation) was explored for its ability to
accelerate convergence by incorporating Nesterov momentum. AdaDelta was covered as an
improvement over Adagrad, helping in situations where learning rates decay too aggressively.
Finally, the Lookahead Optimizer was introduced, showing its effectiveness in stabilizing
updates and improving convergence by reducing oscillations during training. The training then
transitioned to Project Structure on ANN for Regression, where participants learned the
fundamental steps required to build an ANN-based regression model. The importance of feature
selection, normalization, and loss function choice (such as MSE or MAE) was highlighted.
Participants gained insights into designing fully connected neural networks (FCNNs) with
multiple layers and activation functions like ReLU and Leaky ReLU to improve performance in
regression tasks. The project followed an end-to-end pipeline, including data collection,
cleaning, feature scaling, and one-hot encoding of categorical variables. Model evaluation was
done using MSE and R-squared scores to assess prediction accuracy. Participants also explored
hyperparameter tuning using GridSearchCV and KerasTuner to optimize the model’s
performance.

By the end of the week, participants had gained practical experience in building and structuring
ANN-based regression and classification models, fine-tuning optimizers for improved
convergence, and applying real-world predictive modeling techniques for pricing estimation.

ACTIVITY LOG FOR THE FOURTH WEEK

WEEK 4: FROM: 9-12-2024 TO: 14-12-2024

20
Deep Learning using TensorFlow

Day Brief description of the daily activity Learning Outcome

Day 1 Diabetes Classification project using ANN Understanding key

concepts and
implementation

Day 2 Intro to CNN, Padding,pooling

Understanding key concepts
and implementation

Day 3 Flatern layers, ,weight initialization Understanding key concepts

techniques and implementation

Day 4 CNN Architure lenet-5 Understanding key concepts and

implementation

Day 5 Alexnet Understanding key concepts

and implementation

Day 6 Weight Initialization Techniques Understanding key concepts and

implementation

Signature of the Guide

21
Deep Learning using TensorFlow

WEEKLY REPORT

WEEK-4 (FROM: 9-12-2024 TO: 14-12-2024)

Objective of the activity done in week 4: The fourth week aimed to provide participants with
hands-on experience in Diabetes Classification using ANN, along with an introduction to
Convolutional Neural Networks (CNNs). The training covered essential CNN concepts,
including padding, pooling, flatten layers, weight initialization techniques, and CNN
architectures such as LeNet-5 and AlexNet. This structured learning helped participants
develop a strong foundation in deep learning for both structured and unstructured data.

Detailed Report of week 4:

The week began with the Diabetes Classification Project using ANN, where participants
implemented an artificial neural network (ANN) model to classify patients as diabetic or non
diabetic based on medical attributes such as glucose levels, blood pressure, BMI, insulin levels,
and age. The dataset was preprocessed through handling missing values, feature scaling using
StandardScaler, and dealing with class imbalances using techniques like SMOTE (Synthetic
Minority Over-sampling Technique). The ANN architecture included multiple dense layers with
ReLU activation for hidden layers and sigmoid activation for the output layer, with binary
cross- entropy as the loss function. Model evaluation was performed using accuracy, precision,
recall, and AUC-ROC to measure its effectiveness. Participants learned about convolutional
layers, which apply filters to extract important patterns, and how CNNs reduce model
complexity while retaining essential features. Pooling layers, including max pooling (which
retains the most important features) and average pooling (which smooths feature maps), were
introduced to demonstrate how they help in dimensionality reduction and preventing
overfitting. The Flatten layer was explored, showing how it converts the 2D feature maps from
convolutional layers into a 1D vector for input into fully connected layers.

By the end of the week, participants had acquired practical experience in implementing an
ANN- based medical classification model, fundamental CNN operations, and an understanding
of classic CNN architectures like LeNet-5 and AlexNet.

22
Deep Learning using TensorFlow

ACTIVITY LOG FOR THE FIFTH WEEK

WEEK 5: FROM: 16-12-2024 TO: 21-12-2024

Day Brief description of the daily activity Learning Outcome

Day 1 VGG-16 Understanding key

concepts and
implementation

Day 2 INCEPTION V3
Understanding key concepts and
implementation

Day 3 RESNET50 Understanding key concepts and

implementation

Day 4 EFFICIENT NET Understanding key concepts and

implementation

Day 5 Image classification project cat vs dog Understanding key concepts and
implementation

Day 6 Classification using advanced deep learning Understanding key concepts and
models implementation

WEEKLY REPORT

WEEK-5 (FROM: 16-12-2024 TO: 21-12-2024)

Objective of the activity done in week 5: The fifth week aimed to enhance participants'
understanding of advanced CNN architectures by covering VGG-16, InceptionV3, ResNet-50,
and EfficientNet. The week also included a hands-on image classification project: Cat vs Dog,
where participants implemented these architectures to classify images. This training helped

23
Deep Learning using TensorFlow

participants gain practical knowledge in deep learning for image recognition while exploring
the evolution of CNN architectures for improved accuracy and efficiency.

Detailed Report of week 5:

The week began with an introduction to VGG-16, a deep convolutional neural network
(CNN) architecture that uses small 3×3 filters across multiple convolutional layers. Participants
learned about its sequential deep structure, uniform architecture design, and fully connected
layers that enhance feature extraction. They implemented VGG-16 for image classification,
leveraging pre-trained weights from ImageNet and fine-tuning it for specific datasets.

Next, the focus shifted to InceptionV3, an architecture designed to improve computational

efficiency and accuracy using the Inception module. Participants explored the concept of multi-
scale feature extraction, where multiple convolution filters of different sizes operate in parallel
within the same layer. They examined 1×1 convolutions for dimensionality reduction and how
factorized convolutions improve efficiency. The practical session involved applying
InceptionV3 for complex image classification tasks.

Following this, participants studied ResNet-50, a revolutionary deep learning model that
introduced residual learning to combat the vanishing gradient problem in deep networks.

By the end of the week, participants gained in-depth knowledge of state-of-the-art CNN
architectures, their advantages, and practical applications. They successfully implemented
image classification using advanced deep learning models, preparing them for real-world
computer vision challenges

ACTIVITY LOG FOR THE SIXTH WEEK

WEEK 6: FROM: 23-12-2024 TO: 28-12-2024

Signature of Guide

24
Deep Learning using TensorFlow

Day Brief description of the daily activity Learning Outcome

Day 1 Object detection terminology robo flow Understanding key concepts

and implementation

Day 2 Bound box, IOU

Understanding key concepts and
implementation

Day 3 Image segmentation Understanding key concepts and

implementation

Day 4 Yolo Architecture Understanding key concepts and

implementation

Day 5 Yolov11- custom image classification Understanding key concepts and

implementation

Day 6 Grid-based prediction Understanding key concepts and

implementation

WEEKLY REPORT

WEEK-6 (FROM: 23-12-2024 TO: 28-12-2024)

Objective of the activity done in week 6: The sixth week aimed to introduce participants to
object detection and image segmentation concepts, covering object detection terminology,
bounding box fundamentals, aspect ratio (UI ratio), and image segmentation techniques.
Participants explored Roboflow for dataset preprocessing and annotation and learned about the
YOLO (You Only Look Once) architecture, including its evolution. The week concluded with a
YOLOv11 custom image classification project, enabling participants to implement real-world
object detection models.

25
Deep Learning using TensorFlow

Detailed Report of week 6:

The week began with an introduction to object detection terminology, where participants
learned key concepts such as IoU (Intersection over Union), confidence score, anchor boxes,
single-shot detectors (SSD), and region-based CNNs (R-CNNs). They explored the difference
between object detection and image classification, emphasizing how detection identifies
multiple objects and their locations within an image rather than just classifying them. Next, the
focus shifted to bounding boxes and aspect ratio (UI ratio), which are critical in defining the
region where an object is located. Participants understood the importance of accurate bounding
box placement for model performance and learned how aspect ratio affects detection. They
practiced drawing bounding boxes manually and using automated tools in annotation platforms
like Roboflow. The training then covered image segmentation, a technique that goes beyond
object detection by classifying each pixel in an image. Participants explored the difference
between semantic segmentation (classifying each pixel into a category) and instance
segmentation (distinguishing individual objects of the same category).

Following this, participants were introduced to Roboflow, an AI-powered platform for image
dataset management and augmentation. They learned how to upload, preprocess, augment, and
export datasets for training object detection models. They applied data augmentation techniques
such as flipping, scaling, brightness adjustment, and rotation to improve model generalization.
By the end of the week, participants gained hands-on experience in object detection, dataset
annotation, YOLO training, and model deployment, preparing them for advanced computer
vision applications.
ACTIVITY LOG FOR THE SEVENTH WEEK

WEEK 7: FROM: 30-12-2024 TO: 4-1-2025

Day Brief description of the daily activity Learning Outcome

Signature of Guide

26
Deep Learning using TensorFlow

Day 1 Yolov11, custom object detection Understanding key concepts

and implementation

Day 2 Yolov11-brain tumor detection

Understanding key concepts and
implementation

Day 3 Yolov11-PEG detection project Understanding key concepts and

implementation

Day 4 Yolov11-image segmentation Understanding key concepts and

implementation

Day 5 Yolov11-object tracking Understanding key concepts and

implementation

Day 6 YOLOv11 for various applications Understanding key concepts and

implementation

WEEKLY REPORT

WEEK-7(FROM: 30-12-2024 TO: 4-1-2025)

Objective of the activity done in week 7: The seventh week aimed to provide participants
with a deep understanding of YOLOv11 and its applications in custom object detection, brain
tumor detection, PEG (Percutaneous Endoscopic Gastrostomy) detection, image segmentation,
and object tracking. The sessions covered YOLOv11 architecture, dataset preparation, model
training, and real-world deployment for various applications in medical imaging and object
tracking.

Detailed Report of week 7:

The training began with an introduction to YOLOv11, an advanced version of the YOLO (You
Only Look Once) object detection model. Participants explored its architecture, improvements
over previous YOLO versions, and how it achieves real-time detection with high accuracy. Key

27
Deep Learning using TensorFlow

advancements such as transformer-based feature extraction, attention mechanisms, and hybrid

CNN-Transformer networks were discussed.

The next session focused on custom object detection using YOLOv11. Participants learned how
to collect and annotate a dataset using Roboflow, perform data augmentation, and preprocess
images to improve model performance. They trained YOLOv11 on a custom dataset, optimized
hyperparameters, and evaluated the model using metrics like mean Average Precision (mAP),
recall, and Intersection over Union (IoU).

The training then covered PEG (Percutaneous Endoscopic Gastrostomy) detection using
YOLOv11. This project involved detecting medical tubes in X-ray and endoscopic images.
Participants curated annotated medical datasets, applied contrast enhancement techniques, and
trained YOLOv11 to identify PEG placements in real-time medical procedures. Post-processing
methods, including non-maximum suppression (NMS) and confidence score filtering, were
used to refine detections.

By the end of the week, participants gained expertise in YOLOv11 for various applications,
including custom object detection, medical imaging, image segmentation, and object tracking.
They successfully trained, optimized, and deployed YOLOv11 models for real-world use cases,
preparing them for advanced deep learning and computer vision projects.

Signature of Guide

28
Deep Learning using TensorFlow

ACTIVITY LOG FOR THE EIGHTH WEEK

WEEK 8: FROM: 6-1-2025 TO: 11-1-2025

Day Brief description of the daily activity Learning Outcome

Day 1 Project on YOLO-5 Understanding key concepts

and implementation

Day 2 Deteron_2_object detection

Understanding key concepts and
implementation

Day 3 Image segmentation with Sam2 model using Understanding key concepts and
yolo implementation

Day 4 Object detection using R-cnn Understanding key concepts and

implementation

Day 5 Mask R-cnn,U-NET Understanding key concepts and

implementation

Day 6 SAM2 Understanding key concepts and

implementation

WEEKLY REPORT

WEEK-8 (FROM: 6-1-2025 TO: 11-1-2025)

Objective of the activity done in week 8:

The THIS week focused on object detection and image segmentation using advanced deep
learning models. The training covered YOLOv5 for real-time detection, Detectron2 for object
detection, image segmentation with the SAM2 model using YOLO, object detection using R
CNN and Mask R-CNN, and medical image segmentation with U-Net. The objective was to

29
Deep Learning using TensorFlow

equip participants with the knowledge and practical skills required to build, train, and deploy
state-of-the-art object detection and segmentation models.

Detailed Report of week 8:

The training began with YOLOv5 (You Only Look Once), one of the fastest and most efficient
object detection models. Participants explored YOLOv5’s architecture, anchor boxes, feature
pyramids, and its capability to detect multiple objects in a single forward pass. They trained
YOLOv5 on custom datasets using Roboflow for dataset annotation and augmentation. The
implementation involved object detection in traffic surveillance, pedestrian detection, and
industrial defect inspection.

Following this, participants were introduced to Detectron2, a highly modular framework by

Facebook AI Research (FAIR) for object detection and segmentation. They implemented Faster
R-CNN, RetinaNet, and Mask R-CNN using Detectron2. The training emphasized model
customization, hyperparameter tuning, and performance evaluation using mAP (mean Average
Precision).

58 The next segment covered image segmentation using the SAM2 model with YOLO. This
session introduced Segment Anything Model (SAM), which leverages transformers for accurate
image segmentation. Participants used SAM with YOLOv5 to segment objects more precisely,
applying it to tasks like medical image segmentation and satellite image analysis.
By the end of the week, participants successfully implemented and optimized object detection
and image segmentation models using YOLOv5, Detectron2, R-CNN, Mask R-CNN, SAM2,
and U-Net. They also deployed trained models for real-world applications, including
autonomous systems, healthcare imaging, and industrial automation, gaining hands-on
experience in deep learning-based computer vision solutions.

Signature of the Guide

30
Deep Learning using TensorFlow

ACTIVITY LOG FOR THE NINTH WEEK

WEEK 9: FROM: 27-1-2025 TO: 1-2-2025

Day Brief description of the daily activity Learning Outcome

Day 1 RNN-NLP-tokens, types Understanding key concepts

and implementation

Day 2 RNN-NLP-Segmentation
Understanding key concepts and
implementation

Day 3 RNN-NLP-Data cleaning, html, url, Understanding key concepts and

stopwords implementation

Day 4 Onegram, bigram,ngrams Understanding key concepts and

implementation

Day 5 Bag of words,Word2vec Understanding key concepts and

implementation

Day 6 Sequence2seq Understanding key concepts and

implementation

31
Deep Learning using TensorFlow

WEEKLY REPORT

WEEK – 9 (FROM: 27-1-2025 TO: 1-2-2025)

Objective of the activity done in week 9:

This week focused on Recurrent Neural Networks (RNN) and their applications in Natural
Language Processing (NLP). The training covered text tokenization, segmentation, data
cleaning (removing HTML, URLs, stopwords, and emojis), n-gram models (unigram, bigram,
n-grams), Bag of Words (BoW), Word2Vec, and Sequence-to-Sequence (Seq2Seq) models. The
objective was to equip participants with the fundamental and advanced concepts of NLP,
enabling them to preprocess, analyze, and build deep learning models for text-based
applications.

Detailed Report of week 9:

The training began with an introduction to RNN in NLP, explaining how Recurrent Neural
Networks process sequential data by maintaining contextual memory. Participants explored the
architecture of RNNs, including hidden states and weight sharing, making them effective for
language modeling and sequence prediction.

The first core topic was text tokenization, which breaks down text into meaningful units called
tokens. Participants explored types of tokenization: word-level tokenization (splitting text into
words) and character-level tokenization (breaking text into individual characters). They also
studied subword tokenization (Byte Pair Encoding, SentencePiece) used in modern NLP
models.

Following tokenization, text segmentation was covered, demonstrating how texts are divided
into sentences or phrases for better processing. Various segmentation techniques, including
rule- based and machine-learning-based methods, were discussed.

The next segment focused on data cleaning, an essential step in NLP preprocessing. They
explored lemmatization and stemming, which reduce words to their base form to handle
variations in natural language. by the end of the week, participants had gained hands-on
experience in text preprocessing, feature extraction, and deep learning-based NLP models.
They successfully implemented techniques such as n-grams, Word2Vec, and Seq2Seq models

32
Deep Learning using TensorFlow

to develop language understanding systems for applications like sentiment analysis, text
classification, and machine translation.

ACTIVITY LOG FOR THE TENTH WEEK

WEEK 10: FROM: 3-2-2025 TO: 8-2-2025

Day Brief description of the daily activity Learning Outcome

Day 1 Sentiment classification-NLP Understanding key concepts

and implementation

Day 2 Transformer architecture

Understanding key concepts and
implementation

Day 3 LSTM Architecture Understanding key concepts and

implementation

Day 4 Google stock price using LSTM Understanding key concepts and
implementation

Day 5 GRU – Text classification using GRU Understanding key concepts and
implementation

Day 6 GRU-based text classification model Understanding key concepts and

implementation

Signature of the Guide

WEEKLY REPORT

33
Deep Learning using TensorFlow

WEEK – 10 (FROM: 3-2-2025 TO: 8-2-2025)

Objective of the activity done in week 10: The this week aimed to deepen participants'
understanding of Sentiment Classification in NLP, Transformer Architecture, LSTM for time-
series forecasting, and GRU for text classification. The objective was to equip participants with
the knowledge and hands-on experience needed to apply sequential deep learning models in
financial forecasting, NLP-based sentiment analysis, and text classification tasks

Detailed Report of week 10:

The training began with an introduction to Sentiment Classification using NLP, where
participants explored how to analyze textual data and classify it as positive, negative, or
neutral. They learned about text preprocessing techniques, tokenization, stopword removal, and
feature extraction methods such as Bag of Words (BoW), TF-IDF, and Word2Vec. The session
emphasized how deep learning-based models like LSTMs and GRUs outperform traditional
machine learning models (Logistic Regression, SVM, Naïve Bayes) in sentiment analysis.

Following this, the session transitioned to Transformer Architecture, a revolutionary model in

NLP that overcomes the limitations of RNNs and LSTMs by using self-attention mechanisms.
Participants explored the key components of transformers, including multi-head attention,
position-wise feed-forward networks, layer normalization, and positional encoding. The
architecture of BERT (Bidirectional Encoder Representations from Transformers) and GPT
(Generative Pretrained Transformer) was discussed, demonstrating their effectiveness in text
generation, translation, and summarization tasks.

By the end of the week, participants had a strong grasp of sentiment analysis, transformer models,
LSTM- based financial forecasting, and GRU-based text classification. They successfully implemented
deep learning models for NLP and time-series analysis

ACTIVITY LOG FOR THE ELEVENTH WEEK

34
Deep Learning using TensorFlow

WEEK 11: FROM: 10-2-2025 TO: 15-2-2025

Learning Outcome
Day Brief description of the daily activity

Day 1 GAN Understanding key concepts

and implementation

Day 2 Project on GAN

Understanding key concepts
and implementation
Day 3 Language Translation project Understanding key concepts
and implementation

Day 4 Basics of reinforcement learning Understanding key concepts

and implementation

Day 5 Model deployment Understanding key concepts and

implementation

Day 6 Reinforcement Learning (RL) Understanding key concepts

and implementation

Signature of the Guide

WEEKLY REPORT

WEEK – 11 (FROM: 10-2-2025 TO: 15-2-2025)

35
Deep Learning using TensorFlow

Objective of the activity done in week 11: The session aimed to introduce participants to
Generative Adversarial Networks (GANs), covering their architecture, working principles, and
practical applications. Additionally, participants explored Reinforcement Learning (RL) basics,
focusing on actions, rewards, and policy optimization. The session also included project-based
learning, such as GAN-based image generation and language translation using deep learning
models, followed by discussions on deployment strategies for real-world applications

Detailed Report of week 11:

The training began with an introduction to Generative Adversarial Networks (GANs),
explaining how they consist of two neural networks—Generator and Discriminator—
competing against each other to generate realistic data. Participants learned about the concept
of adversarial learning, where the generator tries to produce fake images that resemble real
ones, while the discriminator learns to distinguish between real and generated images. This
iterative training process results in high-quality image synthesis.

A key topic covered was different types of GANs, including DCGAN (Deep Convolutional
GAN), CycleGAN (for style transfer), and Conditional GANs (cGANs), which enable more
controlled image generation. Practical applications of GANs in image super-resolution, face
generation, and synthetic data creation were discussed, along with the challenges of mode
collapse, training instability, and evaluation metrics like FID and IS (Inception Score).

To reinforce learning, participants worked on a GAN-based project, where they trained a

DCGAN to generate realistic human face images from noise. They learned how to prepare
datasets, define generator and discriminator architectures using TensorFlow/Keras or PyTorch,
and fine-tune hyperparameters for optimal performance.

By the end of the session, participants had hands-on experience with GANs, sequence-to
sequence models for translation, reinforcement learning basics, and practical deployment
strategies. This knowledge provided them with a deeper understanding of AI-driven content
generation, language processing, and autonomous learning systems.
ACTIVITY LOG FOR THE TWELVETH WEEK

WEEK 12: FROM: 17-2-2025 TO: 22-2-2025

36
Deep Learning using TensorFlow

Day Brief description of the daily activity Learning Outcome

Day 1 MLOPS tools Understanding key concepts

and implementation

Day 2 AWS ECR, AWS EC2,S3

Understanding key concepts
and implementation

Day 3 GitHub actions , ml flow Understanding key concepts

and implementation

Day 4 Docker basics Understanding key concepts

and implementation

Day 5 Bent ml Understanding key concepts and

implementation

Day 6 ML experiments with MLflow and Understanding key concepts

and implementation
TensorBoard

Signature of the Guide

WEEKLY REPORT

WEEK – 12 (FROM: 17-2-2025 TO: 22-2-2025)

Objective of the activity done in week 12: The session aimed to introduce participants to
MLOps (Machine Learning Operations), focusing on the automation, deployment, and
monitoring of machine learning models. The training covered MLOps tools, including GitHub
Actions for CI/CD, Docker for containerization, AWS for cloud deployment, and model

37
Deep Learning using TensorFlow

monitoring techniques. By the end of the session, participants understood how to build an end-
to-end pipeline for deploying machine learning models efficiently.

Detailed Report of week 12:

The session began with an introduction to MLOps, emphasizing its importance in bridging the
gap between model development and production deployment. Participants explored MLOps
principles, such as continuous integration (CI), continuous deployment (CD), model versioning,
automation, and monitoring. These practices ensure that machine learning models are deployed
seamlessly and maintained efficiently.

Next, the session covered GitHub Actions, a powerful CI/CD tool that automates workflows.
Participants learned how to create YAML-based GitHub Actions workflows to automate model
training, testing, and deployment. The process included triggering builds on code commits,
running unit tests, and deploying models to cloud environments.

To ensure environment consistency, Docker was introduced for containerization. Participants

created Dockerfiles to package ML models along with their dependencies. They also explored
Docker Compose for multi-container applications and learned how to push Docker images to
AWS Elastic Container Registry (ECR).

By the end of the session, participants had a clear understanding of MLOps best practices,
cloud deployment, CI/CD automation, and model monitoring, equipping them with the
necessary skills to deploy scalable, reliable, and automated ML solutions.

38
Deep Learning using TensorFlow

ACTIVITY LOG FOR THE THIRTEENTH WEEK

WEEK 13: FROM: 24-2-2025 TO: 1-3-2025

Learning Outcome
Day Brief description of the daily activity

Day 1 Introduction to project, problem statement & Understanding key concepts

goals and implementation

Day 2 Dataset sourcing and cleaning (CT scan

images) Understanding key concepts
and implementation
Day 3 Image preprocessing Understanding key concepts
and implementation

Day 4 Exploratory Data Analysis (EDA) Understanding key concepts

and implementation

Day 5 Data Splitting (Train/Validation/Test) Understanding key concepts and

implementation

Day 6 Setup of Development Environment (Colab Understanding key concepts

+ VS Code) and implementation

WEEKLY REPORT

WEEK – 13 (FROM: 24-2-2025 TO: 1-3-2025)

39
Deep Learning using TensorFlow

Objective of the activity done in week 13: The objective for Week 13 was to initiate the Chest Cancer
Classification project by setting up the necessary technical environment and processing the dataset. This
phase aimed to lay the groundwork for deep learning model development through proper data collection,
preprocessing, and structuring.

Detailed Report of week 13:

The week commenced with the formulation of the core problem statement—developing an AI-powered
solution for the early detection of chest cancer through the analysis of CT scan images. The aim was to
leverage deep learning techniques to classify scans as either cancerous or non-cancerous, thereby
assisting in faster diagnosis and timely treatment. To build a reliable and accurate model, the team
conducted a detailed review of available datasets and finalized the use of publicly accessible medical
imaging datasets from platforms such as Kaggle and the National Institutes of Health (NIH). These
datasets provided a diverse collection of labeled CT scan images, which served as the foundation for
training and evaluating the model.

The subsequent phase involved preprocessing the raw medical images. Since many of the CT scans were
initially stored in the DICOM (Digital Imaging and Communications in Medicine) format—a standard in
medical imaging—the team used OpenCV to convert these into more manageable formats like JPEG or
PNG. This step enhanced compatibility with the machine learning pipeline. Once converted, each image
was resized to a uniform dimension, and pixel normalization was applied to standardize input values,
ensuring that the model could learn from consistent data. To address potential overfitting and enhance the
model’s ability to generalize to unseen data, various data augmentation techniques were implemented.
These included horizontal and vertical flipping, random rotations, and brightness adjustments, which
artificially expanded the dataset and introduced variability during training.

In order to conduct a fair and balanced evaluation of model performance, the entire dataset was split into
three subsets: 80% for training, 10% for validation, and 10% for testing. This approach allowed the team
to train the model on a large portion of the data while retaining enough samples for unbiased validation
and final performance testing. The split also ensured that the model was not evaluated on data it had
already seen, thereby maintaining the integrity of the results.

Simultaneously, the team focused on setting up a robust development environment to streamline

experimentation and coding workflows. Jupyter Notebook was used for initial data exploration and
visualization due to its interactive interface. Google Colab was configured to leverage GPU acceleration,
providing faster training and inference capabilities.

ACTIVITY LOG FOR THE FOURTEENTH WEEK

40
Deep Learning using TensorFlow

WEEK 14: FROM: 3-3-2025 TO: 8-3-2025

Day Brief description of the daily activity Learning Outcome

Day 1 Model Architecture Design (CNN) Understanding key concepts

and implementation

Day 2 Training the Base Mode

Understanding key concepts
and implementation

Day 3 Hyperparameter Tuning Understanding key concepts

and implementation

Day 4 Performance Evaluation (Accuracy, Understanding key concepts

and implementation
Precision, Recall)

Day 5 Implemented Transfer Learning Understanding key concepts and

implementation
(VGG16/ResNet50)

Day 6 Compared Base Model vs Transfer Learning Understanding key concepts

and implementation

WEEKLY REPORT

WEEK – 14 (FROM: 3-3-2025 TO: 8-3-2025)

Objective of the activity done in week 14: The objective for Week 14 was to explore the dataset
through EDA (Exploratory Data Analysis), build and train a Convolutional Neural Network (CNN), and
evaluate initial model performance using standard metrics.

Detailed Report of week 14:

41
Deep Learning using TensorFlow

The week commenced with an extensive Exploratory Data Analysis (EDA) phase aimed at gaining a
deeper understanding of the dataset's structure, particularly the distribution of classes and image
characteristics. Visualization tools such as Seaborn and Matplotlib were employed to analyze key aspects
including class imbalance, pixel intensity distributions, and variations in image structure. These
visualizations revealed a significant imbalance in the dataset, with cancerous samples being notably
underrepresented compared to non-cancerous ones. Recognizing the potential impact of this imbalance
on model performance, the team documented potential future strategies to mitigate it—such as
implementing weighted loss functions during training or applying oversampling techniques to augment
the minority class.

Model development was carried out using the TensorFlow/Keras deep learning framework. A
Convolutional Neural Network (CNN) architecture was custom-built, consisting of multiple
convolutional layers for feature extraction, interspersed with pooling layers to reduce spatial dimensions,
and fully connected dense layers for classification. In parallel, the team experimented with transfer
learning by utilizing pre-trained models like ResNet50, which are known for their deep feature
representation capabilities. These models were fine-tuned on the dataset to leverage their learned weights
from large-scale image classification tasks. Hyperparameters such as learning rate, batch size, and
number of epochs were methodically tuned using validation accuracy as the guiding metric to optimize
model performance.

Model training was conducted on Google Colab, taking advantage of its GPU acceleration to reduce
training time and handle computationally intensive operations more efficiently. Throughout the training
process, the team generated loss and accuracy plots to monitor learning behavior over epochs. Model
evaluation was comprehensive, using a combination of metrics including Accuracy, Precision, Recall,
F1- score, and AUC-ROC to ensure balanced performance across both classes. To combat overfitting,
Dropout layers were incorporated into the model architecture, and EarlyStopping callbacks were
configured to halt training once the model's performance ceased to improve on the validation set.

ACTIVITY LOG FOR THE FIFTHTEENTH WEEK

WEEK 15: FROM: 10-3-2025 TO: 15-3-2025

42
Deep Learning using TensorFlow

Day Brief description of the daily activity Learning Outcome

Day 1 Model Saving & Export (.h5 format) Understanding key concepts
and implementation

Day 2 Flask REST API – Setup & Routing

Understanding key concepts
and implementation

Day 3 Integrated CNN model with Flask API Understanding key concepts
and implementation

Day 4 Testing API using Postman/cURL Understanding key concepts

and implementation

Day 5 Dockerfile Creation & Image Build Understanding key concepts and
implementation

Day 6 Docker Hub Integration Understanding key concepts

and implementation

WEEKLY REPORT

WEEK – 15 (FROM: 10-3-2025 TO: 15-3-2025)

Objective of the activity done in week 15: The objective for Week 15 was to deploy the trained model
as a RESTful API using Flask, test the endpoints, and prepare the project for containerization using
Docker.

Detailed Report of week 15:

During this phase of the Chest Cancer Classification Project, the primary focus was on integrating the
trained deep learning model into a Flask-based web application, laying the groundwork for real-time
interaction with end-users. The model, trained to classify CT scan images as either cancerous or non-
cancerous, was saved in the .h5 format, a standard format used by TensorFlow and Keras for storing

43
Deep Learning using TensorFlow

models. This model was then loaded within the Flask backend, where it would be accessed during
prediction requests.

A RESTful API route, /predict, was developed to handle incoming HTTP POST requests containing
medical CT scan images. Upon receiving an image, the API would initiate a structured pipeline that
included input validation, image preprocessing, and model inference. The preprocessing stage was
designed to resize input images to the model’s expected dimensions and normalize pixel values to
enhance prediction accuracy. After preprocessing, the model would perform inference, returning a
classification result indicating whether the submitted scan was likely cancerous or non-cancerous. This
output was then returned to the client in a structured JSON format, ensuring usability and clarity.

To verify the robustness of the application, local testing was conducted using tools such as Postman and
cURL. These tools allowed the team to simulate API calls with real image inputs, validate the
functionality of the /predict endpoint, and assess the accuracy and consistency of the model’s
responses. This rigorous testing phase ensured that the API logic was sound and that the backend could
handle various input scenarios effectively.

In preparation for deployment, the team initiated the containerization process to package the application
and its dependencies into a portable environment. A Dockerfile was written, defining the build
instructions to include all required libraries, such as TensorFlow for model execution, Flask for API
management, and OpenCV for image processing. The Docker image was then built and run locally using
Docker Desktop, replicating a production-like environment. Successful container execution confirmed
that the application and its environment were correctly configured and fully functional outside the
development setup. By the end of the week, the project team had achieved a major milestone—a fully
functional and locally tested prediction API, packaged within a Docker container. This ensured the
application was portable, consistent, and ready for cloud deployment. The progress made during this
week was pivotal in moving the project closer to a scalable, production-ready solution capable of
assisting in chest cancer diagnosis through automated CT scan classification.

44
Deep Learning using TensorFlow
ACTIVITY LOG FOR THE SIXTEENTH WEEK

WEEK 16: FROM: 17-3-2025 TO: 22-3-2025

Day Brief description of the daily activity Learning Outcome

Day 1 AWS EC2 Launch & SSH Configuration Understanding key concepts
and implementation

Day 2 Installed Docker on EC2 & Pulled Image

Understanding key concepts
and implementation

Day 3 Configured Nginx + Gunicorn Understanding key concepts

and implementation

Day 4 GitHub Actions CI/CD Pipeline – Setup Understanding key concepts

and implementation

Day 5 Integrated GitHub Actions with Docker & EC2 Understanding key concepts and
implementation

Day 6 Final Testing & Monitoring Setup Understanding key concepts

and implementation

Signature of the Guide

45
Deep Learning using TensorFlow

WEEKLY REPORT

WEEK – 16 (FROM: 17-3-2025 TO: 22-3-2025)

Objective of the activity done in week 16: The objective for Week 16 was to complete cloud
deployment on AWS EC2, implement CI/CD with GitHub Actions, and integrate basic monitoring tools
for maintaining system stability and performance.

Detailed Report of week 16:

The final week of the Chest Cancer Classification Project was dedicated to deploying the trained deep
learning model into a cloud environment, marking a significant transition from a development prototype
to a production-ready application. This stage was crucial for enabling real-world usage of the system,
where users could interact with the model via an API and receive real-time predictions. To accomplish
this, the project team launched an Ubuntu-based Amazon EC2 instance, which served as the hosting
environment for the application. Core software components such as Docker and Git were installed on the
server, laying the groundwork for containerized deployment and version-controlled code management. A
Docker image—containing the Flask API, the trained model, and all required dependencies—was pulled
from Docker Hub and executed on the EC2 instance.

To ensure the Flask API could perform reliably under production-level conditions, the team integrated
Gunicorn, a Python-based WSGI server capable of handling multiple concurrent requests. Gunicorn
offered superior performance and stability compared to Flask’s default development server. To further
optimize request handling and enhance security, Nginx was installed and configured as a reverse proxy
server. Nginx was responsible for managing incoming HTTP requests, routing them to the appropriate
Gunicorn worker, and serving static content when needed. This combination of Gunicorn and Nginx
significantly improved the application’s load distribution, response time, and fault tolerance.

One of the most impactful aspects of the deployment phase was the implementation of a Continuous
Integration and Continuous Deployment (CI/CD) pipeline using GitHub Actions. This automation
strategy was configured to trigger on every push to the project’s main GitHub branch. The pipeline
included multiple critical steps: installing project dependencies, running unit tests to validate
functionality, executing model tests to ensure predictive accuracy, building a new Docker image, and
securely deploying that image to the EC2 instance. This seamless workflow reduced manual intervention
and deployment errors, enabling faster and more reliable application updates with each code iteration.

By the conclusion of the final week, the project team had delivered a fully operational, cloud-deployed,
and production-grade system. The deep learning model was not only trained and encapsulated within a
Flask API but was also containerized with Docker, hosted on a scalable AWS infrastructure, and
supported by a robust CI/CD pipeline. These advancements culminated in a complete and professional
solution capable of supporting real-time cancer classification use cases. The success of this deployment
phase signified the successful completion of the Chest Cancer Classification Project and demonstrated
the system’s readiness for real-world applications in medical imaging diagnostics.

46
Deep Learning using TensorFlow

Conclusion

The study and application of Deep Learning have emerged as a cornerstone in the advancement of Artificial
Intelligence. This training program provided a comprehensive overview of the foundational and advanced
concepts required to understand and implement deep learning systems. Through structured sessions on
neural networks, activation functions, loss functions, optimization algorithms, and practical model training,
learners developed a solid understanding of the mechanics behind intelligent systems.

The capstone project, titled "Chest Cancer Classification Using CT Scan Images with Deep Learning &
Deployment," exemplified the real-world relevance of deep learning. It showcased how convolutional
neural networks (CNNs) can be effectively utilized for medical image classification, contributing to early
detection and diagnosis in the healthcare domain. Beyond model development, the program emphasized
industry- aligned practices such as REST API integration with Flask, containerization using Docker,
deployment on cloud platforms like AWS, and automation through CI/CD pipelines with GitHub Actions.

The hands-on experience across the entire machine learning lifecycle—from data pre-processing and
exploratory analysis to model deployment and monitoring—equipped participants with a practical skillset
that aligns with current industry standards. The inclusion of modern tools and frameworks such as
TensorFlow, OpenCV, Flask, Docker, and AWS ensured that learners are prepared for scalable and
production-ready AI solutions.

Overall, this training program not only reinforced technical competencies in deep learning but also
encouraged critical thinking, problem-solving, and innovation in applying AI to real-world challenges. It has
laid a strong foundation for further exploration and specialization in the rapidly evolving field of artificial
intelligence.

47
Deep Learning using TensorFlow

48
Deep Learning using TensorFlow

49