Potato Blight Detection Using Fine-Tuned CNN Architecture

Abstract

Potato is one of the major cultivated crops and provides occupations and livelihoods for numerous people across the globe. It also contributes to the economic growth of developing and underdeveloped countries. However, potato blight is one of the major destroyers of potato crops worldwide. With the introduction of neural networks to agriculture, many researchers have contributed to the early detection of potato blight using various machine and deep learning algorithms. However, accuracy and computation time remain serious issues. Therefore, considering these challenges, we customised a convolutional neural network (CNN) to improve accuracy with fewer trainable parameters, less computation time, and reduced information loss. We compared the performance of the proposed model with various machine and deep learning algorithms used for potato blight classification. The proposed model outperformed the others with an overall accuracy of 99% using 839,203 trainable parameters in 183 s of training time.

1. Introduction

The agricultural industry is the greatest contributor to food, income, and jobs globally. In India, the industry accounts for 18.0% of the country’s GDP, and 53.3% of its workforce [1], comparable to other low- to middle-income countries. Over the last three years, the percentage of the country’s total GDP contributed by agriculture’s gross value added (GVA) has increased from 17.6% to 20.2% [2,3], supporting India’s economic expansion. Plant illnesses and insect infections may affect agriculture and, thus, the quality of food production, but it is known that preventive drugs are inefficient for preventing epidemic or endemic diseases. Early monitoring and detection of crop diseases with adequate crop protection systems can help prevent production quality losses, and this can be accomplished by monitoring and identifying diseases in crops as early as possible.

Late blight due to the oomycete Phytophthora infestans (henceforth P. infestans) has caused the most damage to potato (Solanum tuberosum L.) crops in recorded history [4]. Many potato types produced in Colombia are susceptible to late blight [5,6], and the disease is difficult to control without using significant amounts of pesticide. The severity of late blight is often evaluated visually by determining what percentage of the crop’s foliage is infected [7,8]. However, visually assessing the severity of a disease is labour intensive, time-consuming, and not highly replicable due to the requirement for professional (subjective) intervention. Infections and bug infestations leave distinct patterns that can be exploited to establish accurate diagnoses [9]. In addition, farmers’ or specialists’ diagnoses of plant diseases may not be accurate [10], potentially leading to inappropriate applications of drugs that may have a detrimental effect on the quality of the crop and eventually damage the environment.

Recent developments in computer imaging have offered solutions to the detection challenges that farmers are currently facing [9]. Since the spots indicating infection first appear as dots and patterns on the leaves, the research community has produced several different approaches for accurately identifying and classifying plant diseases. Conventional image processing, which requires the use of manual methods for tasks, such as feature extraction and segmentation, is still used today [11]. Dubey et al. [12] used a K-means clustering strategy to deliver a multiclass support vector machine (SVM) classification for segregating contaminated leaf sections. Yun et al. [13] used a probabilistic neural network (NN) to extract the statistical and meteorological characteristics of the data. Numerous conventional models, such as the one created by Liu et al. [14], which combines an SVM and K-means clustering with a backpropagation NN, have been developed to identify plant diseases. Since the advent of AI, numerous computer imaging research projects have focused on the use of machine learning (ML) and deep learning (DL) [15,16] models to increase the accuracy of disease recognition.

A study [17] employed CNN architectures, such as AlexNet, GoogLeNet, and ResNet, as basic models for diagnosing disease in tomato leaf samples. Histograms of training and validation accuracy enabled the performance of the model to be visualised. Of the various CNN architectures, ResNet emerged as the model that performed best. LeNet architecture has also been used to identify banana leaf disease, and the model was evaluated in colour and greyscale using the conditional average (CA) and the F1-score [18]. Both colour and greyscale evaluations were performed using these metrics. In [19], a comparison was made between the architectures of five different types of CNNs, referred to by their various names: AlexNet, AlexNetOWTbn, GoogLeNet, Overfeat, and VGG. The research employed many state-of-the-art DL models, including GoogLeNet, ResNet-50, ResNet-101, Inception-v3, InceptionResNetv2, and SqueezeNet. In [20], a modern DL model, known as Inception-v3, was used to diagnose a disease affecting cassava plants.

In the research, the original PlantVillage dataset has been balanced by increasing the healthy potato leaves that were fewer as compared to the rest of the classes in dataset. For unbiased balancing, an algorithm is proposed for random selection of healthy potato leaves and duplicating them. After the detailed study of CNN model, it was realized that reduction in loss of salient features of the images may enhance the accuracy of the model. Therefore, in the proposed model, number of pooling operations has been reduced in comparison to convolutional operation. With multiple experiments, it has been found that the approximate 3:2 ratio of convolution and pooling operations in the model has achieved better performance in comparison with the basic CNN model and other existing works.

Providing a high-accuracy model for detecting potato blight by minimising the loss of salient features due to the pooling layer and enhancing the feature extraction process. The rest of this paper is organised as follows: Section 2 presents the literature review; Section 3 explains the methods and materials, and the data pre-processing and balancing; Section 4 describes the proposed architecture; Section 5 presents the result and discussion; Section 6 outlines the comparative analysis; and Section 7 provides the conclusion and future scope.

2. Literature Review

The powerful recognition and classification capabilities of CNNs, which work by extracting low-level complex information from images, have attracted significant attention. CNNs are preferred to earlier approaches for automatically recognising plant diseases due to the higher performance of CNNs [21]. The CNN-based predictive model described by Sharma et al. [22] can be used to classify paddy plants by applying image processing to the associated images. Asritha et al. [23] also used a CNN in their research to identify diseases in rice paddies. The classification of plants often requires between four and six layers of CNNs to be used by scientists. Mohanty et al. [24] accomplished the classification of plant illnesses, and their identification and segmentation, by employing a CNN trained with a transfer learning methodology. CNNs have been applied to a broad range of investigations, and improved outcomes have been reported in some cases; however, the datasets used in these studies were not truly diverse [25]. Narayanan et al. [26] suggested the use of a hybrid CNN to identify the many diseases that can harm banana trees. They coupled a fusion SVM with a CNN and used a median filter to maintain the standard image dimensions without adjusting the default settings of the raw input image. Jadhav et al. [27] proposed the use of a CNN that had previously been trained to spot illnesses in soybean plants as a means of detecting and identifying plant diseases. However, despite the better results, the model was inadequate in terms of the variety of illnesses it could categorise. Jadhav et al. [28] improved the performance of DL models by first proposing a novel histogram modification technique for synthesising synthetic picture samples from low-quality test-set images.

Following in the footsteps of Olusola et al., Abbas et al. [29] developed a conditional generative adversarial network to construct a library of synthetic pictures of the leaves of tomato plants. In the past, capturing or collecting data in real time was not viable owing to the high costs involved, the scarcity of resources, or both. Today, however, real-time data capture and collection are becoming more practical. For example, Anh et al. [30] presented a multi-leaf classification model that was based on a benchmark dataset using a pre-trained MobileNet CNN model, which they found to be excellent for classification, with an accuracy of 96.58%. In addition, a multilabel CNN was described for the classification of numerous plant diseases based on transfer learning approaches, such as DenseNet, Inception, Xception, ResNet, VGG, and MobileNet [31]. The authors of this study claimed that they were the first to use a multi-label CNN to categorise 28 distinct illnesses that may affect plants. In the context of the article [32], an ensemble classifier was proposed as a method for categorising the diverse illnesses that can affect plants. PlantVillage and Taiwan Tomato Leaves were used in the evaluation process to determine which ensemble classifier performed best. The EfficientNet model, which uses a CNN, was developed by Pradeep et al. [33] to categorise several labels simultaneously. They determined that CNN’s hidden layer network was superior in its ability to detect plant diseases. However, when compared to industry norms, the model did not measure up. The authors of [34] offered a loss-fused, resilient CNN that achieved a classification accuracy of 98.93% based on the freely available PlantVillage benchmark dataset. Later, Enkvetchakul and Surinta [35] introduced a CNN network that used a transfer learning technique to diagnose two plant diseases. Abade et al. [36] evaluated CNN algorithms for the identification of plant diseases. The reviewers considered 121 articles published between 2010 and 2019, concluding that TensorFlow was the most commonly used framework, and PlantVillage was the most widely used dataset. Dhaka et al. [37] provided an overview of the principles underpinning the use of CNN models to identify diseases in leaf samples and examined a selection of CNN models, pre-processing techniques, and foundational frameworks. Another group of researchers, Nagaraju et al. [38], analysed and discussed the best datasets, pre-processing methodologies, and DL algorithms for a variety of plants.

According to Kamilaris et al. [39], DL approaches have the potential to solve multiple issues that arise in the agricultural sector. According to their findings, DL methods performed significantly better than more traditional approaches to image processing. Fernandez Quintanilla et al. [40] conducted research to evaluate weed monitoring systems for agricultural crops. They focused on ground-based and remote-sensing weed monitoring in agricultural areas and concluded that monitoring is necessary for the effective management of weeds. They anticipated that the data obtained by many sensors would be kept in the cloud and used effectively. Lu et al. [41] conducted a review and showed for the first time that plant diseases could be classified through the application of a CNN.

Golhani et al. [42] wrote a review article about the use of hyperspectral data for identifying plant leaf diseases. They reviewed the status of the field, its potential future applications, and NN techniques for accelerating SDI development, Bangari et al. [43] zeroed in on potato blight as the illness of interest. After reviewing the relevant research, the researchers concluded that CNNs are more effective than other methods of disease detection. In addition, they discovered that CNNs performed a significant role in achieving maximum accuracy in disease identification.

Iqbal et al. [44] implemented various ML algorithms using 450 potato leaf images from the PlantVillage dataset. They declared that the random forest (RF) algorithm outperformed the other algorithms. Singh et al. [45] used 300 potato leaf images from the PlantVillage dataset and divided them into three equal classes: early blight, late blight, and healthy. The authors used GLCM to extract the features of dataset images and used these features to classify potato blight using an SVM with an overall accuracy of 96%. Islam et al. [46] segmented potato leaf images extracted from the PlantVillage dataset and used the threshold method to segment the regions of interest (RoI) in the images. They then used the segmented images to train the model using the SVM method and achieved 95% accuracy with 300 samples. Chakraborty et al. [47], using potato leaf images from the PlantVillage dataset, implemented and compared the performance of ResNet 50, VGG 16, MobileNet, and VGG 19 for potato blight classification. The VGG 19 architecture achieved the highest accuracy, at 92.69%. The authors then fine-tuned the VGG 19 architecture and achieved an accuracy of 97.89%. Mahum et al. [48] added extra layers to DenseNet architecture and evaluated the performance of the model by classifying potato blight using potato images from the PlantVillage dataset. The modified DenseNet model achieved a high accuracy of 97.2% compared to the basic DenseNet architecture.

3. Materials and Methods

Data Balancing and Augmentation

To train, validate, and evaluate the proposed model, we acquired photos of potato leaf diseases from the PlantVillage dataset, which is open to the public. The collection included photos of three distinct potato leaf conditions: late blight, early blight, and healthy. Each image in the dataset had a resolution of 256 × 256 pixels. The pictures of early and late blight depicted the two stages of the devastating potato leaf disease, and the images of healthy potato leaves showed leaves in a normal, healthy state. We assigned the values 0, 1, and 2 as indices for the three classes in the dataset.

Table 1. Number of images in each class of PlantVillage dataset.

Class	Count
Late blight	1000
Early blight	1000
Healthy leaves	152
Total	2152

demonstrates the distribution of the total number of photos across each category of the dataset. However, we found a much lower number of healthy potato blight photos in the dataset than images of the other two classes of potato blight.

To balance the data, we increased the number of images of healthy potato leaves by randomly selecting 10 healthy potato leaf images and creating 10 duplicate copies of each. We repeated this process five times. Algorithm 1 shows the balancing process for healthy potato leaf images in the dataset.

Table 2. Count of images in each class in the dataset after balancing.

Class	Count
Early blight (0)	1000
Late blight (1)	1000
Healthy leaves (2)	652
Total	2652

shows the total count of images in each class in the dataset after balancing; there were 1000 images for early and late blight in each class and 652 healthy potato leaf images. Randomly selected sample images for each class are shown in Figure 1 for visualisation.

Algorithm 1. Data balancing.

Input: Healthy potato leave image directory from the PlantVillage dataset. Output: Healthy potato leave image directory with an expanded number of images.  1: i = 0  2: if (i ≤ 4)  3: Select 10 random images  4: Create 10 × 10 copies of each image  5: i = i + 1  6: goto step 2  7: else  8: stop

To accelerate the computation, we divided the dataset into 83 batches containing 32 images each and placed the remaining images in the last batch. We randomly split the dataset into training, testing, and validation samples with ratios of 0.6, 0.2, and 0.2, respectively, and a shuffle size of 10,000. The distributions of the training, testing, and validation images are shown in

Table 3. Number of images in each training, testing, and validation class.

Class	Early Blight	Late Blight	Healthy	Total
No. of training samples	789	795	524	2108
No. of testing samples	107	109	72	288
No. of validation samples	84	97	75	256

.

We normalised the data to enhance the speed of computation and augmented the training data to vigorously train the model and avoid overfitting. For augmentation, the images were horizontally flipped, vertically flipped, rotated between −20 and +20, sheared between −40 and +40, and shifted by width and height within a range of 0.2. A visualisation of the augmentation process is shown in Figure 2.

4. Proposed Model

We used a customised CNN to accurately detect blight on potato leaves. The potato blight classification process comprised data balancing, augmentation, splitting, training, validation, and testing. A flowchart of the working procedure is shown in Figure 3. The data were shuffled, resized, and distributed into batches. For data pre-processing, the unbalanced data were balanced by increasing the number of healthy potato leaf images. Thereafter, the data were split into training, testing, and validation data; the training data were augmented using various parameters and normalised between 0 and 1, whereas the testing and validation data were normalised between 0 and 1. The training and validation data were used to train the model, and the testing data were used to evaluate its performance.

D′ = {(x_i, y_i) | (x_i, y_i) ∈ D}

where D is the dataset and D′ is the shuffled dataset, x_i is the input feature vector for the i-th example in D, y_i is its corresponding label, and the order of the elements (x_i, y_i) in D′ is randomly permuted.

D′ = {(x′_i, y′_i) | (x′_i, y′_i) ∈ D′}

D′_train = {(x′_i, y′_i) | i ∈ [1, n_train]}

D′_test = {(x′_i, y′_i) | i ∈ [n_train + 1, n]}

where D′_train is the training dataset and D′_test is the testing dataset, n_train is the number of examples assigned to the training dataset, and n is the total number of examples in D′.

n_train = α n

n_test = (1 − α) n

where α is a value between 0 and 1 that represents the proportion of D′ assigned to D′_train.

The proposed classification model contains two blocks, each of which has a pair of convolution layers followed by a pooling layer. Both blocks are sandwiched between the pair of convolution layers and the pooling layer. The number of blocks can vary according to the application and the dataset. We intentionally reduced the pooling layers compared with the convolutional layers to reduce the loss of salient features, because pooling layers are prone to information loss due to dimensionality reduction [49,50]. We used the ReLU activation function in the convolution process to reduce linearity and vanishing gradient problems, thus restricting all the negative values in the feature maps and only allowing the positive values. The mathematical equation is shown in Equation (1).

$$f\left(x\right)=\left\{\begin{array}{c}x for x\ge 0\\ 0 for x<0\end{array}\right.$$

(1)

A graphical representation of the working procedure of the ReLU activation function is shown in Figure 4, where the red colour is non-linearity and sky blue colour is rectifier.

To train the model, we used images with sizes of 256, 256, and 3. In the initial convolution layer of the model, we employed 32 kernels of 3 × 3 size with the ReLU activation function, followed by a pooling layer with a window size of 2 × 2. In the model, the output feature maps of the initial layers are assigned to Block 1, which comprises a pair of convolution layers followed by a max pooling layer. Each convolution layer has 64 kernels of size 3 × 3 and a max pool layer with a 2 × 2 window. The generated Block 1 feature maps are passed as inputs to Block 2, and the composition of Block 2 is the same as Block 1, except for the number of kernels. In Block 2, 128 kernels are used instead of 64 kernels. The output feature maps of Block 2 are further passed as inputs to the last layer of the model, which is the same as the first layer. In the last step, the output of the pooling layers is flattened before being used as an input to a fully connected NN. This network has two hidden layers and an output layer with three neurons, which is equal to the number of classes included in the dataset. To perform multiclass classification, we used SoftMax activation in the output layer. The architecture of the model is shown in Figure 5.

5. Results

Here, we discuss the experimental setup, model evaluation, performance analysis, and comparison of the model with other existing models.

5.1. Experimental Setup

We used the Kaggle platform rather than a GPU to train and evaluate the proposed model. The model was implemented using TensorFlow version 2.6.4 with a total of 2652 potato leaf images. In the dataset, the images were distributed almost equally across the three classes. We trained the model using 2108 augmented images for 45 epochs and assessed it using 288 actual images. We found that the model had adequate performance, with 839,203 trainable parameters in 183 s of training time. Furthermore, we used an Adam optimiser with a learning rate of 0.001 to adjust the weights of neurons in the NN, as summarised in

Table 4. Broad summary of the model.

Optimiser	Batch Size	# Epochs	Activation Functions	Learning Rate	# Trainable Parameters
Adam	32	45	ReLU	0.001	839,203

.

5.2. Evaluation Metrics and Performance Analysis

We evaluated the performance of the model using a confusion matrix to represent the classwise performance of the proposed model, as shown in Figure 6. The indices 0, 1, and 2 referred to the corresponding classes (i.e., early blight, late blight, and healthy, respectively). In addition, using a confusion matrix, we calculated the true and false positive and negative values for each class to analyse the performance of the model according to various parameters.

The term ‘true positive’ (TP) refers to the total number of pictures that were accurately predicted in the positive class, whereas ‘false positive’ (FP) refers to the total number of incorrectly predicted pictures in the positive class. Similarly, ‘true negative’ (TN) reflects the total number of accurately predicted photos in the negative class, whereas ‘false negative’ (FN) reflects the total number of incorrectly predicted images in the negative class. Many additional measures, such as accuracy, precision, recall, and F1-scores, were derived based on the confusion matrix.

Accuracy is the ratio of the TN to the total number of predictions (Equation (2)):

$$Accuracy \left(ACC\right) = \frac{TP + TN}{TP + TN + FP + FN}$$

(2)

Precision can be defined as the ratio of TP to the total number of positive predicted samples, as shown in Equation (3):

$$recesion \left(PRE\right) = \frac{TP}{TP + FP}$$

(3)

Recall is the ratio of TP to the sum of the TP and FN samples (Equation (4)):

$$Recall \left(REC\right) = \frac{TP}{TP + FN}$$

(4)

The F1-score can be calculated by taking a harmonic mean of the precision and recall values, as shown in Equation (5):

$$F1 score = \frac{2\ast TP}{2 \ast TP + FP + FN}$$

(5)

The class wise values for all the evaluation parameters for the proposed model are summarised in

Table 5. Performance analysis of the proposed model with testing data.

Classes	TP	FP	TN	FN	Accuracy	Precession	Recall	F1-Score
Early blight	103	3	185	0	0.99	1.0	0.97	0.98
Late blight	107	0	181	3	0.99	0.97	1.0	0.99
Healthy	78	0	210	0	1.0	1.0	1.0	1.0

.

The model achieved an inclusive accuracy of 99%. Figure 7 shows examples of actual and predicted labelled results, along with their confidence values. The training process for the model, represented by accuracy and loss curves, is shown in Figure 8, which reveals a sudden rise and steep fall in accuracy and loss up to the seventeenth epoch but slow progress up to the thirty-fifth epoch and stagnant growth up to the forty-fifth epoch. Prediction = model.Predict(img_array), where img_array is an input image converted to array.

The k-fold cross-validation approach was utilized to assess the model’s performance. The dataset was partitioned into k = 5 equal folds, with k−1 folds serving as the training set and the remaining fold used as the test set. The proposed model is trained and validated for 10 epochs with each fold of the dataset. This process was repeated k times, with each fold used once as the test set.

Table 6. The performance metrics of Accuracy, Precision, Recall, and F1-score using the k-fold cross-validation method (k = 5).

Folds	k = 1			k = 2			k = 3			k = 4			k = 5
Class	0	1	2	0	1	2	0	1	2	0	1	2	0	1	2
Precision	0.9765	0.9595	0.9172	1.0000	0.9268	0.9394	0.9854	0.9550	1.0000	0.9663	0.9770	0.9852	0.9531	0.9515	1.0000
Recall	0.9674	0.9071	1.0000	0.9282	0.9596	1.0000	0.9621	0.9845	0.9920	0.9829	0.9636	0.9852	0.9632	0.9561	0.9778
F1-Score	0.9720	0.9326	0.9568	0.9628	0.9429	0.9688	0.9736	0.9695	0.9960	0.9745	0.9703	0.9852	0.9581	0.9538	0.9888

displays the average accuracy, precision, recall, and f1-score for each fold of data obtained through k-fold cross-validation. The mean and standard deviation for every k-fold cross-validation (k = 5) over training, testing, and validation dataset have been shown in

Table 7. Average mean and standard deviation for training, testing, and validation dataset used in k-fold cross validation for k = 5.

Dataset	Mean	Standard Deviation
Training	0.9682	0.0084
Validation	0.9628	0.0075
Testing	0.9656	0.0093

.

6. Comparison with Existing Methods

In this stage of the research, we compared our model with the most recent research on potato blight classification using ML and DL techniques. We evaluated all the strategies using potato blight photos taken from the PlantVillage dataset to facilitate an objective comparison. We also compared the performance of the proposed model with the performance of some standard ML and DL algorithms, including random forest (RF), SVM, grey-level co-occurrence matrix (GLCM), CNN, and visual geometry group (VGG) networks. According to the findings of the comparative study, we determined that the proposed approach worked better than the other methods across all parameters.

Iqbal et al. [44] compared the effectiveness of various conventional ML techniques using potato leaf pictures taken from the PlantVillage dataset. They found that the RF method stood out in terms of accuracy compared to the other algorithms. Singh et al. [45] used GLCM to analyse and extract characteristics from blight photos taken from the PlantVillage collection. Then, the authors used an SVM technique to conduct potato blight classification using the collected characteristics. The PlantVillage dataset gave Islam et al. [46] 300 different potato leaf photos to work with, and they used the threshold approach to segment the pictures and locate RoI. In addition, they recommended training SVM models to classify blight disorders using segmented pictures. Chakraborty et al. [47] evaluated four different DL techniques (VGG 16, VGG 19, MobileNet, and ResNet 50) and compared their respective levels of performance. They classified potato leaf diseases using potato leaf photos taken from the PlantVillage dataset and found that fine-tuned VGG 16 achieved the highest accuracy at 97.8%. Mahum et al. [48] modified the DenseNet architecture by adding extra layers and evaluated the performance of the model using potato leaf images taken from the PlantVillage dataset. The model classified potato blight with an accuracy of 97.2%. Mohamed et al. [49] used potato leaf images from the PlantVillage dataset to train a four-layered CNN model and classified potato blight with an accuracy of 98.3%.

We compared our proposed model with some popular machine and DL algorithms, and with recent studies, as summarised in

Table 8. Comparison of the proposed model with other models.

References	Model	Accuracy(%)	Precision			Recall			F1-Score
			0	1	2	0	1	2	0	1	2
Iqbal et al. [44]	Random Forest	97.0	1.0	0.91	1.0	0.94	1.0	0.96	0.97	0.95	0.98
Singh et al. [45]	GLCM + SVM	95.99	0.98	0.91	0.99	0.94	0.95	0.98	0.96	0.93	0.98
Islam et al. [46]	SVM	95	0.97	0.89	0.95	0.93	0.94	0.98	0.95	0.98	0.92
Chakraborty et al. [47]	VGG 16	92.69	-	-	-	-	-	-	-	-	-
	VGG 19	80.39	-	-	-	-	-	-	-	-	-
	ResNet 50	73.75	-	-	-	-	-	-	-	-	-
	MobileNet	78.84	-	-	-	-	-	-	-	-	-
	VGG 16(fine-tuned)	97.89	0.9721			0.9613			0.9617
Mahum et al. [48]	DenseNet(customised)	97.2	0.99	0.99	0.96	0.99	0.98	1	0.99	0.99	0.99
Mohamed et al. [51]	CNN	98.2	-	-	-	-	-	-	-	-	-
Proposed model	CNN(customised)	99	1	0.97	1	0.97	1	1	0.98	0.99	1

. In the proposed architecture, we reduced the pooling layers compared to the convolution layer to minimise the loss of salient features, and we performed more convolution in the middle two layers of the architecture to achieve maximum feature extraction. This novel arrangement of layers in the architecture outperformed all methods in terms of evaluation matrices.

7. Conclusions

In this research, we customised the CNN model architecture to enhance performance with fewer trainable parameters, reduced computation time, and minimal information loss. To minimise the loss of salient features, we purposely reduced the pooling layers in the proposed architecture. The architecture contained two blocks, each of which comprised a pair of convolution layers, followed by a pooling layer. We validated the performance of the proposed model using potato blight images taken from the PlantVillage dataset, and the proposed model outperformed others, with an overall accuracy of 99% compared with similar studies using similar datasets. In the future, the performance of the proposed model should be assessed using a dataset with real-time potato blight images rather than segmented and pre-processed images. Moreover, the trainable parameters of the architecture could be further reduced without affecting the performance of the model or making it prone to overfitting.