An enhanced lightweight T-Net architecture based on convolutional neural network (CNN) for tomato plant leaf disease classification

Feature extraction

In our proposed study, the ALVIN methodology enhances tomato plant disease detection by employing active learning with a lightweight T-Net model. Initially trained on small, labelled subsets, the model uses uncertainty sampling to identify complex patterns in a large pool of unlabelled images. Convolutional kernels are refined based on these uncertainties to improve feature extraction, capturing critical patterns like texture and colour variations. Expert feedback is incorporated to label challenging images, and the model is trained iteratively. This process reduces manual labeling efforts, enhances feature extraction, and improves the model’s accuracy and generalization while maintaining low computational cost. The method also allows the model to adapt effectively to novel diseases and ensures efficient performance without excessive computational overhead. By refining kernels based on uncertain data, it strengthens the model’s ability to extract meaningful features from complex image inputs. Mathematically, we can represent the convolutional operation as explained in Eqs. (1), (2) and (3): (1)${\displaystyle \left(I\ast K\right)\left(x,y\right)=\sum _i\sum _{j}I\left(i,j\right)K\left(x-i,y-j\right).}$ Here:

• I is the input image.

• K is the convolutional kernel or filter.

• (x, y) are the coordinates of the output feature map.

These convolutional filters essentially slide over the input image, performing calculations at each position to extract specific features. It’s like looking through different windows to see what’s inside.

A popular choice is the rectified linear unit (ReLU), which is a simple yet effective function: (2)${\displaystyle f\left(x\right)=max\left(0,x\right).}$

This function replaces all negative values with zero, while leaving positive values unchanged, similar to flipping a switch—if there’s no signal, it turns off; if there’s a signal, it passes through. Another technique used in Alvin’s methodology is max pooling, which reduces the spatial dimensions of the data by selecting the maximum value from a region, effectively retaining the most important features (3)${\displaystyle maxpooling\left(x,y\right)=max\text{\_}i,jI\left(x+i,y+j\right).}$ The pooling layer reduces computational complexity, simplifies the subsequent layers, and retains only the most essential information. This allows the model to focus on key features and patterns in the input images. Using specialized tools, like glasses for clarity, a tuning fork for precision, and a magnifying glass for detail, the model is further empowered to accurately identify tomato disease failures. These combined techniques enhance the model’s ability to recognize critical distinguishing features within the images.

Data augmentation

Data augmentation is an important preprocessing method for enhancing the diversity and strength of the training dataset in image classification problems. It reduces overfitting and improves the model’s capacity for generalization by artificially increasing the dataset with modified copies of the original images. The Keras library’s ImageDataGenerator class makes data augmentation easier by transforming input images in several ways. This code illustrates augmentation methods that help build a more resilient model, including shearing, zooming, rescaling, and horizontal flipping.

• Rescaling: By dividing each pixel value by 224, the image’s pixel values are rescaled to fall between (0, 1). Since this normalization, optimization is more reliable and effective since all pixel values are kept within a constant numerical range.

• Shearing: Shearing transformations move pixels along the horizontal or vertical axes to randomly deform the images. Introducing heterogeneity in the orientation of items inside the images helps strengthen the model’s resistance to various viewpoints and orientations.

• Zooming: Zooming changes arbitrarily enlarge or reduce the size of certain image regions. The model can learn characteristics at different degrees of detail thanks to this scale variation, which enhances its capacity to identify things at varied sizes and distances from the camera.

• Horizontal flipping: This technique randomly reflects the images along the vertical axis. By feeding the model photos with objects oriented both left-to-right and right-to-left, this modification contributes to the dataset’s diversity. The dataset is essentially increased by using these augmentation strategies, exposing the model to various variances and deformations that may occur in real-world situations. This leads to better performance and generalization on unobserved data as the trained model becomes more robust against noise, changes in illumination, and varied object orientations.

Proposed T-Net model

This section presents step-by-step ALVIN methodology for developing an enhanced lightweight T-Net model based on CNN architecture for tomato plant leaf disease detection.

Detailed overview of the proposed T-Net

The T-Net model is based on deep learning techniques for image classification applications. This architecture is divided into layers, which extract hierarchical information from the input images and predict output based on the layers. Convolutional layers comprise the T-Net architecture’s framework and identify spatial patterns and characteristics in the input images. This particular design stacks many convolutional layers. Each convolutional layer convolves the input image with tiny receptive fields to create feature maps using a series of learnable filters. These feature maps draw attention to significant visual patterns in the images, such as edges, textures, and forms. Various activation functions (ReLU) and convolutional layers extract more sophisticated input image features (e.g., 32, 64, and 128).

Max-pooling layers are used to downsample the feature maps after each convolutional layer, keeping the most pertinent data while lowering the feature maps’ spatial dimensions. By dividing the feature maps into smaller sections and keeping just the maximum value inside each zone, max-pooling performs this downsampling. As a result of this process, the model is more robust in its ability to resist spatial translations and changes in object placement. Figure 3 shows the whole summary of the model in our proposed system T-Net model with its multiple layers. The architecture consists of flattening and fully connected dense layers as well as convolutional and max-pooling layers. The dense layers operate as the classifier by executing high-level reasoning based on the retrieved features, while the flattening layers turn 2D feature maps into 1D vectors. The given code further processes the flattened features and produces predictions using activation functions (ReLU) and dense layers divided into different numbers (128, 64, etc.) The T-Net model incorporates the “Fire module” and “squeeze layer” terminology, which are inspired by the SqueezeNet architecture developed by Iandola et al. (2016). This architecture enhances efficiency by using squeeze layers that consist of 1 × 1 convolutions followed by expand layers that mix 1 × 1 and 3 × 3 convolutions. As described in SqueezeNet, the Fire module effectively reduces the number of parameters while maintaining performance, making it an optimal choice for lightweight models.

Unlike ReLU, Leaky ReLU allows non-zero outputs for negative inputs, thus maintaining the flow of information and enhancing the model’s classification performance. Table 2 shows the architecture of the T-Net module, a pivotal component enhancing deep learning-based object detection systems.

Table 2:

Overview of the architecture of the T-NetFire Module, a pivotal component enhancing deep learning-based object detection systems.

No	Operation	Layer	Filters	F size	Padding	Stride	Parameters
1		Input					0
2	Standalone CNN	Convolutional (BN + LR)	64	3 × 3	—	2 × 2	1,792
3	Pooling layer	MaximumPooling	1	3 × 3	—	2 × 2	0
		Convolutional (BN + LR)	16	1×1	—	—	1,040
4	Fire one	Convolutional (BN + LR)	64	3 × 3	[1 1 1 1]	—	9,280
		Convolutional (BN + LR)	64	1×1	—	—	4,160
		Convolutional (BN + LR)	16	1×1	—	—	1,040
5	Fire two	Convolutional (BN + LR)	64	3 × 3	[1 1 1 1]	—	9,280
		Convolutional (BN + LR)	64	1×1	—	—	4,160
6	Pooling layer	MaximumPooling		3 × 3	[0 1 0 1]	2 × 2	0
		Convolutional (BN + LR)	32	1×1	—	—	2,080
7	Faire three	Convolutional BN + LR)	128	1×1	—	—	4,224
		Convolutional (BN + LR)	128	3 × 3	[1 1 1 1]	—	147,584
		Convolutional (BN + LR)	32	1×1	—	—	16,512
8	Fire four	Convolutional (BN + LR)	128	3 × 3	[1 1 1 1]	—	36,992
		Convolutional (BN + LR)	128	1×1	—	—	16,512
9	Pooling layer	MaximumPooling		3 × 3	[0 1 0 1]	2 × 2	0
		Convolutional (BN + LR)	48	1×1	—	—	6,192
10	Fire five	Convolutional (BN + LR)	192	1×1	—	—	9,408
		Convolutional(BN + LR)	192	3 × 3	1×1	—	331,968
11		FC + BN + LR + Dropout
12		FC + BN + LR + Dropout
13		FC + Soft max + classification

DOI: 10.7717/peerjcs.2495/table-2

The output from the standalone convolution (first convolution layer) flows into the Fire 1 module, explicitly targeting its initial squeeze layer (the second convolution layer with a 1 × 1 filter), following normalization, activation, and pooling. Subsequently, the output of the first squeeze layer progresses to the third convolution layer (the first expand layer), implementing 64 filters of size 3 × 3 with a padding of 1 pixel. This expanded layer’s output then advances to the fourth convolution layer (expand layer), which utilizes 64 filters of size 1 × 1. This process iterates, with each Fire module’s output forwarded to the following Fire module’s initial convolution layer (squeeze layer). Finally, the output of the fifth Fire module is directed to the first fully connected dense (FCD) layer, which converts the two-dimensional feature map extracted by the convolution layers into a one-dimensional feature vector.

Experimental setup

The experiment was conducted on a 64-bit operating system, an x64-based server, housing an Intel(R) Core(TM) i7-8700 CPU @ 3.20 GHz, which can turbo boost up to 3.19 GHz. This CPU is known for its high performance, especially in tasks requiring significant computational power. Moreover, to further enhance the server’s capabilities, it was augmented with an NVIDIA GeForce GTX GPU, which boasts 6 GB of GPU memory. The GPU operates at frequencies up to 1060 MHz, making it suitable for daily parallel processing tasks in deep learning applications. Its single-precision performance, rated at six TE-LOPS, underscores its ability to handle complex computations efficiently. To utilize powerful computational resources, such as GeForce GTX GPU, to primarily reduce the training time of the proposed lightweight T-Net architecture. It also provided us with real-time feedback to reduce the training time, which was invaluable for refining the proposed lightweight T-Net architecture. The secondary aim was to handle real and augmented image data more efficiently than traditional CPU-based machines. The proposed model was implemented using TensorFlow, a widely adopted deep-learning framework known for its flexibility and scalability. In Table 3, the hardware and software configurations utilized in the study are detailed, providing a comprehensive overview of the experimental setup.

Performance measure

After preprocessing, the dataset comprising 10,000 images of tomato diseases was prepared for experimentation. The dataset was divided into training and testing subsets to facilitate model training and evaluation, with proportions of 80% and 20%, respectively. Deep learning models automatically extracted disease features via convolution operations, eliminating the need for manual feature extraction. The classification performance evaluation varied between deep learning approaches to assess performance; the proposed network is bench-marked against well-known CNN architectures, including the transfer learning models VGG-16, Inception V3, and AlexNet. The standard evaluation metric for image classification, average accuracy, is employed. This evaluation employs distinct metrics such as accuracy, precision, recall, and F1 score. These metrics were calculated using Eqs. (4), (5), (6) and (7). (4)${\displaystyle Accuracy=\frac{TP+TN}{TP+TN+FP+FN}}$ (5)${\displaystyle Precision\left(P\right)=\frac{TP}{TP+FP}}$ (6)${\displaystyle Recall=\frac{TP}{TP+FN}}$ (7)${\displaystyle F1Score=\frac{2PR}{P+R}.}$

Parameter setting

In this experiment, we chose a batch size of 32 to make our process more efficient and address the issue of insufficient data. When we use larger batch sizes, our classification accuracy decreases because the learning rate decreases. We kept all the model settings at their default values. During training, we went through the data in batches, updating the neural network’s weights as we went along throughout 80 epochs. We wanted our models to get as good as possible before they started to over-fit, so we stopped at 80 epochs. We used a fixed learning rate of 0.01 and ensured the models saved themselves automatically as they trained. We used the Adam optimizer because it’s good at handling moving targets and situations where we don’t have much information about the gradients. We used a particular loss function called sparse categorical cross-entropy for our classification tasks. We randomly dropped half of the connections between neurons during training to prevent our models from memorizing the training data too much (which is overfitting), which helped our models perform better. We tried many different combinations of settings while building our models to find the ones that worked the best. You can see the specific settings in Table 4.

Result

This section describes the performance of the proposed model and transfer learning-based models that have been utilized. Accuracy and loss graphs are used to understand the model behavior better. The ROC-AUC curve of all tomato leaf classes, a significant measure of the model’s performance, has been demonstrated. Moreover, the proposed model was compared with other studies to determine reverence. The left graph in Fig. 4 illustrates how effectively the model learns from the training data and generalizes to unknown validation data by displaying the model’s accuracy across epochs on both the training and validation datasets. The right graph displays the loss, showing the variation between the predicted and actual values during training and validation. Understanding the model’s convergence, spotting possible over- or underfitting, and fine-tuning the model’s parameters for better performance depend on these visual aids.

The graphical representation of our proposed model shows model accuracy, training, test, loss, and epoch of the model. The T-Net model’s ability to categorize tomato images into categories corresponding to health or sickness is shown visually by the confusion matrix. The left graph in Fig. 5 displays the number of true positive, true negative, false positive, and false pessimistic predictions, offering valuable information on how well the model can categorize various cases. The confusion matrix visually represents these metrics, which helps evaluate the model’s overall accuracy, precision, recall, and F1 score. By doing so, practitioners can identify biases or incorrect classifications and enhance reliability and performance. The right graph of Fig. 5 shows the ROC-AUC of the tomato leaf classes. The target spot of the tomato leaf has the lowest AUC score compared to the other classes. However, the bacterial spot performs better compared to other courses.

In addition, Table 5 outlines the performance metrics of a proposed model across various classes or categories within a dataset. The model demonstrates high precision and recall for classes like leaf mold, spider mites, two-spotted spider mites, tomato yellow leaf curl virus, and tomato mosaic virus, with F1-scores ranging from 0.94 to 0.98. Notably, the model achieves an exceptional F1-score of 0.97 for the healthy leaf class, with precision and recall values of 0.99 and 0.96, respectively, and an accuracy of 100%. However, classes like target spot and early blight exhibit slightly lower precision and recall scores, leading to comparatively lower F1-scores of 0.89 and 0.91, respectively. These metrics were calculated using macro-level averaging, guaranteeing that every class contributes equally to the final evaluation. They provide information on the model’s general performance for particular tasks or targets within the dataset and how well it labels various classes.

Furthermore, Table 6 compares the empirical effectiveness of the proposed T-Net model with the existing DL models, such as Inception V3, AlexNet, and VGG16. Different metrics are used to evaluate the empirical effectiveness of the proposed T-Net model over the existing models, such as precision, recall, F1 score, and accuracy. The empirical effectiveness highlights that the proposed T-Net model yields better classification performance than the existing models. The proposed model significantly outperforms Inception V3, AlexNet, and VGG16. The proposed model demonstrates its ability to identify relevant instances and accurately minimize false predictions. Therefore, our proposed model with classification improvement over existing models helps farmers mitigate risk in advance to save large portions of the plants from being affected. In addition, our proposed model can lead to better plant disease detection compared to the existing models, which further helps farmers reduce plant losses and optimize resources.

Discussion

The results demonstrate the performance of the T-Net model trained for image classification. First, the evaluation of model performance parameters, such as loss and accuracy, provides crucial clues about the predictive power of the models. High accuracy scores show robust classification abilities, and low loss values indicate the successful alignment of the predicted and accurate labels. These measures function as essential standards for assessing the effectiveness of the model.

More information about the learning dynamics of the models is obtained from the training and validation curves over epochs. When both curves smoothly converged, training was practical, and no overfitting occurred; nevertheless, when there were significant differences between the two, problems like under- or overfitting may have occurred. Furthermore, examining confusion matrices and viewing sample predictions aid in comprehending the categorization behavior of the models. Patterns in misclassifications may be found by analyzing right and wrong predictions, providing essential information for model improvement.

Understanding the relative performance of various model designs, preprocessing approaches, and regularization strategies requires comparative analysis. Adjusting hyperparameters such as batch size and learning rate may optimize model training, improving classification resilience and accuracy. Additionally, examining the models’ scalability and generalizability to different datasets or domains clarifies their usefulness outside the current context. Future research paths and improvements are made possible by discussing the results. It emphasizes areas needing development, such as investigating more intricate designs, utilizing group approaches, or adding cutting-edge strategies like attention processes. Furthermore, resolving any restrictions or difficulties found during assessment encourages the creation of more efficient image classification models with broader applicability and improved performance.

The empirical findings of our proposed T-Net model was evaluated against existing models in Fig. 6 such as Inception V3, AlexNet, and VGG16, showing notable improvements in key performance metrics: accuracy, precision, recall, and F1 score. To substantiate the importance of these improvements, we conducted a paired sample t-test analysis, which confirmed that the enhancements were statistically significant, with p-values below 0.05 across all metrics. Specifically, the T-Net model’s accuracy improvement of 3–5% over the baseline models was statistically significant (p = 0.0083), as was the increase in precision, particularly compared to AlexNet, which was higher by 5.05% (p = 0.0229). The T-Net model also demonstrated a substantial improvement in recall, outperforming AlexNet by 7.37% (p = 0.0098), which is especially significant for minimizing false negatives in practical applications. Additionally, the model achieved a 7.57% enhancement in F1 score over Inception V3 (p = 0.0236), indicating a balanced increase in both precision and recall. These findings validate the T-Net model’s robustness and practical applicability for tomato disease classification. Even minor gains in accuracy can be crucial in real-world agricultural settings, reducing misclassifications and enabling farmers to manage plant diseases more effectively.

In addition, Table 7 compares the computational efficiency of the proposed T-Net model with the existing DL models. The computational efficiency analysis indicates that the proposed model requires fewer trainable parameters than the existing models. The proposed model reduces the number of parameters by approximately 37.17% compared to Inception V3. Similarly, our proposed model requires 96.03% fewer parameters than AlexNet, which indicates the efficiency of the proposed model to faster processing times. Besides Inception V3 and AlexNet, our proposed model reduces the number of parameters by approximately 98.25% compared to the VGG16. Hence, our proposed model achieves high accuracy and offers substantial improvements in computational efficiency compared to existing deep learning models. This makes it an efficient and impactful solution for applications in tomato agriculture.

Furthermore, to evaluate the model’s efficacy in incorrectly identifying healthy and infected tomatoes, its performance metrics accuracy. The conversation may also cover identifying any difficulties discovered in developing the model, such as imbalanced data, overfitting, or underfitting, and suggest possible remedies or directions for more research. It would also be beneficial to investigate parallels with current approaches or earlier studies on categorizing tomato diseases to put the results in perspective and emphasize the improvements or originality of the T-Net model. In conclusion, the T-Net architecture in the given code uses convolutional, pooling, flattening, and dense layers to extract hierarchical features from input photos and provide predictions for binary classification tasks. This architecture is well-suited for various image identification and classification applications because it can automatically train discriminative features from raw pixel data. Table 8 compares multiple architectures used in research articles, each evaluated on different datasets for image classification tasks. In the study by LeafNet (Tm et al., 2018), which utilized the Plant Village dataset consisting of 18,100 images across 10 classes, an accuracy of 95% was achieved. However, deployment posed challenges as the model was applied without any modifications. MPC (Zhang et al., 2018) achieved a slightly higher accuracy of 96% by reducing the dataset size and the number of classes to 5,000 images and 9 classes, respectively. MobileNet (Elhassouny & Smarandache, 2019) attained 90% accuracy on a self-collected dataset of 7,200 images with 10 classes, yet the smaller dataset size may limit its applicability. A CNN architecture (Agarwal et al., 2020) reached 91% accuracy on the Plant Village dataset but experienced a decrease in performance when deployed without modifications. SE-ResNet (Ahmad et al., 2020) achieved 96% accuracy on a smaller self-collected dataset of 4,600 images, indicating potential limitations in data availability. Both AlexNet (Zhao et al., 2021) and ResNet (Ni et al., 2023) achieved 96% accuracy on the Plant Village dataset but struggled with adaptability to varying conditions, raising concerns for real-world deployment. A CNN architecture in Chen et al. (2024) achieved 95% accuracy on the Plant Village dataset but was limited in capturing localized feature representations. The proposed model achieved the highest accuracy of 98.97% compared to other existing models.