Multi-Model Identification of Rice Leaf Diseases Based on CEL-DL-Bagging

Abstract

This study proposes CEL-DL-Bagging (Cross-Entropy Loss-optimized Deep Learning Bagging), a multi-model fusion framework that integrates cross-entropy loss-weighted voting with Bootstrap Aggregating (Bagging). First, we develop a lightweight recognition architecture by embedding a salient position attention (SPA) mechanism into four base networks (YOLOv5s-cls, EfficientNet-B0, MobileNetV3, and ShuffleNetV2), significantly enhancing discriminative feature extraction for disease patterns. Our experiments show that these SPA-enhanced models achieve consistent accuracy gains of 0.8–1.7 percentage points, peaking at 97.86%. Building on this, we introduce DB-CEWSV—an ensemble framework combining Deep Bootstrap Aggregating (DB) with adaptive Cross-Entropy Weighted Soft Voting (CEWSV). The system dynamically optimizes model weights based on their cross-entropy performance, using SPA-augmented networks as base learners. The final integrated model attains 98.33% accuracy, outperforming the strongest individual base learner by 0.48 percentage points. Compared with single models, the ensemble learning algorithm proposed in this study led to better generalization and robustness of the ensemble learning model and better identification of rice diseases in the natural background. It provides a technical reference for applying rice disease identification in practical engineering.

1. Introduction

Rice cultivation has long occupied an important place in agricultural development. However, ill-defined agricultural production patterns and changing climatic environments have affected the yield, quality, and food security of rice cultivation. Plant phenotypes are physical, physiological, and biochemical characteristics that reflect the structural and functional features of plant cells, tissues, organs, plants, and communities [1]. Plant diseases, as important indicators of morphological and structural characteristics of plant phenotypes, can be directly accessed by visible light cameras (including cell phones, digital cameras, etc.) [2]. Rice leaf disease identification is an important research component in the field of plant protection, and efficient disease identification is a major challenge for breeders. Traditional identification methods rely on manual diagnosis by agronomists or disease mapping comparisons. However, due to the complexity and similarity of rice disease spots, manual identification requires extensive experience and agricultural knowledge. This method is extremely demanding for breeders, but it is difficult to provide a large number of specialized human resources in practice. Therefore, intelligent planting combining computer vision, image processing, machine learning (ML), and deep learning (DL) algorithms has attracted much attention. Compared with the artificial vision-based recognition model, this method automatically identifies rice diseases by learning their phenotypic characteristics, which helps farmers to detect, diagnose, and treat the diseases in time at the early stage of disease occurrence, and to seize the best time for prevention and treatment [3].

Previous machine learning disease recognition research incorporating image processing techniques achieved great success, but the method still relied on manual feature extraction [4]. The emergence of deep learning has broken this limitation, and its ability to automatically learn features and reasoning has achieved a major breakthrough in plant disease phenotype recognition applications. A convolutional neural network (CNN), as a representative deep learning technology, performs far better than other traditional recognition methods in image recognition. Lu et al. [5] applied a CNN to rice disease recognition research for the first time, and found that CNNs have better convergence and recognition accuracy than other algorithms, such as the standard BP algorithm, Support Vector Machines (SVMs), and Particle Swarm Optimization (PSO). Jiang et al. [6] combined a CNN and an SVM to improve the recognition performance of rice leaf diseases using a 10-fold cross-validation method. Hu et al. [7] proposed a multi-scale two-branch structured rice pest recognition model based on a generative adversarial network and improved ResNet, which solved the problems of overfitting caused by a too-small dataset and the difficulty of extracting disease features from the background of the picture.

CNN-based rice disease recognition in simple contexts has achieved high accuracy, but there are fewer applications in natural contexts. The most important reason for that is that CNNs are too complex to be deployed on hardware devices, so the application of lightweight networks is necessary. Cai et al. [8] designed a corn leaf disease recognition application based on improved EfficientNet with 3.44 M parameters and 339.74 M Flops, which can be quickly deployed and recognized on Android devices. Butera et al. [9] investigated baseline crop pest detection models that can be applied to real scenarios, taking into account the detection performance and computational resources, in which FasterRCNN with MobileNetV3 as the backbone was outstanding in terms of accuracy and real-time performance. Zhou et al. [10] proposed a lightweight ShuffleNetV2-based crop leaf disease recognition model, which achieved 96.72% accuracy on a field crop leaf disease dataset, with a smaller model size for easy mobile deployment. The above lightweight network model has been widely used to meet the application conditions in natural scenarios.

You Only Look Once (YOLO) is currently a widely used lightweight target detection network. The Ultralytics team released YOLOv5-cls [11], an improved classification model based on YOLOv5, in 2022, comprising five versions. Compared to other traditional CNNs trained on the ImageNet dataset, YOLOv5-cls has practical applications as a lightweight model that ensures model accuracy and reduces parameters. Yang et al. [12] applied YOLOv5-cls for the first time to a real-world classification task, comparing the different versions of the free-roaming bird behavioral classification task on the EfficientNetV2 and YOLOv5-cls, of which YOLOv5m-cls performed best with an average accuracy of 95.3%.

Traditional model training requires constant parameter tuning and a large number of uniformly distributed datasets to obtain efficient models. Currently, it is difficult to construct large-scale, uniform, and high-quality datasets in practical engineering. Transfer learning realizes cross-domain knowledge migration by adapting feature information from pre-trained models to new tasks [13]. When resources and data are limited, this method can effectively reduce data volume requirements and computational costs, and improve the diagnostic and error-correction capabilities of the model. Hassan et al. [14] applied transfer learning to MobileNetV2 and EfficientNet-B0 models by freezing the weights of the models before the fully connected layer and training them to achieve the recognition of multiple plant diseases. Zhao et al. [15] used a model pre-trained on the large dataset ImageNET to initialize the network weight parameters, and the method achieved 92.00% accuracy in recognizing rice plant images. Chen et al. [16] used the PlantVillage dataset for model pre-training, and then fine-tuned the model parameters and applied them to the training of the cotton disease image dataset, achieving an accuracy of 97.16% accuracy. Wang et al. [17] proposed a backbone network based on improved SwinT combined with transfer learning to train a cucumber leaf disease recognition model with 98.97% accuracy. Yuan et al. [18] proposed a framework for rice disease phenotype recognition in a natural context based on transfer learning and SENet with attention policy on a cloud platform that achieved an accuracy rate of 95.73%.

The currently studied rice disease recognition models still face many challenges when facing real field environments. Different deep learning models have different feature extraction strategies, and it is difficult to construct generalized models to achieve optimal recognition performance for various diseases in natural contexts. Therefore, researchers have introduced integrated learning into crop disease recognition [19]. Xu et al. [20] constructed a tomato pest and disease diagnostic model based on Stacking integrated learning, with a diagnostic accuracy of 94.84% and a reduction in inference time of 12.08%. Mathew et al. [21] analyzed the symptoms of plant leaves using the GLCM algorithm and used simple integrated learning techniques such as voting strategies for disease identification. In addition, deep integrated learning models [22] combine the advantages of deep learning models and integrated learning with better recognition performance and generalization ability. Palanisamy et al. [23] used Sequence2D and DenseNet deep learning models combined with integrated learning techniques such as weighted voting strategies for maize leaf infection identification. Yang et al. [24] proposed a Stacking-based deep integrated learning model integrating an improved CNN and using SVM for rice leaf disease recognition.

Some of the above studies introduced integrated learning based on voting strategies into crop disease recognition, which effectively improved the recognition accuracy. However, rice leaf disease recognition under natural background is susceptible to light angle, light intensity, and shading, and there are fewer models available for practical applications. The existing rice leaf disease dataset under a natural background is small and difficult to construct. The stability and generalization ability of deep CNNs on small datasets are difficult to balance.

We propose CEL-DL-Bagging, an integrated learning algorithm combining deep learning (DL) and Bootstrap aggregation (Bagging)-based aggregation, for small-sample rice leaf disease recognition in natural contexts. Four lightweight CNNs are selected as base learners, including YOLOv5-cls, EfficientNet-B0 [25], MobileNetV3 [26], and ShuffleNetV2 [27], to reduce the computational cost while extracting rice leaf disease phenotypic features more comprehensively. Transfer learning was used to train the model to minimize the effect of insufficient data volume. A new CEL-based weighted voting strategy is proposed for disease identification to improve the identification accuracy. In addition, a salient position-based attention mechanism (SPA) is introduced in this paper to further improve the base learner’s ability to extract valid information in complex backgrounds. The method has the following five main contributions:

(1)

A rice disease recognition algorithm based on salient positions attention (SPA) mechanism was designed, which reduces the processing of non-critical information.

(2)

The DL-Bagging algorithm was proposed, and the lightweight model is integrated by using Bootstrap sampling to improve the generalization ability under small sample sizes.

(3)

A CEL-based weighted voting strategy was proposed to improve the DL-Bagging algorithm, and the weights were dynamically adjusted according to the model performance to improve the integration accuracy.

(4)

An improved method was proposed that uses the label smoothing technique and cosine annealing strategy in transfer learning training.

(5)

A large number of ablation experiments were designed to validate the performance of the proposed method in rice leaf disease recognition under natural backgrounds.

The method proposed in this paper can be applied to real fields to effectively recognize rice leaf diseases in a natural context. The rest of the paper is structured as follows: Section 2 describes the image acquisition, preprocessing, model construction, parameter settings, and evaluation metrics; Section 3 analyzes the results of the experiments; Section 4 discusses the advantages and limitations of the model we are currently using compared to other related studies; and Section 5 concludes the whole paper and looks into the future.

2. Materials and Methods

2.1. Image Acquisition

The data used in this study were partially sourced from the experimental fields for the construction of green, high-yield, and efficient rice fields in Yangzhou City, Jiangsu Province, and supplemented with data from the Elsevier Mendeley database and the public database Kaggle. To ensure the diversity and representativeness of the dataset, images were captured at different times of the day and under varying environmental conditions, including changes in lighting and humidity. Images were captured using an iPhone 15 Pro Max at the experimental field. Blurry, blurred, distorted, or images with unknown diseases or missing features were manually removed. The filtered images were uniformly saved in JPG format, and each image was subjected to multiple local cropping using Photoshop, resulting in 332 sample images. Rice leaf disease images were classified into five categories based on disease type: bacterial leaf blight, rice blast, brown spot disease, tungro disease, and healthy leaves. Each category was stored in a separate folder. Since model training typically requires a large amount of uniformly distributed data to effectively avoid overfitting and poor accuracy, an additional 2546 images were screened from public databases Mendeley Data and Kaggle as supplementary data. Finally, a rice disease dataset comprising 2878 sample images was obtained, completing the construction of the dataset used in this study. Figure 1 illustrates the rice disease samples.

2.2. Image Preprocessing and Expansion

In order to improve the generalization ability of the model to the shooting angle, light intensity and light angle in the real environment, this paper carries out data enhancement operations such as flipping, rotating, color enhancement, brightness enhancement, contrast enhancement, and randomly transforming the color of the rice disease sample images, and finally obtains the rice disease dataset consisting of 6090 sample images.

Table 1. Rice disease dataset.

Disease Category	Number of Images
Name	Before Expansion	After Expansion
Bacterial leaf blight	688	1218
Blast	688	1218
Brown spot	784	1218
Tungro	496	1218
health	222	1218
Total	2878	6090

shows the distribution of the rice disease image dataset before and after expansion, and Figure 2 demonstrates the effect of data enhancement on the rice disease sample images after completing the data enhancement. In addition, the image sizes from different sources are inconsistent, and to ensure the validity of the experiment, the image size is standardized to 224 × 224. Finally, to verify the enhancement effect of the model’s generalization ability, 840 disease images with feature information that differs greatly from other images are manually screened as the test set, and the remaining 5250 images are randomly divided into the training set and the validation set according to a ratio of 8:2.

2.3. Model Construction

This study integrates a salient position-based attention mechanism (salient-positions-based attention, SPA) into the original backbone networks of MobileNetV3-large, ShuffleNetV2-2.0, YOLOv5s-cls, and EfficientNet-B0 to enhance the network models’ ability to extract effective information from complex backgrounds. The improved models are referred to as SPA-M, SPA-S, SPA-Y, and SPA-E. The SPA-M, SPA-S, SPA-Y, and SPA-E are used as base learners based on deep guidance aggregation algorithms. A weighted voting strategy based on cross-entropy loss (Cross-Entropy Weighted Soft Voting, CEWSV) is designed by combining the prediction probability of soft voting and the quantization characteristics of cross-entropy loss, improving the original DB algorithm’s integration strategy, and completing the design of the DB-CEWSV algorithm. The algorithm flowchart is shown in Figure 3.

2.3.1. Recognition Model Based on Attention Mechanism in Prominent Positions

MobileNetV3-large, ShuffleNetV2-2.0, YOLOv5s-cls, and EfficientNet-B0 are common high-performance convolutional neural networks that have a lighter structure than traditional neural networks. However, they still suffer from performance issues that are easily affected by background noise when identifying rice diseases in complex field backgrounds. Therefore, this study introduces the salient positions-based attention (SPA) mechanism into the lower and middle layers of MobileNetV3-large, ShuffleNetV2-2.0, YOLOv5s-cls, and EfficientNet-B0 to improve the network model and enhance its recognition performance.

(1)

Attention Mechanism Based on Salient Location

The salient positions-based attention mechanism (SPA) selects a limited number of salient points in the attention map, and then uses the results of the salient positions selection algorithm to calculate the attention map and aggregate the context information in the channel dimension. This reduces computational complexity while extracting useful contextual information. Figure 4 illustrates the architecture diagram of the SPA attention mechanism.

The following equations describe the attention mechanism based on the saliency attention mechanism:

$$\begin{array}{l}Q=\theta \left(X\right)\\ V=\phi \left(X\right)\\ K=S\left(Q\right)\end{array}$$

(1)

$$A=soft\max \left({\displaystyle \frac{K^{T}K}{C}}\right)$$

(2)

$$Y=VA$$

(3)

where, $X,Y\in R^{N\times C}$ is the input and output feature maps; $Q$ and $V$ are the query and key matrices generated by the transformations $\theta$ and $\phi$; $K$ is the saliency matrix generated by the salient location selection algorithm; $A\in R^{C\times C}$ is the affinity matrix; $N$ is the number of spatial locations of the feature maps $H\times W$; and $C$ is the number of channels. The feature map is transformed by two linear transformations to form the query $Q$ and value $V$ matrices. The matrix $Q$ is passed to the salient positions selection (SPS) algorithm. The output matrix $K$ of the SPS module is the matrix of the first $k$ salient positions in the $Q$ matrix. Figure 4b illustrates the selection process, in particular the dimensionality change. The affinity matrix $A$ is calculated using the selected data from the first $k$ positions. After the softmax operation is performed on the affinity matrix $A$ along the channel dimensions during the aggregation process, the value $V$ matrix is multiplied with the affinity matrix $A$ and reshaped to $C\times H\times W$ to obtain the output feature map $Y$.

(2)

Salient Positions Selection (SPS)

The salient positions selection (SPS) algorithm plays an important role in the proposed salient position-based attention mechanism (SPA). Salient position selection for global context information will reduce the complexity of the self-attention mechanism computation, and, more importantly, extracts positive context information when modeling global dependencies. The pseudo-code of the proposed SPS algorithm is shown in Algorithm 1: Pseudo-code for prominent position selection algorithm.

Algorithm 1: Salient Positions Selection (SPS) Algorithm

Input: a matrix of size $\left[C,H\times W\right]$ $Q$, a hyperparameter $k$;

Output: a matrix of size $\left[C,\mathrm{k}\right]$ $K$;

1. Calculate the square of $Q^T$ along the channel dimension;

2. Sum $Q^T$ along the channel dimension to get $Q_p$;

3. Select the largest $k$ location from $Q_p$ and record it as index $inde{x}_k$;

4. Return matrix $K=Q\left(C,inde{x}_k\right)$

Since the histogram of the feature map data for all channels roughly follows a Gaussian distribution, it is valid to choose the square of the data as the importance metric. To emphasize the locations with higher activation values in the feature map, the square matrix is computed along the channel dimension for the transpose of the input query $Q$ matrix. Summing the resulting squared matrix along the channel dimension yields $Q_p$, which combines the activation strengths of each location across all channels into a single value, resulting in an overall significance measure for each location. The largest $k$ values from $Q_p$ are selected, the most important $k$ salient locations in the feature map, which reduces the amount of data to be processed by selecting the salient locations and thus reduces the computational complexity. Finally, based on the index $inde{x}_k$ of the selected $k$ salient locations, the features corresponding to these locations are extracted from the original query matrix $Q$ to form the output matrix $K$ for subsequent attention computation in place of the attention mechanism of the full feature map, which further reduces the computational effort.

2.3.2. DL-Bagging Algorithm

The Deep Bootstrap Aggregating (DB) algorithm is constructed by combining the bagging algorithm with a deep learning model. The algorithm is divided into two phases: the first phase is the dataset sampling and base learner training based on the Deep Bootstrap Aggregating (DB) algorithm and the second phase is the integration of base learner predictions based on a simple voting strategy.

The Deep Bootstrap Aggregating algorithm mainly adopts the Bootstrap sampling to realize the production of datasets with the same underlying distribution and feature information, but are not identical, which enhances the diversity and comprehensiveness of model feature extraction. The main advantages of this method are as follows:

• Significantly reduces model variance and improves model stability by using multiple mutually independent base learners.
• Parallel computing speeds up model training.
• Multiple sub-datasets are generated by random sampling to avoid overfitting of the model to the training data.

Among them, Bootstrap is a sampling method with put-back, which achieves the goal of building an adequate sample set using a limited number of samples after many repeated samplings by using a resampling technique, i.e., randomly selecting a given number of samples from the original sample and generating a new set of samples that are the same size as the original sample, but with a different distribution [28].

The training set $\mathit{D}=\left\{\left(x_1,y_1\right),\left(x_2,y_2\right),\dots ,\left(x_n,y_n\right)\right\}$ is sampled using Bootstrap, and multiple samples are taken to obtain $N$ training subsets ${\mathit{D}}_i\left(i=1,2,\dots ,N\right)$, and the training subset ${\mathit{D}}_i$ is of the same size as the training set $\mathit{D}$. For each base learner, use a different training subset for training to get $N$ base learners ${\mathit{M}}_i\left(i=1,2,\dots ,N\right)$, then use these $N$ base learners to predict the target object separately to get $N$ predicted probability distributions $\left[{\mathit{D}}_1,{\mathit{D}}_2,\dots ,{\mathit{D}}_N\right]$, which are used as inputs to the phase II of the Deep Bootstrap Aggregating algorithm.

(1) 

The first stage

In the first phase of this study, the main task is to construct a base model based on the depth-guided aggregation algorithm. The core of this phase is to utilize the bootstrap sampling technique to generate multiple sub-datasets with the same underlying distribution but not identical feature information from the original training set. In this way, the diversity and comprehensiveness of the model’s feature extraction can be significantly improved, while reducing the variance of the model and improving its stability, and also accelerating the speed of model training due to the possibility of parallel computing.

In the specific implementation process, bootstrap sampling is first performed on the training set to generate multiple subsets of the same size as the original training set but with different distributions. Then, a base learner is trained separately for each subset, and finally, multiple base learners are obtained. These base learners are structurally independent of each other and can extract feature information from different perspectives because they use different training subsets for training, thus effectively avoiding overfitting of the model to the training data. During the training process, techniques such as the Adam optimizer, cross-entropy loss function, and cosine annealing learning rate scheduler are used to ensure efficient training and performance optimization of the model. The pseudo-code of the first stage of the Deep Bootstrap Aggregating algorithm is shown in Algorithm 2: Pseudo-code for the depth-guided aggregation algorithm (stage 1).

Algorithm 2: Deep Bootstrap Aggregating Algorithm (Stage 1)

Input: training set $\mathit{D}=\left\{\left(x_1,y_1\right),\left(x_2,y_2\right),\dots ,\left(x_n,y_n\right)\right\}$.

The training parameters $\mathit{P}=\left\{epochs,batch\_size,label\_smoothing\right\}$, the

Output: base learner ${\mathit{M}}_{\mathit{i}}\left(i=1,2,\dots ,N\right)$.

Begin

Initialize Loss_function, Optimizer, Scheduler

Bootstrap N samples $\mathit{D}\sim {\mathit{D}}_{\mathit{i}}$

For $i=1,2,\dots ,N$ do

For $epoch=1,2,\dots ,epochs$ do

For inputs in batch_size do

Forward(inputs) $\to {\mathit{M}}_{\mathit{i}}$

Loss_function.CrossEntryLoss(label_smooting)

Backward(loss)

Optimizer.

Scheduler.CosineAnnealingLR

Return ${\mathit{M}}_i\left(i=1,2,\dots ,N\right)$

End

(2) 

The second stage

In the second phase of this research, the main task is to construct an integrated model based on a Deep Bootstrap Aggregating algorithm. The machine learning-based recognition algorithm has two types of outputs: category-labeled outputs and predicted probability outputs for each category, which correspond to Majority/Hard Voting (Majority/Hard Voting, HV) [29] and Soft Voting (Soft Voting, SV) [30], respectively. The second stage of the Deep Bootstrap Aggregating algorithm uses hard voting, i.e., by counting the votes of the output categories recognized by the base learner for the target objects, the category with the most votes is the prediction. Assuming that there are $K$ categories of target candidates, the set of category labels of target candidates is $\left\{C_1,C_2,\dots ,C_K\right\}$, there are $N$ classifiers ${\mathit{M}}_i\left(1,2,\dots ,N\right)$, and for the prediction samples $x$ or $C_j$ can be recorded. The statistics of prediction results are shown in

Table 2. Tabulation of hard ballots.

Sorter	Candidate Category						Look for a Draw (Chess)
	${\mathit{C}}_1$	${\mathit{C}}_2$	…	${\mathit{C}}_{\mathit{j}}$	…	${\mathit{C}}_{\mathit{K}}$
$M_1$	$M_1^1\left(x\right)$	$M_1^2\left(x\right)$	…	$M_1^j\left(x\right)$	…	$M_1^K\left(x\right)$	1
$M_2$	$M_2^1\left(x\right)$	$M_2^2\left(x\right)$	…	$M_2^j\left(x\right)$	…	$M_2^K\left(x\right)$	1
…	…	…	…	…	…		1
$M_i$	$M_i^1\left(x\right)$	$M_i^2\left(x\right)$	…	$M_i^j\left(x\right)$	…	$M_i^K\left(x\right)$	1
…	…	…	…	…	…	…	1
$M_N$	$M_N^1\left(x\right)$	$M_N^2\left(x\right)$	…	$M_N^j\left(x\right)$	…	$M_N^K\left(x\right)$	1
look for a draw (chess)	${\displaystyle \sum _{n=1}^N{M}_n^1\left(x\right)}$	${\displaystyle \sum _{n=1}^N{M}_n^2\left(x\right)}$	…	${\displaystyle \sum _{n=1}^N{M}_n^j\left(x\right)}$	…	${\displaystyle \sum _{n=1}^N{M}_n^K\left(x\right)}$	$N$

.

Each classifier has one chance to vote for the category label of the predicted sample $x$ among the candidate classes $\left\{C_1,C_2,\dots ,C_K\right\}$ and the result of the voting can be expressed as Equation (4):

$$M_i^j\left(x\right)=\left\{\begin{array}{l}1,if(M_i\left(x\right)=C_j)\\ 0,if(M_i\left(x\right)\ne C_j)\end{array}\right.$$

(4)

As can be seen from Table 2, each row in the table is a unique 1 vector, when a classifier $M_i$ gives a vote to a candidate class $C_j$, its corresponding ballot $M_i^j\left(x\right)$ is recorded as 1. Observing from the column direction, the $j$ column is the vote obtained by the candidate class $C_j$, and the last row indicates the obtained result of each candidate class, and the candidate class that obtains the most votes is the final prediction result. The final decision result of the classifier ${\mathit{M}}_i\left(1,2,\dots ,N\right)$ on the predicted sample $x$ is denoted as $H\left(x\right)$, and the calculation process can be expressed as Equation (5):

$$\begin{array}{cc}H\left(x\right)\hfill & =\arg \max \left({\displaystyle \sum _{n=1}^N{M}_n^1\left(x\right)},{\displaystyle \sum _{n=1}^N{M}_n^2\left(x\right)},\dots ,{\displaystyle \sum _{n=1}^N{M}_n^i\left(x\right),}\dots {\displaystyle \sum _{n=1}^N{M}_n^N\left(x\right)}\right)\hfill \\ & =\underset{j}{\arg \max }{\displaystyle \sum _{n=1}^N{M}_n^j\left(x\right)}\hfill \end{array}$$

(5)

2.3.3. An Improved Depth-Guided Aggregation Algorithm Based on Cross-Entropy Loss

The simple voting strategy utilized in stage 2 of the Deep Bootstrap Aggregating algorithm only focuses on the category labels but ignores the probabilistic information predicted by the model, which may be subject to the role of low-accuracy models and generate randomness in the case of a tie vote, increasing the uncertainty of the results. In order to be able to enhance the integration effect of the Deep Bootstrap Aggregating algorithm, this study designs the Cross-Entropy Loss-Based Weighted Voting Strategy (Cross-Entropy Weighted Soft Voting, CEWSV) based on the soft voting method. For a detailed description of the cross-entropy loss function, see Appendix A.

In the traditional soft voting approach, the prediction probabilities of all base learners are considered with equal weight. However, CEWSV assigns a global weight to each base learner’s prediction associated with its performance by virtue of the introduction of the cross-entropy loss value as a weighting metric, where each base learner outputs a probability distribution for each labeled sample and the cross-entropy loss measures the difference between these probability distributions and the true label. The cross-entropy loss measures the difference between these probability distributions and the true labels, and the global weights are computed with the help of the performance of the integration model on a large number of labeled samples. A lower cross-entropy loss means that the base-learner’s predictions are closer to the true labels, and should have a greater say in the final integration decision.

Weighted voting strategy based on cross-entropy loss

Hard voting is a binary voting mechanism where classifiers must make an explicit choice, i.e., they can only choose between “agreeing” or “disagreeing” with a candidate. Soft voting, also known as proportional voting, is a voting method that allows voters to express their support for different candidates, and the classifier can split the votes with a value of 1 to different candidates based on its own preference, and then Equation (4) becomes a probabilistic expression, as shown in Equation (6):

$$\begin{array}{l}{M}_i^j\left(x\right)=P\left(C_j|x\right)\\ {\displaystyle \sum _{j=1}^{K}P\left(C_j|x\right)}=1\end{array}$$

(6)

Soft voting can be viewed as a weighted average fusion of base learners using the same weighting parameters, while weighted voting assigns different weighting parameters to different base learners. The method reduces the effect of high bias of some base learners by rewarding the base learners with good performance and penalizing the base learners with poor performance. In this study, the cross-entropy loss (CEL) value with label smoothing is used as a reference for weight assignment. The loss value is first calculated to quantify the degree of difference between the predicted and actual results of the base learners, i.e., the prediction error, as shown in Equation (7):

$$L_i=-{\displaystyle \sum _{k=1}^K\left(\frac{\epsilon }{K-1}+\left(1-\epsilon \right)1\left[y=c\right]\right)}\log \left({\displaystyle \frac{\exp \left(z_k\right)}{{\displaystyle {\sum }_{j=1}^K\exp \left(z_j\right)}}}\right)\mathit{For}i=1,2,\dots ,N$$

(7)

where $K$ denotes the number of categories; $\epsilon$ is a hyperparameter for label smoothing; $1\left[y=c\right]$ denotes an indicator function, i.e., if the true label of the predicted object $y$ is equal to the result predicted by the model, the value of this function is 1, otherwise it is 0; and $z_k$ denotes the output value of the neural network.

In order to obtain a set of weight parameters applicable globally, the average cross-entropy loss values of the $N$ base learners over all labelled samples are first calculated to obtain a vector of loss values $\mathit{L}=\left[{\overline{L}}_1,{\overline{L}}_2,\dots ,{\overline{L}}_N\right]$. In order to ensure that a small loss value does not effectively reward a high-performing model, a power function is used to amplify the loss value to ${\mathit{L}}^{\prime }=\left[{\overline{\mathit{L}}}_1^{\mu },{\overline{L}}_2^{\mu },\dots ,{\overline{L}}_N^{\mu }\right]$, in order to enhance the relative disparity between different base learners. Since a larger loss value indicates a worse prediction performance of the corresponding learner, the inverse of the amplified loss value is taken as ${\mathit{L}}^{″}=\left[{\displaystyle \frac{1}{{\overline{L}}_1^{\mu }}},{\displaystyle \frac{1}{{\overline{L}}_2^{\mu }}},\dots ,{\displaystyle \frac{1}{{\overline{L}}_N^{\mu }}}\right]$, and in order to ensure that the sum of the weight parameters is 1, normalization is performed to obtain a set of global weight parameters, and the computation process is shown in Equation (8):

$$\mathit{W}=\left[{\displaystyle \frac{L_1^{\prime \prime }}{{\displaystyle {\sum }_{n=1}^N{L}_n^{\prime \prime }}}},{\displaystyle \frac{L_2^{\prime \prime }}{{\displaystyle {\sum }_{n=1}^N{L}_n^{\prime \prime }}}},\dots ,{\displaystyle \frac{L_N^{\prime \prime }}{{\displaystyle {\sum }_{n=1}^N{L}_n^{\prime \prime }}}}\right]$$

(8)

When predicting the target object $x$, the global weight parameter is assigned to the prediction probability distribution $\left[{\mathit{F}}_{\mathit{1}},{\mathit{F}}_{\mathit{2}},\dots ,{\mathit{F}}_{\mathit{N}}\right]$ output by the corresponding base learner, and the contribution of different learners to the final prediction result is adjusted to obtain the weighted prediction probability distribution, as shown in Equations (9) and (10):

$${\mathit{F}}_i=\left[P\left(C_1|x\right),P\left(C_2|x\right),\dots ,P\left(C_j|x\right),\dots ,P\left(C_K|x\right)\right]$$

(9)

$$\begin{array}{cc}\mathit{P}\hfill & =\mathit{W}{\mathit{F}}_{\mathit{i}}\hfill \\ & =\left[\begin{array}{cccc}{W}_1{F}_1^1& W_1{F}_1^2& \cdots & W_1{F}_1^K\\ W_2{F}_2^1& W_2{F}_2^2& \cdots & W_2{F}_2^K\\ ⋮& \cdots & \cdots & ⋮\\ W_N{F}_N^1& W_N{F}_N^2& \cdots & W_N{F}_N^K\end{array}\right]\end{array}$$

(10)

where $W_N$ is the weight parameter assigned to the $N$ base learner; $F_N^K$ is the probability of the $N$ base learner to predict the target object $x$ for the $K$ category; the probability distribution after model integration is obtained by accumulating along the column vector direction ${\mathit{P}}^{\prime }$; and the category label corresponding to the maximum probability value is the final prediction result. The final decision result of the classifier $M_i\left(1,2,\dots ,N\right)$ on the predicted sample $x$ is denoted as $H\left(x\right)$, and the computation process can be expressed as Equations (11) and (12):

$${\mathit{P}}^{\prime }=\left[{\displaystyle {\sum }_{i=1}^N{W}_i{F}_i^1,}{\displaystyle {\sum }_{i=1}^N{W}_i{F}_i^2,}\dots ,{\displaystyle {\sum }_{i=1}^N{W}_i{F}_i^K}\right]$$

(11)

$$H\left(x\right)=\arg \max \left({\mathit{P}}^{\prime }\right)$$

(12)

2.4. Evaluation Metrics

In this study, accuracy (Acc), precision (P), recall (R), F1-core (F1), parameter count (Param, P), and computational effort (FLOPs, F) were used to comprehensively measure the performance of the network model on rice disease recognition [31]. Assuming that a certain type of disease is positive and the rest of the diseases are negative, TP denotes the number of samples in which the actual positive category is correctly determined as positive; FP denotes the number of samples in which the actual negative category is incorrectly determined as positive; FN denotes the number of samples in which the actual positive category is incorrectly determined as negative; and TN denotes the number of samples in which the actual negative category is correctly determined as the corresponding negative category. Accuracy is the most commonly used performance metric and is defined as the ratio of correct predictions to total predictions; the higher the value, the better the performance of the model, calculated as shown in Equation (13):

$$Acc={\displaystyle \frac{TP+TN}{TP+FP+FN+TN}}$$

(13)

In order to observe whether the model misclassifies or not, precision is used as a further measure. Precision, also known as check accuracy, indicates the proportion of samples identified by the model as being in the positive category that are in the correct category. This value focuses on the number of samples statistically predicted to be in the positive category that are correct, and is calculated as shown in Equation (14):

$$P={\displaystyle \frac{TP}{TP+FP}}$$

(14)

In order to observe whether the model misses a judgment or not, the recall rate is used as a measure. The recall rate, also known as the check-all rate, indicates the proportion of samples recognized by the model as positive class in the actual positive class samples, and this value measures the ability of the model to recognize all positive class samples, calculated as shown in Equation (15):

$$R={\displaystyle \frac{TP}{TP+FN}}$$

(15)

However, precision and recall are a pair of contradictory indicators. Model recognition requires that the higher the threshold, the higher the precision and lower the recall, and the lower the threshold, the lower the precision and higher the recall. In order to synthesize the proposed $F_{\beta }$ score, which is a kind of weighted average of precision and recall, in the merging process, the weight of recall is $\beta$ times of the precision. The computation is shown in Equation (16):

$$F_{\beta }=\left(1+{\beta }^2\right){\displaystyle \frac{P\times R}{{\beta }^2\times P+R}}$$

(16)

When precision and recall are equally important, i.e., $\beta =1$, then it is the F1 score, which is defined as the reconciled average of precision and recall, calculated as shown in Equation (17):

$$F1={\displaystyle \frac{2\times P\times R}{P+R}}$$

(17)

For the multi-class recognition problem, the accuracy measure is the global sample prediction, and the precision, recall, and F1 score are the evaluation metrics for individual classes, so this paper adopts the macro-average (macro-averaging) method for these three evaluation metrics averaged over each class to evaluate the global prediction performance of the model. The calculation of average precision $\overline{P}$, average recall $\overline{R}$, and average F1 score $\overline{F}1$ [32] is shown in Equation (18):

$$\begin{array}{l}\overline{P}={\displaystyle \frac{1}{K}}{\displaystyle \sum _{i=1}^K{P}_i}\\ \overline{R}={\displaystyle \frac{1}{K}}{\displaystyle \sum _{i=1}^K{R}_i}\\ \overline{F}1={\displaystyle \frac{1}{K}}{\displaystyle \sum _{i=1}^{K}F{1}_i}\end{array}$$

(18)

The number of parameters, which is the core metric for evaluating the measure of algorithmic complexity, grows positively correlated with the increase in hardware configuration requirements of the computational graph, which is defined [33] as shown in Equation (19):

$$\begin{array}{l}{P}_{Conv}=K\times K\times C_{in}\times C_{out}+C_{out}\\ P_{fc}=Input\times Output+Output\\ P=P_{Conv}+P_{fc}\end{array}$$

(19)

where $P_{Conv}$, $P_{fc}$, and $P$ denote the number of parameters in the convolutional layer, fully connected layer, and network model, respectively; $K$ denotes the size of the convolutional kernel; $C_{in}$ denotes the number of input feature map channels; $C_{out}$ denotes the number of output feature map channels; and $Input$ and $Output$ denote the number of input and output weights in the fully connected layer, respectively.

In addition, when evaluating the computing efficacy of the algorithmic architecture, the experiments use floating-point arithmetic as a metric to reflect the difference in the computational complexity of the various types of network models, where a higher value implies that the model inference process consumes more processor computation cycles, which is defined [34] as shown in Equation (20):

$$\begin{array}{l}{F}_{Conv}=2\times K\times K\times C_{in}\times C_{out}\times W\times H\\ F_{fc}=2\times Input\times Output-Output\\ F=F_{Conv}+F_{fc}\end{array}$$

(20)

where $F_{Conv}$, $F_{fc}$, and $F$ denote the computational complexity of the convolutional layer, fully connected layer and network model; and $W$ and $H$ denote the scale size of the output feature map.

3. Experimental Results

3.1. Selection and Comparison of Base Learners

In this experiment, four base models were trained, optimized, and tested separately using the rice leaf disease dataset. First, we explored the performance of five different depth and width models of YOLOv5-cls on the rice leaf disease dataset. These five versions of the model were trained and tested separately and evaluated in terms of four aspects: number of model parameters, model complexity, recognition accuracy, and FPS, and the results are shown in

Table 3. Comparison of results from five versions of YOLOv5-cls on rice leaf disease validation set.

Model	Params	GFLOPs	Accuracy Percent	FPS
YOLOv5x-cls	46.82	7.93	95.54	61
YOLOv5l-cls	25.28	4.21	95.83	78
YOLOv5m-cls	11.68	1.89	95.98	107
YOLOv5s-cls	4.18	0.64	96.28	113
YOLOv5n-cls	1.22	0.18	95.09	116

.

As can be seen from Table 3, YOLOv5s-cls has the highest recognition accuracy on the rice leaf disease dataset, and its number of parameters and complexity satisfy the lightweight requirement. Compared with the lightest YOLOv5n-cls, YOLOv5s-cls better balances the model recognition performance while reducing the training cost and increasing the inference speed. Therefore, YOLOv5s-cls is used for subsequent experiments.

Next, YOLOv5s-cls, EfficientNet-B0, MobileNetV3, and ShuffleNetV2 are trained without label smoothing and learning rate optimization strategies, respectively, keeping other hyperparameters consistent. Subsequently, the label smoothing and cosine annealing learning rate optimization strategies are added to train the four base learners again. The training results before and after optimization are shown in Figure 5.

As can be seen from Figure 5, the optimized model is more stable, with accuracy gradually increasing and eventually leveling off as the epoch increases, indicating that the model is better trained. The final accuracies of YOLOv5s-cls, EfficientNet-B0, MobileNetV3, and ShuffleNetV2 on the rice leaf disease dataset are, respectively, 98.42%, 99.05%, 98.72%, and 99.02%. Finally, the four base models were tested to calculate the recognition accuracy, macro precision, macro recall, and macro F1 score, and the results are shown in

Table 4. Comparison of results from base learners.

Model	Accuracy Percent	Macro-P Percent	Macro-R Percent	Macro-F1 Percent	FPS
YOLOv5s-cls	96.73	96.82	96.73	96.73	129.52
EfficienNet-B0	94.35	94.52	94.35	94.35	110.75
MobileNetV3-large	94.94	94.99	94.94	94.94	110.73
ShuffleNetV2	95.68	95.78	95.68	95.67	123.87

. These four lightweight networks save training resources, and all of them have high recognition accuracy with small performance differences, so they are selected as the base learners for integrated learning.

3.2. Test Platform and Parameter Settings

The computer used in this study is a Lenovo Legion Y7000 made in China, equipped with an Intel(R) Core (TM) i7-12700H CPU, 2.70 GHz, 64.0 GB RAM, and an NVIDIA GeForce RTX 3060 graphics card; CUDA version 11.6; Cudnn version 8.3.2; and Windows 11 64-bit operating system. The software used mainly includes OpenCV image processing software and Pytorch 1.13 Python 3.10 deep learning framework, and the program was compiled using the Python language.

First, we conducted a series of ablation experiments to evaluate the effectiveness of the method in order to determine the hyperparameters that are better for the model training results. The final hyperparameter settings are shown in

Table 5. Training parameter configuration.

Parameter Category	Parameter Name	Setpoint
starting parameter	Input_shape	[224, 224]
	Batch_size	16
	Num_workers	2
	Epoch	110
	Label_smoothing	0.1
Optimizer Adam	Init_lr	5 × 10−4
	Momentum	0.9
	Weight_decay	1 × 10−5
	Scheduler_lr	Cosine Annealing
	T_max	110

.

3.3. Comparison of the Performance of Adding SPA at Different Stages

In order to verify the performance enhancement of the improved SPA-M, SPA-S, SPA-Y, and SPA-E network models for rice disease recognition, the unity of the structure and initial parameter configuration of each network model was strictly maintained during this experiment, and the hyperparameter $k$ of the salient position-based attention mechanism SPA was set to 2. The improved SPA-M, SPA-S, SPA-Y, and SPA-E network models were compared with their original network models. The improved SPA-M, SPA-S, SPA-Y, and SPA-E network models are compared with their original network models, and the results of the parameter counts, computation, and recognition performance comparison of each network model are shown in

Table 6. Network model parametric quantities and calculations.

Model	Layer1		Layer2		Layer3		Layer4
	P/M	F/G	P/M	F/G	P/M	F/G	P/M	F/G
SPA-M	4.209	0.243	4.209	0.243	4.210	0.239	4.210	0.239
SPA-S	5.357	0.616	5.535	0.704	6.072	0.702	8.218	0.699
SPA-Y	4.182	0.677	4.191	0.674	4.191	0.674	4.229	0.673
SPA-E	4.017	0.448	4.015	0.424	4.016	0.419	4.019	0.417

and

Table 7. Comparison of network model performance.

Layer	$\mathit{A}\mathit{c}\mathit{c}$/%				$\overline{\mathit{P}}$/%
	SPA-M	SPA-S	SPA-Y	SPA-E	SPA-M	SPA-S	SPA-Y	SPA-E
(0,0,0,0)	95.952	96.905	96.905	96.190	96.070	96.946	97.006	96.322
(1,0,0,0)	96.190	97.024	97.143	97.381	96.318	97.104	97.317	97.410
(0,1,0,0)	97.143	97.262	97.500	96.548	97.172	97.387	97.686	96.567
(0,0,1,0)	95.833	97.262	97.857	96.310	95.918	97.375	97.976	96.427
(0,0,0,1)	96.071	97.024	97.619	96.190	96.168	97.218	97.651	96.346
	$\overline{\mathit{R}}$/%				$\overline{\mathit{F}}\mathsf{1}$/%
(0,0,0,0)	95.952	96.905	96.905	96.190	95.970	96.907	96.906	96.182
(1,0,0,0)	96.190	97.024	97.143	97.381	96.184	97.033	97.142	97.375
(0,1,0,0)	97.143	97.262	97.500	96.548	97.139	97.277	97.515	96.541
(0,0,1,0)	95.833	97.262	97.857	96.310	95.826	97.276	97.862	96.288
(0,0,0,1)	96.071	97.024	97.619	96.190	96.032	97.050	97.618	96.435

.

Comparing the experimental results in Table 6 and Table 7, compared to the original base networks MobileNetV3-large, ShuffleNetV2-2.0, YOLOv5s-cls, and EfficientNet-B0, the improved SPA-M, SPA-S, SPA-Y, and SPA-E have an increase in the number of parameters by up to 0.002 M, 2.863 M, 0.05 M, and 0.005 M, and the computational volume increased by up to 0.009 G, 0.108 G, 0.024 G, and 0.034 G. The improved network models increased the recognition accuracy of rice diseases by up to 1.191%, 0.357%, 0.952%, and 1.191%; the average accuracies increased by 1.102%, 0.441%, 0.970%, and 1.088%; average recall improved by 1.191%, 0.357%, 0.952%, and 1.191%; and average F1 score values improved by 1.169%, 0.370%, 0.956%, and 1.193%. By introducing a salient position-based attention module to optimize the feature selection mechanism, the improved algorithm has significantly improved the recognition of rice diseases while maintaining the computational efficiency, and compared to the base model, this improvement presents a better performance in all the evaluation metrics and achieves a breakthrough in performance at the cost of only a small amount of resource consumption.

Moreover, to balance the performance and efficiency of the network model and determine a value that ensures the model can effectively process information while maintaining high operational efficiency, this experiment was conducted with settings of two, four, and eight, respectively, and comparative experiments were carried out on SPA-M, SPA-S, SPA-Y, and SPA-E. Transfer learning technology was used to initialize the weight parameters of each network model, and the training of the rice disease dataset was ultimately completed. The recognition accuracy rates of various network models under different settings are compared in

Table A1. Network model accuracy at different k values.

Model	Layer	$\mathit{A}\mathit{c}\mathit{c}$/%
		k = 2	k = 4	k = 8
SPA-M	(1,0,0,0)	96.190 (+0.238)	96.548 (+0.596)	96.548 (+0.596)
	(0,1,0,0)	97.143 (+1.191)	95.714 (−0.238)	96.905 (+0.953)
	(0,0,1,0)	95.833 (−0.119)	96.190 (+0.238)	96.429 (+0.477)
	(0,0,0,1)	96.071 (+0.119)	95.952 (+0.000)	95.952 (+0.000)
SPA-S	(1,0,0,0)	97.024 (+0.119)	97.619 (+0.714)	97.262 (+0.357)
	(0,1,0,0)	97.262 (+0.357)	96.667 (−0.238)	97.738 (+0.833)
	(0,0,1,0)	97.262 (+0.357)	96.786 (−0.119)	97.024 (+0.119)
	(0,0,0,1)	97.024 (+0.119)	96.905 (+0.000)	97.262 (+0.357)
SPA-Y	(1,0,0,0)	97.143 (+0.238)	96.905 (+0.000)	97.262 (+0.357)
	(0,1,0,0)	97.500 (+0.595)	97.143 (+0.238)	97.500 (+0.595)
	(0,0,1,0)	97.857 (+0.952)	97.381 (+0.476)	97.143 (+0.238)
	(0,0,0,1)	97.619 (+0.714)	97.381 (+0.476)	97.381 (+0.476)
SPA-E	(1,0,0,0)	97.381 (+1.191)	96.429 (+0.239)	97.262 (+1.072)
	(0,1,0,0)	96.548 (+0.358)	96.190 (+0.000)	96.548 (+0.358)
	(0,0,1,0)	96.310 (+0.120)	97.262 (+1.072)	96.429 (+0.239)
	(0,0,0,1)	96.190 (+0.000)	97.857 (+1.667)	96.667 (+0.477)

. A detailed comparison of recognition accuracy rates for various network models using different K values is provided in Appendix B.

3.4. DL-Bagging Based Model for Combining Different Base Learners

The performance of integrated learning models with different combinations of base learners is explored in the experiments. Random combinations of YOLOv5s-cls, EfficientNet-B0, MobileNetV3, and ShuffleNetV2 were fused into a new DL-Bagging based integrated learning model. The training parameters are kept consistent with single model training. The recognition accuracy, macro-accuracy, macro-recall, macro-F1 score, and the mean value of each evaluation index of the integrated learning model with different base-learner combinations for rice leaf diseases are shown in

Table 8. Performance of different integration models.

Model	M	S	Y	E	$\mathit{A}\mathit{c}\mathit{c}$/%	$\overline{\mathit{P}}$/%	$\overline{\mathit{R}}$/%	$\overline{\mathit{F}}1$/%
	✓				97.143	97.172	97.143	97.139
		✓			97.738	97.787	97.738	97.739
			✓		97.857	97.976	97.857	97.862
				✓	97.857	97.954	97.857	97.868
MS	✓	✓			97.857	97.926	97.857	97.867
MY	✓		✓		97.857	97.950	97.857	97.865
ME	✓			✓	97.976	98.095	97.976	97.992
SY		✓	✓		97.857	97.938	97.857	97.867
SE		✓		✓	97.976	98.031	97.976	97.978
YE			✓	✓	98.095	98.185	98.095	98.104
MSY	✓	✓	✓		97.857	97.949	97.857	97.867
MSE	✓	✓		✓	98.095	98.205	98.095	98.108
MYE	✓		✓	✓	97.738	97.868	97.738	97.755
SYE		✓	✓	✓	98.095	98.185	98.095	98.104
MSYE	✓	✓	✓	✓	98.095	98.205	98.095	98.108

, where M denotes MobileNetV3, S denotes ShuffleNetV2, Y denotes YOLOv5s-cls, and E denotes EfficientNet-B0.

As can be seen from Table 8, the integrated models have a high level of recognition performance, where the MS, ME, SE, YE, MSE, SYE, and MSYE models have higher recognition performance compared to each base model in their combination, with the highest recognition accuracy, average precision, average recall, and average F1 scores of 98.095%, 98.205%, 98.095%, and 98.108%, which are 0.238%, 0.229%, 0.238%, and 0.246% higher than the best performing single model SPA-Y.

In order to verify the performance enhancement of the depth-guided aggregation algorithm by CEWSV, a weighted voting strategy based on the cross-entropy loss improvement, the same combination of models as described above is used for testing on the rice disease dataset. The recognition accuracy of the models on the test set is shown in

Table 9. Comparison of different integration strategies.

Model	$\mathit{A}\mathit{c}\mathit{c}$/%
	HV	SV	CEWSV
MS	97.857	98.095 (+0.238)	98.214 (+0.357)
MY	97.857	97.857 (+0)	97.857 (+0)
ME	97.976	97.857 (−0.119)	97.976 (+0)
SY	97.857	97.976 (+0.119)	98.095 (+0.238)
SE	97.976	97.976 (+0)	98.095 (+0.119)
YE	98.095	98.095 (+0)	98.214 (+0.119)
MSY	97.857	97.976 (+0.119)	97.976 (+0.119)
MSE	98.095	98.214 (+0.119)	98.333 (+0.238)
MYE	97.738	97.857 (+0.119)	98.214 (+0.476)
SYE	98.095	98.095 (+0)	98.095 (+0)
MSYE	98.095	98.095 (+0)	98.333 (+0.238)

, where HV denotes hard voting, SV denotes soft voting, and CEWSV denotes a weighted voting strategy based on cross-entropy loss.

As can be seen from Table 9, the recognition accuracy of MS, SY, MSY, MSE, and MYE network models is improved when soft voting is used as the integration strategy compared to the hard voting method, in which the recognition accuracy is improved by up to 0.238%, and the recognition accuracy of the MY, ME, and SYE models is kept unchanged when using the improved CEWSV based on soft voting as the integration strategy, and the remaining network models of the network models are improved, with the highest improvement of 0.476%, among which the MSE and MSYE network models have the highest recognition accuracy of 98.333%, which is improved by 0.238% compared to the original integration strategy HV. To further observe the performance of the integrated models, the accuracy, average precision, average recall, and average F1 score of the integrated models for recognition on the rice disease test set were compared, as shown in

Table 10. Performance comparison of integrated models.

Model	$\mathit{A}\mathit{c}\mathit{c}$/%	$\overline{\mathit{P}}$/%	$\overline{\mathit{R}}$/%	$\overline{\mathit{F}}1$/%
MS	98.214	98.273	98.214	98.219
MY	97.857	97.986	97.857	98.865
ME	97.976	98.073	97.976	97.989
SY	98.095	98.155	98.095	98.102
SE	98.095	98.151	98.095	98.098
YE	98.214	98.307	98.214	98.225
MSY	97.976	98.038	97.976	97.982
MSE	98.333	98.412	98.333	98.343
MYE	98.214	98.307	98.214	98.225
SYE	98.095	98.212	98.095	98.105
MSYE	98.333	98.412	98.333	98.343

.

The average precision improved by up to 0.439%, the average recall by up to 0.476%, and the average F1 score by up to 0.47%. The MSE and MSYE network models had the best performance in each of the evaluation metrics, with recognition accuracy, precision, recall, and F1 scores of 98.333%, 98.412%, 98.333%, and 98.343%. Compared to the single base learners SPA-M, SPA-S, SPA-Y, and SPA-E, recognition accuracy is improved by 1.19%, 0.595%, 0.476%, and 0.476%; the average precision is improved by 1.24%, 0.625%, 0.436%, and 0.458%; the average recall is improved by 1.19%, 0.595%, 0.476%, and 0.476%; and the average F1 score improved by 1.204%, 0.604%, 0.481%, and 0.475. In order to reduce the cost of deployment at the edge end, the MSE integration model was chosen as the final model for subsequent deployment.

3.5. Comparison with Other Mainstream Models

To further validate the recognition performance of the model proposed in this paper, other mainstream convolutional neural networks are trained and tested on the rice disease dataset using the same experimental setup as described above. In this paper, ResNet50, DenseNet121, and ConvNeXt-tiny are selected to be compared with the best integrated model MSE, and the recognition accuracies, average precision on the rice disease test set, average recall, and average F1 score are shown in Figure 6.

As can be seen in Figure 6, the MSE integrated model proposed in this paper exhibits excellent performance on all evaluation metrics, with a recognition accuracy of 98.333% on the test set, compared to 96.429% for ResNet50, 96.905% for DenseNet121, and 95.952% for ConvNeXt-tiny. The MSE model performance in the rice disease identification task. The recognition performance of the MSE model proposed in this paper on the rice disease dataset is fully validated through comparison experiments with mainstream CNN models such as ResNet50, DenseNet121, and ConvNeXt-tiny.

To further analyze the model’s recognition performance for each disease category, a confusion matrix (also known as a probability matrix) is used to visualize the model’s recognition results. Each column in the confusion matrix represents the category predicted by the model, and the sum of the columns indicates the number of samples predicted to belong to that category. Each row represents the true category of the data, and the sum of the rows indicates the number of true samples in that category, as shown in Figure 7. ResNet50, DenseNet121, ConvNeXt-tiny, and MSE performed identically on the tungro and healthy categories, achieving an accuracy rate of 100%. ResNet50, DenseNet121, and ConvNeXt-tiny also performed identically on the bacterial leaf blight, with an accuracy rate of 94.048%. The MSE ensemble model shows a significant improvement in recognition performance, with an accuracy rate of 97.024%. The recognition accuracy rates for rice blast disease using ResNet50, DenseNet121, ConvNeXt-tiny, and MSE are 92.262%, 93.452%, 90.476%, and 95.238%, respectively. The identification accuracy rates of ResNet50, DenseNet121, ConvNeXt-tiny, and MSE for brown spot disease are 95.833%, 97.024%, 95.238%, and 99.405%, respectively. The MSE ensemble model proposed in this paper outperforms mainstream models across all categories, demonstrating superior identification performance.

4. Discussion

Recent studies on rice disease classification have made significant progress using deep learning techniques, particularly with lightweight models and ensemble methods. For instance, Gan et al. [35] proposed that BiFPN multi-scale fusion combined with the Wise-IoU loss function can improve small-sample generalization ability, but the mAP of small samples in natural environments is still 3.8% lower than that in laboratory conditions. Similarly, Wang et al. [36] proposed a stacked ensemble of CG-EfficientNet models, achieving 96.10% accuracy by leveraging attention mechanisms and sequential least squares programming for weight optimization. While this approach demonstrates commendable performance, it primarily focuses on balancing model accuracy and computational efficiency, with limited emphasis on handling complex field conditions or small-sample datasets. Jia et al. [37] proposed the MobileNet-CA-YOLO model, which significantly improved the efficiency and lightweight level of rice pest and disease detection by combining the MobileNetV3 lightweight network, the coordinate attention mechanism (CA), and the SIoU loss function. However, their dataset mainly comes from web crawling, and the sample coverage and diversity may be insufficient. Moreover, it does not include real scene data under complex field environments (such as occlusion and light changes), which affects the generalization ability of the model in practical applications. These methods typically rely on single-model optimizations or simple ensemble strategies, which may not fully exploit the diversity of feature representations or adapt dynamically to varying field conditions.

Our method, CEL-DL-Bagging, addresses these limitations by integrating a salient position attention (SPA) mechanism with a cross-entropy loss-weighted voting strategy, achieving 98.33% accuracy. Unlike previous approaches, our framework combines multiple lightweight models (YOLOv5s-cls, EfficientNet-B0, MobileNetV3, and ShuffleNetV2) through Bootstrap Aggregating (Bagging), enhancing feature diversity and robustness. The SPA mechanism specifically targets diagnostically relevant regions, reducing interference from complex backgrounds, while the adaptive weighting strategy ensures optimal contributions from each base learner. This dual focus on attention and ensemble diversity allows our model to outperform existing methods in both accuracy and generalization, particularly in natural field environments where lighting and occlusion variations are prevalent.

While the proposed CEL-DL-Bagging framework demonstrates superior performance in rice leaf disease identification, several important considerations and limitations merit discussion.

(1) The field rice disease dataset used in this paper was sourced from the rice green high-yield, efficient, and productive demonstration fields in Gaoyou City, and Yangzhou City, both in Jiangsu Province. The experiment utilized network data expansion, data enhancement, and transfer learning techniques to mitigate the impact of limited data volume. Further expansion of the field rice disease dataset will be required with the assistance of agricultural researchers;

(2) The field rice disease recognition model in this paper has not yet been tested with a more diverse range of rice disease phenotypic features. Further efforts are needed to increase data diversity and validate the model’s performance under other disease manifestation scenarios to enhance its generalization capability;

(3) This paper improved the network model’s performance in identifying rice diseases in the field through a position-based attention mechanism and an improved depth-guided aggregation algorithm. However, there is still room for improvement. In the future, we will attempt to integrate more advanced deep learning technologies with the identification model to improve identification accuracy, speed, and adaptability under different environmental conditions, thereby optimizing the rice disease identification model in the field.

5. Conclusions

This study presents the CEL-DL-Bagging framework for accurate rice leaf disease identification in complex field environments. By integrating a salient position attention mechanism with cross-entropy loss-weighted ensemble learning, the method achieves 98.33% accuracy while maintaining computational efficiency for practical deployment. The proposed approach outperforms existing models by effectively combining lightweight network design with adaptive feature extraction and decision fusion. This work provides a robust solution for real-world agricultural applications and demonstrates the potential of attention-based ensemble learning in plant disease recognition. To further demonstrate the superiority and effectiveness of this model, we have successfully deployed it to the edge device Jetson Orin Nano. For details, please refer to the supplementary materials section. Future efforts will focus on expanding the system’s applicability to diverse field conditions and crop varieties.