Learning to predict crisp boundaries
Ruoxi Deng Chunhua Shen Shengjun Liu Huibing Wang Xinru Liu















headings
18SubNumber2980  

 

Learning to predict crisp boundaries








Deng et al.





^1Central South University, China;  ^2The University of Adelaide, Australia;  ^3Dalian  University of Technology, ChinaPart of this work was done
when R. Deng and H. Wang were visiting The University of Adelaide. Appearing in Proc. European Conference on Computer Vision (ECCV), 2018.
 







Learning to Predict Crisp Boundaries
    Ruoxi Deng^1,⋆, Chunhua Shen^2, Shengjun Liu^1, Huibing Wang^3,⋆, Xinru Liu^1
    Received 22 May 2018 / Accepted 17 July 2018
=================================================================================





    Recent methods for boundary or edge detection built on Deep Convolutional Neural Networks (CNNs) 
typically suffer from the issue of predicted edges being thick and  need post-processing to obtain crisp boundaries. 
Highly imbalanced categories of boundary versus background in training data is one of main reasons for the above problem.
In this work, the aim is to make CNNs produce sharp boundaries without post-processing. 
We introduce a novel loss for boundary detection, which is very effective for classifying imbalanced data 
and allows CNNs to produce crisp boundaries. 
Moreover, we propose an end-to-end network which adopts the bottom-up/top-down architecture to tackle the task. 
The proposed network effectively leverages hierarchical features and produces pixel-accurate boundary mask, 
which is critical to reconstruct the edge map. 
Our experiments illustrate that directly making crisp prediction not only promotes the visual results of CNNs, 
but also achieves better results against the state-of-the-art 
on the BSDS500 dataset (ODS F-score of .815) and the NYU Depth dataset (ODS F-score of .762).
















 









§ INTRODUCTION


Edge detection is a long-standing task in computer vision <cit.>. 
In early years, the objective is defined as to find sudden changes of discontinuities in intensity images <cit.>. 
Nowadays, it is  expected to localize semantically meaningful objects’ boundaries, 
which play a fundamental and significant role in many computer vision tasks such as image segmentation <cit.> and optical flow <cit.>. 
In the past few years, deep convolutional neural networks (CNNs) have dominated the research on  edge detection. 
CNN based methods, such as DeepEdge <cit.>, DeepContour <cit.>, HED <cit.> and RCF <cit.>, 
take advantage of its remarkable ability of 
 hierarchical feature learning and have demonstrated state-of-the-art F-score performance on the benchmarks such as BSDS500 <cit.> and NYUDv2 <cit.>.







Although CNN-based methods are good at producing semantically meaningful contours, 
we observe a common behavior that their prediction is much thicker than the result of classic methods. 
For example, in Figure <ref> we show two prediction examples  from  
the Sobel detector <cit.> and the HED detector, respectively.  
The edge of the polar bear that we highlight in the dotted rectangle on the HED result is roughly 10 pixels wide, 
which is two times wider than the Sobel result (roughly 4 pixels). 
Note that, the behavior of thick prediction is not only on the result of HED but also can be found in many recent representative works 
such as RCF, Casenet <cit.> and CEDN <cit.>.






Existing works  in the literature seldom  discuss this issue of predicted boundaries being overly thick.
One possible reason 
is that 
edge detection methods typically apply edge thinning post-processing to obtain  one-pixel wide results after generating an initial prediction. 
Therefore it seems no difference that how wide the initial prediction is.  
However, this behavior attracts our attention and we believe it is worth  finding out the reason behind it 
which in turn improves the quality of prediction. 
The work in    <cit.>    addressed this problem by proposing a 
refinement architecture (encoder-decoder) for achieving crips edges. As we show in   our  experiments, 
 it only slightly improves the result of HED.
 Instead of modifying the convolutional network for boundary detection, we   address this problem by investigating the loss function.




In this work, we explore and solve the thickness issue of CNN-based boundary predictions. We present an end-to-end fully convolutional network 
which is accurate, fast and convenient to perform image-to-boundary  prediction. 
Our method consists of two key components,
 which are a fully convolutional neural network of the bottom-up/top-town architecture and a simple yet effective loss function. 
The method can automatically learn rich hierarchical features, resolve ambiguity in prediction and predict crisp results without postprocessing. 
Figure <ref> gives an example of the improvement of edge quality between our method and the HED detector. 
More examples can be found in Section <ref>. 
We demonstrate that tackling the issue of thickness is critical for CNNs performing crisp edge detection, which improves the visual result 
as well as promotes the performance in terms of  boundary detection evaluation metrics. 
We achieve the state-of-the-art performance on the BSDS500 dataset with the ODS F-score of 0.815 and 
the fast version of our method achieves ODS F-score of 0.808 at the speed of  30 FPS.  








§ RELATED WORK


    Edge detection has been studied for over forty years. There are plenty of related works and here we only highlight a few representative works. 
Early edge detectors focus on computing the image gradients to obtain the edges <cit.>. 
For example, the Sobel detector <cit.> slides a 3×3 filter on a gray image to compute the image gradient for the response to the edge pixel. 
The  Canny detector <cit.> goes a step further by removing the noise on the output map and employing non-maximum suppression to extract one-pixel wide contour. 
These traditional methods are often used  as one of the fundamental features in many computer vision applications <cit.>. 
Learning-based methods <cit.>  often  ensemble different low-level features and train a classifier to generate object-level contours. 
Although these methods achieved great performance compared to  traditional methods, they rely on hand-crafted  features which limit their room for improvement.






Recent state-of-the-art methods for edge detection <cit.> are built on deep convolutional neural networks <cit.>. 
CNNs have the virtue of automatically learning low-level, middle-level and high-level features from training samples. 
Taking the advantage, CNN-based edge detectors can seek high response of edge on the fused feature map instead of the original image, which helps them generate semantic meaningful contour and achieve remarkable performance. 
To be more specific, DeepEdge <cit.> extracts multiple patches surrounding an edge candidate point (extracted by the Canny detector) and feeds these patches into a multi-scale CNN to decide if it is an edge pixel. 
DeepContour <cit.> is also a patch-based approach which first divides an image into many patches then put these patches into the network to detect if the patch has a contour. 
Differing from these works, the HED detector <cit.> is an end-to-end fully convolutional neural network which takes an image as input and directly outputs the prediction. 
It proposes a weighted cross entropy loss and takes the skip-layer structure to make independent predictions from each block of the pre-trained VGG model <cit.> and average the results. 
RCF <cit.> also utilizes the skip-layer structure and the similar loss with HED, yet it makes independent predictions from each convolutional layer of the VGG model. 
CEDN <cit.> employs an encoder-decoder network and train the network on the extra data of Pascal VOC dataset. 
CASENet <cit.> propose a novel task which is to assign each edge pixel to one or more semantic classes and solve the task by utilizing an end-to-end system similar to HED and RCF.


Summarizing  the development of deep learning based methods, we find that the HED detector is very popular and has enlightened many subsequent methods such as RCF, CASENet and the works mentioned in the paper <cit.>. 
However, we observe empirically  that the weighted cross entropy loss employed  by the HED detector may have contributed to the resulted edges  being thick. 
We verify this  in the next section.

Contributions In this work, we develop an end-to-end edge detection method.  
    Our main contributions are as follows. 
    We aim to detect crisp boundaries in images using deep learning.
    We explore the  issue of predicted edges being overly thick, which can be found in almost all  recent CNNs based methods.
    
    We propose a method that  manages to tackle the thickness issue. It allows CNN-based methods to predict crisp edge without postprocessing.
    Furthermore, our experiments show that our method outperforms previous state-of-the-art methods on the BSDS500 and NYUDv2 datasets. 






§ THE PROPOSED METHOD



In this section, we describe the details of the proposed method. 
Loss function is the most important component in an end-to-end dense prediction system 
since the quality of prediction is most affected by its loss. 
Thus we first revisit the weighted cross entropy loss used in previous state-of-the-art methods. 
We then propose our edge detection system, including the loss based on image similarity and the network of bottom-up/top-down structure. 










 §.§ Revisiting  the weighted cross-entropy loss for edge detection

Previously  fully convolutional networks (FCN) based 
edge-detection methods often employ  the weighted cross entropy loss as adopted  by the HED detector. 
It is well known that the cross-entropy loss is used to solve two-class classification.
 However, the edge/non-edge pixels are of a highly imbalanced  distribution (the majority of pixels are non-edge) thus the direct use of  the cross-entropy loss would fail to train the network. 
To tackle the issue, HED uses  the weighted cross entropy loss,  which writes 

    ℒ(W,w) = -β∑_j ∈ Y_+log(y_j=1 | X;W,w) 
    
                                       -(1-β )∑_j ∈ Y_-log(y_j=0 | X;W,w),

where Y_+ and Y_- denotes the 
edge pixel set and non-edge pixel sets, respectively. β = |Y_-|/|Y| and 1-β = |Y_+|/|Y|. X is the input image and (y_j| X;W,w) is computed 
using softmax  on the classification scores at pixel y_j. 




The class-balance weights β and 1-β are used to preserve and suppress the losses from the class of edge pixels and non-edge pixels, respectively. 
This simple solution helps CNN manage to better train the network. 
We perform a comparison  test   that     uses the standard  cross-entropy loss and the weighted loss on the same HED network structure,  demonstrating 
the effectiveness of the weight β. The result of the test is shown in Figure <ref>.


As we can see, the standard  loss fails to train the network since the result (Figure <ref>)  
    is not an edge map but an `embossed' image. 
    However, if we carefully look at its details,     we are able to find the contour of rhinoceros that has  reasonable thickness and is thinner 
    than the results  of the weighted loss (Figure <ref>). 
It is likely to indicate that,  although the class-balance weights β and 1-β manage to make CNNs successfully trained, they cause the `thickness' issue. 
This finding explains why recent methods such as RCF and Casenet tend to output overly thick edges.   These two methods have employed  the cross-entropy loss with the same strategy, 
i.e.,  setting weights on edge/non-edge pixels to balance the loss. 
To make the network trainable and output  a crisp  prediction at the same time, we will need alternative solutions. 







 §.§ The proposed loss function for edge detection



We have shown   that a distinct characteristic of edge map is that the data is highly biased because the vast majority of the pixels are non-edges. 
This highly biased issue would cause the learning to 
fail to find the crisp edges which are the `rare events'. 


Similar to our task,  many  applications such as fraud detection, medical image processing, and text classification are dealing with class imbalance data and 
there are corresponding solutions to these tasks <cit.>. 
Inspired by the work of <cit.> using the Dice coefficient <cit.> to solve the class-imbalance problem, we 
propose to use the Dice coefficient for edge detection.

    Given an input image I and the ground-truth G, the activation map M is the input image I processed by a fully convolutional network F. 
Our objective is to obtain a prediction P. 
Our loss function L is given by



    L(P,G) = Dist(P,G) = ∑_i^Np_i^2 + ∑_i^Ng_i^2/2∑_i^Np_ig_i,

where p_i,g_i denote the value of i-th pixel on the prediction map P and the ground-truth G, respectively. 
The prediction map P is computed from the activation map M by the sigmoid function. 
The loss function L is the reciprocal of the Dice coefficient. Since the Dice coefficient is a measure of similarity of two sets. 
Our loss is to compare the similarity of two sets P, G and minimizes their distance on  the training data. 
We do not need to consider the issue of balancing the loss of edge/non-edge pixels by using the proposed loss and are able to achieve our 
 objective—make the network trainable and predict  crisp   edges at the same time.








We should emphasize the way of computing our total loss in a mini-batch. Given a mini-batch of training samples and their corresponding ground-truth, our total loss is given by 

    L(MP, MG) = ∑_i^M Dist(MP_i, MG_i),

where MP and MG denote a mini-batch of predictions and their ground-truth, respectively. 
M is the total number of training samples in the mini-batch. 
Since our loss function is based on the similarity of per image-ground-truth pair, our total loss of a mini-batch is the sum of the total distances  over   all pairs. 






To achieve better performance, we propose to combine the cross-entropy loss and the proposed Dice loss. The Dice  loss may be thought of as 
 image-level  that  focuses on the similarity of two sets of image pixels. 
The cross-entropy loss concentrates on the pixel-level difference, since it is the sum of the distance of every corresponding pixel-pair between prediction and the ground-truth. 
Therefore the combined loss is able to hierarchically minimize the distance from image-level to pixel-level. 

Our final loss function is given by: 

    L_final(P,G) =  α L(P,G) + β L_c(P,G),

where L(P,G) is  Equation <ref>; 
L_c(P,G) is the normal cross-entropy loss which is L_c (P,G)= -∑_j^N(g_jlog p_j + (1-g_j)(1-log p_j) ). 
N is the total pixel number of an image. 
α and β are the parameters to control the influence of two losses. 
In experiments we set α = 1 and β = 0.001. 
We also tried to use the weighted cross-entropy loss (Equation <ref>) instead of L_c, and no improvement is  observed. 

To compute the total loss in a mini-batch, we use Equation <ref> where Dist(P,G) is replaced by L_final(P,G). 
We emphasize that the proposed Dice  loss L(P,G) is the cornerstone for generating crisp edges. 
Using only the  proposed Dice  loss, we achieve an  ODS F-score of .805 on the BSDS500 dataset. 





The formulation (<ref>) can be differentiated yielding the gradient

    ∂ L_final/∂ p_k = α2p_k∑_i=1^Np_ig_i - g_k(∑_i=1^Np_i^2 + ∑_i=1^Ng_i^2)/2(∑_i=1^Np_ig_i)^2 - β2g_k-1/p_k


computed with respect to the k-th pixel of the prediction.



In the next subsection, we  describe our network structure.






 §.§ Network architecture
 


We attempt   to select the network structure which 
has multiple stages to efficiently capture hierarchical features  
and is able to fuse the features of different levels, so as to generate semantically  meaningful contours. 
The success of HED shows the great importance of a carefully designed structure. 
In this paper, we look at another advanced structure, that is the bottom-up/top-down architecture <cit.> 
for inspiration to make better use of hierarchical features.
 The method of <cit.> achieves improved accuracy of object segmentation by proposing a novel top-down refinement approach. 
 We hypothesize that this structure may also work for edge detection well 
 since our task is related to object segmentation. To our knowledge, we may be  the first to adopt the bottom-up/top-down structure for edge detection. 


We follow the setting of the network <cit.> 
to apply the VGG-16 model <cit.> as the backbone and stack its 
`refactored' structure of the refinement module to recover the resolution of features. 
However, we have the following modifications at the refinement module to make it suitable for edge detection: 
(i) to better extract side feature from each stage of VGG-16, we use  the ResNeXt <cit.> block
 to connect each side output layer, respectively conv1_2, conv2_2, conv3_3, conv4_3 and conv5_3. Thus, the feature from each side output 
  first goes  through a ResNeXt block then is  fused with the mask-encoding from the top-down path; 
(ii) we use 1×1 conv layer to replace original 3×3 conv layers of the module. 
By doing so, we find the performance is improved with the decrease of model complexity; 
(iii) we use the learned deconv layer to double the resolution of fused features.
 Especially, the deconv layer is grouped. The group number equals to the channel number of the fused features. 
The grouped deconv layer allows our model to keep the performance with less model complexity. 
The modified refinement module is fully back-propable. We show the overall structure in Figure <ref> and our refinement module in the dotted rectangle. 


Our network is simple yet very effective for edge detection. 
We  highlight  that it is vital for an edge-detection network to increase the ability of feature extraction with the decrease of model complexity. 
Compared to the original structure, our network has the advantage of using fewer parameters to achieve 
better performance. To be more specific, our network has 15.69M parameters and achieves an ODS of .808 on the BSDS500 dataset. 
Without the modifications described in  (ii) and (iii), the parameter number increases to 22.64M but the performance decreases to ODS of .802. 

 The  reason behind this phenomenon might be due to  overfitting,  as 
the dataset for edge detection has limited number of training samples (for example, the BSDS500 dataset only has only 200 training images). 

In experiments, we tried a few  more sophisticated   bottom-up/top-down networks such as Refinenet <cit.>, 
but failed to achieve better performance possibly because of limited training data. Using the ResNeXt block is for the same reason. 
It groups the inside conv layers to decrease the model complexity. 
We also test the ResNet block <cit.> to extract the side features, 
which is used to compare the performance against  the ResNeXt block. 
We find that they are both helpful to boost the performance while the ResNeXT block performs slightly better with roughly  50% complexity of the ResNet block. 
 






§ EXPERIMENTS


In this section, we first present the implementation details as well as a brief description of the   datasets. 
Our experiments start with an ablation study of the proposed method. 
We then conduct a comparative study on HED to demonstrate the effectiveness of the proposed loss on the crispness of prediction. 
We further compare our method with the state-of-the-art edge detectors and demonstrate the advantages.



 §.§ Implementation details

We implement our method using  Pytorch <cit.>. 
We evaluate edge detectors on 
Berkeley Segmentation Dataset (BSDS 500) and 
NYU depth dataset (NYUD), 
which are widely used in previous works <cit.>. 
The hyper-parameters of our model include: 
mini-batch size (36), input image resolution (480×320), weight-decay (1e-4), 
 training epochs  (30). 
We use the ADAM solver <cit.> for optimization. 



Beside the hyper-parameters, the following  several key issues  are worth mentioning:
 
Data augmentation 

Data augmentation is an effective way to boost performance when the amount of training data is limited. 
We first random scale the image-label pairs (0.7 to 1.3). 
We then rotate the pairs to 16 different angles and crop the largest rectangle in the rotated angle. 
We finally flip the cropped images, 
which leads to an augmented training set from 200 images to more than 100k images.

Up-sampling method 
We employ learned deconvolution in the backward-refining pathway to 
progressively increase the resolution of feature maps. 
Although bilinear upsampling was demonstrated to be  useful in HED, 
it is abandoned in our method. 
 We observe in experiments that bilinear upsampling may make  the prediction discontinuous at a number of locations 
 and cause a  slight decrease in performance. 

Multi-scale edge detection 
Inspired by the works <cit.>,  during testing 
we make use of multi-scale edge detection to further improve performance. 
We first resize an input image to three different resolutions (0.5×, 1.0× and 1.5× of the original size), 
which are fed into the network. We then resize the outputs back to the original size and average them to obtain   the final prediction. 
 





 §.§ BSDS500 dataset

Berkeley Segmentation Dataset (BSDS 500) <cit.> contains 200 training images, 100 validation images, and 200 testing images. 
Each image is annotated by multiple users. 
We use the train set (200 training images) for training 
and employ all the ground-truth labels to prepare the training data. 
That is, if an image has five annotations, we first create five copies of the image. 
Each copy is corresponding to one of the annotations, respectively. 
We then apply these five image-annotation pairs for data augmentation. 
This would introduce ambiguity in the ground-truth pairs because
 different annotators may disagree with each other  for   a small number of pixels. 
However, in this case, we are able to get more annotations for data augmentation. 
In the meantime, we observed that introducing certain ambiguity prevented the training from overfitting. 









  §.§.§ Ablation study

We first conduct a series of ablation studies to 
evaluate the importance of each component in the proposed method.  
Our first experiment is to examine the effectiveness of 
the basic encoder-decoder network (Ours-w/o-rN-w/o-FL) for the task. 
To this end, our baseline model is 
the proposed network removing all the ResNeXt blocks in the backward-refining path.
We train this baseline using the balanced cross-entropy loss.
Moreover, we trained two versions of the proposed network 
via the balanced cross-entropy loss (Ours-w/o-FL) and the proposed fusion loss (Ours), respectively. 


The accuracy of prediction is evaluated via two standard measures: 
fixed contour threshold (ODS) and per-image best threshold (OIS). 

Previous works tend to only examine the correctness of prediction 
since they apply  a standard non-maximal suppression (NMS) to predicted edge maps before evaluation.
While in this study and the following comparative study, 
we would like to evaluate each model twice (before and after NMS). 
By doing so, we can examine both the correctness and the sharpness since low-crispness 
prediction is prone to achieve low ODS scores, 
without the aid of NMS. 
We are aware that CED <cit.> and PMI <cit.> 
apply  a different way to benchmark the crispness of predictions 
by varying a matching distance parameter. 
However, we consider that  directly evaluating non-NMS results 
is simpler yet effective for the same purpose.

The quantitative results are listed in Table <ref> 
and two qualitative examples are shown in Figure <ref>(c), (d) and (e). 
From the results, we  observe  three findings. 
Firstly, each component is able to improve performance; 
Secondly, a convolutional encoder-decoder network may be more competent for  the task, 
compared to the network of HED. 
We can see that the baseline (Ours-w/o-rN-w/o-FL) achieves an  ODS score .797, 
which significantly outperforms HED (.790 on the BSDS500 dataset).
Lastly, both the quantitative and the qualitative results have demonstrated 
the effectiveness of the proposed fusion loss. 
By  simply  using  the proposed fusion  loss, the ODS f-score (before NMS) of our network is increased from .674 to .693
and the improvement of boundary sharpness can be also 
observed in Figure <ref>(d) and (e).





  §.§.§ Improving the crispness of HED




As mentioned in  Section <ref>, 
the proposed fusion loss plays a key role in our method in terms  of generating   sharp boundaries, 
which was demonstrated in the ablation study. 
One may ask a question: 
Does the fusion loss only work on the convolutional encoder-decoder network? 
Could it also allow different methods such as HED to improve crispness? 

To answer this question, we perform a comparative study on the HED edge detector. 
Similar to the ablation experiments, we evaluate two versions of HED: 
one is trained by means of the proposed fusion loss, 
the other is applying the balanced cross-entropy loss. 
Both  methods are trained using deep supervision. 
Note that our training data of BSDS500 is generated in a different way, compared to HED <cit.>, 
thus the performance of the re-implemented HED is slightly different from the original paper. 
We summarize the quantitative results in Table <ref> and 
show two qualitative examples in Figure <ref>(f) and (g).

The results are consistent with those of the ablation experiments. With the use  of the proposed loss, 
HED-FL improves the non-NMS results over HED-BL by almost 9%, 
which is a significant increase at boundary crispness.








  §.§.§ State-of-the-art comparisons
 
In this subsection, we further compare against the top performing edge detectors. 
The methods to be evaluated are composed of two classes: 
the first class is deep-learning based, which includes HED <cit.>, RCF <cit.>, DeepContour <cit.>, DeepEdge <cit.>, CED <cit.>, 
HFL <cit.>, CEDN <cit.>, MIL+G-DSN+MS+NCuts <cit.> and our method; 
the second class contains SE  <cit.>, gPb-UCM <cit.> and the Canny detector <cit.>. 
We also follow the works of <cit.> to employ the extra training data from PASCAL VOC Context dataset <cit.>. 
The results are shown in Figure <ref>, Figure <ref> and Table <ref>. 

We first look at the qualitative result in Figure <ref>. 
RCF and CED are the leading edge detectors at present. 
Especially, CED shares the same aim with our method, which is to solve the issue of boundary crispness. 
Comparing to the other methods, our approach shows a clear advantage in quality of edge maps which are cleaner and sharper. 
Consider the `cow' in the third example. Our method is able to precisely match its contour, 
whereas RCF and CED incur much more blurry and noisy edges. 
The qualitative comparisons suggest that our method generates sharper boundaries.

The quantitative results are summarized in Table <ref>. 
Figure <ref> shows Precision-Recall curves of all methods. 
Note that, all the results have been post processed (using NMS) before evaluation. 
Without extra training data and the multi-scale testing, our method already outperforms most of the state-of-the-art edge detectors. 
By means of extra training data, our single-scale model achieves a significant improvement on ODS f-score from .800 to .808. 
With the multi-scale testing, our method achieves the same top performance with CED. 
However, CED adopted both the train and validation set for training while we only use the train set. 

In addition to this, we evaluate the non-NMS results of CED (single-scale, without extra training data) 
and obtain  the performance of ODS f-score of .655, OIS f-score of .662. 
The result is far behind our single-scale non-NMS performance (ODS f-score of .693). 
Another advantage of our method is that our detector is able to run in real time. The single scale detector can operate at 30FPS on a GTX980 GPU. 
Since our method is simple, effective and very fast, it is easy to be used along with  high-level vision tasks such as image segmentation.









 §.§ NYUDv2 dataset

The NYU depth dataset <cit.> is a large depth benchmark for indoor scenes, 
which is collected by a Microsoft Kinect sensor. 
It has a densely labeled dataset (every pixel has a depth annotation) which has 1449 pairs of aligned RGB and depth images. 
Gupta <cit.> processed the data to generate edge annotation and split the dataset into 381 training images, 414 validation images, and 654 testing images. 
We follow their data-split setting and change several hyper-parameters of our method for training: mini-batch size (26), image resolution (480×480). The maximum 
tolerance allowed for correct matches of edge prediction in evaluation is increased from .0075 to .011, as used in <cit.>. 
We compare against the state-of-the-art methods which include 
OEF <cit.>, gPb-UCM <cit.>, gPb+NG <cit.>, SE <cit.>, 
SE+NG+ <cit.>, HED <cit.> and RCF <cit.>. 

Motivated by the previous works <cit.>, we leverage the depth information to improve performance. 
We employ the HHA feature <cit.> in which 
the depth information is encoded into three channels: horizontal disparity, height above ground, and angle with gravity. 
The way of employing the HHA feature is straightforward. 
We simply train two versions of the proposed  network, one on the RGB data, another on HHA feature images. 
The final prediction is generated by directly averaging the output of the RGB model and HHA model.

We show the quantitative results in Table <ref> and 
the precision-recall curve in Figure <ref>. Our method achieves the best performance of ODS F-score .762. 
The qualitative results in Figure <ref> show consistent performance with those of the experiments on BSDS 500. 
Our prediction produces sharper boundaries against the leading competitor RCF, 
which demonstrates the effectiveness of our method.







§ CONCLUSIONS

In this work, we have presented a simple yet effective method for edge detection which achieves state-of-the-art results. 
We have shown that it is possible to achieve excellent boundary detection results using a carefully designed loss function 
and a simple  convolutional encoder-decoder network. 
 
In future work, we plan to extend the use of the edge detector to the tasks like object detection and optical flow 
which have the requirement of boundary sharpness and a fast  processing  speed.
 


splncs

