Salient Object Detection with Lossless Feature Reflection and Weighted Structural Loss

TL;DR

This paper introduces a novel symmetrical fully convolutional network with lossless feature reflection and a weighted structural loss for improved salient object detection, achieving superior results across multiple datasets.

Contribution

The paper proposes a new symmetrical fully convolutional network and a weighted structural loss to enhance salient object detection accuracy and boundary clarity.

Findings

Outperforms recent state-of-the-art methods on seven datasets.

Achieves more accurate and boundary-preserving saliency maps.

Demonstrates robustness in complex scenes.

Abstract

Salient object detection (SOD), which aims to identify and locate the most salient pixels or regions in images, has been attracting more and more interest due to its various real-world applications. However, this vision task is quite challenging, especially under complex image scenes. Inspired by the intrinsic reflection of natural images, in this paper we propose a novel feature learning framework for large-scale salient object detection. Specifically, we design a symmetrical fully convolutional network (SFCN) to effectively learn complementary saliency features under the guidance of lossless feature reflection. The location information, together with contextual and semantic information, of salient objects are jointly utilized to supervise the proposed network for more accurate saliency predictions. In addition, to overcome the blurry boundary problem, we propose a new weighted structural loss function to ensure clear object boundaries and spatially consistent saliency. The coarse prediction results are effectively refined by these structural information for performance improvements. Extensive experiments on seven saliency detection datasets demonstrate that our approach achieves consistently superior performance and outperforms the very recent state-of-the-art methods with a large margin.

Figures

Tables

Algorithm 1: Layer-wise Adaptive Batch Normalization (AdaBN)
Input: Neuron responses $x_i$ in $l$-th convolutional layer.
Output: Neuron responses ${\overline{x}}_i$ in $l$-th convolutional layer.
1: for each neuron $i$ in SFCN do
2:  Concatenate neuron responses on all images in a minibatch of target domain $t$ (the other sibling branch): ${\text{x}}_i=[\dots ,x_i\left(m\right),\dots ]$
3:  Compute the mean and variance of the target domain:
${\mu }_i^t=𝔼\left({\text{x}}_i^t\right),{\sigma }_i^t=\sqrt{Var\left({\text{x}}_i^t\right)}$.
4: for each neuron $i$ in SFCN, testing image $m$ in target domain do
5:  Compute BN output ${\overline{x}}_i\left(m\right)={\alpha }_i\frac{x_i\left(m\right)-{\mu }_i^t}{{\sigma }_i^t}+{\beta }_i$.
6: end

Table 2. TABLE I: Quantitative comparison with 24 methods on 4 large-scale datasets. The best three results are shown in red ,  green and blue , respectively. ∗ means methods using multi-stage training or post-processing, such as CRF or superpixel refinements.

	DUT-OMRON			DUTS-TE			ECSSD			HKU-IS-TE
Methods	$F_{\eta }\uparrow$	$MAE\downarrow$	$S_{\lambda }\uparrow$	$F_{\eta }\uparrow$	$MAE\downarrow$	$S_{\lambda }\uparrow$	$F_{\eta }\uparrow$	$MAE\downarrow$	$S_{\lambda }\uparrow$	$F_{\eta }\uparrow$	$MAE\downarrow$	$S_{\lambda }\uparrow$
Ours+	0.718	0.0643	0.811	0.742	0.0622	0.853	0.911	0.0421	0.916	0.906	0.0357	0.914
Ours [2]	0.696	0.0862	0.774	0.716	0.0834	0.799	0.880	0.0523	0.897	0.875	0.0397	0.905
AMU [12]	0.647	0.0976	0.771	0.682	0.0846	0.796	0.868	0.0587	0.894	0.843	0.0501	0.886
BDMP [19]	0.692	0.0636	0.789	0.751	0.0490	0.851	0.869	0.0445	0.911	0.871	0.0390	0.907
DCL∗ [6]	0.684	0.1573	0.743	0.714	0.1493	0.785	0.829	0.1495	0.863	0.853	0.1363	0.859
DGRL [22]	0.709	0.0633	0.791	0.768	0.0512	0.836	0.880	0.0424	0.906	0.882	0.0378	0.896
DHS [9]	–	–	–	0.724	0.0673	0.809	0.872	0.0601	0.884	0.854	0.0532	0.869
DS∗ [41]	0.603	0.1204	0.741	0.632	0.0907	0.790	0.826	0.1216	0.821	0.787	0.0774	0.854
DSS∗ [10]	0.729	0.0656	0.765	0.791	0.0564	0.812	0.904	0.0517	0.882	0.902	0.0401	0.878
ELD∗ [55]	0.611	0.0924	0.743	0.628	0.0925	0.749	0.810	0.0795	0.839	0.776	0.0724	0.823
LEGS∗ [3]	0.592	0.1334	0.701	0.585	0.1379	0.687	0.785	0.1180	0.787	0.732	0.1182	0.745
MCDL∗ [4]	0.625	0.0890	0.739	0.594	0.1050	0.706	0.796	0.1007	0.803	0.760	0.0908	0.786
MDF∗ [5]	0.644	0.0916	0.703	0.673	0.0999	0.723	0.807	0.1049	0.776	0.802	0.0946	0.779
NLDF [17]	0.684	0.0796	0.750	0.743	0.0652	0.805	0.878	0.0627	0.875	0.872	0.0480	0.878
PAGRN [20]	0.711	0.0709	0.751	0.788	0.0555	0.825	0.894	0.0610	0.889	0.887	0.0475	0.889
PICA∗ [23]	0.710	0.0676	0.808	0.755	0.0539	0.850	0.884	0.0466	0.914	0.870	0.0415	0.905
RFCN∗ [8]	0.627	0.1105	0.752	0.712	0.0900	0.784	0.834	0.1069	0.852	0.838	0.0882	0.860
RST∗ [18]	0.707	0.0753	0.792	–	–	–	0.884	0.0678	0.899	–	–	–
SRM∗ [14]	0.707	0.0694	0.777	0.757	0.0588	0.824	0.892	0.0543	0.895	0.873	0.0458	0.887
UCF [13]	0.621	0.1203	0.748	0.635	0.1119	0.777	0.844	0.0689	0.884	0.823	0.0612	0.874
BL [56]	0.499	0.2388	0.625	0.490	0.2379	0.615	0.684	0.2159	0.714	0.666	0.2048	0.702
BSCA [57]	0.509	0.1902	0.648	0.500	0.1961	0.633	0.705	0.1821	0.725	0.658	0.1738	0.705
DRFI [50]	0.550	0.1378	0.688	0.541	0.1746	0.662	0.733	0.1642	0.752	0.726	0.1431	0.743
DSR [58]	0.524	0.1389	0.660	0.518	0.1455	0.646	0.662	0.1784	0.731	0.682	0.1405	0.701

Table 3. TABLE II: Quantitative comparison with 24 methods on 4 complex structure datasets. The best three results are shown in red ,  green and blue , respectively. ∗ means methods using multi-stage training or post-processing, such as CRF or superpixel refinements.

	PASCAL-S			SED1			SED2			SOD
Methods	$F_{\eta }\uparrow$	$MAE\downarrow$	$S_{\lambda }\uparrow$	$F_{\eta }\uparrow$	$MAE\downarrow$	$S_{\lambda }\uparrow$	$F_{\eta }\uparrow$	$MAE\downarrow$	$S_{\lambda }\uparrow$	$F_{\eta }\uparrow$	$MAE\downarrow$	$S_{\lambda }\uparrow$
Ours+	0.813	0.0732	0.851	0.925	0.0442	0.913	0.886	0.0447	0.888	0.822	0.1012	0.804
Ours [2]	0.772	0.1044	0.809	0.913	0.0484	0.905	0.871	0.0478	0.870	0.789	0.1233	0.772
AMU [12]	0.768	0.0982	0.820	0.892	0.0602	0.893	0.830	0.0620	0.852	0.743	0.1440	0.753
BDMP [19]	0.770	0.0740	0.845	0.867	0.0607	0.879	0.789	0.0790	0.819	0.763	0.1068	0.787
DCL∗ [6]	0.714	0.1807	0.791	0.855	0.1513	0.845	0.795	0.1565	0.760	0.741	0.1942	0.748
DGRL [22]	0.811	0.0744	0.839	0.904	0.0527	0.891	0.806	0.0735	0.799	0.800	0.1050	0.774
DHS [9]	0.777	0.0950	0.807	0.888	0.0552	0.894	0.822	0.0798	0.796	0.775	0.1288	0.750
DS∗ [41]	0.659	0.1760	0.739	0.845	0.0931	0.859	0.754	0.1233	0.776	0.698	0.1896	0.712
DSS∗ [10]	0.810	0.0957	0.796	-	-	-	-	-	-	0.788	0.1229	0.744
ELD∗ [55]	0.718	0.1232	0.757	0.872	0.0670	0.864	0.759	0.1028	0.769	0.712	0.1550	0.705
LEGS∗ [3]	–	–	–	0.854	0.1034	0.828	0.736	0.1236	0.716	0.683	0.1962	0.657
MCDL∗ [4]	0.691	0.1453	0.719	0.878	0.0773	0.855	0.757	0.1163	0.742	0.677	0.1808	0.650
MDF∗ [5]	0.709	0.1458	0.692	0.842	0.0989	0.833	0.800	0.1014	0.772	0.721	0.1647	0.674
NLDF [17]	0.779	0.0991	0.803	–	–	–	–	–	–	0.791	0.1242	0.756
PAGRN [20]	0.807	0.0926	0.818	0.861	0.0948	0.822	0.794	0.1027	0.757	0.771	0.1458	0.716
PICA∗ [23]	0.801	0.0768	0.850	–	–	–	–	–	–	0.791	0.1025	0.790
RFCN∗ [8]	0.751	0.1324	0.799	0.850	0.1166	0.832	0.767	0.1131	0.771	0.743	0.1697	0.730
RST∗ [18]	0.771	0.1127	0.796	–	–	–	–	–	–	0.762	0.1441	0.747
SRM∗ [14]	0.801	0.0850	0.832	0.885	0.0753	0.854	0.817	0.0914	0.761	0.800	0.1265	0.742
UCF [13]	0.735	0.1149	0.806	0.865	0.0631	0.896	0.810	0.0680	0.846	0.738	0.1478	0.762
BL [56]	0.574	0.2487	0.647	0.780	0.1849	0.783	0.713	0.1856	0.705	0.580	0.2670	0.625
BSCA [57]	0.601	0.2229	0.652	0.805	0.1535	0.785	0.706	0.1578	0.714	0.584	0.2516	0.621
DRFI [50]	0.618	0.2065	0.670	0.807	0.1480	0.797	0.745	0.1334	0.751	0.634	0.2240	0.624
DSR [58]	0.558	0.2149	0.594	0.791	0.1579	0.736	0.712	0.1406	0.715	0.596	0.2345	0.596

Table 4. TABLE III: Run time analysis of the compared methods. It is conducted with an i5-6600 CPU and an NVIDIA GeForce GTX 1070 GPU.

Models	Ours	AMU	BDMP	DCL	DGRL	DHS	DS	DSS	ELD	LEGS	MCDL	MDF	NLDF	PAGRN	PICA	RFCN	RST	SRM	UCF	BL	BSCA	DRFI	DSR
Times (s)	0.08	0.05	0.06	0.62	0.56	0.05	0.23	5.21	0.93	2.31	3.31	26.45	2.33	0.07	0.236	5.24	7.12	0.16	0.15	3.54	1.42	47.36	5.11

Table 5. TABLE IV: Results with different input settings on the ECSSD dataset.

Inputs	RGB	O-Input	R-Input	RGB+YCbCr	O-Input+R-Input
$F_{\eta }\uparrow$	0.802	0.844	0.845	0.852	0.880
$MAE\downarrow$	0.1415	0.1023	0.1002	0.0931	0.0523
$S_{\lambda }\uparrow$	0.853	0.879	0.880	0.882	0.897

Table 6. TABLE V: Results with different mean settings on the ECSSD dataset. The best result are shown in bold.

Means	ImageNet	MSRA10k	Each Image	Middle Mean	Zero Mean
$F_{\eta }\uparrow$	0.880	0.879	0.875	0.873	0.871
$MAE\downarrow$	0.0523	0.0535	0.0544	0.0602	0.0605
$S_{\lambda }\uparrow$	0.897	0.895	0.886	0.887	0.889
$Time\left(h\right)\downarrow$	38.5	38.5	50.2	38.5	33.7

Table 7. TABLE VI: Results with different values of k 𝑘 k on the ECSSD dataset.

$k$	-4	-2	-1	0	1	2	4
$F_{\eta }\uparrow$	0.842	0.844	0.843	0.844	0.880	0.880	0.881
$MAE\downarrow$	0.1025	0.1023	0.1022	0.1023	0.0523	0.0520	0.0521
$S_{\lambda }\uparrow$	0.880	0.879	0.880	0.879	0.897	0.898	0.898

Table 8. TABLE VII: Results with different model settings on ECSSD. The best three results are shown in red ,  green and blue , respectively.

Models	(a) SFCN-hf+${ℒ}_{bce}$	(b) SFCN-hf+${ℒ}_{wbce}$	(c) SFCN-hf+${ℒ}_{wbce}$+${ℒ}_{sc}$	(d) SFCN-hf+${ℒ}_{wbce}$+${ℒ}_{sc}$+${ℒ}_{s1}$	(e) SFCN+${ℒ}_{bce}$	(f) SFCN+${ℒ}_{wbce}$	(g) SFCN+${ℒ}_{wbce}$+${ℒ}_{sc}$	(h) SFCN+${ℒ}_{wbce}$+${ℒ}_{s1}$	Overall
$F_{\eta }\uparrow$	0.824	0.841	0.858	0.863	0.848	0.865	0.873	0.867	0.880
$MAE\downarrow$	0.1024	0.1001	0.0923	0.0706	0.0834	0.0721	0.0613	0.0491	0.0523
$S_{\lambda }\uparrow$	0.833	0.852	0.860	0.869	0.872	0.864	0.880	0.882	0.897

Table 9. TABLE VIII: Results with/without sharing weights on the ECSSD dataset.

Models	w/o	w/
$F_{\eta }\uparrow$	0.862	0.880
$MAE\downarrow$	0.0569	0.0523
$S_{\lambda }\uparrow$	0.883	0.897
Model size (MB)$\downarrow$	386.1	194.4

Table 10. TABLE IX: Results with different BN settings on the ECSSD dataset.

	BN [36]			Layer-wise AdaBN
Batchsize	$F_{\eta }\uparrow$	$MAE\downarrow$	$S_{\lambda }\uparrow$	$F_{\eta }\uparrow$	$MAE\downarrow$	$S_{\lambda }\uparrow$
1	0.859	0.0722	0.874	0.876	0.0624	0.879
2	0.863	0.0701	0.877	0.891	0.0604	0.895
4	0.866	0.0601	0.876	0.882	0.0583	0.899
8	0.867	0.0604	0.874	0.903	0.0511	0.910
12	0.866	0.0607	0.874	0.911	0.0421	0.916
16	0.864	0.0605	0.876	0.911	0.0420	0.917
20	0.867	0.0605	0.873	0.915	0.0421	0.910
24	0.870	0.0606	0.872	0.913	0.0422	0.916

Equations

$$Ref(X,k)$$

$$=(X-M,-k(X-M))$$

$$=(X_O,X_R^k).$$

$${\hat{x}}_i$$

$${\bar{x}}_i$$

$$f_l(X)=\{\begin{array}{rl}& h([g_l(X_O),f_{l+1}(X),g_l^{\ast }(X_R^k)]),l<L\\ & h([g_l(X_O),g_l^{\ast }(X_R^k)]),l=L\end{array}$$

$${\mathcal{L}}_{bce}=-\sum _{j\in Y_{+}}\text{log Pr}(y_j=1|X;\theta )$$

$$-\sum _{j\in Y_{-}}\text{log Pr}(y_j=0|X;\theta ).$$

$${\mathcal{L}}_{wbce}=-\rho \sum _{j\in Y_{+}}\text{log Pr}(y_j=1|X;\theta )$$

$$-(1-\rho )\sum _{j\in Y_{-}}\text{log Pr}(y_j=0|X;\theta ).$$

$${\mathcal{L}}_{sc}=\sum _{\tilde{l}=1}^{\tilde{L}}{\lambda }_{\tilde{l}}||{\varphi }_{\tilde{l}}(Y;w)-{\varphi }_{\tilde{l}}(\hat{Y};w)|{|}_2,$$

$${\mathcal{L}}_{s1}=\{\begin{array}{rlr}& \frac{1}{2ϵ}||D|{|}_2^2+\frac{1}{2}ϵ,& ||D|{|}_1<ϵ\\ & ||D|{|}_1,& otherwise\end{array}$$

$$\mathcal{L}=\text{arg min}{\mathcal{L}}_{wbce}+\mu {\mathcal{L}}_{sc}+\gamma {\mathcal{L}}_{s1},$$

$$\text{Pr}(y_j=1|X;\theta ,w)=\frac{e^{z_1}}{e^{z_0}+e^{z_1}},$$

$$\text{Pr}(y_j=0|X;\theta ,w)=\frac{e^{z_0}}{e^{z_0}+e^{z_1}},$$

$$=\sigma ({\text{M}}^{fe}-{\text{M}}^{be})=max(0,{\text{M}}^{fe}-{\text{M}}^{be}),$$

Full text

I Introduction

Salient object detection (SOD) is a fundamental yet challenging task in computer vision. It aims to identify and locate distinctive objects or regions which attract human attention in natural images. In general, SOD is regarded as a prerequisite step to narrow down subsequent object-related vision tasks, such as sematic segmentation, visual tracking and person re-identification.

In the past two decades, a large number of SOD methods have been proposed. Most of them have been well summarized in [1]. According to these works, conventional SOD methods focus on extracting discriminative local and global handcrafted features from pixels or regions to represent their visual properties. With several heuristic priors such as center surrounding and visual contrast, these methods predict salient scores according to the extracted features for saliency detection. Although great success has been made, there still exist many important problems which need to be solved. For example, the low-level handcrafted features suffer from limited representation capability and robustness, and are difficult to capture the semantic and structural information of objects in images, which is very important for more accurate SOD. What’s more, to further extract powerful and robust visual features manually is a tough mission for performance improvement, especially in complex image scenes, such as cluttered backgrounds and low-contrast imaging patterns.

With the recent prevalence of deep architectures, many remarkable progresses have been achieved in a wide range of computer vision tasks, e.g., image classification, object detection and semantic segmentation. Thus, many researchers start to make their efforts to utilize deep convolutional neural networks (CNNs) for SOD and have achieved outstanding performance, since CNNs have strong ability to automatically extract high-level feature representations, successfully avoiding the drawbacks of handcrafted features. However, most of state-of-the-art SOD methods still require large-scale pre-trained CNNs, which usually employ the strided convolution and pooling operations. These downsampling methods largely increase the receptive field of CNNs, helping to extract high-level semantic features, nevertheless they inevitably drop the location information and fine details of objects, leading to unclear boundary predictions. Furthermore, the lack of structural supervision also makes SOD an extremely challenging problem in complex image scenes.

In order to utilize the semantic and structural information derived from deep pre-trained CNNs, in this paper we propose to solve both tasks of complementary feature extraction and saliency region classification with an unified framework which is learned in the end-to-end manner. More specifically, we design a novel symmetrical fully convolutional network (SFCN) architecture which consists of two sibling branches and one fusing branch. The two sibling branches take reciprocal image pairs as inputs and share weights for learning complementary visual features under the guidance of lossless feature reflection. The fusing branch integrates the multi-level complementary features in a hierarchical manner for SOD. More importantly, to effectively train our network, we propose a novel weighted loss function which incorporates rich structural information and supervises the three branches during the training process. In this manner, our proposed model can sufficiently capture the boundaries and spatial contexts of salient objects, hence significantly boosts the performance of SOD.

In summary, our contributions are three folds:

• •

We present a novel deep network architecture, i.e., SFCN, which is symmetrically designed to learn complementary visual features and predict accurate saliency maps under the guidance of lossless feature reflection.

• •

We propose a new structural loss function to learn clear object boundaries and spatially consistent saliency. This novel loss function is able to utilize the location, contextual and semantic information of salient objects to supervise the proposed SFCN for performance improvements.

• •

Extensive experimental results on seven public large-scale saliency benchmarks demonstrate that the proposed approach achieves superior performance and outperforms the very recent state-of-the-art methods by a large margin.

A preliminary version of this work appeared at IJCAI 2018 [2]. Compared to our previous work, this paper employs an analysis for our reflection method and extends our original adaptive batch normalization (AdaBN) into layer-wise AdaBN, which achieves better performance than original methods. Secondly, more related works are reviewed, especially for two-stream networks. We add more comparisons and discussions with respect to recent deep learning based SOD methods that came after our original paper. Moreover, more experiments are conducted to show the influence of different configurations.

II Related Work

In this section, we first briefly review existing deep learning based SOD methods. Then, we discuss the representative works on the intrinsic reflection of natural images and two-stream deep networks, which clarifies our main motivations.

Salient Object Detection.

Recent years, deep learning based methods have achieved solid performance improvements in SOD. For example, Wang et al. [3] integrate both local pixel estimation and global proposal search for SOD by training two deep neural networks. Zhao et al. [4] propose a multi-context deep CNN framework to benefit from the local context and global context of salient objects. Li et al. [5] employ multiple deep CNNs to extract multi-scale features for saliency prediction. Then they propose a deep contrast network to combine a pixel-level stream and segment-wise stream for saliency estimation [6]. Inspired by the great success of fully convolutional networks (FCNs) [7], Wang et al. [8] develop a recurrent FCN to incorporate saliency priors for more accurate saliency map inference. Liu et al. [9] also design a deep hierarchical network to learn a coarse global estimation and then refine the saliency map hierarchically and progressively. Then, Hou et al. [10] introduce dense short connections within the holistically-nested edge detection (HED) architecture [11] to get rich multi-scale features for SOD. Zhang et al. [12] propose a bidirectional learning framework to aggregate multi-level convolutional features for SOD. And they also develop a novel dropout to learn the deep uncertain convolutional features to enhance the robustness and accuracy of saliency detection [13]. To enhance the boundary information, Wang et al. [14] and Zhuge et al. [15] provide stage-wise refinement frameworks to gradually get accurate saliency detection results. Hu et al. [16] provide a deep level set framework to refine the saliency detection results. Luo et al. [17] integrate non-local deep features into global predictions for boundary refinements. Besides, Zhu et al. [18] formulate the saliency pattern detection by ranking structured trees. Zhang et al. [19] propose a bi-directional message passing model for saliency detection. Zhang et al. [20] propose a recurrent network with progressive attentions for regional locations. To speed up the inference of SOD, Zhang et al. [21] introduce a contextual attention module that can rapidly highlight most salient objects or regions with contextual pyramids. Wang et al. [22] propose to detect objects globally and refine them locally. Liu et al. [23] extend their previous work [9] with pixel-wise contextual attention.

Despite aforementioned approaches employ powerful CNNs and make remarkable success in SOD, there still exist some obvious problems. For example, the strategies of multi-stage training significantly reduces the efficiency for model deployment. And the explicit pixel-wise loss functions used by these methods for model training cannot well reflect the structural information of salient objects. Hence, there is still a large space for performance improvements in accurate SOD. While our model is trained in end-to-end manner and supervised by a structural loss. Thus, our model does not need any multi-stage training and complex post-processing.

Image Intrinsic Reflection.

Image intrinsic reflection is a classical topic in computer vision field [24, 25]. It can be used to segment and analyze surfaces with image color variations due to highlights and shading [25]. Most of existing intrinsic reflection methods are based on the Retinex model [24], which captures image information for Mondrian images: images of a planar canvas that is covered by samll patches of constant reflectance and illuminated by multiple light sources. Recent years, researchers have augmented the basic Retinex model with non-local texture cues [26] and image sparsity priors [27]. Sophisticated techniques that recover reflectance and shading along with a shape estimate have also been proposed [28]. Inspired by these works, we construct a reciprocal image pair based on the input image (see Section III. A). However, there are three obvious differences between our proposed method and previous intrinsic reflection methods:

1. the task objective is different. The aim of previous methods is explaining an input RGB image by estimating albedo and shading fields. Our aim is to learn complementary visual features for SOD.
2. the resulting image pair is different. Image intrinsic reflection methods usually factory an input RGB image into a reflectance image and a shading image. For every pixel, the reflectance image encodes the albedo of depicted surfaces, while the shading image encodes the incident illumination at corresponding points in the scene. In our proposed method, a reciprocal image pair, that captures the characteristics of planar reflection, is generated as the input of deep networks.
3. the source of reflection is different. The source of previous intrinsic reflection methods is the albedo of depicted surfaces, while our reflection is originated from deep features in CNNs. Therefore, our reflection is feature-level not image-level. In the experimental section, we will show that our method is very useful for SOD.

Two-stream Deep Networks.

Due to their power in exploring feature fusion, two-stream deep networks [30] have been popular in various multi-modal computer vision tasks, such as action recognition, face detection, person re-identification, etc. Our proposed SFCN is encouraged by their strengths. In two-stream deep networks, the information from different sources is typically combined with the input fusion, early fusion and late fusion stage at a specific fusion position. However, prior works using two-stream networks train both streams separately, which prevents the network from exploiting regularities between the two streams. To enhance such fusion, several multi-level ad-hoc fusion methods [31, 32] have also been introduced by considering the relationship between different scales and levels of deep features. Different from previous methods, we argue that dense fusion positions (shown in Fig.1) can be applied to the feature fusion problem to enhance the fusion process, while few works take this fact into account. Moreover, human vision system perceives a scene in a coarse-to-fine manner [33], which includes coarse understanding for identifying the location and shape of the target object, and fine capturing for exploring its detailed parts. Thus, in this paper we fuse the multi-scale features in a coarse-to-fine manner. Our fusion method ensures to highlight the salient objects from a global perspective and obtain clear object boundaries in a local view.

III The Proposed Approach

Fig. 1 illustrates the semantic overview of our proposed approach. In our method, we first convert an input RGB image into a reciprocal image pair, including the origin image (O-Input) and the reflection image (R-Input), by utilizing the ImageNet mean [34] and a pixel-wise negation operator. Then the image pair is fed into the sibling branches of our proposed SFCN, extracting multi-level deep features. Afterwards, the fusing branch hierarchically integrates the complementary features into the same resolution of input images. Finally, the saliency map is predicted by exploiting integrated features and the proposed structural loss. In the following subsections, we will elaborate the proposed SFCN architecture, weighted structural loss and saliency inference in detail.

III-A Symmetrical FCN

The proposed SFCN is an end-to-end fully convolutional network. It consists of three main branches with a paired reciprocal image input to achieve lossless feature reflection learning. We describe each of them as follows.

Reciprocal Image Input.

Essentially, computer vision system understands complex environments from planar perception. Image intrinsic reflection plays an important role in this perception process [35]. It aims to separate an observed image into a transmitted scene and a reflected scene. When two scenes are separated adequately, existing computer vision algorithms can better understand each scene since an interference of the other one is decreased. Motivated by the complementary of image reflection information [24], we first convert the given RGB image $X\in\mathbb{R}^{W\times H\times 3}$ into a reciprocal image pair by exploiting the following planar reflection function,

[TABLE]

where $k$ is a hyperparameter to control the reflection scale, $\phi$ is a content-persevering transform, and $M\in\mathbb{R}^{W\times H\times 3}$ is the mean of an image or image dataset. From above equations, one can see that the converted image pair, i.e., $X_{O}$ and $X^{k}_{R}$, is reciprocal with a reflection plane. In detail, the reflection scheme is a pixel-wise negation operator, allowing the given images to be reflected in both positive and negative directions while maintaining the same objects of images, as shown in Fig. 1. In the proposed reflection, we adopt the multiplicative operator $k$ to measure the reflection scale, but it is not the only feasible method. For example, this reflection can be combined with other non-linear operator $\phi$, such as quadratic form and exponential transform, to add more diversity. Besides, changing $k$ will result into different reflection planes. We perform ablation experiments to analyze the effects in Section IV. D. To reduce the computation burden, in this paper we mainly use the image planar reflection ($k=1$) and the mean of the ImageNet dataset [34], which is pre-computed from large-scale natural image datasets and well-known in current computer vision community.

Sibling Branches with Layer-wise AdaBN.

Based on the reciprocal image pair, we propose two sibling branches to extract complementary reflection features. More specifically, we follow the two-stream structure [30] and build each sibling branch based on the VGG-16 model [29]. Each sibling branch has 13 convolutional layers (kernel size = $3\times 3$, stride size = 1) and 4 max pooling layers (pooling size = $2\times 2$, stride = 2). To achieve the lossless reflection features, the two sibling branches are designed to share weights in each convolutional layer, but with an adaptive batch normalization (AdaBN). The main reason of AdaBN design is that after the reflection transform, the reciprocal images have different image domains. Domain related knowledge heavily affects the statistics of BN layers. In order to learn domain invariant features, it’s beneficial for each domain to keep its own BN statistics in each layer. For the implementation, we keep the weights of corresponding convolutional layers of the two sibling branches the same, while use different learnable BN operators between the convolution and ReLU operators [12].

Besides, both shallow layers and deep layers of CNNs are influenced by domain shift, thus domain adaptation by manipulating specific layer alone is not enough. Therefore, we extend the AdaBN [2, 37] to the layer-wise AdaBN, which computes the mean and variance in each corresponding layer from different domains. Fig. 2 shows the key difference between the regular BN [36] and our layer-wise AdaBN. The regular BN layer is originally designed to alleviate the issue of internal covariate shifting – a common problem when training a very deep neural network. It first standardizes each feature in a mini-batch, and then learns a common slope and bias for each mini-batch. Formally, given the input to a BN layer $X\in\mathbb{R}^{n\times d}$, where $n$ denotes the batch size, and $d$ is the feature dimension, the BN layer transforms the input into:

[TABLE]

where $x_{i}$ and $\bar{x}_{i}$ ($i\in{1,...,d}$) are the input/output scalars of one neuron response in one data sample; $X_{.i}$ denotes the $i$-th column of the input data; and $\alpha_{i}$ and $\beta_{i}$ are parameters to be learned. This transformation guarantees that the input distribution of each layer remains unchanged across different mini-batches. During the testing phase, the global statistics of all training samples is used to normalize every mini-batch of test data, as shown in Fig. 2 (a). Thus, there is a large domain shift for the testing, which may decrease the performance for the target domain. Different from the regular BN, we adopt different learnable BN operators between each convolution and ReLU operator [12] for each domain. The intuition behind our method is straightforward: The standardization of each layer by AdaBN ensures that each layer receives data from a similar distribution, no matter it comes from the source domain or the target domain. During training AdaBN, the domain-dependent statistics are jointly calculated from corresponding layers, which automatically capture the characteristic of different domains. During the testing phase, our layer-wise AdaBN can retain the statistics of different domains for all testing samples. Given two corresponding convolutional responses of the two sibling branches (treated as two independent domains, i.e., source domain and target domain), our layer-wise AdaBN algorithm is described in Algorithm 1. In practice, following previous work [37], we adopt an online algorithm to efficiently estimate the mean and variance.

Hierarchical Feature Fusion.

After extracting multi-level reflection features from the two sibling branches, we adhere an additional fusing branch to integrate them for the final saliency prediction. In order to preserve the spatial structure of input images and enhance the contextual information, we integrate the multi-level reflection features in a hierarchical manner. Formally, the fusing function is defined by

[TABLE]

where $h$ denotes the integration operator, which is a $1\times 1$ convolutional layer followed by a deconvolutional layer to ensure the same resolution. $[\cdot]$ is the concatenation operator in channel-wise. $g_{l}$ and $g^{*}_{l}$ are the reflection features of the $l$-th convolutional layer in the two sibling branches, respectively. We note that though the structures of $g_{l}$ and $g^{*}_{l}$ are exactly the same, the resulting reflection features are essentially different. The main reason is that they are extracted from different inputs and by using different statistics of AdaBN. As shown in the experimental section, they are very complementary for improving the saliency detection. We also find that there are other fusion methods, such as hierarchical recurrent convolutions [9], multi-level refinement [38] and progressive attention recurrent network [20]. These feature refinement modules can further improve the performances and are complementary to our work. However, they are more complex than ours. Our work mainly aims to learn lossless reflection features and incorporate the structural loss. So we keep the fusion module simple.

In the end of the fusion, we add a convolutional layer with two $3\times 3$ filters for the saliency prediction. The numbers of Fig. 1 illustrate the detailed filter setting in each convolutional layer. More details can be found in Section IV. B.

III-B Weighted Structural Loss

Given the SOD training dataset $S=\{(X_{n},Y_{n})\}^{N}_{n=1}$ with $N$ training pairs, where $X_{n}=\{x^{n}_{j},j=1,...,T\}$ and $Y_{n}=\{y^{n}_{j},j=1,...,T\}$ are the input image and the binary ground-truth image with $T$ pixels, respectively. $y^{n}_{j}=1$ denotes the foreground pixel and $y^{n}_{j}=0$ denotes the background pixel. For notional simplicity, we subsequently drop the subscript $n$ and consider each image independently. In most of existing deep learning based SOD methods, the loss function used to train the network is the standard pixel-wise binary cross-entropy (BCE) loss:

[TABLE]

where $\theta$ is the parameter of the network. Pr$(y_{j}=1|X;\theta)\in[0,1]$ is the confidence score of the network prediction that measures how likely the pixel belong to the foreground. $Y_{+}$ and $Y_{-}$ denote the foreground and background pixel set in an image, respectively.

However, for a typical natural image, the class distribution of salient/non-salient pixels is heavily imbalanced: most of the pixels in the ground truth are non-salient. To automatically balance the loss between positive/negative classes, we introduce a class-balancing weight $\rho$ on a per-pixel term basis, following [11, 12]. Specifically, we define the weighted binary cross-entropy (WBCE) loss function as,

[TABLE]

The loss weight $\rho=|Y_{+}|/|Y|$, and $|Y_{+}|$ and $|Y_{-}|$ denote the foreground and background pixel number, respectively.

For saliency detection, it is also crucial to preserve the overall spatial structure and semantic content. Thus, rather than only encouraging the pixels of the output prediction to match with the ground-truth using the above pixel-wise loss, we also minimize the differences between their multi-level features by a deep convolutional network [39]. The main intuition behind this operator is that minimizing the difference between multi-level features, which encode low-level fine details and high-level coarse semantics, helps to retain the spatial structure and semantic content of predictions. Formally, let $\phi_{\tilde{l}}$ denotes the output of the $\tilde{l}$-th convolutional layer in a CNN, our semantic content (SC) loss is defined as

[TABLE]

where $\hat{Y}$ is the overall prediction, $w$ is the parameter of a pre-trained CNN and $\lambda_{\tilde{l}}$ is the trade-off parameter, controlling the influence of the loss in the $\tilde{l}$-th layer. In our work, we use the light CNN-9 model [40] pre-trained on the ImageNet dataset as the semantic CNN. Each layer of the network will provide a cascade loss between the ground-truth and the prediction. More specifically, the semantic content loss feeds the prediction $\hat{Y}$ and ground truth $Y$ to the pre-trained CNN-9 model and compares the intermediate features. It’s believed that the cascade loss from the higher layers control the global structure; the loss from the lower layers control the local detail during training. We verify the loss with different layers of the light CNN-9 model for feature reconstruction loss by setting value of $\tilde{l}$ to one of 9. Besides, following [39], parameters of the CNN-9 model is fixed during the training. The cascade loss can provide the ability to measure the similarity between the ground-truth and the prediction under $\tilde{L}$ different scales and enhance the ability of the saliency classifier.

To overcome the blurry boundary problem [41], we also introduce an edge-persevering loss which encourages to keep the details of boundaries of salient objects. In fact, the edge-preserving $L_{1}$ loss is frequently used in low-level vision tasks such as image super-resolution, denoising and deblurring. However, the exact $L_{1}$ loss is not continuously differentiable, so we use the soomth $L_{1}$ loss, i.e., modified Huber Loss, for our task and ensure the gradient learning. Specifically, the smooth $L_{1}$ loss function is defined as

[TABLE]

where $D=Y-\hat{Y}$ and $\epsilon$ is a predefined threshold. We set $\epsilon=0.1$, following the practice in [42]. This training loss also helps to minimize pixel-level differences between the overall prediction and the ground-truth.

By taking all above loss functions together, we define our final loss function as

[TABLE]

where $\mu$ and $\gamma$ are hyperparameters to balance the specific terms. All the above losses are continuously differentiable, so we can use the standard stochastic gradient descent (SGD) method [43] to obtain the optimal parameters.

III-C Saliency Inference

For saliency inference, different from the methods used sigmoid classifiers in [9, 11], we use the following softmax classifier to evaluate the prediction scores:

[TABLE]

[TABLE]

where $z_{0}$ and $z_{1}$ are the score of each label of training data. In this way, the prediction of the SFCN is composed of a foreground excitation map ($\textbf{M}^{fe}$) and a background excitation map ($\textbf{M}^{be}$), as illustrated at the bottom of Fig. 1. We utilize $\textbf{M}^{fe}$ and $\textbf{M}^{be}$ to generate the final result. Formally, the final saliency map can be obtained by

[TABLE]

where $\sigma$ is the ReLU activation function for clipping the negative values. This strategy not only increases the pixel-level discrimination but also captures context contrast information.

IV Experimental Results

IV-A Datasets and Evaluation Metrics

To train our model, we adopt the MSRA10K [1] dataset, which has 10,000 training images with high quality pixel-wise saliency annotations. Most of images in this dataset have a single salient object. To combat overfitting, we augment this dataset by random cropping and mirror reflection [12, 2].

For the SOD performance evaluation, we adopt seven public saliency detection datasets described as follows: DUT-OMRON [44] dataset has 5,168 high quality natural images. Each image in this dataset has one or more objects with relatively complex image background. DUTS-TE dataset is the test set of currently largest saliency detection benchmark (DUTS) [45]. It contains 5,019 images with high quality pixel-wise annotations. ECSSD [46] dataset contains 1,000 natural images, in which many semantically meaningful and complex structures are included. HKU-IS-TE [5] dataset has 1,447 images with pixel-wise annotations. Images of this dataset are well chosen to include multiple disconnected objects or objects touching the image boundary. PASCAL-S [47] dataset is generated from the PASCAL VOC [48] dataset and contains 850 natural images with segmentation-based masks. SED [49] dataset has two non-overlapped subsets, i.e., SED1 and SED2. SED1 has 100 images each containing only one salient object, while SED2 has 100 images each containing two salient objects. SOD [50] dataset has 300 images, in which many images contain multiple objects either with low contrast or touching the image boundary.

To evaluate our method with other algorithms, we follow the works in [12, 13, 2] and use four main metrics as the standard evaluation score (with typical parameter settings), including the widely used precision-recall (PR) curves, F-measure ($\eta=0.3$), mean absolute error (MAE) and S-measure ($\lambda=0.5$). More details can be found in [1, 51].

IV-B Implementation Details

We implement our proposed model based on the public Caffe toolbox [52] with the MATLAB 2016 platform. We train and test our method in a quad-core PC machine with an NVIDIA GeForce GTX 1070 GPU (with 8G memory) and an i5-6600 CPU. We perform training with the augmented training images from the MSRA10K dataset. Following [12, 13], we do not use validation set and train the model until its training loss converges. The input image from different datasets is uniformly resized into $384\times 384\times 3$ pixels. Then we perform the reflection transform by subtracting the ImageNet mean [34]. The weights of two sibling branches are initialized from the VGG-16 model [29]. For the fusing branch, we initialize the weights by the “msra” method [53]. For the hyper-parameters ($\lambda_{\tilde{l}}$, $\mu$, $\gamma$), we mainly following the practice in previous works [39, 54]. The authors in [39] proved that setting equal $\lambda_{\tilde{l}}=1$ can capture better results to utilize the multi-level semantic features. We also adopt this setting and observe the same fact. Besides, we follow [54] to adopt $\mu=0.01$ and $\gamma=20$. We optimize the final loss function for our experiments without further tuning. Indeed, better hyper-parameters can further improve the performances. During the training, we use standard SGD method [43] with a batch size 12, momentum 0.9 and weight decay 0.0005. We set the base learning rate to 1e*-8* and decrease the learning rate by 10% when training loss reaches a flat. The training process converges after 150k iterations. When testing, our proposed SOD algorithm runs at about 12 fps. The source code is made publicly available at http://ice.dlut.edu.cn/lu/.

IV-C Comparison with the State-of-the-arts

To fully evaluate the detection performance, we compare our proposed method with other 22 state-of-the-art ones, including 18 deep learning based algorithms (AMU [12], BDMP [19], DCL [6], DGRL [22], DHS [9], DS [41], DSS [10], ELD [55], LEGS [3], MCDL [4], MDF [5], NLDF [17], PAGRN [20], PICA [23], RFCN [8], RST [18], SRM [14], UCF [13]) and 4 conventional algorithms (BL [56], BSCA [57], DRFI [50], DSR [58]). For fair comparison, we use either the implementations with recommended parameter settings or the saliency maps provided by the authors.

Quantitative Evaluation.

As illustrated in Tab. I, Tab. II and Fig. 3, our method outperforms other competing ones across all datasets in terms of near all evaluation metrics. From these results, we have other notable observations: (1) deep learning based methods consistently outperform traditional methods with a large margin, which further proves the superiority of deep features for SOD. (2) our method achieves higher S-measure than other methods, especially on complex structure datasets, e.g., the HKU-IS-TE, PASCAL-S, SED and SOD datasets. We attribute this impressive result to our structural loss. (3) without segmentation-based pre-training, our method only fine-tuned from the image classification model still achieves better results than the DCL, DS, DSS, and RFCN. (4) compared to the very recent BDMP, DGRL, DSS and PAGRN, our method is inferior on the DUT-OMRON and DUTS-TE datasets. However, our method ranks in the second place and is still very comparable. We note that BDMP, DGRL and PAGRN are trained with the DUTS training dataset. Thus, it is no wonder they can achieve better performance than other methods. (5) in contrast to our previous work [2], our enhanced method achieves much better performance.

Tab. III shows a comparison of running times. As it can be seen, our method is much faster than most of compared methods. The testing process only costs 0.08s for each image.

Qualitative Evaluation.

Fig. 4 provides several examples in various challenging cases, where our method outperforms other compared methods. For example, the images in the first two columns are of very low contrast between the objects and backgrounds. Most of the compared methods fail to capture the whole salient objects, while our method successfully highlights them with sharper edges preserved. For multiple salient objects (the 3-4 columns), our method still generates more accurate saliency maps. The images in the 5-6 columns are challenging with complex structures or salient objects near the image boundary. Most of the compared methods can not predict the whole objects, while our method captures the whole salient regions with preserved structures. Fig. 5 shows some failure examples of the proposed method. For example, when the salient objects are hard to define (the first three rows), the proposed method detect the backgrounds as salient objects. While in this case the human visual system can also easily focus on the ambiguous objects. When the salient objects have very large disconnected regions (the 4-5 rows), the proposed method cannot assign different values to them and distinguish them. When the salient objects are very small and have similar colors with backgrounds (the last row), it is difficult to correctly detect them with our method. The other deep learning based approaches almost also fail to detect the salient objects.

IV-D Ablation Analysis

We also conduct experiments to evaluate the main components of our model. All models in this subsection are trained on the augmented MSRA10K dataset and share the same hyper-parameters described in Section IV. B. Due to the limitation of space, we only show the results on the ECSSD dataset. Other datasets have the similar performance trend. For these experiments, if not specified, we use AdaBN [2] to erase the effect of layer-wise AdaBN.

Effect of Complementary Inputs.

Our proposed model takes paired images as inputs for complementary information. One may be curious about the performance only with one input, for example, O-Input or R-Input (no paired input given). With only one input, our model reduces to a plain multi-level feature fusion model. Tab. IV shows the results with different input settings. From the experimental results, we observe that 1) only with the O-Input (R-Input), our model achieves 0.844 (0.845), 0.102 (0.100) and 0.879 (0.880) in terms of the F-measure, MAE and S-measure metrics on the ECSSD dataset. These results are very comparable with other state-of-the-art methods and much better than the raw RGB image input. This indicates that our feature fusion model is very effective. 2) with paired reciprocal inputs, our model achieves about 4% performance leap of F-measure, around 2.5% improvement of S-measure, as well as around 50% decrease in MAE compared with only one input. To show that the extra model complexity is not the reason of improvements, we also perform an experiment in which RGB and YCbCr images are input into our framework (everything else remains the same). The paired RGB+YCbCr input can achieve much better performance than raw RGB, and a little better performance than the O-Input or R-Input. The main reason may be the introduction of additional YCbCr information. Obviously, our reflection features achieve better performance than the one of RGB+YCbCr in all metrics. From these results, we can see that even the O-Input and R-Input are simple reciprocal in planar reflection, the complementary effect is very expressive. We attribute this improvement to the lossless feature learning.

Effect of Adopted Means.

As described in the “Reciprocal Image Input” part, the mean is not unique and the main reason we chose the mean of ImageNet is reducing the computation burden. To verify the effect of different means, we also perform experiments with typical means in dataset-level (trained MSRA10K) or image-level (Each Image Mean, Middle Mean and Zero Mean). The middle mean is set to (128, 128, 128). Experimental results are shown in Tab. V. With the pre-computed mean of the MSRA10K dataset, our model shows a little performance decrease compared with using the ImageNet mean. The main reason may be that the model is initialized from the pre-trained model on the ImageNet classification task. With the same mean subtraction, the model can minimize the transfer learning gap between the image classification and saliency detection tasks. With the mean of each input image, we find that it is still feasible to train our model. The results are still comparable. For example, we got 0.875 (F-measure), 0.054 (MAE) and 0.886 (S-measure) on the ECSSD dataset. However, because we need to compute the mean of each input image online, the training is relatively slow and slightly unstable. With the middle mean, the model achieves worse results. For the zero mean, the model achieves similar results with the middle mean. However, the training time is reduced because there is no need to compute and subtract the mean online. Besides, compared to the results of O-Input/R-Input in Tab. IV (using the ImageNet mean), the O-Input+R-Input can bring about 0.035 improvement of F-measure. Zero mean brings about 0.070 improvement to raw RGB image input in Tab. IV. Meanwhile, using O-Input+R-Input and ImageNet mean can bring about 0.078 improvement to raw RGB image input. For the performance improvements, the main reason is that the paired inputs can capture more information than single input.

Effect of Changing the Reflection Parameter.

In the proposed reflection, we adopt the multiplicative operator $k$ to measure the reflection scale. Changing the reflection parameter $k$ will result into different reflection planes. Tab. VI shows experimental results with different values of $k$ on the ECSSD dataset. When enlarging $k>1$, our model makes improvement on performance. However, the improvement is rather small and is reasonable. In fact, enlarging $k$ only changes the range of reflection images. After the AdaBN, the impact of value range of reflection images decreased significantly, resulting to the similar performance. Besides, when adopting negative values of $k$, the performance has almost no improvement. The reason is obvious. When using negative values of $k$, the two sibling branches essentially take the same input $X-M$ (even scaled), as shown in Equ. 1. The complementary of the paired input is very limited. These results further prove that the feature reflection is the core of performance improvements.

Effect of Hierarchical Fusion.

The results in Tab. VII show the effect of hierarchical fusion module. We can see that the SFCN only using the channel concatenation operator without hierarchical fusion (model (a)) has achieved comparable performance to most deep learning based methods. This further confirms the effectiveness of learned reflection features. With the hierarchical fusion, the resulting SFCN (model (e)) improves the performance by about 2% leap. The main reason is that the fusion method introduces more contextual information from high layers to low layers, which helps to locate the salient objects with large receptive fields. We also try to use summation for fusing the reflection information. We found that the resulting model can reduce the feature dimensionality and parameters. Besides, the model converges faster than our proposed SFCN. However, the performance decreases too much. For example, the F-measure of the ECSSD dataset decreases from 0.848 to 0757. The main reason may be that summing the features weakens interaction or fusion, leading to the degeneration problem. With concatenation, the features are still kept and can be recaptured for the robust prediction.

Effect of Diverse Losses.

The proposed weighted structural loss also plays a key role in our model. Tab. VII shows the effect of different losses. Because the essential imbalance of salient/no-salient classes, it’s no wonder that training with the class-weighted loss $\mathcal{L}_{wbce}$ (model (b) and model (f)) achieves better results than the plain cross-entropy loss $\mathcal{L}_{bce}$ (model (a) and model (e)), about 2% improvement in three main evaluation metrics. With other two losses $\mathcal{L}_{sc}$ and $\mathcal{L}_{s1}$, the model achieves better performance in terms of MAE and S-measure. Specifically, the semantic content loss $\mathcal{L}_{sc}$ improves the S-measure with a large margin. Thus, our model can capture spatially consistent saliency maps. The edge-preserving loss $\mathcal{L}_{s1}$ significantly decreases the MAE, providing clear object boundaries. These results demonstrate that individual loss components complement each other. When taking them together, the overall model, i.e., SFCN+$\mathcal{L}_{wbce}$+$\mathcal{L}_{sc}$+$\mathcal{L}_{s1}$, achieves best results in all evaluation metrics. In addition, our model can be trained with these losses in the end-to-end manner. This advantage makes our saliency inference more efficient, without any bells and whistles, such as result fusing [3, 41, 12] and condition random field (CRF) post-processing [6, 8]. For better understanding, we also provide several visual comparisons with different losses in Fig. 6.

Effect of Sharing Weights.

To achieve the lossless reflection features, the two sibling branches of our SFCN are designed to share weights in each convolutional layer. In order to verify the effect of sharing weights, we also perform experiments with models of independently learnable weights. Note that if the SFCN doesn’t share weights between two sibling branches, it has about $2\times$ parameters. To some extent, the model is over-fitting. We find the performance decreases. The results are shown in Tab. VIII. From the results, we can see that with shared weights the model can significantly improve the performance. Thus, it is beneficial for each branch to share weights and keep its own BN statistics in each layer.

Effect of Layer-wise AdaBN.

In our SFCN, we adopt layer-wise AdaBN operators in each convolutional layer for capturing each domain statistic. The results in Tab. I and Tab. II show that our proposed layer-wise AdaBN generally outperforms our previous plain AdaBN [2]. To further verify the effectiveness, we replace the proposed layer-wise AdaBN with the regular BN [36] in our SFCN model. Tab. IX shows that when adopting the regular BN, the performance decreases significantly when testing. As described in Section III. A, the main reason is that there is a large domain shift for the testing in the different domain. Besides, the size of minibatch also affects our proposed layer-wise AdaBN and regular BN. For comparison, we have also tried to use different batch size, e.g., 1, 2, 4, 8, 12, 16, 20, 24, etc. We find that 1) with the small batch size ($<4$), the training is unstable and the performance of our model may decrease; 2) with the relatively large batch size ($>=$16), the influence of batch size is very limited to performance, and larger batch size will cost more computation resources. Thus, we adopt the batch size of 12 to achieve both effectiveness and efficiency.

V Conclusion

In this work, we propose a novel end-to-end feature learning framework for salient object detection. Our method devises a symmetrical FCN to learn complementary visual features under the guidance of lossless feature reflection. The proposed symmetrical FCN architecture contains three branches. Two of the branches are used to generate the features of the paired reciprocal images, and the other is adopted for hierarchical feature fusion. For training, we also propose a new weighted structural loss that integrates the location, semantic and contextual information of salient objects. Thus, the new structural loss function can lead to clear object boundaries and spatially consistent saliency to boost the detection performance. Extensive experiments on seven large-scale saliency datasets demonstrate that the proposed method achieves significant improvement over the baseline and performs better than other state-of-the-art methods.