A Lightweight and Erudite VGG 16+ResNet 50 Based Deep Learning Architecture Model for Enhanced Plant Yield Production

In most of the countries across the world, agriculture has been a significant driver for economic growth. By 2050, there will be 10 billion individuals on the entire globe. Since there is a limited supply of agricultural land, crop production must maintain up with population growth. In 2050, the Food and Agriculture Organization of the United Nations (FAO) estimates that an additional 70% of food will be needed to sustain the world's population, yet more than one third of all food produced would be lost due to illnesses or diseases of plants. The cultivator selects the required crop based on factors such as soil type, local weather, and crop value. Expanding human populations, changing weather patterns, and political unrest drove the sectors to seek for new ways to increase food production [1]. This enables researchers to discover new, highly productive, accurate, and successful technologies.

Farmers are able to collect data and information using information technology and precision agriculture to help people make informed decisions about high yields of agriculture. Precision agriculture, or PA, is a cutting-edge technology that provides advanced methods for maximizing agricultural output. Leveraging this advanced technology can help foster agricultural economic growth [2, 3]. A farmer uses pesticides to prevent diseases at bay, handle insects, and boost crop productivity. Farmers are facing difficulties as a consequence of crop diseases brought about by industrial farming, reduced yield, and financial losses. As a result, the focus of disease severity and diagnosis is on the requirement for adequate terminology. Agriculture is essential to the domestic financial system and the quality of life for the people in many countries. Abnormalities in leaf development, chromatic distortion, growth delays, wilted and damaged units constitute typical symptoms. Despite the fact that diseases and pests can seriously harm crops or spread to other plants, they can also have a legitimate impact on the well-being of people. To prevent excessive losses on the yields, these need to be carefully evaluated and properly maintained. Diseases can occur in a variety of different plant parts, including the leaves, root, and products from nature [4, 5]. Leaf provides a few interesting advantages over flowers and organic products in every season of the year. The precision of the results and the acknowledgement rate have been enhanced through the deployment of advanced technologies such as ML and DL. Unique investigations took place in the field of machine learning for the identification and verification of plant contaminants. Machine learning techniques are fundamentally employed in agricultural research to identify, sense, and predict plant pressure characterization and crop diseases [6]. Typically, data is gathered from significant standard images or sensor data and then retaken shortly after to eliminate irrelevant but interesting information. The purpose of ML is to interpret data and extract knowledge from it. They applied to receive the decision according to the specifications. To handle numerous tasks of classification, clustering, mining association rules, anomaly identification, and others, several algorithms have been developed [7, 8]. A component of machine learning's evolution that adjusts to various dataset types in a compatible way is deep learning. In the factors of deep learning setting, CNN is a great tool for image recognition tasks [9, 10]. The structural relationship corresponds with the understanding process that humans go through from learners to information that can be processed by neurons in the brain. The standard plant leaf disease identification system is shown in Figure 1.

1.png

Figure 1. Plant leaf disease detection system

Conventional studies develop several CNN architectural models [11, 12] and other techniques [13, 14] for plant leaf disease identifying and classifying. However, the primary issues facing most approaches are their high complexity, longer training and validation times, higher mistake rates, and decreased efficiency. Thus, the proposed work seeks to advance a novel and distinctive deep learning methodology for plant leaf disease detection and classification. The paper's unique contribution is the development of the VGG16+ResNet 50 hybrid architecture model, which is intended to detect plant leaf diseases. These are the most well-liked and frequently utilized CNN designs, each of which has the advantage of greater accuracy, rapid processing, and the capacity to handle increasingly complicated images. The proposed effort seeks to combine these two approaches to advance an automated system for identifying plant leaf diseases. The remaining sections of this paper are organized as follows: Section 2 presents a literature review, exploring various deep learning architecture models utilized in plant leaf disease detection. For a deeper understanding, it also looks into the specifics of the dataset, the benefits, and the drawbacks of each work. The architecture model, mathematical examples, and a comprehensive explanation of the suggested hybrid VGG 16 + ResNet 50 models are provided in Section 3. Using a number of factors, Section 4 validates the performance outcomes and results of the suggested methodology. The suggested method is also contrasted with some of the most recent cutting-edge methods. Section 5 provides a summary of the paper's problems, findings, outcomes, and recommendations for future work.

1.1 Objectives of the work

(1) Design and implement a hybrid DL model that integrates VGG16 and ResNet 50 architectures, optimized for reduced computational complexity and resource efficiency.

(2) Improve the recognition rate of plant leaf diseases compared to traditional ML, statistical methods, and standalone DL models.

(3) Implement a model capable of accurately identifying and categorizing disease affecting leaves of various plant species, including fruits and vegetables.

(4) Achieve high accuracy in identify and analyze plant leaf diseases and age which maintain a lightweight model suitable for deployment on resource constrained device.

(5) Develop techniques to optimize the training and inference stages of the hybrid model, ensuring faster processing times and lower energy consumption.

This part includes architecture designs, mathematical formulations, and a thorough description of the ResNet 50, VGG 16, and suggested hybrid models. The proposed work's unique contribution lies in the improvement of a lightweight, combined deep learning approach for identifying plant diseases. Furthermore, the age prediction is carried out by machine learning using lightweight VGG 16. To do this, the most well-liked and effective architectures, such as ResNet 50 and VGG 16, are combined to create a hybridized algorithm that can identify various diseases with their respective ages from the plant leaves of any fruit or vegetable.

3.1 VGG 16 architecture

To enhance performance and differentiate the disease affected crop images and healthy ones, a pre-trained VGG16 models relied on Convolutional Neural Networks (CNNs) are employed. To recognize and analyze plant leaf images for effectiveness, the primary model uses data from previously trained VGG16 models. New field images have been retained by the CNN model, which also trained to operate as a disease identification and classification method. Large kernel filters, consisting of 11 and 5 convolutional layers having a 3×3-kernel filter size, strengthened the VGG model. 224×224 is the fixed size of the input image. After pre-processing, a convolutional layer with a 3×3 filter size had been applied to the images. The filter size has been set to 1 x 1 for the input channel's linear transformation. With a fixed stride size of 1 and max pooling using 2×2 sizes, the length of the stride is set to 2 [35]. The fully interconnected layers in the following stages all consist of 4096 channels have an identical configuration. The softmax activation layers is the last layer, and the RELU function of activation comes next. From additional feature maps or unprocessed images, the CNN layer is extracted. The majority of the user-specified parameters are stored on this part of the network. The two most crucial characteristics are the total number and size of the kernels. Specifically, the feature map of the convolution layer is computed as follows:

$v_{i, j, m}=\operatorname{Max}_m K \times P_{i, j}+\mathfrak{B}_m, 0$         (1)

where, $v_{i, j, m}$ indicates the activation factor of input image $m$, $i$, $j$ is the position of input image, $P_{i, j}$ denotes the location centered input patch, and $\mathfrak{B}_m$ is the bias value. The ReLU activation function is significant since, even in an instance that the neuron activates, the gradient remains high (which is equivalent to 1). Simply stated, the ReLU layer applies the function to every value in the source region and sets all negative activations to 0.0. Without altering the convolution layer's receptive fields, this layer strengthens the nonlinear characteristics of the model and the entire network.

$v_{i, j, m}=\operatorname{Max}\left(\mathcal{S}_{i, j, m}, 0\right)$        (2)

where, $\mathcal{S}_{i, j, m}$ represents the activation function’s input at m^th channel. Pooling layers, like convolution layers, have a specific function. For example, they can be applied for maximum pooling, which captures the highest value from a specific area, which measures the average value by pooling. Typically, these processes are used to attenuate the dimensionality of the network.

$\mathcal{H}_{i, j, m}=\left[\sum_{(a, b) \in \tau_{i, j}}\left(v_{a, b, m}\right)^z\right]^{1 / z}$          (3)

where, $\mathcal{H}_{i, j, m}$ denotes the output of pooling at region $(i, j)$ in the feature map, $v_{a, b, m}$ indicates the feature value with the pooling region $\tau_{i, j}$ at the location of $(a, b)$. The main purpose of pooling is to assist with extract features that are lightweight and sharp. Additionally, it is carried out to decrease calculations and error. Max-pooling facilitates elimination of low-level features like points, edges, etc. The function map's area covered by the philtre's protection will yield the greatest feature. The result that follows pooling layer(max) will be a map that involves the feature of the notable elements from the prior feature map. This operation is mathematically represented as follows:

$\begin{aligned} h_{i, j, m}=\beta \max _{(a, b) \in \tau_{i, j}} & v_{a, b, m}+(1 -\beta) \frac{1}{\left|\tau_{i, j}\right|} \sum_{(a, b) \in \tau_{i, j}} v_{a, b, m}\end{aligned}$        (4)

where, $\beta$ represents the random number that 0 or 1 indicates the option. The pooling layes in the fully connected network are utilised to flatten the results before to classification in order to improve network performance in classification. This is the same as the output layer of an MLP [37]. A neural network regularization method called dropout aids in reducing interdependent neuron learning. The term "dropout" in a neural network describes units that fall out (both transparent and hidden). Dropout, to put it simply, is the act of forgetting units, or neurons, that are chosen at random from any set of neurons at the learning stage.

$y=r \times v\left(\omega^K s\right)$        (5)

$s=\left[s_1, s_2 \ldots s_n\right]^K$       (6)

where, $s$ indicates the input of fully connected layer, $\omega$ is the weight matrix, $r$ is the size of matrix, and $y$ is the resultant output. The Softmax process gets an integer vector as input, normalizes it, and then creates a probability distribution with values that are proportionate to the exponential functions of the input integer. The values of units in a softmax category use a non-local linearity distribution, and is mathematically represented in below:

$\mathcal{P}(x=z \mid y)=\frac{e^{y_k}}{\sum_j e^{y_j}}$          (7)

where, y and z are the probability values obtained from the softmax layer.

3.2 ResNet architecture

The structure of Residual Networks, or ResNet, consists of fifty levels. Compared to VGG-16, ResNet50 has an extra identification map, and the ResNet model predicts delta for the final prediction from a particular layer to the next. ResNet50 offers a different route to deal with the vanishing gradient problem and permits gradient flow in Figure 2 [38]. The very first layer of this architecture is input layer, which is used to read the image from the given set. Customized linear processes make up the convolution process. In this case, convolution is used rather than matrix multiplication. Generating feature maps can be the concise definition for this layer's function. The discrete time convolution procedure is carried out using the following equation:

$x(k)=(z \times \omega)(k)=\sum_{m=-\infty}^{\infty} p(m) \omega(k-m)$      (8)

where, $\omega$ represents the kernel filter, $p$ denotes the input data, $k$ indicates the time, and $x$ is the result. If the image is in the two dimensional form, the expression can be represented as follows:

$X(i, j)=(Q \times T)(i, j)=\sum_a \sum_b Q(i, j) T(i-a, j-b)$         (9)

where, $i$, $j$ indicates the positions of matrix, which is used to obtained the result of convolution. Typically, it is positioned with the filter's center at the origin.

$X(i, j)=(Q \times T)(i, j)=\sum_a \sum_b(i+a, j+b) T(a, b)$           (10)

Typically, the activation functions are used to convert the value found in deep learning operations to a non-linear form. Multi-layer artificial neural networks use activation functions for non-linear transformation processes [39]. There are usually numerous methods to activate something. The most widely used are Relu, Sigmoid, and Tanh. The method that was created makes use of Relu.

$\textit{Sigmoid:}\; \mathscr{f}(p) = \frac{1}{1 + e^{-p}}, \; \mathscr{f}'(p) = \mathscr{f}(p)(1 - \mathscr{f}(p))$      (11)

$\begin{gathered}\text { Tanh: } \mathscr{f}(p)=\tanh (p)=\frac{2}{1+e^{-2 p}}-1, \mathscr{f}^{\prime}(p) =1-\mathscr{f}(p)^2\end{gathered}$     (12)

ReLu $=\mathscr{f}(p)=\left\{\begin{array}{ll}0 & p<0 \\ p & p \geq 0\end{array}, \mathscr{f}^{\prime}(p)= \begin{cases}0 & p<0 \\ 1 & p \geq 0\end{cases}\right.$       (13)

2.png

Figure 2. Architecture of VGG 16 

The final result of convolutional or fully connected layers has been normalized by batch normalization. This procedure restores the layer output and typically occurs prior the activation function. The network is trained more quickly as a result of this approach. Furthermore, the batch normalization approach lessens the covariance shift, and the function is represented as shown in the following equation:

$Z_i=\frac{P_i-\delta_\alpha}{\sqrt{\varphi_\alpha^2+\varepsilon}}$   (14)

$\varphi_\alpha=\frac{1}{A} \sum_{i=1}^A\left(P_i-\delta_\alpha\right)^2$     (15)

$\delta_\alpha=\frac{1}{A} \sum_{i=1}^A\left(P_i\right)$       (16)

where, $A$ indicates the count of input, $P_i: i=1,2, \ldots A, \delta_\alpha$ denotes the average stack value, $\varphi_\alpha$ represents the standard deviation, and $Z_i$ is the obtained value of batch normalization process. A model's capacity to extrapolate can be lost if it learns to memorize training material. By randomly removing nodes and connections throughout the network's training process, the dropout layer inhibits overlearning. Weights are kept from over matching the data by utilizing this method. The only purpose of the dropout layer in training is to avoid overlearning, and is typically used for testing and validation [40]. The fully interconnected layer's neurons rely on every part of the layer before them. In this stage, the data that came before is transformed into a one-dimensional matrix. Depending on the model, various number of fully connected layers may be employed, and the operation is mathematically represented as shown in below:

$c_i^{\ell}=\sum_j \mathfrak{w}_{i j}^{\ell-1} y_j^{\ell-1}$     (17)

$y_i^{\ell-1}=\mathscr{f}\left(c_i^{\ell}\right)+\mathscr{b}^{(\ell)}$    (18)

where, $\ell$ indicates the layer number, $i, j$ are the neuron number, $y_j^{\ell}$ denotes output layer value, $\mathfrak{w}_{i j}^{\ell}$ represents the value of the hidden layer, $c_i^{\ell}$ represents the value of output layer before activation function, and $\mathscr{b}^{(\ell)}$ is the value of deviation. Typically, the convolutional layer is employed before the pooling layer. Reducing the insights in the convolutional layer's output is the pooling layer's task as shown in Figure 3. Condensed feature maps have been generated by the pooling layer integrating each feature map's information obtained from the convolutional layer. The most popular techniques are max-pooling and average-pooling. There is no process of learning going on in this layer.

This layer selects N×N size filters, and the following equation determines the size of the image that emerges from the pooling layer:

$X=\mathfrak{w} 2 \times \mathfrak{h} 2 \times \mathfrak{d} 2$      (19)

$\mathfrak{w} 2=\frac{(\mathfrak{w} 1-\mathscr{f})}{\mathfrak{X}+1}$   (20)

$\mathfrak{y} 2=\frac{(\mathfrak{h} 1-\mathscr{f})}{\mathfrak{X}+1}$     (21)

$\mathfrak{d} 2=\mathfrak{d} 1$    (22)

where, $\mathfrak{w} 2, \mathfrak{h} 2$, and $\mathfrak{d}2$ are the width, height and depth of input, $\mathscr{f}$ represents the size of filter, $\mathfrak{X}$ denotes the number of steps used, and $X$ indicates the size of original image. Here, the maximum pooling operation is performed for an improved classification. Prior to the Classification operation, the Softmax function is employed, which makes use of the network's probabilistic computation to produce a value for every class. Employing the following equation, this layer computes the probability for every class:

$\mathcal{T}(z=j \mid p ; \mathcal{W}, \mathscr{b})=\frac{\exp ^{P^K \mathcal{W}_j}}{\sum_{j=1}^b \exp ^{P^K \mathcal{W}_j}}$      (23)

where, $\mathcal{W}$ and $\mathscr{b}$ are the weight vector. Lastly, the final layer is the classification layer, which is employed following the Softmax layer. The total number of classes produced is the outcoome of this layer.

3.png

Figure 3. Architecture of ResNet 50

3.3 Hybrid VGG16+ResNet 50

The hybrid VGG16+ResNet 50 model is developed in the proposed research to make efficient disease prediction and classification. The layered architecture model of the suggested proposed approach is presented in Figure 4. The VGG16 +ResNet50 architecutre is employed for obtaining the features from the input images. Deep CNN is built using the CNN algorithm by combining a convolutional layer with additional layers such fully connected layers, pooling, and non-linear [41]. CNN trains members through the method of backpropagation and convolutional filters to train them. Within the application, one filter does edge extraction and another handles classification. CNN filters are not very customizable, and learning determines what values have been selected. For obtaining features, the intricate designs of the VGG16 and ResNet50 models have been picked. Convolutional layers, activation functions, and fully-connected layers are the core elements of the CNN architecture paradigm. Training multilayer networks is made simple with ResNet50, as it does not raise the training error %. Furthermore, compared to ResNet50, AlexNet lacks depth, which tends technical loss. The subspace value is perfect when the ResNet50 is considered, where there is a possibility that the feature sub-space will overlap. When those features are used in the training and testing stage, the error value varies according to the change in error. The technique of detecting leaf diseases is enhanced with high accuracy and performance yields by employing the hybrid model.

4.png

Figure 4. Hybrid VGG 16+ResNet 50 classifier architecture model

3.3.1 Hybrid architecture overview

The suggested model is a mixture of two state-of-the-art Convolutional Neural Networks (CNNs) namely VGG16 and ResNet50 in order to improve feature extraction. We use the VGG16 model to provide high-resolutions features for the images as well as the ResNet50 model due to its residual learning ability which enables it to train deeper models as it solves the vanishing gradient problem.

Detailed Integration Process:

Feature Extraction: Initially, input is fed to the VGG16 model to obtain high level parameters (features) from the image. In the meantime, the same image is forwarded into ResNet50 for the extraction of the more profound, and abstract level features.

Feature Fusion: The output feature maps from both the VGG16 and ResNet50 are then combined in order to develop a more inclusive presentation of the image. This combination makes the model to borrow the best from both the worlds; the VGG16 for its ability in feature extraction and the ResNet50 for deep learning.

Global Average Pooling: Finally, a GAP layer is added to decrease the spatial dimensionality of the feature map, which helps in reducing the computational complexity while maintaining all the necessary information.

Classification: The image features are then combined and fed through fully connected layers and end with a SoftMax layer to produce the probabilities of the image falling under which category of disease.

3.3.2 Specific benefits of the integration

Improved Accuracy: VGG16 and ResNet50 are used in this work to enhance the accuracy of the model due to its capability to identify various features, both minute and general to enhance the distinction between various disease patterns.

Balanced Complexity: The hybrid model therefore has the advantage of complexity and performance and can therefore be implemented in scenarios where there are resources constraints while at the same achieving high classification accuracy.

Robustness Across Datasets: The adopted approach helps improve the model’s flexibility since it is capable of performing well across different datasets as seen from the results.

Algorithm 1. Hybrid VGG 16+ResNet 50 Classification Model

Input:    Given plant image;

Output:    Classified result;

Step 1:    Perform convolutional layer operation;

    For each layer in VGG 16

    Obtain all the features for training F_1;

    End for;    

    For each layer in ResNet 50

    Obtain all the features for training F_2;

    End for;

Step 2:    Integrate the outputs of both models VGG 16+ResNet 50 as represented in below:

Fea_L = Concatenation F₁+F₂;

Step 3:    Initialize G = Global Avg Pool (Fea_L);

G=Dense (1024, $\mathcal{R}$);

P=Dense ($N_C, \delta$);

where, N_C -Number of classes, P represents the prediction result, $\mathcal{R}$ denotes the ReLU function and $\delta$ indicates the softmax function;

Step 4:    Determine the final model $\mathbb{T}$ as shown in below:

$\mathbb{T}=$ Model $\left(F_1, F_2\right)+P$;

Step 5:    Estimate the loss function with Adam optimizer;

Step 6:    Return the final output result;