DILLA UNIVERSITY

COLLEGE OF ENGINEERING AND TECHNOLOGY

SCHOOL OF ELECTRICAL AND COMPUTER
ENGINEERING
DEPARTMENT OF COMPUTER ENGINEERING
PROJECT TITLE: POTATO DISEASE
CLASSIFICATION AND DETECTION USING DEEP
LEARNING
BY:
No. FULL NAME ID No.
1. DAWIT SHIMELIS 4054/19
2. AYELE ASMAMAW 5275/19
3. ASMAMAW ABATE 4938/19

Advisor’s Name: Mr. DARARA D.(MSc.)

DILLA, ETHIOPIA
JUNE 2024
 Declaration
We, the undersigned, hereby declare that the project titled "Potato Disease
Classification and Detection Using Deep Learning" is our original work, carried out
under the supervision of [Mr. Darara D. (MSc.)], at Dilla University, College of
Engineering and Technology, School of Electrical and Computer Engineering,
Department of Computer Engineering. This project is submitted in partial fulfillment
of the requirements for the degree of Bachelor of Science in Computer Engineering.
We affirm that the work presented in this project is our own and has not been
submitted previously for any degree or examination at any other institution. We have
properly acknowledged all sources used in the preparation of this project.

No. Student’s Name ID No. Signature

1. Dawit Shimelis 4054/19 -----------
2. Ayele Asmamaw 5275/19 -----------
3. Asmamaw Abate 4938/19 -----------

No. Advisor’s Name Signature

1. Mr. Darara D. (MSc.) -----------

I
 Abstract
In this project, we present a deep learning-based approach for the classification and
detection of diseases in potato plants. Potato diseases pose a significant threat to
agricultural productivity, leading to substantial economic losses. Early and accurate
detection is crucial for effective disease management and control. Leveraging
advancements in deep learning, this study aims to develop a robust and efficient
system capable of identifying common potato diseases from leaf images.
Our methodology involves the collection and preprocessing of a diverse dataset of
potato leaf images, covering various disease conditions such as early blight, late blight,
and healthy leaves. We employ convolutional neural networks (CNNs) to build and
train our model. The performance of the model is evaluated using key metrics
including accuracy, precision, recall, and F1-score.
The results demonstrate that our deep learning model achieves high accuracy in
classifying and detecting potato diseases, outperforming traditional machine learning
methods. This system not only aids farmers and agricultural professionals in timely
disease identification but also contributes to reducing the reliance on expert
knowledge and manual inspection.
In conclusion, the proposed deep learning approach offers a promising solution for the
automatic detection and classification of potato diseases, potentially improving crop
management practices and mitigating the impact of plant diseases on agricultural
yield and integration with a web application. Future work will focus on expanding the
dataset, incorporating additional disease types, and enhancing model performance
through continuous learning and adaptation.

II
 Acknowledgement
First and foremost, we express our deepest gratitude to God, the Creator, for His
guidance, wisdom, and blessings throughout our academic journey and the completion
of this thesis project. Without His divine support and inspiration, this work would not
have been possible.
We would like to extend our heartfelt thanks to our academic advisor, [Mr Darara D.
MSc.], for his invaluable guidance, continuous support, and encouragement
throughout the duration of this project. His expertise and insights were instrumental in
shaping the direction and outcome of our research.
Finally, Thank you all for your support and contributions.

III
 Table of Contents

Declaration......................................................................................................................I
Abstract..........................................................................................................................II
Acknowledgement........................................................................................................III
List of Tables.................................................................................................................II
ACRONYMS................................................................................................................III
CHAPTER ONE.............................................................................................................1
INTRODUCTION..................................................................................................1
1.1 Background of the Project........................................................................1
1.2 Statement of the Problem.........................................................................2
1.3 Objectives.................................................................................................3
1.4 Methodology.............................................................................................3
1.5 Significance of the Project........................................................................4
1.6 Scope of the Project..................................................................................5
CHAPTER TWO............................................................................................................7
LITERATURE REVIEW.......................................................................................7
2.1 Introduction...............................................................................................7
2.2 Theoretical reviews..................................................................................7
2.3 Summary of related works......................................................................10
CHAPTER THREE......................................................................................................12
METHODOLOGY AND MATERIALS USED..................................................12
3.1 Introduction.............................................................................................12
3.2 Overall Methodology and Process..........................................................12
3.3 Model Architecture.................................................................................15
3.4 Materials and Experimental Setup..........................................................28
CHAPTER FOUR........................................................................................................31
Results and Discussions........................................................................................31
4.1 Training the model.................................................................................31
4.2 Evaluation Metrics Analysis...................................................................31
4.3 Training and validation Accuracy Analysis...........................................32
CHAPTER FIVE..........................................................................................................36
CONCLUSION AND RECOMMENDATION...................................................36
5.1 Conclusion..............................................................................................36

IV
 5.2 Limitations..............................................................................................36
5.3 Recommendation....................................................................................36
Reference......................................................................................................................38
APPENDIX..................................................................................................................40

V
 List of Figures
Fig. 1. Proposed methodology......................................................................................12
Fig. 2. Early blight disease of potato leaf.....................................................................13
Fig. 3. Late blight disease of potato leaf......................................................................14
Fig. 4. Healthy potato leaf............................................................................................14
Fig.5. CNN Architecture...............................................................................................17
Fig.6. CNN detailed Architecture.................................................................................18
Fig.7. Confusion matrix report the proposed model.....................................................32
Fig. 8. Training, validation, and loss for 10 epochs.....................................................33
Fig. 9. Training, validation, and loss for 30 epochs.....................................................33
Fig. 10. Training, validation, and loss for 50 epochs...................................................34
Fig. 11. Training, validation, and loss for 50 epochs...................................................35

I
 List of Tables
Table 1: Summary of Literature Reviews.....................................................................10
Table 2: Training Parameters........................................................................................20
Table 3: Hardware/Software Characteristic..................................................................29
Table 4: Classification report of proposed model........................................................31
Table 5. Validation results for classification................................................................34

II
ACRONYMS
API Application Programming Interface
CI/CD Continuous Integration/Continuous Deployment
CNN Convolutional Neural Network
CVL Convolutional Layer
DIP Digital Image Processing
DL Deep Learning
DOM Document Object Model
EB Early Blight
FC Fully Connected
GCF Google Cloud Function
GCP Google Cloud Platform
HTML Hypertext Markup Language
HTTP Hypertext Transfer Protocol
JS JavaScript
LB Late Blight
ML Machine Learning
MP Max Pooling
PC Personal Computer
PLD Potato Leaf Disease
RAM Random Access Memory
ReLU Rectified Linear Unit
RNN Recurrent Neural Network
UI User Interface

III
 CHAPTER ONE

INTRODUCTION

1.1 Background of the Project

Potato is a significant crop in Ethiopia, playing a crucial role in the country's food
security and economy. Introduced to Ethiopia in 1858 by a German immigrant,
Wilhelm Schimper, potato has gradually become an important food and cash crop,
particularly in the high and mid-altitude areas.
Potato (Solanum tuberosum) is one of the most widely consumed staple foods
globally, providing vital nutrients and calories to millions of people. However, potato
cultivation faces significant challenges due to various diseases that can severely
impact crop yield and quality. These diseases, caused by pathogens such as fungi,
bacteria, and viruses, manifest in different forms, including leaf spots, tuber rots, and
stem cankers. Some of the most common potato diseases include late blight
(Phytophthora infestans), early blight (Alternaria solani), and common scab
(Streptomyces scabiei)[1].
Traditionally, the detection and diagnosis of potato diseases have relied on visual
inspection by experienced agronomists or pathologists. However, this manual
approach is time-consuming, subjective, and often prone to errors, leading to delayed
interventions and significant yield losses. Moreover, as the global population
continues to grow, the demand for potatoes and other agricultural products is
increasing, necessitating more efficient and reliable disease management practices[2].
In recent years, advances in artificial intelligence, particularly in the field of deep
learning, have revolutionized various industries, including agriculture. Deep learning
techniques, such as Convolutional Neural Networks (CNNs), have demonstrated
remarkable capabilities in image recognition, enabling automated analysis of complex
visual data. Leveraging these advancements, researchers have increasingly explored
the application of deep learning for crop disease detection and classification[3].
The use of deep learning for potato disease detection and classification offers several
advantages over traditional methods. By analyzing digital images of diseased potato
plants or tubers, deep learning models can rapidly and accurately identify the presence
of diseases and classify them into specific categories. This automated approach not

1
only reduces the reliance on human expertise but also enables early disease detection,
facilitating timely interventions and improved crop management practices[4].
Furthermore, the development of robust deep learning models for potato disease
detection and classification can contribute to sustainable agriculture practices by
minimizing the use of chemical pesticides and fertilizers. By enabling targeted
interventions based on real-time disease monitoring, farmers can optimize resource
allocation, reduce environmental impact, and enhance overall crop health and
productivity.
In summary, the integration of deep learning techniques into potato disease detection
and classification represents a promising approach to addressing the challenges faced
by the potato industry. Through automated and accurate disease diagnosis, deep
learning has the potential to revolutionize potato cultivation practices, ultimately
ensuring food security and sustainability in a rapidly changing world.

1.2 Statement of the Problem

The cultivation of potatoes, a vital crop globally, is constantly threatened by various
diseases caused by pathogens such as fungi, bacteria, and viruses. These diseases,
including late blight and early blight significant challenges to farmers, leading to
substantial yield losses and economic damage. Traditional methods of disease
detection rely heavily on manual inspection by trained agronomists or pathologists.
However, this approach is labor-intensive, time-consuming, and subjective, often
resulting in delayed diagnoses and inadequate disease management. The primary
problem addressed by this project is the lack of an automated and accurate system for
potato disease detection and classification. Current methods are limited in their ability
to provide timely and precise diagnoses, hindering effective disease management
strategies.
The manual inspection process for potato disease detection is not only labor-intensive
and time-consuming but also subjective, relying heavily on the expertise of
agronomists or pathologists. This subjectivity can lead to inconsistencies in diagnoses
and delays in implementing necessary interventions. Additionally, the increasing
demand for potatoes coupled with the global spread of diseases necessitates more
efficient and reliable disease management solutions. Without automated systems
capable of providing timely and accurate diagnoses, farmers face significant
challenges in mitigating the spread of diseases and minimizing yield losses. Therefore,

2
the development of a deep learning-based solution for potato disease detection and
classification is imperative to address these pressing issues and improve agricultural
practices.

1.3 Objectives

1.3.1 General Objective

The general objective of this project is to develop an automated system for potato
disease detection and classification using deep learning techniques.

1.3.2 Specific Objective

 To collect a dataset of potato images containing various diseases for model

training.
 To preprocess the dataset, including data augmentation and normalization, to
enhance model robustness.
 To design and implement a deep learning architecture for accurate disease
detection and classification.
 To train the deep learning model using the preprocessed dataset and evaluate its
performance metrics.
 To develop a user-friendly interface for practical deployment of the trained model
by farmers or agriculture professionals.

1.4 Methodolgy

Data Collection
i. Data Source: The dataset used for this project consists of images of potato leaves
with various diseases, including early blight, late blight, and healthy leaves. The
images were collected from various sources, including the PlantVillage dataset .
ii. Data Preprocessing: The collected images were preprocessed to enhance their
quality and reduce noise. This included resizing the images to a uniform size of
256 × 256 pixels, normalizing the pixel values to the range , and applying data
augmentation techniques such as rotation, flipping, and zooming to increase the
dataset size.
Model Architecture Design

3
 Convolutional Neural Network (CNN) Architecture: The CNN architecture used
for this project is based on the custom(standard) model, which consists of several
convolutional and pooling layers.
 The architecture includes a series of convolutional layers with different filter
sizes and activation functions, followed by max-pooling layers to reduce the
spatial dimensions of the input data.
Model Training
The CNN model was trained on the preprocessed dataset using the Adam optimizer
with a learning rate of 0.001 and a batch size of 32. The model was trained for 50
epochs, and the validation accuracy was monitored to prevent overfitting.
Model Evaluation
Evaluate the trained model's performance using the validation set and appropriate
metrics such as accuracy, precision, recall, and F1-score. The metrics were calculated
for each disease class (early blight, late blight, and healthy) and for the overall model.
Fine-tune the model parameters based on the evaluation results to improve
performance.
Model Deployment
Develop a user-friendly interface (e.g., web application) for deploying the trained
model. Integrate the model into the interface to allow users, such as farmers or
agriculture professionals, to upload potato images and receive real-time disease
detection and classification results.
Results
 Accuracy: The proposed CNN model achieved an accuracy of 99% on the test
dataset, outperforming the state-of-the-art models.
 Precision, Recall, and F1-Score: The model achieved a precision of 1, a recall of
1, and an F1-score of 1 for the overall model.
By following this methodology, the project aims to develop an accurate and efficient
system for potato disease detection and classification using deep learning techniques,
ultimately benefiting the agricultural sector and promoting sustainable crop
management practices.

1.5 Significance of the Project

The significance of the project lies in its potential to revolutionize agricultural
practices and enhance food security. Potatoes are a staple crop globally, and their

4
cultivation is susceptible to various diseases that can drastically reduce yield and
quality, leading to substantial economic losses. Traditional methods of disease
detection rely on manual inspection by experts, which is time-consuming, labor-
intensive, and often prone to human error. Deep learning, a subset of artificial
intelligence, offers a robust solution by automating and significantly improving the
accuracy of disease identification. Through the use of convolutional neural networks
(CNNs) and other advanced algorithms, deep learning models can analyze large
datasets of potato plant images, learning to identify disease patterns with high
precision. This technology enables real-time monitoring and early detection of
diseases, allowing farmers to take swift and targeted actions to mitigate damage.
Additionally, the scalability of deep learning systems makes them accessible to
farmers on a global scale, including those in remote or resource-limited areas.
Ultimately, the implementation of deep learning for potato disease classification and
detection not only enhances crop management and productivity but also contributes to
sustainable agricultural practices, reduces dependency on chemical treatments, and
supports the broader goal of ensuring food security in the face of growing population
demands and climate challenges.

1.6 Scope of the Project

The scope of our project encompasses a comprehensive process, including the
development of a deep learning model, image acquisition and preprocessing, training
and testing, evaluation metrics, image classification, and web app development. Our
focus is on distinguishing between late blight, early blight, and healthy potato plants.
We start with the acquisition of high-quality images representing these three
categories. These images undergo meticulous preprocessing steps such as resizing,
normalization, and augmentation to enhance dataset robustness and ensure
consistency.
We then develop and fine-tune a convolutional neural network (CNN) model
specifically designed to classify potato plants into late blight, early blight, or healthy
categories. The training and testing phases involve splitting the dataset to iteratively
improve the model's performance, utilizing techniques like batch normalization.
Evaluation metrics such as accuracy, precision, recall, and F1-score are established to
rigorously assess the model's effectiveness and ensure it meets the desired
performance standards.

5
Once a high-performing model is achieved, we integrate it into a user-friendly web
application. This web app allows users to upload images of potato plants and receive
immediate diagnostic results, displaying whether the plant is affected by late blight,
early blight, or is healthy, along with actionable recommendations. The web app is
designed to be accessible across various devices, ensuring ease of use for farmers and
agricultural professionals. Additionally, the application supports continuous learning,
enabling users to contribute new images and feedback to further refine and adapt the
model over time. Through this comprehensive scope, our project aims to deliver a
practical, scalable solution that enhances potato disease management and supports
sustainable agricultural practices.

6
 CHAPTER TWO

LITERATURE REVIEW

2.1 Introduction
Numerous studies and suggestions have been done in order to automatically identify
plant diseases. Each literary work, however, seeks to discuss various plants and
components of a plant in particular. Because of this, relevant research on deep
learning and machine learning systems for autonomous plant disease diagnosis is
covered in this section.

2.2 Theoretical reviews

In paper published by Akila and Deepan (2018), specialized deep learning models
based on specific CNN architectures were developed for the detection of plant
diseases using images of healthy or diseased leaves. Both photos obtained from
various sources and images taken on-site by various camera systems were utilized.
Their experimental findings and comparisons of various deep architectures with
feature extractors showed how their deep-learning-based detector was capable of
accurately identifying various types of diseases in different plants and also offering
remedies for concerning disorders. Instead of particular plants, they accomplished this
with more common plants. But, if a remedy is discovered and it is done using
particular plants, the results are better. It is also insufficient to simply say if a plant is
healthy or not. If the weight of the disease is determined, it is critical to include a
disease severity level so that pesticides can be used to prevent disease[5]
Deep learning architecture for potato leaf blight classification was proposed in a paper
(Khalifa, et al., 2021). The suggested architecture consists of 14 layers, including two
primary convolutional layers for feature extraction with various convolution window
sizes and two fully linked layers for classification. There was a significant
improvement in the overall testing accuracy as a result of using augmentation
methods to expand the dataset's image count from 1722 to 9822. A mean testing
accuracy of 98% was attained by the suggested architecture overall. The performance
metrics were computed, and a confusion matrix displaying all the various accuracy
types was presented in their study. They didn't take into account actual environmental
datasets to see; instead, they used premade datasets that were plant village datasets.
7
Moreover, they left out the disease severity degree. There is variation in potato
diseases in different parts of the world due to variation in variousfactorssuch asshape,
variety, and environmental factors. Therefore, the existing plant village dataset
systems have a high false-positive rate for detecting potato disease in other countries
potato leafimages[6].
In the paper by Rozaqi (2020) focuses on the application of Convolutional Neural
Network (CNN) algorithms to identify diseases in potato leaves, specifically early
blight and late blight. The motivation for this study arises from the significant impact
these diseases have on potato crop yields, threatening food security and farmers'
livelihoods. Traditional methods of disease identification rely heavily on expert
knowledge, which is not always accessible to the average farmer, leading to
inaccurate and delayed diagnosis. By leveraging digital image processing and CNNs,
this study aims to provide an automated, accurate, and efficient method for detecting
potato leaf diseases, thus empowering farmers with timely information to take
preventive measures.
The study utilizes a dataset from the PlantVillage repository on Kaggle, which
includes images of healthy potato leaves as well as those affected by early and late
blight. The dataset is pre-processed to resize the images to 150x150 pixels, ensuring
uniformity and speeding up the processing time. The researchers experimented with
different data splits for training and validation—70:30 and 80:20—to evaluate the
model's performance. The CNN architecture used in the study consists of multiple
convolutional and max-pooling layers, followed by a fully connected layer, designed
to extract and learn significant features from the images for accurate classification.
Results from the experiments show that the model achieved high accuracy in
identifying the diseases, with the 70:30 data split yielding better results than the 80:20
split. Specifically, the model achieved a 97% accuracy on training data and 92% on
validation data for the 70:30 split, while the 80:20 split resulted in a 96% accuracy on
training data and 92% on validation data. These results indicate that a slightly higher
proportion of training data contributes to better model performance. The study's
findings highlight the effectiveness of CNNs in plant disease detection and
demonstrate the potential for practical applications in agriculture.
The CNN model described in the document demonstrates commendable performance,
achieving an accuracy of 97% and a validation accuracy of 92%. This model was
trained on a dataset divided into a 70:30 ratio for training and validation, respectively,

8
over the course of 10 epochs. These results suggest that the model is quite effective in
learning and identifying patterns within the dataset, though there is a noticeable gap
between training and validation accuracy which could hint at slight overfitting or
room for improvement in generalization[7].
In contrast, our proposed CNN model shows enhanced performance metrics, with an
accuracy of 99% and a validation accuracy of 98%. This model was trained with a
more extensive dataset division, utilizing 80% for training and 20% for validation,
and over a significantly longer period of 50 epochs. The higher accuracy and
validation accuracy indicate that our model has a better generalization capability and
robustness compared to the model in the document. The increased training data and
extended epochs likely contributed to the model's superior performance, allowing it to
learn more intricate patterns and nuances in the dataset, thus improving its overall
predictive power.
Islam, et al. (2020) have developed a system that combines machine learning and
image segmentation processing to diagnose potato disease from images of the leaves.
Almost 300 images and the plant village dataset, which contain the study's data, are
used. They first remove the backdrop and the green portion of the leaf. Thus, only
extract the areas of interest that have observable illness signs. By using color and
texture cues to train a multiclass support vector machine (SVM) classifier, they were
able to identify and distinguish between disorders. From every leaf image in the
dataset, ten features (color and textural) were retrieved. Using the Gray Level Co-
occurrence Matrix (GLCM), statistical texture parameters such as contrast, correlation,
energy, and homogeneity were retrieved. Throughout the experiment, the database
was split into two sets, with 180 photographs in the training set (60%) and 120 images
in the testing set 40%. They attained a 95% accuracy rate in the suggested model that
divides potato leaf disease into three categories: healthy, late blight affected, and early
blight affected. The automatic assessment of the diagnosed disease's severity and the
recommendation for medical care, however, were not taken into account in this
investigation. The study's focus was relatively narrow; it didn't take into account the
majority of potato leaf diseases, and the dataset they used wasn't considering real
environment data[8].
In the paper A Deep Learning Approach to Classify the Potato Leaf Disease by Md.
Ashraful Islam, and Md. Hanif Sikder proposes a deep learning approach using
convolutional neural networks (CNNs) to classify potato leaf diseases. The authors

9
aimed to develop a model that could assist farmers in identifying and taking action
against early and late blight, two common potato diseases.
The study achieved promising results. The model achieved 100% accuracy in the
testing phase for classifying healthy, early blight, and late blight potato leaves. The
authors trained the model on a dataset of 10,000 images and explored the impact of
different training epochs (iterations) on the model's performance. They found that 40
epochs yielded the best results.
However, some limitations are considering.the model is focus only to train the dataset
and doesn’t deploy a web-application to predict the potato disease[9].

2.3 Summary of related works

Table 1: Summary of Literature Reviews

Authors Titles Accuracy Approches Gap

Akila and Detection and Not CNN -They

Deepan classification explained consider
(2018) of plant leaf common
diseases by plants not
using deep specific plants
learning
algorithm
Khalifa, et al., Potato leaf 98 CNN -they didn’t
2021 blight use real data
classification
using deep
learning
Abdul Jalil Identification 97 CNN -low accuracy
Rozaqi and of Disease in -use small
Andi Sunyoto Potato Leaves amount of
(2020) Using dataset
Convolutional
Neural

10
 Network
(CNN)
Algorithm
Islam, et al. Detection of 95 GLCM for feature -they didn’t
(2020) Potato extraction and use real data
Diseases Using SVM for
Image classification
Segmentation
and Multiclass
Support Vector
Machine
Md. Ashraful A Deep 99.80 CNN -Not deploy
Islam, Md. Learning with a web-
Hanif Approach to app to predict
Sikder(2022) Classify the the diseases
Potato Leaf
Disease

11
 CHAPTER THREE

METHODOLOGY AND MATERIALS USED

3.1 Introduction

The methodology and materials used provides a detailed overview of the approach
taken to conduct the study on potato disease detection and classification using deep
learning techniques. This chapter outlines the methods employed for data collection,
preprocessing, model development, training, evaluation, deployment, and
experimental setup. Additionally, it describes the materials, tools, and resources
utilized throughout the research process.

3.2 Overall Methodology and Process

Fig. 1. Proposed methodology

12
Data acquisition
Different image resolutions and sizes were obtained from an open-access image
database from Kaggle. we collected 2152 from Kaggle. All the images are divided
into three classes. These are Early Blight, Late Blight, and Healthy[10].
Early Blight:
Early blight is a form of plant epidemic brought on by the bacterium Alternaria solani.
Tiny black dots grow into massive, brown-to-black, round-to-ovoid lesions, which are
sometimes constrained by leaf veins but may also be related to lenticels. The
underside of the leaves then develops a black fungus. Tuber wilt in potatoes can be
brought on by early blight. When temperatures exceed 26 C, this disease will start to
spread. It frequently appears when potatoes’ activity is decreased due to high-
temperature drying or a lack of fertilizer.

Fig. 2. Early blight disease of potato leaf

Late Blight:
Plant infections known as late blight are brought on by the bacterium Phytophthora
infestans. A large amount of damage to potato output can be done by outbreaks in
years with low temperatures and plenty of rain.

13
 Fig. 3. Late blight disease of potato leaf
Healthy Leaf: Health leaf looks fresh and is not infected with any disease.

Fig. 4. Healthy potato leaf

Data Preprocessing
Data preprocessing plays a crucial role in preparing the dataset for training deep
learning models. This step involves various techniques to enhance the quality,
consistency, and suitability of the data for model training. The following outlines the
detailed data preprocessing procedure:
I. Image Loading and Resizing:
 The first step is to load the images from the dataset into memory. Images are
typically stored in formats such as JPEG or PNG.
 Images are resized to a standard resolution suitable for model input. Common
resolutions include 224x224 or 256x256 pixels, depending on the requirements of
the deep learning architecture.
II. Normalization of Pixel Values:
 Pixel values in the images are normalized to ensure consistency and improve
model convergence during training.
 Normalization typically involves scaling pixel values to a range between 0 and 1
or -1 and 1, depending on the input requirements of the deep learning model.
Data Augmentation:
Data augmentation techniques are applied to increase the diversity of the dataset and
improve model generalization. Common data augmentation techniques include:
 Rotation: Images are rotated by a certain angle (e.g., 90 degrees, 180 degrees).
 Horizontal and Vertical Flipping: Images are flipped horizontally or vertically to
create mirror images.

14
 Random Cropping: Random sections of the image are cropped and resized to
augment the dataset.
 Zooming: Random zooming in or out of the image to simulate varying
perspectives.
Image classification
Machine learning (ML), also referred to as deep learning (DL), deep neural learning,
or deep neural network, is a component of artificial intelligence (AI). Deep learning
contains more layers than machine learning, as indicated by the word "deep". Deep
learning techniques have raised the bar in several fields, including object detection,
speech recognition, object categorization, and image classification[11]. Convolutional
Neural Network is one of the most well-liked classes in deep learning. Convolutional
neural networks have been used in several research to identify plant illnesses based on
the health of the leaves. One or more convolutional layers that are organized into
groups according to function make up convolutional neural networks in general. The
subsampling layer is frequently followed by one or more fully linked layers that are
typical of a neural network. A feature set contained in a limited area on the previous
layer serves as input for each feature layer.

3.3 Model Architecture

3.3.1 Convolutional Neural Network Architecture (CNN)

I. Input Layer:
Input images of potato plants or tubers are fed into the network with dimensions
suitable for processing, typically resized to a standard size as 256x256 pixels. This
ensures uniformity in input dimensions across all images.
II. Convolutional Layers:
The network begins with a series of convolutional layers responsible for extracting
features from input images. Each convolutional layer comprises multiple filters
(kernels) that convolve over the input image to detect spatial patterns such as edges,
textures, and shapes. The number of filters and the size of the convolutional kernels
are hyperparameters that can be adjusted based on the complexity of the dataset and
the desired level of feature extraction.
III. Activation Function (ReLU):

15
After each convolutional layer, a Rectified Linear Unit (ReLU) activation function is
applied element-wise to introduce non-linearity into the network. ReLU activation
helps the model learn complex patterns by enabling it to model non-linear
relationships within the data.
IV. Pooling Layers:
Max pooling layers are interspersed between convolutional layers to downsample
feature maps and reduce computational complexity. This layers extracts the maximum
value within each pooling window to retain important features while discarding less
relevant information. Pooling layers help to reduce spatial dimensions and control
overfitting by abstracting spatial information.
V. Intermediate Convolutional Layers:
The network includes additional convolutional layers with increasing depth and
complexity to extract higher-level features from the input images. Deeper layers
capture more abstract representations of features learned from earlier layers, allowing
the network to encode complex patterns associated with potato diseases.
VI. Fully Connected Layers:
The global average pooling layer is followed by one or more fully connected layers
responsible for mapping extracted features to output classes (disease categories). Each
neuron in the fully connected layers represents a category, and the activations of these
neurons are combined to generate a probability distribution over the disease classes.
Fully connected layers utilize softmax activation to compute class probabilities and
generate predictions.
VII.Output Layer:
The output layer consists of neurons corresponding to the number of disease classes to
be classified. The output neuron with the highest probability indicates the predicted
disease class.

16
 Fig.5. CNN Architecture

Here is a more detailed architecture:

 Input Layer: 256x256x3 (image size).
 Convolutional Layer 1: 32 filters, kernel size 3x3, stride 1, padding 1, activation
function ReLU.
 Pooling Layer 1: Max pooling, kernel size 2x2, stride 2.
 Convolutional Layer 2: 64 filters, kernel size 3x3, stride 1, padding 1, activation
function ReLU.
 Pooling Layer 2: Max pooling, kernel size 2x2, stride 2.
 Convolutional Layer 3: 128 filters, kernel size 3x3, stride 1, padding 1, activation
function ReLU.
 Pooling Layer 3: Max pooling, kernel size 2x2, stride 2.
 Flatten Layer: Flatten the output of the pooling layers into a one-dimensional
array.
 Fully Connected Layer 1: 128 neurons, activation function ReLU.
 Fully Connected Layer 2: 5 neurons, activation function softmax.
 Output Layer: Output the class probabilities for each of the five classes.

17
Fig.6. CNN detailed Architecture

18
Additional Considerations:
 Dropout Regularization: Dropout layers may be included between fully connected
layers to prevent overfitting by randomly dropping neurons during training.
 Batch Normalization: Batch normalization layers may be added to stabilize and
accelerate the training process by normalizing the inputs to each layer.
 Optimization Algorithm: Gradient-based optimization algorithms such as Adam
or RMSprop can be used to optimize model parameters and minimize the loss
function during training.
 Loss Function: Categorical cross-entropy loss is commonly used as the loss
function for multi-class classification tasks.

3.3.2 Model Training

The preprocessed potato leaf disease dataset was split into training (80%), validation
(10%), and test (10%) sets. The training set is used to train the deep learning model,
while the validation set is used to monitor performance and prevent overfitting during
training. The test set is used for final evaluation of the trained model's generalizability
on unseen data. The training process involves the following steps:

1. Data Loading:
 Training images and their corresponding disease labels are loaded from the
training set in batches of size 32. This batch size is a hyperparameter chosen
based on factors like memory constraints and computational efficiency.
2. Forward Pass:
 The model performs a series of operations including convolutions, pooling,
activation functions, and fully connected layers to generate a probability
distribution for each potato leaf disease class.
3. Loss Calculation:
 The predicted probability distribution for each image in the batch is compared to
the actual disease label using the categorical cross-entropy loss function. This
function measures the difference between the model's predictions and the ground
truth, essentially calculating the error.
4. Backpropagation:

19
 The calculated loss is propagated backward through the network using the Adam
optimization algorithm. Adam is a gradient-based optimizer that iteratively
updates the weights and biases of the model in a way that minimizes the overall
loss function. This helps the model learn from its mistakes and improve its
predictions in future iterations.
5. Epoch Iteration:
 Steps 1-4 are repeated for a specified number of epochs (typically 50 in this case).
An epoch represents one complete pass through the entire training set. With each
epoch, the model refines its ability to differentiate between healthy and diseased
potato leaves based on the features it extracts from the training data.
6. Validation:
 After each epoch, the model's performance is evaluated on the validation set.
Metrics like accuracy, precision, recall, and F1-score are calculated to assess how
well the model generalizes to unseen data. This helps identify potential
overfitting and allows for early stopping if validation performance stagnates or
deteriorates.
7. Model Selection:
 The model with the best performance on the validation set is selected as the final
trained model. This model represents the optimal balance between fitting the
training data and generalizing to unseen data.

Table 2: Training Parameters

Parameter Values
Split Ratio (Training:Validation:Test) 80%:10%:10%
Batch Size 32
Optimization Algorithm Adam
Loss Function Categorical Cross-Entropy
Epochs 50

By following these steps and carefully monitoring the training process, the deep
learning model is trained to effectively classify potato leaf diseases based on image
features. The final trained model is then evaluated on the unseen test set to assess its
generalizability and real-world applicability.

20
3.3.3 Model Evaluation

After training the deep learning model for potato leaf disease classification, the next
crucial step is evaluation. Here, we assess the model's performance on unseen data
from the test set (10% of the original dataset). This evaluation helps determine how
well the model generalizes to real-world scenarios and identifies any potential
weaknesses.

Evaluation Metrics:

The effectiveness of machine learning models on a particular job is measured using

evaluation metrics. The sort of task at hand and the particular issue that has to be
handled were determine the evaluation metrics that are used. To evaluate the
performance of our model we have used the following well known evaluation matrix.
The confusion matrix is often shown as a table, with the actual and anticipated classes
represented as rows and columns, respectively. The amount of data points that fall
into each combination of actual and anticipated classifications is shown by the entries
in the matrix. A confusion matrix's foundational components are:

 True Positives (TP): The number of data points that are correctly classified as
positive.
 False Positives (FP): The number of data points that are incorrectly classified as
positive.
 True Negatives (TN): The number of data points that are correctly classified as
negative.
 False Negatives (FN): The number of data points that are incorrectly classified as
negative.

Accuracy: This is the overall proportion of correct predictions made by the model. It
represents the percentage of images from the test set that the model classified
correctly (both healthy and diseased).

(TP + TN)
accuracy =
𝑃+𝑁+𝑃+𝑁

21
Precision: The proportion of true positives among all positive predictions. A
classification model's precision is a metric used to assess the percentage of genuine
positives among all positive predictions. To put it another way, precision assesses a
model's capacity for avoiding false positives

TP
Precision =
𝑃+𝑃

Recall: Recall (also known as Sensitivity or True Positive Rate): The proportion of
true positives among all actual positive samples. Recall, also referred to as sensitivity
or the true positive rate, is used to calculate the percentage of real positive samples.
Recall assesses a model's accuracy in properly identifying positive samples, in other
words.

TP
Recall =
𝑃+𝑁

F1-Score: When assessing the effectiveness of a classification model, the F1-score

metric combines precision and recall into a single statistic. Given that it uses the

harmonic mean to calculate precision and recall, both metrics are given equal weight.

2 x (Precision x Recall)
F1_Score = (𝑃𝑟𝑐𝑠𝑜 +𝑐𝑎)

The F-score has a scale from 0 to 1, with 1 denoting perfect precision and recall and 0
denoting zero precision or recall.

Macro-average: A classification model's performance metrics can be compiled over

all classes using the micro-average technique. The true positives, false positives, true
negatives, and false negatives are calculated over all classes in macro-average, and the
resulting totals are then combined to produce the performance measures.

=1 𝑁 𝑃= 𝑃1+𝑃2+.....+ 𝑃𝑁
precision macro-average ∑ 𝑁
𝑁 =1

where Pi stands for the itℎ precision score and N denotes the number of precision
scores for the trained model. Further, the recall macro-average is also defined as

22
 𝑁
recall macro-average = 1
∑ = 1+2+.....+
𝑁 𝑁
=1

where Ri represents the itℎ recall score and N is the number of recall scores of the
model.

Evaluation Process:

 The trained model is used to predict disease labels for the images in the test set.
 The predicted labels are compared with the actual labels (ground truth) for each
image in the test set.
 The chosen evaluation metrics (accuracy, precision, recall, and F1-score) are
calculated based on the comparison of predicted and actual labels.

The evaluation results are analyzed to understand the model's strengths and
weaknesses. High accuracy indicates the model is making mostly correct predictions
across all disease classes. High precision for a specific class suggests the model is
good at identifying that disease with minimal false positives. Similarly, high recall
indicates the model is effectively capturing most cases of a particular disease.

Additional Considerations:

Confusion Matrix: A confusion matrix is a visualization tool that can be helpful for
evaluating a multi-class classification model's performance. It shows how many
images from each class were predicted correctly and incorrectly by the model.
Class Imbalance: If the dataset has imbalanced classes (unequal distribution of
disease types), then metrics like accuracy might be misleading. In such cases, using
F1-score or other metrics that consider both precision and recall is crucial.
By evaluating the model's performance using these metrics and techniques, we gain
valuable insights into its effectiveness for potato leaf disease classification. This
information can be used to further refine the model or select the best performing
model for deployment in a real-world application.

3.3.4 Model Optimization

While the previous sections discussed training and evaluating the initial model, this
section focuses on model optimization techniques. Here, we explore strategies to

23
potentially improve the model's performance on the potato leaf disease classification
task. Here are some common approaches to model optimization:

1. Hyperparameter Tuning:

The initial training process likely involved choosing specific values for
hyperparameters like the number of convolutional filters, learning rate, or the number
of neurons in hidden layers. These hyperparameters significantly impact the model's
learning behavior and performance. Techniques like grid search, random search, or
Bayesian optimization can be used to systematically explore different hyperparameter
combinations and identify the settings that yield the best results on the validation set.

2. Data Augmentation:

Data augmentation involves artificially expanding the training dataset by creating new
variations of existing training images. This can be done through techniques like
random cropping, flipping, rotation, or adding noise. Data augmentation helps the
model learn from a wider range of image variations and improve its generalizability to
unseen data that might have slight differences from the original training set.

3. Regularization Techniques:

Regularization helps prevent overfitting by penalizing the model for having overly
complex decision boundaries. Techniques like L1/L2 regularization or dropout can be
employed during training. These methods add constraints that encourage the model to
learn simpler representations of the data and reduce the risk of memorizing the
training set instead of learning generalizable patterns.

4. Model Ensembling:

Ensemble methods involve training multiple models with different architectures or

hyperparameter settings and then combining their predictions. Techniques like
averaging or weighted averaging can be used to create an ensemble model that
leverages the strengths of each individual model and potentially achieves better
overall performance than any single model.

Evaluation of Optimized Model:

24
Once you've applied optimization techniques, re-evaluate the model on the validation
set to assess the impact of the changes. If the performance improves, you can then test
the optimized model on the unseen test set to see if the generalization ability has also
improved.

Choosing the Best Model:

Based on the evaluation results, we compare the performance of the initial model with
the optimized model. The model that achieves the best balance of accuracy, precision,
recall, and F1-score on the test set is considered the optimal model for our potato leaf
disease classification task.

3.3.5 Model Deployment and Integration

The deployment and integration of deep learning-based systems for potato disease
classification represent pivotal steps in modern agricultural diagnostics. These
systems leverage advanced computer vision techniques to automatically analyze
images of potato plants and identify the presence of diseases accurately. By deploying
such systems on accessible platforms like web applications or mobile apps, farmers
and agricultural professionals gain timely insights into disease outbreaks, enabling
proactive management strategies. Seamless integration of frontend interfaces, backend
APIs, and deep learning models ensures user-friendly interaction and reliable
performance. Overall, through effective deployment and integration, these systems
contribute significantly to enhancing crop protection and optimizing yields in potato
cultivation.

1. Platform Selection

Web Application: A web application was chosen as the deployment platform due to
its versatility and accessibility. By opting for a web-based solution, the system
becomes platform-independent, allowing users to access it from any device with a
web browser, including desktop computers, laptops, tablets, and smartphones. This
accessibility ensures that farmers and agricultural professionals can utilize the
application regardless of their device preferences or operating systems.

1. Model Optimization

25
Quantization: Quantization is a model optimization technique used to reduce the
memory footprint and computational overhead of deep learning models. By
converting the model's parameters and activations to lower precision representations
(e.g., from 32-bit floating-point to 8-bit integers), quantization significantly reduces
the storage requirements and improves inference speed without sacrificing model
accuracy. This optimization is particularly beneficial for deployment on resource-
constrained environments such as web browsers or mobile devices, where memory
and processing power are limited.

2. Framework Selection

TensorFlow.js: TensorFlow.js is an open-source JavaScript library developed by

Google for building and deploying machine learning models in web applications. It
allows developers to train, run, and retrain TensorFlow models directly in the browser
or on Node.js servers, leveraging the power of WebGL for hardware-accelerated
numerical computations. TensorFlow.js provides a high-level API for defining and
executing computational graphs, making it easy to integrate deep learning models into
web applications with minimal effort.

3. Backend Infrastructure

TensorFlow Serving: TensorFlow Serving is a high-performance serving system

designed for deploying machine learning models in production environments. It
provides a scalable and efficient solution for serving TensorFlow models over a
network, supporting features such as model versioning, dynamic batching, and model
introspection. TensorFlow Serving allows the optimized deep learning model to be
hosted as a standalone service, decoupling the inference logic from the application
code and enabling seamless integration with other backend components.

FastAPI: FastAPI is a modern web framework for building APIs with Python,
designed to be fast, easy to use, and highly performant. It leverages Python type
annotations and asynchronous programming to automatically generate OpenAPI
documentation and interactive API documentation, making it simple to define and
document API endpoints. FastAPI's built-in support for asynchronous request

26
handling ensures low latency and high concurrency, making it well-suited for serving
machine learning models and handling HTTP requests efficiently.

5. API Development

API Functionality: The backend API provides a user-friendly interface for uploading
image data and obtaining classification results. Users can interact with the API
through a drag-and-drop interface, allowing them to easily upload images of potato
plants for analysis. Upon receiving an image, the API performs inference using the
optimized deep learning model, extracting relevant features and predicting the most
likely disease class. The API returns the predicted disease class along with confidence
scores, providing users with actionable insights into the health status of their potato
plants.

6. Frontend Development

React.js: React.js is a popular JavaScript library for building user interfaces,

developed by Facebook. It enables developers to create reusable UI components using
a declarative and component-based approach, making it easy to build complex and
interactive user interfaces. React.js provides a virtual DOM for efficient rendering and
updates, optimizing the performance of web applications by minimizing unnecessary
DOM manipulations. The use of React.js ensures that the web application interface is
responsive, dynamic, and user-friendly, enhancing the overall user experience.

React Native: React Native is a framework for building cross-platform mobile

applications using JavaScript and React.js. It allows developers to write mobile
applications using familiar web development technologies, while still providing
access to native platform features and APIs. React Native enables code sharing
between iOS and Android platforms, streamlining the development process and
reducing time-to-market. By utilizing React Native for mobile app development, the
system ensures consistency across different devices and operating systems, providing
a seamless user experience for both web and mobile users.

7. Model Deployment

27
Google Cloud Platform (GCP): Google Cloud Platform is a suite of cloud
computing services offered by Google, providing a range of infrastructure and
platform services for building, deploying, and managing applications and services in
the cloud. GCP offers a scalable and reliable environment for hosting application
infrastructure, including compute, storage, networking, and machine learning services.
By deploying the system on GCP, users benefit from Google's global network
infrastructure, advanced security features, and managed services, ensuring high
availability, performance, and scalability.

Google Cloud Functions (GCF): Google Cloud Functions is a serverless computing

platform provided by Google Cloud Platform, allowing developers to run event-
driven functions in response to cloud events without provisioning or managing servers.
Cloud Functions automatically scales to handle incoming traffic and executes code in
response to events triggered by HTTP requests, Pub/Sub messages, or Cloud Storage
events. By deploying serverless functions on GCF, the system benefits from
automatic scaling, pay-per-use pricing, and simplified deployment and management,
enabling cost-effective and efficient execution of backend logic.

3.4 Materials and Experimental Setup

This section details the hardware, software, and datasets used to develop and evaluate
the deep learning model for potato leaf disease classification.

3.4.1 Hardware

The deep learning model was trained and tested on a computer equipped with an
Intel(R) Core(TM) i3-5005U CPU @ 2.00GHz processor and 8GB of RAM. While
this setup is sufficient for basic model development, a more powerful computer with a
dedicated GPU (Graphics Processing Unit) would accelerate training times for
complex models.

3.4.2 Software

 Deep Learning Framework: TensorFlow, a popular open-source deep learning

framework, was used to develop and train the model.

28
 Programming Languages: Python, a versatile and widely used programming
language, was the primary language for coding the model and associated scripts.
 Development Tools: PyCharm, an Integrated Development Environment (IDE),
was used for code development and editing.
 Data Preprocessing Libraries: Scikit-image, a Python library for image processing,
was used for tasks like image resizing and manipulation during data
preprocessing.
 Data Visualization Libraries: Matplotlib, a Python library for creating static,
animated, and interactive visualizations, was used to visualize the training data or
model performance (e.g., loss curves).
 API Development Framework : FastAPI, a high-performance framework for
building APIs, was used to develop an API for the model.
 HTTP Client : Postman, a tool for sending API requests and testing functionality,
was used to interact with the developed API .

Table 3: Hardware/Software Characteristic

Hardware/Software Hardware/Software Characteristic

Processor (CPU) Intel core-i5 (8th Gen)
RAM 8GB DDR4
Operating System Windows 10
Graphics (GPU) NVIDIA GeForce MX230
Environment Tensorflow
Programming Language Python
API Development Framework FastAPI
Docker Containerization

3.4.3 Dataset

A publicly available potato leaf disease image dataset was obtained from Kaggle, a
platform for data science and machine learning. The dataset consists of a total of
2,152 images belonging to three classes:

 Potato Early Blight (1000 images)

29
 Potato Healthy (152 images)
 Potato Late Blight (1000 images)

The dataset underwent pre-processing steps including resizing, normalization, and

data partitioning for training, validation, and testing purposes.

This section provides a clear overview of the computational resources, software tools,
and dataset used in your project. It allows readers to understand the technical
environment in which the model was developed.

30
 CHAPTER FOUR

Results and Discussions

4.1 Training the model

Our deep learning model for potato leaf disease classification leverages the power of
Convolutional Neural Networks (CNNs) to extract spatial features from pre-processed
potato leaf images. The network architecture comprises input layers tailored to the
image resolution and RGB channels, followed by multiple convolutional layers that
apply filters to extract intricate features like edges and textures. Activation functions
such as ReLU introduce non-linearity, while optional pooling layers aid in
downsampling and translation invariance. The flattened layer prepares the output for
fully connected layers that learn abstract features, with the final output layer utilizing
a softmax function to classify the potato leaves into distinct disease classes. Through
this structured CNN architecture, our model aims to accurately classify healthy leaves,
Early Blight, and Late Blight with optimized performance and efficiency.

4.2 Evaluation Metrics Analysis

In this section, real data that was collected from kaggle was trained using proposed
classifier model. The detail analysis of each class label performance is presented in
Table 10.

Table 4: Classification report of proposed model

Precision Recall F1_score support

Potato_Early_blight 1.00 1.00 1.00 124
Potato_Late_blight 1.00 1.00 1.00 111
Potato_Healthy 1.00 1.00 1.00 21
accuracy 1.00 256
Macro avg 1.00 1.00 1.00 256
Weighted avg 1.00 1.00 1.00 256

As show in Table 4, 100% of early blight cases could be properly classified by the
proposed model correctly. In addition, the model accurately categorized every image
as healthy and none were incorrectly classified. Similar to this, 100% of the images

31
were correctly classified as late blight disease. As a result, the classifier model has a
100% success rate for classification with real data only.

Fig.7. Confusion matrix report the proposed model

As it is shown in Figure 7, out of a total of 124 images of potato leaves, all 124 were
correctly characterized as having early blight disease. Moreover, healthy potato leaves
were correctly identified in all 21 images. And also, out of 111 images, all 111 images
were correctly recognized as having the late blight disease. We can infer that the
model usually always accurately classified data into the correct class of the images.

4.3 Training and validation Accuracy Analysis

The dataset contains 2152 images belonging to three classes of potato leaves. The
results of training and validation accuracy and loss for epochs 30, 40 & 50 are given
below. From the below figure 8, 9 & 10, we identify the relationship between the
number of epochs and learning outcomes.

32
Fig. 8. Training, validation, and loss for 10 epochs

Fig. 9. Training, validation, and loss for 30 epochs

33
 Fig. 10. Training, validation, and loss for 50 epochs

According to the figure, we can see that our model performed better when we applied
50 epochs. We used a total of 20 images randomly to evaluate the proposed tool and
investigate the classification accuracy. Table 5 is shown the results of potato leaf
disease classification for three different classes. The dataset has been split into three
parts; training dataset, test data set and validation dataset. Neither the testing nor the
validation data set were included in the training data set.

Table 5. Validation results for classification

Epoch Class quantity Accuracy Average Accuracy

Early Blight 11 99.92%
10 Healthy 4 94.93% 98.07%
Late Blight 5 99.37%
Early Blight 13 99.19%
30 Healthy 1 100% 99.16%
Late Blight 6 98.31%
Early Blight 13 100%
50 Healthy 0 99.72
Late Blight 7 99.44%

34
In Fig. 11 are shown the actual classes and predicted classes, including the confidence.
100% confidence means the accuracy is 100% of the predicted leaf. For every class,
the accuracy of our model is 99.72%, which indicates that the model is working fine.
The classification results show that the proposed model has good accuracy for 50
epochs

Fig. 11. Training, validation, and loss for 50 epochs

35
 CHAPTER FIVE

CONCLUSION AND RECOMMENDATION

5.1 Conclusion

This project aimed to develop a deep learning model for classifying potato leaf
diseases using image recognition. The model leveraged Convolutional Neural
Networks (CNNs) to extract features from pre-processed potato leaf images and
classify them into three distinct categories: Early blight, Late blight, and Healthy.
The project followed a structured approach, starting with a comprehensive literature
review to understand existing techniques for disease detection. Subsequently, a deep
learning model was designed and implemented using TensorFlow. The model was
trained on a publicly available dataset of potato leaf images obtained from Kaggle.
The dataset contained a total of 2,152 images belonging to the three aforementioned
classes.
Evaluation metrics like accuracy, precision, recall, and F1-score were employed to
assess the model's performance. The results were highly promising, with the model
achieving an overall accuracy of 99% on real-world data collected from Kaggle and
the proposed model results higher accuracy indicatendicate that our model has a better
generalization capability and robustness compared to the model in the document. .
The confusion matrix further corroborated this finding, indicating a high degree of
accuracy in classifying images into their respective disease categories.

5.2 Limitations

While the project yielded encouraging results, it is essential to acknowledge certain

limitations. The model was trained on a relatively small dataset, which might limit its
generalizability to a wider range of potato leaf images captured under diverse
environmental conditions. Additionally, the project focused on classifying three
specific diseases. Expanding the model's capability to identify a broader spectrum of
potato leaf diseases would enhance its practical applicability.

5.3 Recommendation

Based on the findings of this project, several avenues exist for further research and
development. Here are some potential directions to consider:

36
 Multiple Disease Classification: Expanding the model's classification
capabilities to encompass a wider range of potato leaf diseases would
significantly enhance its practical value for farmers and agricultural
professionals.
 Severity Level Prediction Integration: Develop an additional model stage or
refine the existing model to predict the severity level of the detected disease. This
could involve incorporating severity-specific features or leveraging techniques
like multi-class classification or regression tasks.

37
 Reference
[1] G. K. Abebe, J. Bijman, S. Pascucci, and O. Omta, “Adoption of improved
potato varieties in Ethiopia: The role of agricultural knowledge and innovation
system and smallholder farmers’ quality assessment,” Agric. Syst., vol. 122, no.
November, pp. 22–32, 2013, doi: 10.1016/j.agsy.2013.07.008.
[2] IPPC Secretariat, “Plant health and food security (FAO),” FAO behalf Secr. Int.
Plant Prot. Conv. ;, vol. 1, p. 2p., 2017, [Online]. Available:
https://openknowledge.fao.org/handle/20.500.14283/i7829en
[3] U. Y. Tambe, A. Shobanadevi, A. Shanthini, and H.-C. Hsu, “Potato Leaf
Disease Classification using Deep Learning: A Convolutional Neural Network
Approach,” Nov. 2023, Accessed: May 30, 2024. [Online]. Available:
https://arxiv.org/abs/2311.02338v1
[4] M. H. Saleem, J. Potgieter, and K. M. Arif, “Plant Disease Detection and
Classification by Deep Learning,” Plants, vol. 8, no. 11, Nov. 2019, doi:
10.3390/PLANTS8110468.
[5] M. Akila and P. Deepan, “Detection and Classification of Plant Leaf Diseases
by using Deep Learning Algorithm,” Iarjset, vol. 6, no. 7, pp. 72–75, 2018.
[6] N. E. M. Khalifa, M. H. N. Taha, L. M. Abou El-Maged, and A. E. Hassanien,
Artificial Intelligence in Potato Leaf Disease Classification: A Deep Learning
Approach, vol. 77, no. January 2022. Springer International Publishing, 2021.
doi: 10.1007/978-3-030-59338-4_4.
[7] A. J. R. and Andi Sunyoto, “Identification of Disease in Potato
LeavesUsingConvolutionalNeuralNetwork ( C NN ) Algorithm,” 3rd Int. Conf.
Inf. Commun. Technol., pp. 72–76, 2020.
[8] M. T. Islam, “Plant Disease Detection using CNN Model andImage Processing
Plant Disease Detection using CNN Model and Image Processing,” no.
February, 2020, [Online]. Available:
https://www.researchgate.net/publication/358768246
[9] M. A. Islam and M. H. Sikder, “A Deep Learning Approach to Classify the
Potato Leaf Disease,” J. Adv. Math. Comput. Sci., vol. 37, no. 12, pp. 143–155,
2022, doi: 10.9734/jamcs/2022/v37i121735.
[10] A. Tejaswi, “Plant village late blight, early blight and healthy dataset,” kaggle.
[Online]. Available: https://www.kaggle.com/datasets/arjuntejaswi/plant-

38
 village
[11] H. Lee, R. Grosse, R. Ranganath, and A. Y. Ng, “Convolutional deep belief
networks for scalable unsupervised learning of hierarchical representations,”
Proc. 26th Int. Conf. Mach. Learn. ICML 2009, pp. 609–616, 2009, doi:
10.1145/1553374.1553453.

39
APPENDIX

40
41
42
43
44
45