Artificial neural networks were inspired by the seemingly inconceivable learning capability of the human brain. The human brain consists of billions of neurons interconnected by synapses, and their relationship changes as learning proceeds. Therefore, similar to a human brain, artificial neural networks can learn any task in principle. To improve learning capabilities, in 1998, LeCun et al. proposed the CNN architecture focusing on recognition, which is especially useful in image identification [23] .

CNNs use image input directly and use the image pixels to automatically obtain features by convolving the pixels with filters. Multiple layers of convolutions can be calculated, which are followed by several fully connected layers. A set of weights and biases can be obtained through learning, and after the model has been trained, it can perform classification. In general, a CNN used in supervised learning contains an input layer, convolutional layer, pooling layer, flattening layer, and softmax layer, as illustrated in Figure 1 . CNNs are applied in many areas such as handwriting recognition, traffic flow, automatic driving, face identification, and plant disease diagnosis.

In this study, we designed the architecture of our DCNN based on our goal. The model consists of three dense layers, one max-pooling layer, two dropout layers, and one flattening layer. Furthermore, the dense layers contain two convolutional layers and one softmax output layer. The architecture of our DCNN is specified in Table 1 . The total number of parameters is 420,738, but if we use an image 256 × 256 pixels, the total number of parameters is 30,938,690.

The convolutional layer computes the output of each tensor. Each computation is a dot product between the weights and a small region input covered by a kernel window of 5 × 5 pixels. Moreover, each computation extracts a feature map from the input image. When the window finishes sliding over the image, a map of the main features is obtained, and the tensor output dimensionality is reduced. We design the pooling layer to subsample the features. The pooling kernel size is (4 × 4), which also reduces the dimensionality of the tensor output and can decrease the probability of overfitting. We introduce two dropout layers to avoid overfitting and improve the training speed. The final CNN model is the result of many experimental trials.

We used Python 3 as our design environment platform and the Keras deep learning application programming interface. Therefore, we must convert the raw images into the data type required by the dataset. Hence, we must first preprocess the data and then design the recognition architecture, as shown in Figure 2 . This architecture contains two main parts, data preprocessing and the DCNN model, in which we embed the identification algorithm. Data preprocessing includes reducing the number of pixels, creating the label set, and reshaping and creating the training and test sets.

Artificial neural networks can learn by adjusting the weights and bias to minimize the error between the true and predicted labels. In general, there are two common methods for describing errors, either as a loss function or as a cross-entropy function. Moreover, there are several methods (called optimizers) for finding the best weights, including stochastic gradient descent (SGD), RMSprop, and Adam. Finally, using an index to evaluate our model performance, we design an accuracy function.

1) Loss function

The loss function is an important part of machine learning. Treating it as the standard of model learning, we use the loss function to measure the classification performance. It measures the error between the actual and predicted labels of an object. Many statistical measures can be used as a loss function, such as the mean squared error, mean absolute error, mean absolute percentage error, and mean squared logarithmic error. Cross-entropy, used in binary classification, allows to measure two probability distributions. Hence, we use the cross-entropy loss to increase the predicted probability as follows:

$E\left(w\right)=-\frac{1}{N}{\displaystyle \underset{n=1}{\overset{N}{\sum }}\left[y_n\log {\bar{y}}_n+\left(1-y_n\right)\log \left(1-{\bar{y}}_n\right)\right]}$ (1)

where $\bar{y}=\text{ReLU}\left(w\cdot x+b\right)$, w is the weight vector of each x, b is the vector of the bias, $y_n$ is the actual label, and ${\bar{y}}_n$ denotes the predicted value.

2) SGD

SGD is a fundamental optimization method that stochastically approximates gradient descent through iterative parameter updates, capable of achieving strong performance in specific tasks despite its simplicity. The DCNN uses SGD to change w to minimize the following objective function:

$w_i=w_{i-1}-\eta \frac{\partial E\left(w\right)}{\partial w}$ (2)

where $\eta$ is the learning ratio, which is an important parameter. A smaller $\eta$ easily improves the performance but increases the computation burden. If $\eta$ is large, the performance fluctuates. Hence, the best value per case must be determine experimentally. In addition, $w_i$ is the current weight, and $w_{i-1}$ is the previous weight, which is the weight updated using the SGD algorithm and the one that minimizes $E\left(w\right)$.

3) Softmax

In the DCNN, the output of the last layer is the classification result, and hence in this layer, dense output numbers are based on the number of classes. We determine them according to the softmax function, which takes the maximum value as the classification result as follows:

$\text{soft}\max \left(y=c_i\right)=\frac{e^{x\cdot w+b_i}}{{\displaystyle \sum {}_{j=1}^N{e}^{x\cdot w+b_j}}}$ (3)

where N is the number of classes, y is the learning output, $c_i$ is the $i^{th}$ class, w is the set of weights, and $b_i$ is the $i^{th}$ bias.

To evaluate our model, we tested the performance using the following accuracy calculation:

$\text{Score}\left(c_i\right)=\frac{P_T}{P_T+P_R}$ (4)

where $\text{Score}\left(c_i\right)$ denotes the accuracy of the $i^{th}$ class, and $P_T$ and $P_R$ are the numbers of correctly classified and misclassified images, respectively.

We used the Python 3 platform, and the model was implemented using Keras, with TensorFlow being the backend. Our raw cherry leaf dataset contains 1906 leaf images, which includes 854 healthy leaf images and 1052 diseased leaf images. Each image is 256 × 256 pixels. We show four 256 × 256-pixel images from the healthy and diseased leaf datasets in Figure 3 .

Preprocessing raw data is necessary and involves many tasks, as shown in Figure 2 . Before feeding an image into a model, we must substantially reduce its pixel size such that it drastically decreases the computation cost. In addition, we must create the image label set. Next, we convert its type into float32 and reshape the images into size (−1, x, y, 1). Therefore, we must convert each image of the training and test sets into x × y × 1, where x and y are the image width and height, respectively. Here, we convert images into 64 × 64-pixel images. The number of pixels in each image reduces from 65,535 to 4,096, a decrease be a factor of 16. Example 64 × 64-pixels images including their features are shown in Figure 4 . Then, we create the label set of the dataset for supervised learning. First, we reshape the image size to (−1, 64, 64, 1) and divide the dataset into training and test sets in an 80% - 20% split, where all the sample images are randomly selected. Moreover, no cross-samples exist between the training and test sets. Therefore, the dimensions of the training and test sets are (1, 524, 64, 64, 1) and (382, 64, 64, 1), respectively.

Comparing the raw images in Figure 3 and Figure 4 , although the number of pixels is reduced, Figure 4(a) and Figure 4(c) remain clear after conversion to float32 and reshaping into size (−1, 64, 64, 1).

In deep learning, hyperparameters play a key role, and the model performance substantially differs under diverse hyperparameters for the same model, causing problems ranging from overfitting to nonconvergence. In our experiments, we used the hyperparameters listed in Table 2 .

The results from our experiments are shown in Figure 5 as loss and accuracy curves for both training and testing. The visual output from the intermediate layers 1 - 5 are shown in Figures 6-9 .

Figure 5(a) shows the change in accuracy. During both training (blue curve) and testing (red curve), the accuracy continues to increase, except for a fluctuation at epoch 3 on the red curve. Figure 5(b) shows the change in cross-entropy, which indicates that over the whole course of both training (blue curve) and testing (red curve), the curve decreases stably, except for a fluctuation at epoch 7 on the red curve. Table 3 lists the classification results, indicating an accuracy of 99.2%, precision of both classes of 99%, and recall of class 1 (diseased) of 100%, indicating that all samples of class 1 diseased leaves are recognized correctly. Therefore, the training and testing results show that the model performs well.

Figures 6-9 show output images from the intermediate layers. Figure 6 and Figure 7 show the outputs of healthy leaves for each layer from channels 1 and 4, respectively. Figure 8 and Figure 9 show the output for each layer of channels 1 and 4 for diseased leaves, respectively. Figure 6 shows that the extracted features are different between layers. The dense 1 and pooling layers extract many large-scale features. By contrast, the dense 2 layer extracts more detailed characteristics. These images also help understanding the dropout method, which not only prevents overfitting but also retains feature information by comparing the outputs of the dense 2 and dropout layers.

Comparing the outputs of channels 1 and 4, we can easily determine that channel 1 suitably represents the edge information of an object, and channel 4 includes a large amount of feature information contained in the edge and inner regions. Hence, in deep learning, the channels of the tensor have different roles in feature detection.

Further comparison between Figure 6 and Figure 7 and Figure 8 and Figure 9 reveals that the characteristics of healthy leaves are mainly on the edge. However, the dominant information of diseased leaves is in the inner region of the object. Figure 8 clearly shows that the pooling layer can extract crucial features from the object. In addition, Figure 8 also shows that the DCNN model is efficient for our recognition goal. Thus, it is important to design the model architecture using several methods, which is a key advantage of DCNNs.

Table 4 lists the performance of our model, which includes accuracy, test loss, number of epochs, and training time per epoch. The accuracy is high, and training consumes only 72 s/epoch over 10 epochs. Regarding the other methods, Bhange et al. reported an accuracy of 82% using SVM classification, and Mousavi et al. proposed a classification method based on Gabor wavelet features and SVM, achieving an accuracy of 90.4%. Yang et al. [14] proposed an approach to identify rice disease using deep learning and achieved an accuracy of 95.48%. Ferentinos [23] used a deep learning model in 2018 to achieve 99.53% accuracy after training for 10,000 epochs over 5.5 days and testing over 67 epochs at 7,034 s each using a VGG. Obviously, our model provides a high performance and balance between accuracy and speed.