DefectNET: multi-class fault detection on highly-imbalanced datasets

TL;DR

DefectNET is a novel neural network architecture designed for multi-class fault detection in highly-imbalanced datasets, effectively detecting small and large defects with improved accuracy over existing methods.

Contribution

The paper introduces DefectNet, combining parallel fully convolutional and dilated convolutional paths with a hybrid loss and leaky ReLU to enhance fault detection in imbalanced datasets.

Findings

Outperforms state-of-the-art networks by ~10% accuracy on wind turbine data.

Effectively detects small and large defects in highly-imbalanced datasets.

Uses hybrid loss and leaky ReLU to improve training on rare defect classes.

Abstract

As a data-driven method, the performance of deep convolutional neural networks (CNN) relies heavily on training data. The prediction results of traditional networks give a bias toward larger classes, which tend to be the background in the semantic segmentation task. This becomes a major problem for fault detection, where the targets appear very small on the images and vary in both types and sizes. In this paper we propose a new network architecture, DefectNet, that offers multi-class (including but not limited to) defect detection on highly-imbalanced datasets. DefectNet consists of two parallel paths, which are a fully convolutional network and a dilated convolutional network to detect large and small objects respectively. We propose a hybrid loss maximising the usefulness of a dice loss and a cross entropy loss, and we also employ the leaky rectified linear unit (ReLU) to deal with rare occurrence of some targets in training batches. The prediction results show that our DefectNet outperforms state-of-the-art networks for detecting multi-class defects with the average accuracy improvement of approximately 10% on a wind turbine.

Figures

Tables

Table 1. Table 1 : Classification performances of CNN models on defect detection. The average accuracies are computed from 6 defects and previously repaired masks. The accuracies are shown in percentage and the processing time are shown in ms/patch.

Network	Class accuracy									Avg acc.	Time
	BG	Blade	Erosion	Repairs	Contamination	Peeling paint	Scratches	Surface voids	Chipped paint	of defects	(ms)
FCN ($L_{wce}$)	99.92	99.97	80.48	20.30	52.48	17.34	21.09	33.53	23.50	35.53	52.35
FCN dilated ($L_{wce}$)	99.90	99.87	97.29	59.54	55.29	52.51	82.57	69.62	33.93	64.39	58.48
UNET ($L_{gdice}$)	99.92	99.98	92.14	78.34	56.41	43.25	56.20	52.86	42.81	60.28	44.27
deepLabv3+ ($L_{wce}$)	99.95	99.95	95.10	88.45	76.85	51.04	74.15	73.52	53.44	73.22	60.42
DefectNet ($L_{ce}$)	99.97	99.92	74.18	14.30	32.36	14.15	9.79	25.16	33.04	29.00	-
DefectNet ($L_{wce}$)	99.82	99.85	96.39	66.84	84.55	65.56	80.86	70.71	48.09	73.29	-
DefectNet ($L_{gdice}$)	99.81	99.81	89.01	57.19	62.21	77.28	69.47	68.33	54.83	68.33	-
DefectNet ($L_{hybrid}$)	99.82	99.80	95.62	90.10	84.75	74.57	84.04	70.94	57.97	79.71	62.83

Equations

$$(F{\ast }_{l}k)(\text{p})=\sum _{\text{s}+l\text{t}=\text{p}}F(\text{s})k(\text{t})$$

$$L_{hybrid}=(1-\gamma )\max (1,L_{wce})+\gamma L_{gdice}$$

$$\gamma =\frac{1}{K}\sum _{c=1}^K\left((\sum _{m=1}^M{t}_{cm})>0\right)$$

$$L_{gdice}=1-\frac{2{\sum }_{c=1}^K{w}_c{\sum }_{m=1}^M(y_{cm}{t}_{cm})}{{\sum }_{c=1}^K{w}_c{\sum }_{m=1}^M(y_{cm}^2+t_{cm}^2)}$$

$$f(x)=\{\begin{array}{ll}x& \text{if x>0}\\ \alpha x& \text{otherwise}\end{array}$$

Full text

**Index Terms— ** convolutional neural network, segmentation, detection, classification

1 Introduction

Vision-based inspection for anomalous objects or faults has become an attractive tool as it offers cost effectiveness, potentially real-time operation and automation that deals with continuously generated data. In general, detection of such anomalies involves two tasks, namely segmentation and classification. Machine learning techniques, particularly recent popular deep learning methods, have been proposed to achieve both processes simultaneously, referred to as semantic segmentation [1]. However, their performance of detecting multiple faults on very large background is still limited due to the variations of fault types, their sizes and uncontrolled lighting for outdoor image acquisition. Moreover, the frequency of occurrence of each fault type varies, leading to highly imbalanced datasets. This causes classifier algorithms to bias classes which have a greater number of instances and preferentially predict majority class data. In this paper, we use the important application of detecting defects on wind turbines (Fig. 1) as a vehicle for addressing this problem.

Numerous approaches have been proposed to create balanced distributions of data using data manipulation [2]. These include downsampling majority classes, oversampling minority classes, or both. However, for semantic segmentation, augmenting the number of samples in the smaller classes always includes more of the surrounding areas, resulting in more samples of the larger class too – augmenting the small classes always add more background samples. Hence we employ the other techniques that deal with the imbalanced training data issue by modifying the network architecture and the validation loss.

For convolutional neural networks (CNNs), classical techniques balance classes using weights computed by analysing dataset statistics. A dice coefficient-based loss has been employed by Milletari et al. [3], giving better segmentation results than re-weighted soft-max with loss. Later, the generalised dice loss was proposed for multiple classes by Sudre et al. [4]. Although the dice loss has become popular for medical imaging tasks, the cross entropy loss has been reported to have better performance in some applications [5]. Recently the ideas of combined loss have been introduced [6, 7]. However none of these approaches have been tested in a challenging scenario, such as defect detection, where each training batch does not contain all class samples.

Another problem when detecting small objects using CNNs is the decrease of receptive field size as the network depth increases. CNNs used for classification employ a pooling layer after the convolutional layer to combine the outputs of neuron clusters from one layer into a single neuron in the next layer. This results in feature maps with reduced spatial resolution with the outcome that very small areas could be represented by only one pixel. Dilated convolutional layers have therefore been introduced to enlarge the field of view of the filters [8]. Generally the dilation rate of the filter size (inserting more zeros) increases with larger depth. However this can cause false positives for small classes [9]. We therefore diminish this problem here by combining feature maps from traditional convolutional layers with dilated convolutional layers.

In this paper, we propose a new network, DefectNet, for detecting various defect size on a highly imbalanced dataset. The proposed DefectNet, shown in Fig. 2, has two parallel paths, where one of them makes use of skip layers [1] to detect medium to large objects. The additional path employs the dilated convolutional layers to increase receptive field size for small object defect detection. The two paths are combined with sum fusion at the construction end. We also propose a hybrid loss function that combines the advantages of the cross entropy and dice losses. The cross entropy loss compensates for some absent classes in the training batches, whilst the dice loss improves the balance between the precision and recall. We employ LeakyReLU (Leaky rectified linear unit) to prevent zero gradients when some small classes are not included in several training batches consecutively.

Although the example application is defect detection on wind turbine images, our approach should be useful in general as various applications across a wide range of fields experience problems associated with highly imbalanced classes, e.g. segmentation on medical images [10], radio frequency interference mitigation [11], event classification of eye movement [12], hazard monitoring [13].

The remainder of this paper is organised as follows. The proposed DefectNet is described in Section 2. The performance of the method is evaluated in Section 3. Finally, Section 4 presents the conclusions of this work.

2 DefectNet

The architecture of DefectNet is illustrated in Fig. 2. It combines two paths able to detect different target sizes. The first path makes use of the VGG-19 architecture and skip layer fusion creating fully convolutional network. It is an enhanced version of the architecture of the FCN-8 network [1], introducing additional skip layers in pool1 and pool2 in order to include the low-level features for finer prediction. The second path employs the dilated convolution (further described in Section 2.1) to detect the small objects. All filters of the convolutional layers have a kernel size of 3$\times$3, but those of the second path have zero-inserts to create dilated convolution. All convolution processes operate with the stride of 1. The following subsections highlight the differences of the proposed deep learning network to the traditional ones.

2.1 Dilated convolution

Dilated convolution, also referred to as atrous convolution, enlarges the field of view of the filters to incorporate larger context by expanding the receptive field without loss of resolution. The dilated convolutions are defined in Eq.1 [14], where $F$ is a feature map, $k$ is a filter, $\ast_{l}$ is a convolution operator with a dilation factor $l$, meaning ($l-$1) zeros are inserted. We construct eight dilated convolution layers (coloured pink in Fig. 2) after the second group of convolutional layers of the other FCN path. The dilation factor $l$ is defined in Fig. 2. This structure is similar to the basic context network architecture proposed in [14], but we add more dilated convolution layers with decreasing $l$. This improves local low-level features, where spatial relationships amongst adjacent pixels may be ignored due to sparsity of the dilated filters when increasing $l$ [15].

[TABLE]

2.2 Hybrid loss

The most commonly used loss function for the task of image segmentation is a pixel-wise cross entropy loss. The class weighting technique is employed to balance the classes to improve training. Another popular loss is the dice loss. The dice coefficient performs better on class imbalanced problems because it maximises a metric that directly measures the region intersection over union. The gradients of the dice coefficients are however not as smooth as those of cross entropy, particularly when both predictions and labels are close to zero. For our dataset, the data in each batch do not contain all classes, leading to very noisy training error. The cross entropy loss, on the other hand, allows the absent classes to affect the backpropagation less than the dice loss. Therefore we propose the hybrid loss defined in Eq. 2, where the weighted cross entropy loss $L_{wce}$ and generalised dice loss $L_{gdice}$ are merged in the proportion of the number of class samples present in the training batch (Eq. 3).

[TABLE]

[TABLE]

The loss $L_{wce}$ is definded as $L_{wce}=-\sum^{K}_{c=1}w_{c}t_{c}log(y_{c})$, where $K$ is the number of classes and $y_{c}$ and $t_{c}$ represent the prediction and target, respectively. Generally the weights are computed from pixel counts, i.e. a weight of class $c$ is $w_{c}=1/f_{c}$, where $f_{c}$ is pixel counts of class $c$ [16]. However applications such as defect detection have highly-imbalanced classes. Their scores could approach zero and cause poor performance because significantly higher weight values are given to the smaller classes. We hence propose to use $w_{c}=1/\sqrt{f_{c}}$. Equation 4 shows the generalized dice loss proposed in [4], where $y_{cm}$ and $t_{cm}$ represent the prediction and groundtruth of the pixel $m$ from the total $M$ pixels. The weight in the generalized dice loss is generally calculated as the inverse of the squared sum of all pixels of class $c$, but this will give priority to the small and absent classes. Therefore in DefectNet, we adapt the dice loss with the same $w_{c}$ used in $L_{wce}$.

[TABLE]

2.3 Leaky rectified linear unit

Because an entire dataset cannot be fed into the neural network at once, it is divided into multiple batches with random data selection. This means some classes may not present in particular batches, causing some nodes within the layers to have an activation of zero. The backpropogation process does not update the weights for these nodes because their gradient is also zero. This is called the ‘dying ReLU’ problem. To prevent this, we employ the leaky ReLU activation function. It allows a small gradient when the unit is not active (negative inputs) so that the backpropogation will always update the weights. The leaky ReLU is defined as shown in Eq. 5 [17] and $\alpha$ is set to 0.1 during training.

[TABLE]

3 Results and discussion

The defect dataset contains a total of 2,188 images. Two thirds of the images were used for training and the remainder for testing. Nine classes were segmented and identified. The statistics of their areas and sizes are shown in Fig. 3. The blue and red bars show the number of pixels and regions of each class, respectively. The majority of segments were classed as background (BG) and blades. The most common defect type is erosion. Surface voids are the smallest targets, whilst chipped paint is the rarest class. The backgrounds include various contents, e.g. sky, sea, vegetation and other objects, such as distant wind turbines and houses.

The original images vary in size and the blades can be very close or far from the cameras. In this experiment, each image was downsampled to 2000$\times$3000 pixels for computational purposes. For training, each image was divided into overlapping 400$\times$400 patches (Fig. 4) with each patch shifted vertically and/or horizontally by 20 pixels. If a patch only contains 2 classes, it will not be used. In total we have 61,250 training patches. We initialised weights and biases with the VGG-19 network trained on the ImageNet database [18]. For testing, each image is also divided into patches that overlap by 200 pixels. The probability output maps are merged using an equally weighted average and the class with highest probability is labelled.

The results were compared with three state-of-the-art of semantic segmentation approaches, namely FCN [1], UNET [10] and deepLabv3+ (Encoder-Decoder with dilated convolution) by Google [19]. We applied weights $w_{c}=1/\sqrt{f_{c}}$ to the loss functions of FCN and deepLabv3+, because it achieved better results than using $w_{c}=1$ or $w_{c}=1/{f_{c}}$. We employed the dice loss for UNET as it gave the best result, but the leaky ReLU was used because the dying ReLU created big variations in dice scores. We also show the results of the dilated convolution path alone (FCN dilated) with our proposed loss function. When any network was trained using the cross entropy loss without weights $L_{ce}$, the performances was very poor. All networks were trained on BlueCrystal (High Performance Computing facility with NVIDIA Tesla P100) at the University of Bristol. A batch size was set to 10 which was limited by system memory. The Adam optimiser was employed with an initial learning rate of 10*-4*. We evaluated several dropout values for preventing the potential overfitting problem but observed no significant differences in performance.

Table 1 shows the accuracy of each detected category. The average accuracy is computed from 6 defects along with the previous repairs (as these are more important for monitoring the blade health of the wind turbines). It can be observed that DefectNet+$L_{hybrid}$ outperforms other networks in overall. However, it requires the most execution time in the prediction process ($\sim$4% more than deepLabv3+). DefectNet+$L_{hybrid}$ may not be the best detector for some defects, but is the most consistent and gives the accuracies within 2.8% of the most accurate techniques. The dilated convolution can detect small objects better than traditional convolution with pooling (the accuracy of FCN dilated is almost twice that of FCN). deepLabv3+ and DefectNet+$L_{wce}$ were trained with the same loss function and their average accuracies were very close. However, the variance amongst class accuracies of DefectNet+$L_{wce}$ is lower ($\sim$9%), i.e. the network is less biased to specific classes. We also show that the proposed hybrid loss can improve the detection performance by 9% and 16% over $L_{wce}$ and $L_{gdice}$, respectively. Fig. 5 shows three subjective results. The magnified regions show that DefectNet incorrectly identified pixels of blades as defects more than deepLabv3+. However it missed defects less than deepLabv3+, which is more important for inspection of wind turbine blade health (false negatives is more serious than false positives in most applications of fault detection).

4 Conclusion

This paper presents a new architecture, DefectNet, for multi-class fault detection, where the numbers of class samples vary significantly. We address the problem of a highly-imbalanced dataset using two parallel CNN paths to detect different target sizes. Large targets are detected using a modified FCN based on the VGG-19 structure and skip layers. Small targets are detected using dilated convolutional layers replacing the pooling layers that reduce the resolution of feature maps. To deal with the problem when some classes are absent in several successive training batches, a leaky ReLU is employed. We also proposed a hybrid loss that combines the weighted cross entropy and the generalised dice loss adaptively. The proposed DefectNet outperforms the state-of-the-art networks when detecting the defects on the blades of wind turbines by 9$-$32%.