DAC-SDC Low Power Object Detection Challenge for UAV Applications

09/01/2018 ∙ by Xiaowei Xu, et al. ∙ University of Notre Dame University of Pittsburgh The Chinese University of Hong Kong 0

The 55th Design Automation Conference (DAC) held its first System Design Contest (SDC) in 2018. SDC'18 features a lower power object detection challenge (LPODC) on designing and implementing novel algorithms based object detection in images taken from unmanned aerial vehicles (UAV). The dataset includes 95 categories and 150k images, and the hardware platforms include Nvidia's TX2 and Xilinx's PYNQ Z1. DAC-SDC'18 attracted more than 110 entries from 12 countries. This paper presents in detail the dataset and evaluation procedure. It further discusses the methods developed by some of the entries as well as representative results. The paper concludes with directions for future improvements.



There are no comments yet.


This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

TThe 55th Design Automation Conference (DAC) held its first System Design Contest (SDC) in 2018 which features a lower power object detection challenge (LPODC) on designing and implementing novel algorithms based object detection in images taken from unmanned aerial vehicles (UAV). This challenge provides a unified platform to develop and compare state-of-the-art object detection algorithms, and discusses the lessons learned from these participated entries.

The LPODC at DAC-SDC’18 focuses on unmanned aerial vehicles (UAV) applications as such applications have stringent accuracy, real-time, and energy requirements. Specifically, first, the LPODC task is to detect a single object of interest, one of the most important tasks in UAV applications [21]

. Second, different from general computer visual challenges, such as ImageNet

[18] and PASCAL VOC dataset [8], which focused only on accuracy, LPODC evaluates the final performance based on a combination of throughput, power, and detection accuracy. Thus, LPODC takes into full consideration the features of UAV applications: real-time processing, energy-constrained embedded platform, and detection accuracy. Third, the images of the dataset are all captured from actual UAVs which reflect the real circumstances and problems of UAV applications. Fourth, LPODC provides two hardware platforms: embedded GPU (Jetson TX2 from Nvidia [4]) and FPGA SoC (PYNQ Z-1 board from Xilinx [6]) to all the participating teams to choose from for their implementations. Note that GPUs and FPGAs are widely adopted for energy-efficient processing on UAVs [7].

The publically released dataset contains a large quantity of manually annotated training images, while the testing dataset is withheld for the evaluation purpose. There are a total of 150k images provided by a UAV company DJI [3]. Participating teams trained their models/algorithms with the training dataset, and sent the trained models/algorithms to the organizers to get the final testing results including throughput, energy, and detection accuracy. Such evaluation was performed at the end of each month and the detailed rank was released then. The final rank was released at the end of the competition and the top-3 entries from both GPU and FPGA categories were invited to present their work at a technical session at DAC.

This paper describes the LPODC in detail including: the task, the evaluation method and the dataset. Furthermore, a comprehensive discussion of the methods and results of the top-3 entries from both GPU and FPGA categories is presented to provide insights and rich lessons for future development of object detection algorithms especially for UAV applications. Particularly, we will elaborate hardware-software co-design for efficient processing on embedded platforms.

The training dataset, the source codes of the top-3 entries of both GPU and FPGA categories, and additional information about this challenge can be found at www.github.com/xyzxinyizhang/2018-DAC-System-Design-Contest.

1.1 Related Work

In this section we briefly discuss the related work about benchmark image datasets for object detection. As segmentation datasets can also be used for object detection, some widely-used segmentation datasets are also included.

Most of the datasets for object detection contain common photographs. LabelMe [19] has 187k images each of which contains multiple objects annotated with bounding polygon. It also provides a web-based online annotation tool for easy contribution by the public. Like LabelMe, PASCAL VOC dataset [8] further increases the number of images to 500k. ImageNet [18]

is one of the most popular datasets in computer vision community, and contains more than 14 million images. It was primarily for classification in 2010 and extended to support object detection and scene recognition in 2013. Compared with ImageNet, SUN database

[23] mainly focuses on scene recognition and contains about 131k images. Microsoft Common Objects in Context (COCO) [15] contains complex everyday scenes of common objects in their natural context and has 2.5 million images. Open Images [5] contains more than 9 million real-life images within 6,000 categories which is much larger than that of ImageNet (about 1,000).

There are also some datasets for specific applications, and the images are taken from particular views. KITTI vision benchmark dataset [9] is specific for autonomous driving, and the images are taken from a autonomous driving platform in a mid-size city. FieldSAFE [13] is for agriculture application and has approximately 2 hours of raw sensor data from a tractor-mounted sensor system in a grass mowing scenario. DOTA [22] focuses on aerial applications, and all the images are captured from cameras on aircrafts.

The dataset in this paper is specific for UAV applications. The images in the dataset are taken from UAVs which operates on a much lower height than general aircrafts in DOTA. The associated environment in the images is also much more complex than that in DOTA.

1.2 Paper Layout

We have given an overview of the LPODC at DAC’18. The rest of the paper is organized as follows. In Section 2, the challenge task and its evaluation method, as well as the provided two hardware platforms are described. The details of the dataset and its analysis are given in Section 3. The analysis and discussion of the methods for object detection of GPU and FPGA entries are presented in Section 4. Section 5 details the results of the GPU and FPGA entries. We conclude the paper with some discussions of the challenge and possible improvements.

2 LPODC Task and Evaluation Criteria

In this section, the details of the challenge task are presented, followed with an introduction of the hardware platforms and the evaluation method.

2.1 Object Detection

The LPODC task is to perform single object detection in each image with an axis-aligned bounding box indicating the object’s position and scale. As the challenge is targeted at UAV applications, there are several aspects that need to be emphasized. First, the object detection task is to locate a specific object from the training dataset, rather than objects from a training category. For example, if images containing person A are in the training dataset, then the task is to detect person A rather than other persons. More details about the detection objects are discussed in Section 3. Second, the object detection task needs to be executed with high throughput and high accuracy which are required by UAV applications. This requirement is achieved through the weighting of throughput in the scoring system, discussed in Section 2.3.

2.2 Hardware Platforms

In this challenge, two hardware platforms, either FPGA or GPU, were provided to the participating teams from the challenge sponsors Xilinx [6] and Nvidia [4], respectively. Particularly, the FPGA platform is Xilinx PYNQ Z-1 board which is an embedded systems based platform combining Zynq system and Python [12]. Participants are allowed to use Cortex-A9 processor and ZYNQ XC7Z020-1CLG400C on the platform to realize their solutions to the challenge. The embedded FPGA chip contains 53K 6-input look-up-tables, 220 DSPs, and 630KB fast block RAM. A 512MB DDR3 memory with 16-bit bus at 1,050Mbps is also embedded on the platform which can be accessed by both the processor and the FPGA. The power consumption of the FPGA platform is about 1-4 watts.

The GPU platform is Nvidia Jetson TX2, which is an embedded AI computing device. This GPU is very powerful with a 6-core CPU (Dual-core NVIDIA Denver2 + quad-core ARM Cortex-A57), a 256-core Pascal GPU, and 8GB LPDDR4 DRAM. It can provide more than 1TFLOPS of FP16 compute performance in less than 7.5 watts of power. Note that both hardware platforms target low-power embedded computation and are suitable for UAV applications.

Fig. 1: Overview of the dataset provided by DJI. There are 12 categories, each of which includes several sub-categories as indicated in the bracket, and there are totally 95 sub-categories. Note that there is only one object in each image.

2.3 Evaluation Method

The evaluation for the challenge is based on detection accuracy, throughput, and energy consumption. As energy consumption is relatively straightforward, the following content mainly discusses the metrics for accuracy and throughput.

The metric for object detection accuracy is Intersection over Union (IoU). Suppose there are two bounding boxes (BB): a predicted BB and the ground-truth BB. Then the accuracy or IoU of the predicted BB is the ratio between the area of the union of the predicted BB and the ground-truth BB and the area of the overlap encompassed by both the predicted BB and the ground-truth BB, i.e.,


where and are the areas of the predicted and ground-truth BBs, respectively. Note that the challenge only cares the IoU results, but does not care the object categories.

The metric for throughput is frames per second (FPS). For real-time processing in UAV applications, the minimum throughput requirement in this challenge was set to 20 FPS on the GPU platform and 5 FPS on the FPGA platform. If the FPS is lower than the requirement, then a penalty to IoU is added, i.e.,


where and are the actual and measured IoUs, respectively, and and are the required and measured FPSs, respectively. The function outputs the minimum one of its inputs.

The final score is a combination of accuracy, throughput, and energy consumption. Suppose there are registered entries and the dataset contains evaluation images. Let be the IoU score of image () for entry (). Then the IoU score for entry is computed as


Let be the energy consumption of processing all images for entry . Let be the average energy consumption of the entries. is computed as


Then the energy consumption score for entry is


where is set to 2 and 10 for FPGA category and GPU category, respectively. Through profiling, we find that the energy-performance Pareto frontier of the GPU platform exhibits much smaller gradient than that of the FPGA platform, reflecting the fact that the FPGA is more resource constrained than the GPU and thus its performance is much more sensitive to energy consumption. As such, we stress more on the accuracy for the GPU, while more on the energy for the FPGA. The final total score for entry is


The factor 0.2 in Equation (5

) is set based on the estimated range of energy consumption variation in participating teams. Through our profiling of the platform, we anticipate that a team will normally have an energy consumption from 1/4x to 4x the average of all teams for both GPU and FPGA categories. As such,

will take a range of -0.25 to 2, and a factor of 0.2 will make in the range of 0.6 to 1.4. Thus, the final (1+) in Equation (6) is in the range of 1.6 to 2.4 which is appropriate to act as a reward factor for energy efficiency. The function and the addition of 1 to are for teams with extremely low performance on energy efficiency. In such condition, is a large negative number, and the function ensures that is not a negative number but zero. Then the addition of 1 to further ensures that can still be graded based on accuracy with no multiplying rewarding factor for energy efficiency rather than being frozen to zero even if very high IoUs are obtained.

3 Dataset

As shown in Fig. 1, the adopted dataset from DJI [3] contains 12 categories of images and 95 sub-categories. For each sub-category, 70% of the images are provided for training and 30% are reserved for evaluation. It should be highlighted that compared with existing general purpose datasets such as ImageNet [18] and PASCAL VOC dataset [8], the object is captured in a UAV view and with different points of view.

The distributions of the training and testing datasets with respect to category, object size ratio, image brightness and amount of information are shown in Figs. 2-5. Here, object size ratio is the ratio of the object size to the image size. The brightness of a pixel is defined as in Equation (7)[20] (r, g, b are the three channels of images), where the image brightness is the average brightness of all its pixels. The amount of information is defined as the average pixel entropy of the object where the pixel entropy is calculated in a 55 region.

Fig. 2: Distributions of the training and testing datasets with respect to image categories.
Fig. 3: Distributions of the training and testing datasets with respect to object size ratio.
Fig. 4: Distributions of the training and testing datasets with respect to image brightness.
Fig. 5: Distributions of the training and testing datasets with respect to amount of information.

Fig. 2 shows that the ratio of quantity of training and testing images in different categories are almost the same, which is manually segmented to achieve a good balance of training and testing dataset. The categories person, car, and rider contain much more images than others as they contain more sub-categories than others. It can be noticed that there is also a good balance between the training dataset and the testing dataset for different object sizes except for some large object size ratio as shown in Fig. 3. As the object size ratio increases, the image quantity decreases. Note that the average object size ratio in ILSVRC is 17% and in PASCAL VOC is 20%. However, in this dataset, most of the images have an object size of 1-2% of the captured images (640x360), which is the main character of UAV-view images. This good balance still holds for image brightness and amount of information as shown in Fig. 4 and Fig. 5

. Both the two distributions in the two figures have the same shape: most of the images have a moderate brightness/amount of information, while many fewer images contain too large or too small brightness/amount of information, which are like a Gaussian distribution.

4 Methods for Object Detection

In this section, the analysis and discussion of the methods for object detection reported by the representative GPU and FPGA entries are presented. The details of the top-3 entries of GPU and FPGA categories are discussed, and statistical significance analysis is also presented.

4.1 Gpu

A total of 24 out of the 53 participating teams successfully implemented their designs under the GPU category, and all of them adopted deep learning approach. The distributions of used neural network models and deep learning frameworks are shown in Fig.

6. Tiny YOLO [17] is the most widely used model in the contest, and a majority of the entries achieve high performance by adding some revision to the network structure. Darknet is the most popular deep learning framework as tiny YOLO is originally implemented in Darknet. The top three entries ICT-CAS, DeepZ, and SDU-Legend all adopted the YOLO model as the base design and improved it with structure and computation optimization. Note that the image size is 640360 in the challenge, and ICT-CAS and SDU-Legend resized it to improve accuracy and throughput.

ICT-CAS adopted the original tiny YOLO as their network structure as shown in Fig. 7(a), and deployed the Tucker decomposition, hard example mining and low-bits computation for fast and accurate processing. In Tucker decomposition, they tested different decomposition parameters for optimal precision and throughput. By extracting the hard examples, re-training was performed to increase accuracy. In order to speed up the inferencing stage, they deployed half precision float point computation to reduce computation complexity and power consumption. In the TX2 GPU platform, this entry also adopted TensorRT [1] as the inference optimizer to speed up the inference.

DeepZ implemented their own network structure as shown in Fig. 7(b). It combined Feature Pyramid Network [14]

to fuse fine-grained features with strong semantic features to enhance the ability in detecting small objects. Meanwhile, DeepZ utilized focal loss function to mitigate the imbalance between the single ground truth box and the candidate boxes in the training phase, thereby partially resolving occlusions and distractions.

SDU-Legend focused on both neural network and architectural level optimization to achieve better balance between system performance and detection accuracy. SDU-Legend chose YOLO v2 as the starting design point, and performed design space exploration to choose the key training parameters including anchors, coordinates scale in the loss function, batch size, and learning rate policy. Moreover, SDU-Legend reduced YOLO v2 network architecture from 32 layers to 27 layer (as shown in Fig. 7(c)), and decreased the downsampling rate to strengthen the performance on small targets. At the architectural level, SDU-Legend aimed at balancing the workload between the GPU and the CPU by executing the last 2 layers on the CPU. SDU-Legend utilized the half data type (16-bit float) instead of 32-bit float to improve the memory throughput and reduce computation cost with minimum loss in accuracy.

Fig. 6: Number of entries using (a) neural network models and (b) deep learning frameworks.
Fig. 7: Neural network structure of the top-3 GPU entries: (a) ICT-CAS, (b) DeepZ, and (c) SDU-Legend.

4.2 Fpga

There are a total of seven out of the 61 participating teams that successfully implemented their designs on the FPGA platform provided. Among these entries, only entry TGIIF adopted Verilog hardware description language for compact FPGA implementation, while the rest utilized high-level synthesis for fast FPGA implementation.

The top three entries TGIIF, SystemsETHZ, and iSmart2

adopted Convolution Neural Network and used variations on the models such as Single Shot MultiBox Detector (SSD) 

[16], SqueezeNet [11], MobileNet [10], and Yolo [17]. From the original models, the proposed models used 1) fewer deep layers, 2) dynamic precision, 3) pruned topology, and 4) layer-shared Intellectual Property (IP). To further speed up the inference, these entries downsized the images in the CPU before FPGA processing. In order to compensate the limited on-chip BRAM, these entries utilized the off-chip 512MB DRAM to store the intermediate data between network layers.

The entry TGIIF proposed an optimized SSD network. It downsized the SSD network topology by removing the last two convolutional layers and quantized the network parameters to eight-bit fixed point. After modifying the network depth, it also pruned and fine-tuned the resultant network, making it with 14.2x less parameters and 10x less operations. The network topology proposed by TGIIF is shown in Fig. 8(a).

Fig. 8: Neural network structure of the top-3 FPGA entries: (a) TGIIF, (b) SystemETHZ, and (c) iSmart2.

The entry SystemsETHZ proposed a variation of SqueezeNet+Yolo networks. It reduced the fire layer in SqueezeNet to half and binaried the fire layer, and introduced a deep network consisting of 18 convolutional layers where the halfFire layers are binary. The network topology proposed by SystemsETHZ is shown in Fig. 8(b). It also adopted dynamic precision weights among different layers: five-bit fixed point parameters in all activation layers, eight-bit fixed point parameters in the first convolutional layer, and binary weights in all fire layers. With dynamic precision, it reduced the weight size to 64 KB and the number of multiplication operations to 154 millions.

The entry iSmart2

proposed a variation on MobileNet+Yolo networks. It introduced a hardware-friendly network, consisting of multiple depth-wise separable convolution kernels. In each kernel, it adopted a convolution-Relu-Convolution-Relu topology. The network topology proposed by

iSmart2 is shown in the Fig. 8(c). By calling one depth-wise separable convolution IP when processing different layers, the proposed network achieved a relatively low resource utilization with minimum look-up-table and Flip-Flop usage.

The entry traix proposed a varied SSD network with sixteen-bit fixed-point parameters. The entry hwac_object_tracker proposed a varied Tiny YOLO network topology with half-precision floating point parameters. The entry Lilou proposed a binaried VGG16 network topology with less pooling layers, thus retaining the inference data flow on the FPGA. The entry Qiu’s Team proposed a varied PYNQ-BNN [2], adopting 2-bit precision for all layers’ parameters.

The FPGA resource utilization of all the entries is shown in Table I. For entries that adopted parameters with sixteen or eight bit-width (TGIIF, SystemsETHZ, iSmart2, traix, hwac_object_tracker), the DSP utilization is close to 90%. The top entry TGIIF achieved a 100% DSP utilization. For entries that adopted parameters with one or two bit-width (Lilou, Qiu’s Team), the DSP utilization is as low as 12% (LiLou), while the LUT utilization can be as high as 100% (Qiu’s Team).

Entries LUTs Flip-Flop BRAM DSP
(53K) (106K) (630KB) (220)
TGIIF 83.89% 54.24% 78.93% 100%
SystemsETHZ 88% 62% 77% 78%
iSmart2 63% 22% 95% 86%
traix 90% - 90% 90%
hwac_object_tracker 85.02% 41.51% 42.14% 87.73%
Lilou 75% 38% 98% 12%
Qiu’s Team 100% 61% 96% 23%
TABLE I: Resource utilization of FPGA entries

5 Results and Analysis

In this section, we will discuss and analyze the result with respect to method, category, object size, image brightness, and amount of information for both GPU and FPGA entries. As power and throughput are determined once the method is chosen, we focus on the detection accuracy in this section.

5.1 Results of GPU Entries

5.1.1 Overall Results

As shown in Fig. 9, the optimal IoU, power and FPS are 0.6975, 4834mW, and 58.91 FPS, respectively. Note that all the top-3 entries (ICT-CAS, DeepZ, SDU-Legend) have high IoUs and FPS. Only high IoU or FPS is not enough to achieve a high total score/good ranking. For example, the entry OSSDC obtains a rather high FPS and a low IoU, which only ranks the 15th. While another entry Talos-G achieved a high IoU and a low FPS (lower than 20), which triggers the penalty as discussed in Equation (2) and only ranks the 14th.

Actually all the top-8 entries get IoUs higher than 0.60 and throughput higher than 20 FPS. Moreover, their values are both very close to each other which shows rather fierce competition among the top entries. Compared with IoUs, the power has a less influence on the final ranking.

In order to analyze whether results of different entries are statistically significantly different from each other, statistical significance analysis is performed. The bootstrap method is adopted here which is also employed by PASCAL VOC [8] and ImageNet [18]. In each bootstrap round, M images are sampled with replacement from the available M testing images and the average IoU for the sampled images is obtained for one entry. The above process iterates for each entry until reaching the pre-defined bootstrapping round. With the results obtained from all the bootstrapping rounds, the lower and upper

fraction are discarded, and the range of the remaining results are the 1-2a confidence interval. We set the number of bootstrapping rounds to 20,000 and

to 0.0005 (99.9% confidential interval), and the final results of the entries are shown in Fig. 10. It can be observed that almost all the entries are statistically significantly different from each other, and the difference of the top-4 entries are also very obvious even with minor differences.

Fig. 9: Overall results of GPU entries. Note that the entries are ranked from high to low in the horizontal axis. The details of the scores can be found on the website of the challenge.
Fig. 10: Statistical significance analysis using bootstrapping with 99.9% confidence intervals for GPU entries. Note that the entries are ranked from high to low in the vertical axis.

5.1.2 Detection Results by Category

As shown in Fig. 11, the category boat is with the highest detection accuracy as it contains moderate quantity of images and its object size is relatively larger than other categories as shown in Fig. 1. The category person, rider, and car are with a high accuracy as their image quantities are large which can provide a large variety of the object for training as shown in Fig. 2. The category drone and paraglider also get high accuracy (though their image quantities are small) which is due to the fact that their backgrounds are usually simple such as the sky and their structures are also very special compared with others.

The rest six categories are with relatively lower accuracy as their image quantities are small as shown in Fig. 2. Furthermore, the category whale has a very low contrast between the object and the background (the sea) as shown in Fig. 1. The category building is rather challenge as there exists many similar objects which results in a very low accuracy. The category group gets the lowest accuracy as there also exists multiple similar objects which makes it very hard to detect the right one.

Fig. 11: Detection accuracy of GPU entries with respect to image category. Note that the category is sorted in a ranked order and the left-most one is the one with the highest average total score.
Fig. 12: Detection accuracy of GPU entries with respect to size.
Fig. 13: Detection accuracy of GPU entries with respect to brightness.
Fig. 14: Detection accuracy of GPU entries with respect to amount of information.

5.1.3 Detection Results by Object Size

In Fig. 3 the quantity of images with 1% object size ratio is larger than that of images with 2% object size ratio. However, as shown in Fig. 12, the accuracy of images with 1% object size ratio is much smaller than that of images with 2% object size ratio. The main reason is that too small object is much harder to be detected with high accuracy. The accuracy of the images with 2%-5% object size ratios is almost the same and relatively higher than others as their corresponding image quantity is large and the object size is moderate. However, when the object size ratio increases from 6%, the accuracy decreases as the corresponding training image quantity is much lower than others.

5.1.4 Detection Results by Image Brightness

As shown in Fig. 13, there is a almost linear trend between the accuracy and the image brightness. As the image brightness increases, the accuracy also increases. However, if the accuracy is directly correlated with the image brightness, the accuracy with a brightness of about 135 should be the highest as the image quantity with this brightness is the largest. Thus, we tend to believe that higher brightness will make the object more clear to show its features which will make it relatively easier to be detected with high accuracy.

5.1.5 Detection Results by Amount of Information

As shown in Fig. 14, images with larger amount of information tend to have higher accuracy as larger amount of information contains more features which are relatively easier to be detected. The images with amount of information of 0.35-0.40 get a slightly higher accuracy than that with amount of information of 0.45-0.50 which may caused by that these images are with unique characteristics and a small quantity. We can also notice that the entry ICT-CAS can get a much higher accuracy for images with amount of information of 0.35-0.40 than others, and get relatively lower accuracy for images with amount of information of 0.90 than other top-3 entries.

Fig. 15: Overall results of FPGA entries. The details of the scores can be found on the website of the challenge.

5.2 Results of FPGA entries

5.2.1 Overall Results

Fig. 15

summarizes the performance of all FPGA entries. Entry TGIIF stands out as the most successful method, obtaining an IoU score of 0.6238 and a throughput of 11.96 FPS. The adopted deep network leads to a high IoU score, and the network pruning ensures the inference throughput. Entry SystemsETHZ comes second while it achieves a throughput of 25.97 FPS and an IoU score of 0.4919. Its dynamic precision architecture and binarized layers accelerate the inference throughput at the expense of IoU loss. iSmart2 comes third with a throughput of 7.35 FPS and an IoU score of 0.5733. Its uniform-layer deep network design gives rise to IP reuse and fine-grained memory allocation, keeping a good balance between throughput and accuracy.

Many entries achieved IoUs of around 0.5-0.6, such as entry which achieves an IoU of 0.6100 with sixteen-bit fixed-point network parameters. Despite the success in accuracy, there is a quite range in inference throughput. As mentioned in section 2.2 and 4.2, the FPGA platform has 630KB on-chip BRAM, which is not sufficient to retain all parameters and output feature maps of layers. Thus, a frequent data transfer between DRAM and FPGA are observed in all designs, and then keeping a proper balance between accuracy and network size is very important in this challenge. The standout top-3 entries adopted network pruning, parameters binarization and IP-reuse to ensure the inference throughput.

The statistical significance analysis is shown in Fig. 16. It can be easily noticed that all the entries are statistically significantly different from each other, and the difference of the top-3 entries are even larger and there is also moderate difference between their accuracies.

Fig. 16: Statistical significance analysis using bootstrapping with 99.9 confidence intervals for FPGA entries.

5.2.2 Detection Results by Category

Fig. 17 summaries the results obtained according to object category. The categories are listed in sequence of average IoU. There is drastic variation among categories and in different entries, in which, keeps the most promising average IoU of 0.5734 and with an average IoU of 0.2060 is the most challenging category to be detected. On average IoU, the most promising categories are , , , and , while those four categories have moderate quantities of images and their object sizes are relatively larger than other categories. Among those four categories, stands out as the most promising category while it contains 5k (the least) training images compared with which contains 28k (the most) training images. This is due to the fact that the background in the category is simple (the sea) and the target is distinct, while the category contains numerous noise such as trees, grass, and even other non-objected persons. The stands ahead of while the category contains 25k training images and contains only 1.6k training images. This is due to the fact that the category is captured from a relatively close view while category is captured from a distant view.

For these challenging categories such as , , , and , there is an approximately 20% accuracy gap between these categories and the promising categories for both maximum IoU and average IoU. Not only the low image quantity, but also the complex object features worsen the detection accuracy. The features of these four challenging categories can be summarized as follows: the category contains blurry object and background, while categories , , and have tiny objects or similar objects to the target objects such as the same color and shadow.

5.2.3 Detection Results by Object Size

Fig. 18 summaries the overall IoU of the seven entries with the target size. It can be observed than the most promising target size is located at 2%~6%, and 4% stands out as the most promising target size. While the training images with target size lower than 2% count the largest quantity of the dataset, its accuracy is inferior compared with images with a target sizen of 2%~6%. The accuracy of images with less than 2% target size is slightly superior than those images with 6%~10% target size, while the number of images with less than 2% target size is almost 100x more than those with 6%~10% target size. The overall accuracy starts downgrading after ratio 4% while entry keeps a relatively high accuracy. This may due to the fact that its framework has a good capability in extracting features of big objects.

Fig. 17: Detection accuracy of FPGA entries with respect to image categories. Note that the category is sorted in a ranked order and the left-most one is with the highest average total score.
Fig. 18: Detection accuracy of FPGA entries with respect to size.

5.2.4 Detection Results by Image Brightness

In Fig. 19, most of the training images are captured with the brightness between 105 to 165. However, the overall accuracy of seven entries doesn’t follow the same trend as shown in Fig. 19. The optimum point first arises when the brightness reaches 90 from 30. And the trend of accuracy starts slowly climbing until 195. After 195, the detection results show a drastic variation among entries due to the small quantities of the corresponding training images. Thereby, it can be deducted that the detection accuracy is correlated to brightness which is the same as that for GPU entries.

5.2.5 Detection Results by Amount of Information

Fig. 20 summaries the accuracy of all entries with the amount of information. It can be observed that the overall accuracy trends to increase until the amount of information reaches 0.65, which is the same with the trend shown in Fig. 5. However, for images with an amount of information of 0.9, their accuracy is the highest though their quantities are the smallest. Thus, it can be deducted that larger amount of information tends to achieve higher accuracy which is the same as that for GPU entries.

Fig. 19: Detection accuracy of FPGA entries with respect to brightness.
Fig. 20: Detection accuracy of FPGA entries with respect to amount of information.
Fig. 21: Hard examples with hard categories, small size, low brightness, and low amount of information in the challenge.

5.3 Hard Examples and Lessons

The results for GPU and FPGA entries show almost the same phenomena and trends as they adopted the same method (deep neural networks), and their hard-to-detect images are also almost the same. Fig. 21 shows some hard examples with hard categories, small sizes, low brightness, and low amount of information for both GPU and FPGA entries. The most challenge category is group as discussed in Section 5.1.2 and Section 5.2.2. As shown in Fig. 21(a) and (b), the objects in the two images are very small, and there are several similar objects around, which makes accurate detection rather hard. The two images (c) and (d) contain very small objects (rider in image (c) and truck in image (d)), both of which are hard to be recognized even by humans. Images (e) and (f) are two images with very low brightness, and the objects are very blurry without clear outlines. With the context in image (e), humans can infer that the object is a car. However, the object in image (f) is very hard for humans to recognize as the light is too dim. The objects in image (h) and (i) are with very low average amount of information, which is also hard to recognize. Image (h) contains a very small object which is almost invisible and has very limited information, while image (i) has a object which is large however with smooth surfaces and unclear boundaries with the sea. Within all the hard examples, it can be observed that almost all the images are within very small objects. In fact small objects are common for UAV applications which is the major challenge for accurate object detection. Furthermore, similar objects (persons, rider, buildings, boats, cars, etc.) and special scenarios (wake board, operation at night) add more difficulties.

With the above hard examples and previous results discussed, we present the learned lessons as follows. First, FPGA is much more energy efficient than GPU. Though FPGA achieves a relatively lower FPS than GPU, it can achieve almost the same accuracy but with only 1/3-1/2 energy consumption as that of GPU, which is promising for long-term UAV applications. Second, object detection from UAV views in real world is complicated. In the contest, there are many images that can not be accurately detected by all the entries. Dividing the task into well-defined sub-tasks for specific scenarios may improve the performance. Third, more data is preferred for more accurate detection. In the challenge we find that many objects get a low detection accuracy when their brightness or view-angle changes. Training images with more diversity (scale, view-angel, etc.) of the object will further improve the overall accuracy.

6 Conclusion

In this paper we present the DAC-SDC low power object detection challenge for UAV applications. Specifically, we describe the unique dataset from UAV views, and give a detailed discussion and analysis of the participating entries and their adopted methods. We also discuss the details of methods proposed by the LPODC entries for efficient processing for UAV applications. The result analysis provides a good practical lesson for researchers and engineers to further improve energy-efficient object detection in UAV applications.


The authors would like to thank DJI for providing the dataset, Xilinx and Nvidia for providing free GPU and FPGA platforms, and DAC organizers for their support to the DAC SDC challenge.


  • [1] https://developer.nvidia.com/tensorrt.
  • [2] https://github.com/xilinx/bnn-pynq.
  • [3] https://www.dji.com/.
  • [4] Nvidia. http://www.nvidia.com/page/home.html, 2018. [Online; accessed 5-July-2018].
  • [5] Open Images. https://www.kaggle.com/bigquery/open-images, 2018. [Online; accessed 4-July-2018].
  • [6] Xilinx. https://www.xilinx.com/, 2018. [Online; accessed 5-July-2018].
  • [7] H. Chao, Y. Gu, and M. Napolitano. A survey of optical flow techniques for uav navigation applications. In Unmanned Aircraft Systems (ICUAS), 2013 International Conference on, pages 710–716. IEEE, 2013.
  • [8] M. Everingham, L. Van Gool, C. K. Williams, J. Winn, and A. Zisserman. The pascal visual object classes (voc) challenge. International journal of computer vision, 88(2):303–338, 2010.
  • [9] A. Geiger, P. Lenz, and R. Urtasun. Are we ready for autonomous driving? the kitti vision benchmark suite. In

    Conference on Computer Vision and Pattern Recognition (CVPR)

    , 2012.
  • [10] A. G. Howard, M. Zhu, B. Chen, D. Kalenichenko, W. Wang, T. Weyand, M. Andreetto, and H. Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.
  • [11] F. N. Iandola, S. Han, M. W. Moskewicz, K. Ashraf, W. J. Dally, and K. Keutzer. Squeezenet: Alexnet-level accuracy with 50x fewer parameters and¡ 0.5 mb model size. arXiv preprint arXiv:1602.07360, 2016.
  • [12] B. Janßen, P. Zimprich, and M. Hübner. A dynamic partial reconfigurable overlay concept for pynq. In Field Programmable Logic and Applications (FPL), 2017 27th International Conference on, pages 1–4. IEEE, 2017.
  • [13] M. F. Kragh, P. Christiansen, M. S. Laursen, M. Larsen, K. A. Steen, O. Green, H. Karstoft, and R. N. Jørgensen. Fieldsafe: dataset for obstacle detection in agriculture. Sensors, 17(11):2579, 2017.
  • [14] T.-Y. Lin, P. Dollár, R. B. Girshick, K. He, B. Hariharan, and S. J. Belongie. Feature pyramid networks for object detection. In CVPR, volume 1, page 4, 2017.
  • [15] T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and C. L. Zitnick. Microsoft coco: Common objects in context. In European conference on computer vision, pages 740–755. Springer, 2014.
  • [16] W. Liu, D. Anguelov, D. Erhan, C. Szegedy, S. Reed, C.-Y. Fu, and A. C. Berg. Ssd: Single shot multibox detector. In European conference on computer vision, pages 21–37. Springer, 2016.
  • [17] J. Redmon, S. Divvala, R. Girshick, and A. Farhadi. You only look once: Unified, real-time object detection. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 779–788, 2016.
  • [18] O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.
  • [19] B. C. Russell, A. Torralba, K. P. Murphy, and W. T. Freeman. Labelme: a database and web-based tool for image annotation. International journal of computer vision, 77(1-3):157–173, 2008.
  • [20] A. Sanmorino. Clustering batik images using fuzzy c-means algorithm based on log-average luminance. Computer Engineering and Applications Journal (ComEngApp), 1(1):25–31, 2012.
  • [21] J. Torres-Sánchez, F. López-Granados, and J. M. Peña. An automatic object-based method for optimal thresholding in uav images: Application for vegetation detection in herbaceous crops. Computers and Electronics in Agriculture, 114:43–52, 2015.
  • [22] G.-S. Xia, X. Bai, J. Ding, Z. Zhu, S. Belongie, J. Luo, M. Datcu, M. Pelillo, and L. Zhang. Dota: A large-scale dataset for object detection in aerial images. In Proc. CVPR, 2018.
  • [23] J. Xiao, J. Hays, K. A. Ehinger, A. Oliva, and A. Torralba. Sun database: Large-scale scene recognition from abbey to zoo. In Computer vision and pattern recognition (CVPR), 2010 IEEE conference on, pages 3485–3492. IEEE, 2010.