Deep interpretable architecture for plant diseases classification

TL;DR

This paper introduces a novel deep learning architecture with built-in visualization for plant disease classification, enhancing interpretability while maintaining high accuracy on a large dataset.

Contribution

A new CNN-based architecture with Teacher-Student multitask learning for transparent plant disease classification and improved visualization quality.

Findings

Sharper visualization of important image regions.

Effective classification on PlantVillage dataset.

Enhanced interpretability of deep models.

Abstract

Recently, many works have been inspired by the success of deep learning in computer vision for plant diseases classification. Unfortunately, these end-to-end deep classifiers lack transparency which can limit their adoption in practice. In this paper, we propose a new trainable visualization method for plant diseases classification based on a Convolutional Neural Network (CNN) architecture composed of two deep classifiers. The first one is named Teacher and the second one Student. This architecture leverages the multitask learning to train the Teacher and the Student jointly. Then, the communicated representation between the Teacher and the Student is used as a proxy to visualize the most important image regions for classification. This new architecture produces sharper visualization than the existing methods in plant diseases context. All experiments are achieved on PlantVillage dataset that contains 54306 plant images.

Figures

Tables

Table 1. Table 1: Deconvolution blocks details.

Layer	Input tensor	Output tensor
Upsampling2d	$(X,Y,Z)$	$(2X,2Y,Z)$
Conv2D	$(2X,2Y,Z)$	$(2X,2Y,Z1)$
Concatenate	$(2X,2Y,Z1)+(2X,2Y,Z1)$	$(2X,2Y,2Z1)$
Conv2D	$(2X,2Y,2Z1)$	$(2X,2Y,Z1)$
Conv2D	$(2X,2Y,Z1)$	$(2X,2Y,Z1)$

Table 2. Table 2: Over the Perturbation Curve ( A ​ O ​ P ​ C 𝐴 𝑂 𝑃 𝐶 AOPC ).

Proposed method	0,907
Grad-CAM	0,587
Gradient	0,372
Deep Taylor	0,294
LRP-Z	0,558
LRP-Epsilon	0,550

Equations

$$Loss=\alpha \ast LossTeacher+(1-\alpha )\ast LossStudent$$

$$LossTeacher=-\frac{1}{N}\sum _{i=1}^N\sum _{j=1}^C{Y}_j^{i}log(Y{T}_j^i)$$

$$LossStudent=-\frac{1}{N}\sum _{i=1}^N\sum _{j=1}^C{Y}_j^{i}log(Y{S}_j^i)$$

$$Heatmap(i,j)=\sqrt{V(i,j,0{)}^2+V(i,j,1{)}^2+V(i,j,2{)}^2}$$

$$Heatmap(i,j)=\frac{Heatmap(i,j)-Min}{Max-Min}$$

$$AOPC=\frac{1}{11}\sum _{i=1}^N\sum _{j=1}^{11}\left(f(X_i)-f(X_i^{(j)})\right)$$

Full text

K****eywords Plant diseases classification  $\cdot$ Deep visualization algorithms  $\cdot$ Convolutional Neural Networks (CNNs)

1 Introduction

Plant diseases cause great damages to agriculture crops by significantly decreasing production [1]. Protecting plants from diseases is vital to guarantee the quality and the quantity of crops [2]. A successful protection strategy starts with an early detection of the disease and the right treatment to prevent its spreading. Many studies proposed the use of Convolutional Neural Network (CNN) to detect and classify diseases. This new trend produced more accurate classifiers compared to shallow machine learning approaches based on hand crafted features [3, 4, 2, 5]. Despite all these successes, CNN still suffers from the lack of transparency that limits its spreading in many domains. These CNNs are complex deep models that yield good results at the expense of explainability and interpretability. High accuracy is not sufficient for plant diseases classification. Users also need to be informed how the detection is achieved and which symptoms are present in the plant.

In this paper, we propose a classification and visualization architecture based on multitask learning of two classifiers: Teacher and Student. This architecture represents a trainable visualization method for plant diseases classification. The main contribution is the design of an interpretable deep architecture able to do classification and visualization simultaneously. The visualization algorithm is embedded directly in the network design instead of using it after the training as post treatment.

2 Related works

Visualization algorithms are used to explain CNN decision using a heatmap. This heatmap highlights the importance of each pixel for the classifier’s decision. These methods backpropagate to the input image the discriminant features used by the network for classification. Most of these methods use heuristics during the backpropagation. For example, gradients based methods like deconvolution [6] and guided backpropagation [7] filter some signals during the backpropagation according to heuristic rules. These filtered signals are ignored to produce sharp visualizations. Furthermore, Layer Wise Relevance Propagation (LRP) methods [8, 9] are based on choosing the layer’s roots to determine propagation rules for each layer in the network. The global visualization method GRAD-CAM [10] projects the features from the penultimate convolution layer based on a linear interpolation which degrades the precision of the produced heatmaps. These visualization algorithms can produce different heatmaps according to the chosen heuristics and propagation rules, which makes the understanding of the classifier difficult. In the present paper, we combine two classifiers to extract discriminant features from images. These discriminant features are extracted by the first classifier and projected as an input for the second classifier. This trainable visualization is similar to segmentation architectures like U-Net [11] where the supervision masks are replaced with a second classifier.

3 Proposed method

We propose a classification and visualization generic architecture, named Teacher/Student architecture, based on learning transfer from a first classifier (Teacher) to a second one (Student). This learning transfer from the Teacher to the Student is achieved using an autoencoder having the Teacher as an encoder. The decoder consumes the Teacher latent representations to reconstruct an image with the same dimension of the input image. This image is used as an input of the Student. The whole network (Teacher + Decoder + Student) is trained to minimize jointly the losses of the two classifiers (Teacher and Student). More formally, the network has two outputs $YT$ (Teacher output) and $YS$ (Student output). During the training, the loss function (1) is minimised. The hyperparameter $\alpha$ represents the tradeoff between the Teacher loss (2) and the Student loss (3).

[TABLE]

[TABLE]

[TABLE]

The Teacher/Student network is designed to reconstruct an image containing the discriminant features formed by the Teacher to help the Student training. As a side effect of this design, the reconstructed image can be used as a visualization of the important regions for the classification. This architecture represents an autoencoder to denoise the image from irrelevant features from the classification viewpoint. The difference between the usual denoising autoencoder and this architecture lies in the loss function design. The denoising autoencoder minimizes a reconstruction loss while this architecture minimizes the classification loss of two classifiers. This proposed architecture is also designed to extract the important regions for classification without using masks. For this reason, any segmentation architecture can be modified to fit the proposed architecture by modifying the loss function to include a Student classifier and avoid the segmentation masks.

Fig. 1 details the Teacher/Student architecture. For the sake of simplicity, VGG16 [12] architecture is used as Teacher and Student. Nevertheless, the Teacher/Student architecture is flexible and other classification architectures can be used as Teacher or Student. To use another architecture, the decoder must be adapted to inverse the Teacher’s layers to reconstruct the input of the Student.

The Teacher/Student architecture is composed of the following components:

3.1 Teacher/Student architecture

The Teacher and the Student architectures are identical to standard architecture VGG16 [12]. Skip connections (blue arrows) are used from the Teacher to the decoder. This skip connections concatenate the input tensors of pooling layer of each convolution block with deconvolution block tensors.

3.2 Reversed fully connected layers

Convolutional autoencoders reverse only convolution layers to do reconstruction task. Here, the decoder requires discriminant features from fully connected layers. Therefore, two fully connected layers are used to reverse the Teacher’s fully connected layers. Furthermore, a skip connection (red arrow) is used to reinforce the decoder by adding the vector of the Teacher’s first fully connected layer.

3.3 Deconvolution blocks

Deconvolution blocks reverse the flow of tensors to form the reconstructed image. The details of this block are shown in Tab. 1. This block consumes an input tensor of dimension $(x,y,z)$ and produce a tensor of dimension $(2x,2y,z_{1})$. In each deconvolution block, tensor is upsampled, concatenated with the corresponding tensor of skip connection and the depth of resulted tensor after concatenation is reduced. The first two deconvolution block (DECONV Block1, DECONV Block2) double the input tensor spatially without changing its depth $(z_{1}=z)$. However, the other deconvolution blocks double the tensor spatially and reduce its depth $(z_{1}=z/2)$.

3.4 Reconstructed image refinement

After many stages of deconvolution, the spatial dimension of the produced tensor will be equal to input image spatial dimension. However, the depth of the tensor must be reduced to match the depth of the input image. To do this, two convolution layers are applied. The first one (red in Fig. 1) reduces the depth to two channels which applies pressure on the data flow by throwing unnecessary details. The second convolution layer (green in Fig. 1) expands the tensor to three channels to use it as the Student’s input. The last decoder’s convolution layer uses sigmoid activation function to scale the values in the interval $[0,1]$. This final tensor is used as Student’s input and can be used also as proxy to understand the communication between the Teacher and the Student.

4 Experimental results

Experimental results are conducted using the segmented version of PlantVillage dataset with black backgrounds [13]. This dataset includes 54306 images of 14 crop species with 38 classes of diseases and healthy plants. The data set is split into a training set that contains 32572 images and a validation set that contains 21734 images. The code source of the proposed architecture is available at https://github.com/Tahedi1/Teacher_Student_Architecture.

4.1 Classification results

In this section, we present the results of training and validation of the proposed architecture. The training is based on gradient descent algorithm with the following hyperparameters: (learning rate $=1e-4$, momentum $=0.9$, batch size= 16, number of iterations $=15$, multitask hyperparamater $\alpha=0.4$). Training and validation are executed on a workstation containing Graphical Processing Unit GPU Nvidia GTX 1080.

At the beginning of training, the Teacher is more accurate than the student. This may be explained by the dependency of the Student on the representation constructed by the Teacher. However, the loss and the accuracy of the Teacher and the Student converge at the end of the training because the communicated representation becomes stable. Furthermore, the Student’s loss is more stable than the Teacher’s loss in validation which reinforce the hypothesis of the transfer learning from the Teacher to the Student. This transfer learning is achieved through the quality of the reconstructed image. This reconstructed image focuses on discriminant regions and filters non-discriminant regions. To assess this information filtering mechanism, we analyze the architecture as a visualization method in the following sections.

4.2 Visualization results

The visualizations depicted on Fig. 3 represent the reconstructed three channels images used as an input for the Student. In Fig. 4, important regions are segmented using a simple binary thresholding algorithm (threshold = 0.9). The thresholding algorithm is applied after a simple aggregation across channels of reconstructed image (noted $V$) to produce one channel heatmap. To produce this heatmap from the reconstructed image $V$, the formula (4) is applied. This formula measures the distance between pixel’s color and black $(0,0,0)$.

[TABLE]

The produced heatmaps (Fig. 4) show clearly the symptoms of the plant disease. Furthermore, these heatmaps are sharp and precise. The healthy regions of the leaves are filtered and only the important regions are highlighted. In the next section, the proposed method is compared quantitatively to other methods using perturbation curves to show its effectiveness.

4.3 Comparison with visualization algorithms

In this section, the proposed method is compared to the following visualization algorithms : visualization based on gradient [14], Grad-CAM [10] and Layer-wise Relevance Propagation (LRP) methods (Deep Taylor [9], LRP-Epsilon [8], LRP-Z [8]).

4.3.1 Heatmaps comparison

Fig. 5 shows the difference between the heatmaps of the visualization algorithms. The proposed algorithm’s heatmaps are sharper than the other heatmaps. Indeed, gradient, LRP-Z and LRP-Epsilon heatmaps are noisy and difficult to explain. The gradient heatmaps are noisy because the gradients measure the pixel’s sensitivities instead of their contributions. Beside, the presence of negative and positive contributions in LRP heatmaps makes them difficult to understand. On the other hand, Deep Taylor algorithm has good and clear heatmaps compared to other algorithms. The heatmaps of Deep Taylor algorithm highlight almost the same highlighted regions by our algorithm, but with some activated regions on the background. In the proposed algorithm, the background is completely deactivated which gives clean heatmaps.

Fig. 6 shows the difference between the proposed method and Grad-CAM. The Grad-cam algorithm localizes globally the important regions. Furthermore, the Grad-CAM visualizations miss some important regions highlighted by the proposed method. This inaccurate localization is due to the resizing used by Grad-CAM to propagate the contributions from the last convolution layer to the input image. In the Teacher/Student architecture, this propagation is ensured by a trainable decoder which makes the visualizations more precise.

4.3.2 Histograms of heatmaps values

all the produced heatmaps are normalized in the interval $[0,1]$ to analyze the distribution of values in each method. This normalization based on equation (5) where $Min$ and $Max$ are the minimum and the maximum of $Heatmap$ respectively.

[TABLE]

Histograms of methods are shown in Fig. 7. We notice that the heatmaps values distribution of the proposed method is different from the other methods. Grad-CAM, gradient and Deep Taylor distributions are concentrated in very small values while the density decreases gradually as values increase. LRP-Epsilon and LRP-Z have gaussian-like distribution centered on 0.5. In contrast, the proposed method distribution has three clusters:

• •

Cluster1 ($C_{1})$: $72\%$ of deactivated pixels where the heatmap values are zeros ($Heatmap(pixel)=0$). This cluster represents the background and non-discriminant pixels.

• •

Cluster2 ($C_{2})$: $15\%$ of pixels having small heatmap’s values ($0.2<Heatmap(pixel)\leq 0.3$).

• •

Cluster3 ($C_{3})$: $13\%$ of pixels having high heatmap values ($0.9<Heatmap(pixel)\leq 1$) and can be considered as important pixels for the classifier.

4.3.3 Perturbation curves

To measure the quality of visualization method quantitatively, the produced heatmap is considered as a ranking function of pixels. Good heatmap ranks the pixels correctly according to their importance for the classification. Therefore, if we start erasing the pixels having high values in the heatmap then the classifier output decreases rapidly. To evaluate this ranking, the heatmap values are discretized into intervals of size $\frac{1}{10}$. Afterwards, pixels are erased iteratively according to their heatmaps values in descending order. This erasing procedure is formulated in Algorithm.1To erase one pixel, a small black square with a size of three pixels centered on the pixel of interest is used. All dataset images have a black background which motivates the use of black color as reference to erase with. The function $f(X^{j})$ gives the classifier estimation of the probability that $X^{j}$ has the same class of initial image $X^{0}=X$. The perturbation curve is traced using points $(j,f(X^{(j)}))$ to track the evolution of the classifier output during the erasing. To produce this perturbation curve that characterizes a visualization method, the perturbation curves of validation images are averaged.

[TABLE]

Fig. 8 shows the perturbation curves of tested methods. The proposed method’s curve decreases rapidly after erasing the pixels of the cluster $C_{3}$. Afterwards, before erasing pixels of the cluster $C_{2}$ the curve is stationary. Erasing pixels of the cluster $C_{2}$ decreases slightly $f$. Cluster $C_{1}$ does not contribute to the decreasing of the classifier output because this cluster contains background and non-discriminant pixels.

Fig. 8 shows that the perturbation curves of the other methods decrease gradually because of the distribution of values in their heatmaps. On the other hand, the perturbation curve of the proposed method decreases steeply because the pixels of $C_{3}$ contains the most important pixels in respect to the classifier.

Tab. 2 shows Area Over the Perturbation Curve ($AOPC$) for each method. This quantity measures the decreases of the curve compared to its first value formulated in (6) and Algorithm.1.

The proposed method has better $AOPC=0.907$ than other methods $AOPC<0.6$ because of the concentration of important pixels in $C_{3}$. In the proposed method, erasing only $13\%$ of image can decrease of $f$ to $0.1$.

5 Conclusion and further research

In this work, we have proposed an interpretable Student/Teacher architecture for plant diseases classification. This architecture leverages the multitask to produce a trainable visualization method. Our experiments demonstrate the benefit of adding the Student classifier to guide the architecture in order to reconstruct a sharp visualization images. This reconstructed images contain the discriminant regions, which helps to explain the classifier’s decision. In the future, our objective is to test the Student/Teacher architecture on other classification problems. Besides, we will work to optimize the computation cost of this architecture.