PLANT DISEASE IDENTIFICATION USING A NOVEL CONVOLUTIONAL NEURAL

NETWORK

ABSTRACT

The timely identification of plant diseases prevents the negative impact on crops.
Convolutional neural network, particularly deep learning is used widely in machine vision and
pattern recognition task. Researchers proposed different deep learning models in the
identification of diseases in plants. However, the deep learning models require a large number of
parameters, and hence the required training time is more and also difficult to implement on small
devices. In this paper, we have proposed a novel deep learning model based on the inception
layer and residual connection. Depthwise separable convolution is used to reduce the number of
parameters. The proposed model has been trained and tested on three different plant diseases
datasets. The performance accuracy obtained on plantvillage dataset is 99.39%, on the rice
disease dataset is 99.66%, and on the cassava dataset is 76.59%. With fewer number of
parameters, the proposed model achieves higher accuracy in comparison with the state-of-art
deep learning models.

INTRODUCTION

The agriculturist in provincial regions may think that it’s hard to differentiate the malady
which may be available in their harvests. It's not moderate for them to go to agribusiness office
and discover what the infection may be. Our principle objective is to distinguish the illness
introduce in a plant by watching its morphology by picture handling and machine learning. Pests
and Diseases results in the destruction of crops or part of the plant resulting in decreased food
production leading to food insecurity. Also, knowledge about the pest management or control
and diseases are less in various less developed countries. Toxic pathogens, poor disease control,
drastic climate changes are one of the key factors which arises in dwindled food production.
Various modern technologies have emerged to minimize postharvest processing, to fortify
agricultural sustainability and to maximize the productivity. Various Laboratory based
approaches such as polymerase chain reaction, gas chromatography, mass spectrometry,
thermography and hyper spectral techniques have been employed for disease identification.
However, these techniques are not cost effective and are high time consuming. In recent times,
server based and mobile based approach for disease identification has been employed for disease
identification. Several factors of these technologies being high resolution camera, high
performance processing and extensive built in accessories are the added advantages resulting in
automatic disease recognition.

Modern approaches such as machine learning and deep learning algorithm has been employed to
increase the recognition rate and the accuracy of the results. Various researches have taken place
under the field of machine learning for plant disease detection and diagnosis, such traditional
machine learning approach being random forest, artificial neural network, support vector
machine(SVM), fuzzy logic, K-means method, Convolutional neural networks etc.… Random
forests are as a whole, learning method for classification, regression and other tasks that operate
by constructing a forest of the decision trees during the training time. Unlike decision trees,
Random forets overcome the disadvantage of over fitting of their training data set and it handles
both numeric and categorical data.

Fig 1: Real Time Data analysis

The timely identification and early prevention of crop diseases are essential for improving
production. In this paper, deep convolutional-neural-network (CNN) models are implemented to
identify and diagnose diseases in plants from their leaves, since CNNs have achieved impressive
results in the field of machine vision. Standard CNN models require a large number of
parameters and higher computation cost. In this paper, we replaced standard convolution with
depth=separable convolution, which reduces the parameter number and computation cost. The
implemented models were trained with an open dataset consisting of 14 different plant species,
and 38 different categorical disease classes and healthy plant leaves. To evaluate the
performance of the models, different parameters such as batch size, dropout, and different
numbers of epochs were incorporated. The implemented models achieved a disease-classification
accuracy rates of 98.42%, 99.11%, 97.02%, and 99.56% using InceptionV3, InceptionResNetV2,
MobileNetV2, and EfficientNetB0, respectively, which were greater than that of traditional
handcrafted-feature-based approaches. In comparison with other deep-learning models, the
implemented model achieved better performance in terms of accuracy and it required less
training time. Moreover, the MobileNetV2 architecture is compatible with mobile devices using
the optimized parameter. The accuracy results in the identification of diseases showed that the
deep CNN model is promising and can greatly impact the efficient identification of the diseases,
and may have potential in the detection of diseases in real-time agricultural systems.

The automated identification of plant diseases based on plant leaves is a major landmark in the
field of agriculture. Moreover, the early and timely identification of plant diseases positively
impacts crop yield and quality [1]. Due to the cultivation of a large number of crop products,
even an agriculturist and pathologist may often fail to identify the diseases in plants by
visualizing disease-affected leaves. However, in the rural areas of developing countries, visual
observation is still the primary approach of disease identification [2]. It also requires continuous
monitoring by experts. In remote areas, farmers may need to travel far to consult an expert,
which is time-consuming and expensive [3,4]. Automated computational systems for the
detection and diagnosis of plant diseases assist farmers and agronomists with their high
throughput and precision.

In order to overcome the above problems, researchers have thought of several solutions. Various
types of feature sets can be used in machine learning for the classification of plant diseases.
Among these, the most popular feature sets are traditional handcrafted and deep-learning (DL)-
based features. Preprocessing, such as image enhancement, color transformation, and
segmentation, is a prerequisite before efficiently extracting features. After feature extraction,
different classifiers can be used. Some popular classifiers are K-nearest neighbor (KNN), support
vector machine (SVM), decision tree, random forest (RF), naive Bayes (NB), logistic regression
(LR), rule generation, artificial neural networks (ANNs), and Deep CNN. KNN is a simple
supervised-machine-learning algorithm used in classification problems, and it uses similarity
measurements (i.e., distance, proximity, or closeness). SVM is also a popular supervised-
machine-learning technique used for classification purposes. The idea behind SVM is to find a
hyperplane between data classes that divides each class. An NB classifier makes predictions on
the basis of probability measurements. It assumes that the generated features are independent
from each other. ANN is a set of connected inputs, an output network that is modeled after the
human neural system cells. The network consists of an input layer, intermediate layer, and output
layer. Learning is performed by adjusting weights.Handcrafted-feature-based methods achieve
good classification results, but have some limitations such as requiring huge amounts of
preprocessing, and the process is time-consuming. Feature extraction in the handcrafted-based
approach is limited, and extracted features might not be enough for correct identification, which
affects accuracy.

Fig 2: CNN Based Detection

On the other hand, deep-learning-based techniques, particularly CNNs, are the most promising
approach for automatically learning decisive and discriminative features. Deep learning (DL)
consists of different convolutional layers that represent learning features from the data. Plant-
disease detection can be accomplished using a deep-learning model. Deep learning also has some
drawbacks, as it requires large amounts of data to train the network. If an available dataset does
not contain enough images, performance is worse. Transfer learning has several advantages; for
example, it does not needs a large amount of data to train the network. Transfer learning
improves learning a new task through knowledge transfer from a similar task that had already
been learned. Many studies used transfer learning in their disease-detection approach. The
benefits of using transfer learning are a decrease in training time, generalization error, and
computational cost of building a DL model. In this work, we use different DL models to identify
plant diseases. The inception module can extract more specific and relevant features as it allows
for simultaneous multilevel feature extraction. We replaced the standard convolution of an
inception block with depthwise separable convolution to reduce the parameter number. Multiple
feature extraction improves the performance of the model. In a residual network, it has a shortcut
connection that basically feeds the previous layer output to the next layer, which strengthens
features and improves accuracy. To evaluate performance on a lightweight memory-efficient
interface, the Mobile Net model is used. MobileNetV2 architecture can achieve high accuracy
rates while keeping parameter number and computation as low as possible. According to,
network depth, width, and resolution can lead to better performance accuracy with fewer
parameters. We also used this Efficient Net model to identify diseases in plant and evaluated its
performance. In the implemented DL architecture, we used different batch sizes of 32–180 to
evaluate performance. Different dropout values and learning rates were also used to examine
performance. Several epochs were used to run the model. The evaluation showed that the
implemented deep CNN achieved impressive results and better performance in comparison with
those of state-of-the-art machine-learning techniques. The main contributions of the paper are as
follows:

One of the major sources of yield in India is the production of crops. It is of enhancing the
technological advancement in the fields related to crop productivity. Here farmers cultivate a
maximum diversity of plants and crops. More studies are built with the important domain of
qualitative and efficient farming is concentrated on enhancing the yield and food crop
productivity at a minimum time with a greater outcome. The detection of plant disease by human
visualization is a more difficult task and at the same time, less efficient, and it’s done with a
limited set of leaf images and takes more time. Whereas the automatic identification technique
will take less effort and time and a more accurate program. Here we use image processing to
detect the diseases. We can put the image into a system and a computer can perform various
phases for identification and detect the related classes to which that image belongs. This work
aims to make a leaf recognition technique based on the specific characteristics derived from
images.

First of All, here import the packages like OpenCV, NumPy, tqdm, TensorFlow, matploatlib,
etc., and define the functions for label images, and load training data. We classify the images into
four categories depending on the code name of plant diseases. For training, phase loads the
variety of images and it resizes with a resolution of 50*50. Then images and corresponding
labels are appended to the list. The above steps are used for testing the data. For classification
here, we use the CNN algorithm. It consists of several layers for efficient implementation. In
each step, convolutional layer build and pooling are added. Finally, the regression layer is added
to get the output. Another important parameter is learning rate (LR) which consists of how the
speed at which learning the model. Here 1.e-3 set as LR. After the model building, load the data
in the model. Here we use the variable consisting of a model name that Common diseases like
viral, bacterial, fungal infections can be difficult to distinguish, and these symptoms can be
represented in the difference in color, function, and shape in which plant responds to the
pathogen. Smaller datasets are less efficient and affect the model performance. Training a large
set of data can not only reduce overfitting but can enhance a model’s overall performance. The
quality and type of training dataset massively impact the model capabilities. The training data
contains noise the classifier’s accuracy becomes dependent on this composition. This topic of
early detection is explored due to a limited number of datasets, and it consists of less accuracy
and detection. This system avoids the gathering of more leaf inputs for studying them in the
laboratory because preexisting images and datasets are taken and identify the plant diseases.it
imparts a feasible functioning approach that can use not be costly and complex. It works by
using CNN to detecting the leaf is healthy or diseased and if it is a disease it identifies the
diseases like fungi, viruses, bacteria, black spots, powdery mildew, downy mildew, blight,
canker, etc. and also provides remedies for recoverability of these diseases.
RELATED WORK

Eftekhar Hossain et al., [1] proposed a system for recognizing the plant leaf diseases with the
appropriate classifier K-nearest neighbor (KNN). The features that were extracted through the
images of diseased image were used to execute the classification. In the paper, the system KNN
classifier classified the diseases commonly found in plants like bacterial blight, early blight,
bacterial spot, leaf spot of various plant species. This method exhibited an accuracy of 96.76%.
Sammy et al., [2] proposed a CNN for the classifying the disease types and in this paper the
author used 9 different varieties of leaf diseases of tomato, grape, corn, apple and sugarcane. In
this paper the training is conducted on the system for nearly about 50 epochs and they used 22
size of batch. In this model with the help of categorical crossentropy, Adam optimizer is
conducted. Accuracy obtained is 96.5%. Ch Usha Kumari et al., [3] developed a system that
deploys the methods of K- Means clustering and Artificial Neural Network and performs
computation of various features like Contrast, Correlation, Energy, Mean, Standard Deviation
and Variance were performed. The major limitation was that accuracy of four different diseases
was analyzed and the average accuracy is comparatively low.

Merecelin et al., [4] put forward a detailed study of identification of disease in plant (appleand
tomato leaf) using the concepts of CNN. The model was trained on leaf image dataset containing
3663 images of apple and tomato plant leaf achieving an accuracy of 87%

Jiayue et al., [5] performed the recognition of tomato fruits with disease, the technique called
YOLOv2 CNN was used. YOLOv2 is based on regression model and uses a target detection
algorithm, which exhibits fast detection speed and good accuracy. The MAP (mean Average
Precision) was estimated to be around 97%. The major limitationof the paper was the need to
perform different tuning if the images. Robert G et al., [6] proposed a system using CNN to
detect the type of tomato leaf diseases. This paper reported that the F-RCNN trained model
obtained 80% confidence score, while accuracy of 95.75% was obtained by the Transfer
Learning model. The automated image seizing method registered 91.67 % accuracy. Halil et al.,
[7] proposed a deep learning model was deployed with two different deep learning network
architectures, Alex Net and then Squeeze Net. The training and validation of these deep learning
networks were performed on the Nvidia Jetson TX1. The Alex Net achieved an accuracy of
95.6% and on the other hand Squeeze Net model achieved an accuracy of 94.3%. Sabrol et al.,
[8], the authors used an easy and uncomplicated mechanism is utilized for doing the process of
classification of the different kind of diseases that occur in tomato leaves namely Early blight,
Yellow curl virus, late blight, Mosaic virus, Bacterial spot and Healthy. The dataset contained
400 images clicked using a digital camera. Supervised learning method have been used for
classification, where in the accuracy achieved was high, but decision tree has certain
disadvantages – if instance of noisy data overfitting happens.

The implementation model was developed with a system consisting of higher system
requirements. Here users have to give leaf images and the specified thing in this model is users
must install the various packages like TensorFlow, Opencv, Keras, etc. The existing system
consisting of users has detected the diseases which present in the plant leaves. But it does not
provide the remedies for overcoming the deficiency. Paper [1] proposed various methods for the
automated identification of plant diseases. The disease can manifest in various parts of the plant
such as root, stem, fruit, leaves, etc. As stated before this work concentrate, particularly on
leaves. Paper [2] presents the identification of diseased and healthy leaves from created sets of
data. These are built with many strategies on feature extraction like the histogram of an oriented
gradient (HOG). Paper [3] Mr. Ashish Nage and Prof V.R Raut discussed with identification of
diseases in leaves. They suggest an android application that helps farmers for identifying plant
diseases by uploading images on the computer. This program builds with a set of algorithms that
identifies the disease type. User-given input undergoes several processing steps to detect the
disease and results are returned to the user with the android application. Paper [4] uses image
processing to identify unhealthiness in plants and detect downsides in the tomato leaves from
images. For detection here consider the features like color, bound and texture to give the brisk
and decrease the losses for farmers and ensure productivity. Here, KNN (K- nearest neighbors)
algorithm is used for classification. Which is guided and implemented to find solutions for
classification and regression problems. Paper [5] focus on finding plant diseases and reducing
losses. For building the model here using deep learning techniques for leaf identification and
important hierarchy of neural networks like Faster region basis convolution neural network
(Faster R-CNN), region-based fully CNN(R-CNN), and single-shot multibook detector (SSD).
After validation, it produces the results consisting with an accuracy of 94.6% which depicts
feasibility on the CNN and finding deep learning solutions. Paper [6] aims to rice leaf
identification model using machine learning approaches. The algorithm used for this purpose is
KNN (K Nearest Neighbor), J48(decision tree), Naïve Bayes and Decision tree algorithm,
Logistic Regression, etc. Higher accuracy was found in this paper by the use of efficient
algorithms.

Patil et al. [5] developed a deep CNN model to detect diseases in cotton plants. Augmentation,
fine tuning and image processing was performed on the leaves and different test cases gave an
efficient outcome for detecting diseases in cotton plants. These methods can help farmers detect
diseases as early as possible and prevent their crops from being damaged. Chen et al. [6] studied
the transfer learning of deep convolutional neural networks for detecting plant diseases. They
selected the VGGNet-19 model pre-trained on ImageNet dataset, combining with the Inception
Module. The proposed approach was able to give validation accuracy of around 92% even under
complex background conditions. Chohan et al.[7] proposed a Plant Disease detector which uses
pictures of plants to detect the diseases. Convolutional Neural Network with multiple
convolution and pooling layers is used on PlantVillage dataset with 15 percent data chosen for
testing. They proposed that this model could be integrated with drones and other systems for
disease detection in plants.Sibiya et al.[8] utilised CNN (GUI) in maize to detect diseases like
northern corn leaf blight, grey leaf spot and common rust with accuracies 99.9%, 91% and 87%,
respectively. The healthy leaf detection percentage was at 93.5% and the overall accuracy was
92.85%.

Binh et al. [9] proposed a method to detect gray spots on tea leaves using computer vision and
image processing algorithms. They used a Neural of Multi-Layer Perceptron (MLP) built with
extracted identifying features on the gray spots tea leaves. They combined image processing
algorithms, neural networks with computer vision to determine gray spots on tea leaves. Barbedo
[10] used individual lesions and spots for detecting plant diseases instead of considering the
entire leaf. This was done to increase the variability of data. Multiple diseases could be detected
on a single leaf with this approach. Better results were achieved using this approach. Also, each
crop had an accuracy of at least 75%.
SYSTEM ANALYSIS

EXISTING SYSTEM:

The current approach for detecting plant disease is simple naked eye observation by plant
experts, which can be used to detect and identify plant diseases. In these circumstances, the
suggested technique is useful for tracking vast fields of crops. Furthermore, in some nations,
farmers lack adequate facilities or are unaware that they can contact experts. As a result,
consulting experts is not only more expensive but also more time consuming. In those
circumstances, the suggested technique for tracking a large number of plants would be useful.

but we don’t know what they are doing.

DISADVANTAGES:

Single user access within network

• Less efficient
• Absence of real-time environment
• Can’t take Screenshot
• Does not allow Multiuser monitoring

PROPOSED SYSTEM:

This study is focused on the identification of plant diseases. The segmentation, feature
extraction, and classification techniques are used to detect plant diseases. Photos of leaves from
various plants are taken with a digital camera or similar unit, and the images are used to classify
the affected region in the leaves. Then comes extracting features of a preprocessed image which
is done with the help of HOG. HoG is a feature descriptor used for object detection. In this
feature descriptor the appearance of the object and the outline of the image is described by its
intensity gradients. One of the advantages of HoG feature extraction is that it operates on the
cells created.

ADVANTAGES

 Detects related images with a low-cost camera and open cv.

 Opencv aids in the efficient analysis of images and videos.
SYSTEM ARCHITECTURE
SYSTEM DESIGN

DATA FLOW DIAGRAM:

1. The DFD is also called as bubble chart. It is a simple graphical formalism that can be
used to represent a system in terms of input data to the system, various processing carried
out on this data, and the output data is generated by this system.
2. The data flow diagram (DFD) is one of the most important modeling tools. It is used to
model the system components. These components are the system process, the data used
by the process, an external entity that interacts with the system and the information flows
in the system.
3. DFD shows how the information moves through the system and how it is modified by a
series of transformations. It is a graphical technique that depicts information flow and the
transformations that are applied as data moves from input to output.
4. DFD is also known as bubble chart. A DFD may be used to represent a system at any
level of abstraction. DFD may be partitioned into levels that represent increasing
information flow and functional detail.
FLOW ACTIVITY DIAGRAM:

Activity diagrams are graphical representations of workflows of stepwise activities and

actions with support for choice, iteration and concurrency. In the Unified Modeling Language,
activity diagrams can be used to describe the business and operational step-by-step workflows of
components in a system. An activity diagram shows the overall flow of control.
MODULES

MODULES:

 Image Acquisition.
 Image Pre-Processing.
 Image Enhancement.
 Image Segmentation.
 Image Analysis
 Feature Extraction.
 Disease Classification.

MODULES DESCRIPTION:

IMAGE ACQUISITION:

The first step is to gather data from a publicly accessible repository. The picture is used
as the input for further processing. We've chosen the most common image domains so that we
can accept any format as input to our method, including.bmp,.jpg, and.gif. The camera feeds the
real-time images directly. Since most leaves colour varies from red to green for exact
segmentation, a white background is provided for further study, proper visibility, and easy image
analysis. Cotton images are captured using an image capturing system in this process. The
picture is taken in such a way that any distortion is avoided. The photo was not taken in direct
sunlight because it would distort the picture.

IMAGE PRE-PROCESSING:

The use of computer algorithms to perform image processing on digital images is known
as image pre-processing. Detect the plant by analysing the image with a specific algorithm. Use a
similar approach for image processing and detection with a specific algorithm. The image quality
is critical in this process; we can't use the algorithm if the image isn't clear.
IMAGE ENHANCEMENT:

The process of modifying digital images so that the effects are more appropriate for
display or further image processing is known as image enhancement. Any of the following can
be used to improve an image:

 Histogram Equalization.
 Noise removal using filters.
 Unsharp mask filtering.
 Decorrelation stretch etc.

IMAGE SEGMENTATIONS:

The method of segmenting a digital image into multiple segments is known as image
segmentation (sets of pixels, also known as image objects). Image segmentation is used to make
image identification and analysis simpler by dividing the image into several segments and
analysing each segment individually. Color, texture, and intensity are all common characteristics
among the various segments.

IMAGE ANALYSIS:

In this step, image segmentation is used to locate the region of interest. The technique
used in segmentation is region-based segmentation, which uses the colour of the leaf to
distinguish between healthy and diseased regions of the plant leaf.

FEATURE EXTRACTION:

Feature extraction is a part of the dimensionally reduction method in machine learning,

which divides and reduces a large collection of raw data into smaller classes. When we have a
large amount of data and need to minimise the number of resources while avoiding errors, this
step is critical. As a result, function extraction aids in the extraction of the best feature from large
data sets by selecting and combining variables into functions.
DISEASE CLASSIFICATIONS:

It is the method of using our qualified deep learning model to recognise plant disease. A
digital camera or equivalent system should be used to take an image of the contaminated plant's
leaf. Opencv was used to scan the image. Then it determines what kind of plant it is. It
determines what kind of disease the plant has after finding it.

SYSTEM REQUIREMENTS

HARDWARE REQUIREMENTS

 System : Pentium IV 2.4 GHz.

 Hard Disk : 500 GB.
 Monitor : 15 VGA Colour.
 Mouse : Logitech.
 RAM : 4 GB.

SOFTWARE REQUIREMENTS

 Operating System : Windows-7/10 (64-bit).

 Language : Python 3.7
 IDE Tools : Visual Studio Code 1.7
SOFTWARE ENVIRONMENT

PYTHON:

Python is an interpreter, high-level and general-purpose programming language. Python's

design philosophy emphasizes code readability with its notable use of significant whitespace. Its
language constructs and object-oriented approach aim to help programmers write clear, logical
code for small and large-scale projects. Python is dynamically-typed and garbage-collected. It
supports multiple programming paradigms, including structured (particularly, procedural),
object-oriented and functional programming. Python is often described as a "batteries included"
language due to its comprehensive standard library.

Python was created in the late 1980s, and first released in 1991, by Guido van Rossum as
a successor to the ABC programming language. Python 2.0, released in 2000, introduced new
features, such as list comprehensions, and a garbage collection system with reference counting,
and was discontinued with version 2.7 in 2020. Python 3.0, released in 2008, was a major
revision of the language that is not completely backward-compatible and much Python 2 code
does not run unmodified on Python 3. With Python 2's end-of-life (and pip having dropped
support in 2021), only Python 3.6.x and later are supported, with older versions still supporting
e.g. Windows 7 (and old installers not restricted to 64-bit Windows).
Python interpreters are supported for mainstream operating systems and available for a
few more (and in the past supported many more). A global community of programmers develops
and maintains CPython, a free and open-source reference implementation. A non-profit
organization, the Python Software Foundation, manages and directs resources for Python and
CPython development.
HISTORY:

Python was conceived in the late 1980s by Guido van Rossum at Centrum Wiskunde &
Informatica (CWI) in the Netherlands as a successor to ABC programming language, which was
inspired by SETL,capable of exception handling and interfacing with the Amoeba operating
system.[9] Its implementation began in December 1989. Van Rossum shouldered sole
responsibility for the project, as the lead developer, until 12 July 2018, when he announced his
"permanent vacation" from his responsibilities as Python's Benevolent Dictator For Life, a title
the Python community bestowed upon him to reflect his long-term commitment as the project's
chief decision-maker. He now shares his leadership as a member of a five-person steering
council. In January 2019, active Python core developers elected Brett Cannon, Nick Coghlan,
Barry Warsaw, Carol Willing and Van Rossum to a five-member "Steering Council" to lead the
project. Guido van Rossum has since then withdrawn his nomination for the 2020 Steering
council. Python 2.0 was released on 16 October 2000 with many major new features, including a
cycle-detecting garbage collector and support for Unicode.

Python 3.0 was released on 3 December 2008. It was a major revision of the language that is not
completely backward-compatible.Many of its major features were backported to Python 2.6.x
and 2.7.x version series. Releases of Python 3 include the 2to3 utility, which automates (at least
partially) the translation of Python 2 code to Python 3.
Python 2.7's end-of-life date was initially set at 2015 then postponed to 2020 out of concern that
a large body of existing code could not easily be forward-ported to Python 3. No more security
patches or other improvements will be released for it. With Python 2's end-of-life, only Python
3.6.x and later are supported.

DESIGN PHILOSOPHY AND FEATURES:

Python is a multi-paradigm programming language. Object-oriented programming and

structured programming are fully supported, and many of its features support functional programming
and aspect-oriented programming (including by metaprogramming and metaobjects (magic
methods)).Many other paradigms are supported via extensions, including design by contract and logic
programming. Python uses dynamic typing and a combination of reference counting and a cycle-
detecting garbage collector for memory management. It also features dynamic name resolution (late
binding), which binds method and variable names during program execution.Python's design offers
some support for functional programming in the Lisp tradition. It has filter, map, and reduce functions;
list comprehensions, dictionaries, sets, and generator expressions.The standard library has two
modules (itertools and functools) that implement functional tools borrowed from Haskell and
Standard ML.The language's core philosophy is summarized in the document The Zen of Python
(PEP 20), which includes aphorisms such as:

 Beautiful is better than ugly.

 Explicit is better than implicit.

 Simple is better than complex.

 Complex is better than complicated.

 Readability counts.

STATEMENTS AND CONTROL FLOW:

Python's statements include (among others):

 The assignment statement (token '=', the equals sign).

 The if statement, which conditionally executes a block of code, along with else and elif (a
contraction of else-if).

 The for statement, which iterates over an iterable object, capturing each element to a local
variable for use by the attached block.

 The while statement, which executes a block of code as long as its condition is true.
 The try statement, which allows exceptions raised in its attached code block to be caught and
handled by except clauses; it also ensures that clean-up code in a finally block will always be
run regardless of how the block exits.
METHODS:
Methods on objects are functions attached to the object's class; the syntax instance.
method(argument) is, for normal methods and functions, syntactic sugar for Class.
method(instance, argument). Python methods have an explicit self parameter to access instance
data, in contrast to the implicit self (or this) in some other object-oriented programming
languages (e.g., C++, Java, Objective-C, or Ruby).

TYPING:

Python uses duck typing and has typed objects but untyped variable names. Type
constraints are not checked at compile time; rather, operations on an object may fail, signifying
that the given object is not of a suitable type. Despite being dynamically-typed, Python is
strongly-typed, forbidding operations that are not well-defined (for example, adding a number to
a string) rather than silently attempting to make sense of them. Python allows programmers to
define their own types using classes, which are most often used for object-oriented
programming. New instances of classes are constructed by calling the class (for example,
SpamClass() or EggsClass()), and the classes are instances of the metaclass type (itself an
instance of itself), allowing metaprogramming and reflection.Before version 3.0, Python had two
kinds of classes: old-style and new-style. The syntax of both styles is the same, the difference
being whether the class object is inherited from, directly or indirectly (all new-style classes
inherit from object and are instances of type). In versions of Python 2 from Python 2.2 onwards,
both kinds of classes can be used. Old-style classes were eliminated in Python 3.0. The long-term
plan is to support gradual typing and from Python 3.5, the syntax of the language allows
specifying static types but they are not checked in the default implementation, CPython. An
experimental optional static type checker named mypy supports compile-time type checking.

PROGRAMMING EXAMPLES:

print('Hello, world!')

LIBRARIES:

Python's large standard library, commonly cited as one of its greatest strengths, provides
tools suited to many tasks. For Internet-facing applications, many standard formats and protocols
such as MIME and HTTP are supported. It includes modules for creating graphical user
interfaces, connecting to relational databases, generating pseudorandom numbers, arithmetic
with arbitrary-precision decimals,manipulating regular expressions, and unit testing. Some parts
of the standard library are covered by specifications (for example, the Web Server Gateway
Interface (WSGI) implementation wsgiref follows PEP 333), but most modules are not. They are
specified by their code, internal documentation, and test suites. However, because most of the
standard library is cross-platform Python code, only a few modules need altering or rewriting for
variant implementations.As of January 2020, the Python Package Index (PyPI), the official
repository for third-party Python software, contains over 287,000 packages with a wide range of
functionality, including:

 Automation
 Data analytics
 Databases
 Documentation
 Graphical user interfaces
 Image processing
 Machine learning
 Mobile App
 Multimedia

USES:

Since 2003, Python has consistently ranked in the top ten most popular programming
languages in the TIOBE Programming Community Index where, as of February 2020, it is the
third most popular language (behind Java, and C). It was selected Programming Language of the
Year in 2007, 2010, and 2018. An empirical study found that scripting languages, such as
Python, are more productive than conventional languages, such as C and Java, for programming
problems involving string manipulation and search in a dictionary, and determined that memory
consumption was often "better than Java and not much worse than C or C++".Large
organizations that use Python include Wikipedia, Google, Yahoo!, CERN, NASA,Facebook,
Amazon, Instagram, Spotify and some smaller entities like ILM and ITA. The social news
networking site Reddit is written entirely in Python.Python can serve as a scripting language for
web applications, e.g., via mod_wsgi for the Apache web server. With Web Server Gateway
Interface, a standard API has evolved to facilitate these applications. Web frameworks like
Django, Pylons, Pyramid, TurboGears, web2py, Tornado, Flask, Bottle and Zope support
developers in the design and maintenance of complex applications. Pyjs and IronPython can be
used to develop the client-side of Ajax-based applications. SQLAlchemy can be used as a data
mapper to a relational database. Twisted is a framework to program communications between
computers, and is used (for example) by Dropbox. Libraries such as NumPy, SciPy and
Matplotlib allow the effective use of Python in scientific computing, with specialized libraries
such as Biopython and Astropy providing domain-specific functionality. SageMath is a
mathematical software with a notebook interface programmable in Python: its library covers
many aspects of mathematics, including algebra, combinatorics, numerical mathematics, number
theory, and calculus.OpenCV has python bindings with a rich set of features for computer vision
and image processing.

TKINTER:

Tkinter is a Python binding to the Tk GUI toolkit. It is the standard Python interface to the Tk
GUI toolkit, and is Python's de facto standard GUI. Tkinter is included with standard Linux, Microsoft
Windows and Mac OS X installs of Python.

Window

This term has different meanings in different contexts, but in general it refers to a rectangular
area somewhere on the user's display screen.

Top-level window

A window which acts as a child of the primary window. It will be decorated with the standard
frame and controls for the desktop manager. It can be moved around the desktop and can usually be
resized.

Widget

The generic term for any of the building blocks that make up an application in a graphical user
interface.

 Core widgets: The containers: frame, labelframe, toplevel, paned window. The buttons:
button, radiobutton, checkbutton (checkbox), and menubutton. The text widgets: label,
 message, text. The entry widgets: scale, scrollbar, listbox, slider, spinbox, entry (singleline),
optionmenu, text (multiline), and canvas (vector and pixel graphics).
 Tkinter provides three modules that allow pop-up dialogs to be displayed: tk.messagebox
(confirmation, information, warning and error dialogs), tk.filedialog (single file, multiple file
and directory selection dialogs) and tk.colorchooser (colour picker).
 Python 2.7 and Python 3.1 incorporate the "themed Tk" ("ttk") functionality of Tk 8.5. This
allows Tk widgets to be easily themed to look like the native desktop environment in which
the application is running, thereby addressing a long-standing criticism of Tk (and hence of
Tkinter). Some widgets are exclusive to ttk, such as the combobox, progressbar and treeview
widgets

Frame

In Tkinter, the Frame widget is the basic unit of organization for complex layouts. A frame is a
rectangular area that can contain other widgets.

Child and parent

When any widget is created, a parent–child relationship is created. For example, if you place a
text label inside a frame, the frame is the parent of the label.
MACHINE LEARNING:

Python has a vast number of libraries for data analysis, statistics, and Machine Learning itself,
making it a language of choice for many data scientists.

Machine Learning, as the name suggests, is the science of programming a computer by which they are
able to learn from different kinds of data. A more general definition given by Arthur Samuel is –
“Machine Learning is the field of study that gives computers the ability to learn without being
explicitly programmed.” They are typically used to solve various types of life problems.

In the older days, people used to perform Machine Learning tasks by manually coding all the
algorithms and mathematical and statistical formulas. This made the processing time-consuming,
tedious, and inefficient. But in the modern days, it is become very much easy and more efficient
compared to the olden days with various python libraries, frameworks, and modules. Today, Python is
one of the most popular programming languages for this task and it has replaced many languages in
the industry, one of the reasons is its vast collection of libraries.

SciPy Stack:

The SciPy stack consists of a bunch of core helper packages used in data science for statistical
analysis and visualising data. Because of its huge number of functionalities and ease of use, the Stack
is considered a must-have for most data science applications.

The Stack consists of the following packages (link to documentation given):

 NumPy
 SciPy library
 Matplotlib
 IPython
 pandas
 Sympy
 nose

Installation
For installing the full stack, or individual packages, you can refer to the instructions given here.
NB: Anaconda is highly preferred and recommended for installing and maintaining data science
packages seamlessly.
scikit-learn
Scikit is a free and open source machine learning library for Python. It offers off-the-shelf
functions to implement many algorithms like linear regression, classifiers, SVMs, k-means,
Neural Networks, etc. It also has a few sample datasets which can be directly used for training
and testing.
Because of its speed, robustness, and ease of, it’s one of the most widely-used libraries for many
Machine Learning applications.

Installation
Through PyPI:
pip install -U scikit-learn

Through conda:
conda install scikit-learn

UNDERSTANDING DATA PROCESSING:

Data Processing is the task of converting data from a given form to a much more usable and
desired form i.e. making it more meaningful and informative. Using Machine Learning
algorithms, mathematical modeling, and statistical knowledge, this entire process can be
automated. The output of this complete process can be in any desired form like graphs, videos,
charts, tables, images, and many more, depending on the task we are performing and the
requirements of the machine. This might seem to be simple but when it comes to massive
organizations like Twitter, Facebook, Administrative bodies like Parliament, UNESCO, and
health sector organizations, this entire process needs to be performed in a very structured
manner. So, the steps to perform are as follows:
Fig-Data Processing
COLLECTION:
The most crucial step when starting with ML is to have data of good quality and
accuracy. Data can be collected from any authenticated source like data.gov.in, Kaggle or UCI
dataset repository. For example, while preparing for a competitive exam, students study from the
best study material that they can access so that they learn the best to obtain the best results. In the
same way, high-quality and accurate data will make the learning process of the model easier and
better and at the time of testing, the model would yield state-of-the-art results.
A huge amount of capital, time and resources are consumed in collecting data. Organizations or
researchers have to decide what kind of data they need to execute their tasks or research.
Example: Working on the Facial Expression Recognizer, needs numerous images having a
variety of human expressions. Good data ensures that the results of the model are valid and can
be trusted upon.

PREPARATION:
The collected data can be in a raw form which can’t be directly fed to the machine. So, this is a
process of collecting datasets from different sources, analyzing these datasets and then
constructing a new dataset for further processing and exploration. This preparation can be
performed either manually or from the automatic approach. Data can also be prepared in numeric
forms also which would fasten the model’s learning.
Example: An image can be converted to a matrix of N X N dimensions, the value of each cell
will indicate the image pixel.
INPUT:

Now the prepared data can be in the form that may not be machine-readable, so to convert this
data to the readable form, some conversion algorithms are needed. For this task to be executed,
high computation and accuracy is needed. Example: Data can be collected through the sources
like MNIST Digit data(images), Twitter comments, audio files, video clips.

PROCESSING:
This is the stage where algorithms and ML techniques are required to perform the instructions
provided over a large volume of data with accuracy and optimal computation.

OUTPUT:
In this stage, results are procured by the machine in a meaningful manner which can be inferred
easily by the user. Output can be in the form of reports, graphs, videos, etc

STORAGE:

This is the final step in which the obtained output and the data model data and all the useful
information are saved for future use.

CONCLUSION AND FUTURE SCOPE

Detecting plant diseases using Deep Learning can help farmers protect and minimise the damage
to the crops. Using pre-trained models such as VGGNet19 and modifying a few parameters can
significantly increase the accuracy in classifying images of plants. Transfer learning is a great
method that can reduce the time and computation power required to train the models. Using
VGGNet19 and adding a few layers can provide better results for classifying and detecting
diseases in plants. Also, these methods can be used to predict and classify images for a wider
range of plants and other crops. Moreover, Deep Transfer Learning can be used in other real
world applications using mobile devices for classifications and predictions using images.

SOURCE CODE

UI - Windows Code:
import tkinter as tk
from tkinter.filedialog import askopenfilename
import shutil
import os
import sys
from PIL import Image, ImageTk

window = tk.Tk()

window.title("Dr. Plant")

window.geometry("500x510")
window.configure(background ="lightgreen")

title = tk.Label(text="Click below to choose picture for testing disease....", background =

"lightgreen", fg="Brown", font=("", 15))
title.grid()
def bact():
    window.destroy()
    window1 = tk.Tk()

    window1.title("Dr. Plant")

    window1.geometry("500x510")
    window1.configure(background="lightgreen")

    def exit():
        window1.destroy()
    rem = "The remedies for Bacterial Spot are:\n\n "
    remedies = tk.Label(text=rem, background="lightgreen",
                      fg="Brown", font=("", 15))
    remedies.grid(column=0, row=7, padx=10, pady=10)
    rem1 = " Discard or destroy any affected plants. \n  Do not compost them. \n  Rotate yoour
tomato plants yearly to prevent re-infection next year. \n Use copper fungicites"
    remedies1 = tk.Label(text=rem1, background="lightgreen",
                        fg="Black", font=("", 12))
    remedies1.grid(column=0, row=8, padx=10, pady=10)

    button = tk.Button(text="Exit", command=exit)

    button.grid(column=0, row=9, padx=20, pady=20)

    window1.mainloop()

def vir():
    window.destroy()
    window1 = tk.Tk()

    window1.title("Dr. Plant")

    window1.geometry("650x510")
    window1.configure(background="lightgreen")

    def exit():
        window1.destroy()
    rem = "The remedies for Yellow leaf curl virus are: "
    remedies = tk.Label(text=rem, background="lightgreen",
                      fg="Brown", font=("", 15))
    remedies.grid(column=0, row=7, padx=10, pady=10)
    rem1 = " Monitor the field, handpick diseased plants and bury them. \n  Use sticky yellow
plastic traps. \n  Spray insecticides such as organophosphates, carbametes during the seedliing
stage. \n Use copper fungicites"
    remedies1 = tk.Label(text=rem1, background="lightgreen",
                         fg="Black", font=("", 12))
    remedies1.grid(column=0, row=8, padx=10, pady=10)

    button = tk.Button(text="Exit", command=exit)

    button.grid(column=0, row=9, padx=20, pady=20)

    window1.mainloop()

def latebl():
    window.destroy()
    window1 = tk.Tk()

    window1.title("Dr. Plant")

    window1.geometry("520x510")
    window1.configure(background="lightgreen")

    def exit():
        window1.destroy()
    rem = "The remedies for Late Blight are: "
    remedies = tk.Label(text=rem, background="lightgreen",
                      fg="Brown", font=("", 15))
    remedies.grid(column=0, row=7, padx=10, pady=10)
    rem1 = " Monitor the field, remove and destroy infected leaves. \n  Treat organically with
copper spray. \n  Use chemical fungicides,the best of which for tomatoes is chlorothalonil."
    remedies1 = tk.Label(text=rem1, background="lightgreen",
                         fg="Black", font=("", 12))
    remedies1.grid(column=0, row=8, padx=10, pady=10)

    button = tk.Button(text="Exit", command=exit)

    button.grid(column=0, row=9, padx=20, pady=20)

    window1.mainloop()

def analysis():
    import cv2  # working with, mainly resizing, images
    import numpy as np  # dealing with arrays
    import os  # dealing with directories
    from random import shuffle  # mixing up or currently ordered data that might lead our
network astray in training.
    from tqdm import \
        tqdm  # a nice pretty percentage bar for tasks. Thanks to viewer Daniel BA1/4hler for this
suggestion
    verify_dir = 'testpicture'
    IMG_SIZE = 50
    LR = 1e-3
    MODEL_NAME = 'healthyvsunhealthy-{}-{}.model'.format(LR, '2conv-basic')

    def process_verify_data():
        verifying_data = []
        for img in tqdm(os.listdir(verify_dir)):
            path = os.path.join(verify_dir, img)
            img_num = img.split('.')[0]
            img = cv2.imread(path, cv2.IMREAD_COLOR)
            img = cv2.resize(img, (IMG_SIZE, IMG_SIZE))
            verifying_data.append([np.array(img), img_num])
        np.save('verify_data.npy', verifying_data)
        return verifying_data

    verify_data = process_verify_data()
    #verify_data = np.load('verify_data.npy')

    import tflearn
    from tflearn.layers.conv import conv_2d, max_pool_2d
    from tflearn.layers.core import input_data, dropout, fully_connected
    from tflearn.layers.estimator import regression
    import tensorflow as tf
    #tf.reset_default_graph()
    tf.compat.v1.reset_default_graph()

    convnet = input_data(shape=[None, IMG_SIZE, IMG_SIZE, 3], name='input')

    convnet = conv_2d(convnet, 32, 3, activation='relu')

    convnet = max_pool_2d(convnet, 3)

    convnet = conv_2d(convnet, 64, 3, activation='relu')

    convnet = max_pool_2d(convnet, 3)

    convnet = conv_2d(convnet, 128, 3, activation='relu')

    convnet = max_pool_2d(convnet, 3)

    convnet = conv_2d(convnet, 32, 3, activation='relu')

    convnet = max_pool_2d(convnet, 3)

    convnet = conv_2d(convnet, 64, 3, activation='relu')

    convnet = max_pool_2d(convnet, 3)

    convnet = fully_connected(convnet, 1024, activation='relu')

    convnet = dropout(convnet, 0.8)

    convnet = fully_connected(convnet, 4, activation='softmax')

    convnet = regression(convnet, optimizer='adam', learning_rate=LR,
loss='categorical_crossentropy', name='targets')

    model = tflearn.DNN(convnet, tensorboard_dir='log')

    if os.path.exists('{}.meta'.format(MODEL_NAME)):
        model.load(MODEL_NAME)
        print('model loaded!')

    import matplotlib.pyplot as plt

    fig = plt.figure()

    for num, data in enumerate(verify_data):

        img_num = data[1]
        img_data = data[0]

        y = fig.add_subplot(3, 4, num + 1)
        orig = img_data
        data = img_data.reshape(IMG_SIZE, IMG_SIZE, 3)
        # model_out = model.predict([data])[0]
        model_out = model.predict([data])[0]

        if np.argmax(model_out) == 0:
            str_label = 'healthy'
        elif np.argmax(model_out) == 1:
            str_label = 'bacterial'
        elif np.argmax(model_out) == 2:
            str_label = 'viral'
        elif np.argmax(model_out) == 3:
            str_label = 'lateblight'

        if str_label =='healthy':
            status ="HEALTHY"
        else:
            status = "UNHEALTHY"

        message = tk.Label(text='Status: '+status, background="lightgreen",

                           fg="Brown", font=("", 15))
        message.grid(column=0, row=3, padx=10, pady=10)
        if str_label == 'bacterial':
            diseasename = "Bacterial Spot "
            disease = tk.Label(text='Disease Name: ' + diseasename, background="lightgreen",
                               fg="Black", font=("", 15))
            disease.grid(column=0, row=4, padx=10, pady=10)
            r = tk.Label(text='Click below for remedies...', background="lightgreen", fg="Brown",
font=("", 15))
            r.grid(column=0, row=5, padx=10, pady=10)
            button3 = tk.Button(text="Remedies", command=bact)
            button3.grid(column=0, row=6, padx=10, pady=10)
        elif str_label == 'viral':
            diseasename = "Yellow leaf curl virus "
            disease = tk.Label(text='Disease Name: ' + diseasename, background="lightgreen",
                               fg="Black", font=("", 15))
            disease.grid(column=0, row=4, padx=10, pady=10)
            r = tk.Label(text='Click below for remedies...', background="lightgreen", fg="Brown",
font=("", 15))
            r.grid(column=0, row=5, padx=10, pady=10)
            button3 = tk.Button(text="Remedies", command=vir)
            button3.grid(column=0, row=6, padx=10, pady=10)
        elif str_label == 'lateblight':
            diseasename = "Late Blight "
            disease = tk.Label(text='Disease Name: ' + diseasename, background="lightgreen",
                               fg="Black", font=("", 15))
            disease.grid(column=0, row=4, padx=10, pady=10)
            r = tk.Label(text='Click below for remedies...', background="lightgreen", fg="Brown",
font=("", 15))
            r.grid(column=0, row=5, padx=10, pady=10)
            button3 = tk.Button(text="Remedies", command=latebl)
            button3.grid(column=0, row=6, padx=10, pady=10)
        else:
            r = tk.Label(text='Plant is healthy', background="lightgreen", fg="Black",
                         font=("", 15))
            r.grid(column=0, row=4, padx=10, pady=10)
            button = tk.Button(text="Exit", command=exit)
            button.grid(column=0, row=9, padx=20, pady=20)

def openphoto():
    dirPath = "testpicture"
    fileList = os.listdir(dirPath)
    for fileName in fileList:
        os.remove(dirPath + "/" + fileName)
    # C:/Users/sagpa/Downloads/images is the location of the image which you want to test.....
you can change it according to the image location you have  
    fileName = askopenfilename(initialdir='C:/Users/user/Downloads/images', title='Select image
for analysis ',
                           filetypes=[('image files', '.jpg')])
    dst = "C:/Users/user/Python2022/FlaskProject/Plant_Disease_Detection_GUI/testpicture"
    shutil.copy(fileName, dst)
    load = Image.open(fileName)
    render = ImageTk.PhotoImage(load)
    img = tk.Label(image=render, height="250", width="500")
    img.image = render
    img.place(x=0, y=0)
    img.grid(column=0, row=1, padx=10, pady = 10)
    title.destroy()
    button1.destroy()
    button2 = tk.Button(text="Analyse Image", command=analysis)
    button2.grid(column=0, row=2, padx=10, pady = 10)
button1 = tk.Button(text="Get Photo", command = openphoto)
button1.grid(column=0, row=1, padx=10, pady = 10)
window.mainloop()
SCREEN SHOTS

Main Window:
Leaf Load on Window:
Analyze Image:
Remedies Details:

 Less efficient
 • Absence of real-time environment
 • Can’t take Screenshot
 • Does not allow Multiuser monitoring
 Less efficient
 • Absence of real-time environment
 • Can’t take Screenshot
 • Does not allow Multiuser monitoring

REFERENCES
1. Munisami, T.; Ramsurn, M.; Kishnah, S.; Pudaruth, S. Plant leaf recognition using shape
features and colour histogram with K-nearest neighbour classifiers. Procedia Comput.
Sci. 2015, 58, 740–747. [Google Scholar]
2. Ebrahimi, M.; Khoshtaghaza, M.; Minaei, S.; Jamshidi, B. Vision-based pest detection based on
SVM classification method. Comput. Electron. Agric. 2017, 137, 52–58. [Google Scholar]
[CrossRef]
3. Garcia-Ruiz, F.; Sankaran, S.; Maja, J.M.; Lee, W.S.; Rasmussen, J.; Ehsani, R. Comparison of
two aerial imaging platforms for identification of Huanglongbing-infected citrus trees. Comput.
Electron. Agric. 2013, 91, 106–115. [Google Scholar] [CrossRef]
4. Yao, Q.; Guan, Z.; Zhou, Y.; Tang, J.; Hu, Y.; Yang, B. Application of support vector machine
for detecting rice diseases using shape and color texture features. In Proceedings of the 2009
International Conference on Engineering Computation, Hong Kong, China, 2–3 May 2009; pp.
79–83. [Google Scholar]
5. Islam, M.; Dinh, A.; Wahid, K.; Bhowmik, P. Detection of potato diseases using image
segmentation and multiclass support vector machine. In Proceedings of the 2017 IEEE 30th
Canadian Conference on Electrical and Computer Engineering (CCECE), Windsor, ON, Canada,
30 April–3 May 2017; pp. 1–4. [Google Scholar]
6. Tan, J.W.; Chang, S.W.; Kareem, S.B.A.; Yap, H.J.; Yong, K.T. Deep Learning for Plant
Species Classification using Leaf Vein Morphometric. IEEE/ACM Trans. Comput. Biol.
Bioinform. 2018, 17, 82–90. [Google Scholar] [CrossRef] [PubMed]
7. McCallum, A.; Nigam, K. A comparison of event models for naive bayes text classification. In
Proceedings of the AAAI-98 Workshop on Learning for Text Categorization, Madison, WI,
USA, 26–27 July 1998; Volume 752, pp. 41–48. [Google Scholar]
8. ÖZTÜRK, A.E.; Ceylan, M. Fusion and ANN based classification of liver focal lesions using
phases in magnetic resonance imaging. In Proceedings of the 2015 IEEE 12th International
Symposium on Biomedical Imaging (ISBI), Brooklyn, NY, USA, 16–19 April 2015; pp. 415–
419. [Google Scholar]
9. Pujari, D.; Yakkundimath, R.; Byadgi, A.S. SVM and ANN based classification of plant diseases
using feature reduction technique. IJIMAI 2016, 3, 6–14. [Google Scholar] [CrossRef][Green
Version]
10. Lee, S.H.; Chan, C.S.; Mayo, S.J.; Remagnino, P. How deep learning extracts and learns leaf
features for plant classification. Pattern Recognit. 2017, 71, 1–13. [Google Scholar] [CrossRef]
[Green Version]
11. Shah, M.P.; Singha, S.; Awate, S.P. Leaf classification using marginalized shape context and
shape+ texture dual-path deep convolutional neural network. In Proceedings of the 2017 IEEE
International Conference on Image Processing (ICIP), Beijing, China, 17–20 September 2017;
pp. 860–864. [Google Scholar]
12. Li, Y.; Yang, J. Few-shot cotton pest recognition and terminal realization. Comput. Electron.
Agric. 2020, 169, 105240. [Google Scholar] [CrossRef]
13. Lee, S.H.; Goëau, H.; Bonnet, P.; Joly, A. New perspectives on plant disease characterization
based on deep learning. Comput. Electron. Agric. 2020, 170, 105220. [Google Scholar]
[CrossRef]
14. Fuentes, A.; Yoon, S.; Kim, S.C.; Park, D.S. A robust deep-learning-based detector for real-time
tomato plant diseases and pests recognition. Sensors 2017, 17, 2022. [Google Scholar]
[CrossRef][Green Version]
15. Mohanty, S.P.; Hughes, D.P.; Salathé, M. Using deep learning for image-based plant disease
detection. Front. Plant Sci. 2016, 7, 1419. [Google Scholar] [CrossRef][Green Version]
16. Ferentinos, K.P. Deep learning models for plant disease detection and diagnosis. Comput.
Electron. Agric. 2018, 145, 311–318. [Google Scholar] [CrossRef]