Bilateral Cyclic Constraint and Adaptive Regularization for Unsupervised Monocular Depth Prediction

TL;DR

This paper introduces a novel unsupervised monocular depth prediction method using stereo imagery, bilateral cyclic constraints, and adaptive regularization, achieving state-of-the-art results on KITTI and good generalization to other datasets.

Contribution

It proposes a new objective leveraging bilateral cyclic relationships and adaptive regularization to improve unsupervised depth estimation from a single image.

Findings

Outperforms state-of-the-art on KITTI benchmarks

Generalizes well to Make3d dataset

Effectively handles occluded and co-visible regions

Abstract

Supervised learning methods to infer (hypothesize) depth of a scene from a single image require costly per-pixel ground-truth. We follow a geometric approach that exploits abundant stereo imagery to learn a model to hypothesize scene structure without direct supervision. Although we train a network with stereo pairs, we only require a single image at test time to hypothesize disparity or depth. We propose a novel objective function that exploits the bilateral cyclic relationship between the left and right disparities and we introduce an adaptive regularization scheme that allows the network to handle both the co-visible and occluded regions in a stereo pair. This process ultimately produces a model to generate hypotheses for the 3-dimensional structure of the scene as viewed in a single image. When used to generate a single (most probable) estimate of depth, our method outperforms state-of-the-art unsupervised monocular depth prediction methods on the KITTI benchmarks. We show that our method generalizes well by applying our models trained on KITTI to the Make3d dataset.

Figures

Tables

Table 1. Table 1: Error and accuracy metrics. z ​ ( x ) 𝑧 𝑥 z(x) is the predicted depth at x ∈ Ω 𝑥 Ω x\in\Omega and z gt ​ ( x ) subscript 𝑧 gt 𝑥 z_{\text{gt}}(x) is the corresponding ground truth. Three different thresholds ( 1.25 , 1.25 2 1.25 superscript 1.25 2 1.25,1.25^{2} and 1.25 3 superscript 1.25 3 1.25^{3} ) are used in the accuracy metric as a convention in the literature.

Metric	Definition
AbsRel	$\frac{1}{\left|\Omega \right|}\sum _{x\in \Omega }\frac{\left|z\left(x\right)-z_{\text{gt}}\left(x\right)\right|}{z_{\text{gt}}\left(x\right)}$
SqRel	$\frac{1}{\left|\Omega \right|}\sum _{x\in \Omega }\frac{{\left|z\left(x\right)-z_{\text{gt}}\left(x\right)\right|}^2}{z_{\text{gt}}\left(x\right)}$
RMS	$\sqrt{\frac{1}{\left|\Omega \right|}\sum _{x\in \Omega }{\left|z\left(x\right)-z_{\text{gt}}\left(x\right)\right|}^2}$
logRMS	$\sqrt{\frac{1}{\left|\Omega \right|}\sum _{x\in \Omega }{\left|\log z\left(x\right)-\log z_{\text{gt}}\left(x\right)\right|}^2}$
${\log }_{10}$	$\frac{1}{\left|\Omega \right|}\sum _{x\in \Omega }\left|\log z\left(x\right)-\log z_{\text{gt}}\left(x\right)\right|$
Accuracy	% of $z\left(x\right)$ s.t.

Table 2. Table 2: Quantitative results 1 1 {}^{\ref{eval_metrics}} on the KITTI [ 13 ] Eigen split [ 6 ] benchmark. Depths are capped at 50 and 80 meters. K denotes training on KITTI. CS+K denotes pretraining on Cityscape [ 4 ] and fine-tuning on KITTI. Our full model using a generic encoder-decoder consistently outperforms other methods in all metrics across both depth caps with the exception of δ < 1.25 3 𝛿 superscript 1.25 3 \delta<1.25^{3} where [ 53 ] , which used temporal information (sequences of stereo-pairs), marginally beats our us by 0.1%. Our proposed decoder (*) improves over our encoder-decoder model across all metrics and is the state-of-the-art.

			Error Metrics				Accuracy Metrics
Method	Dataset	Cap	AbsRel	SqRel	RMS	logRMS
Zhou et al. [54]	K	80m	0.208	1.768	6.856	0.283	0.678	0.885	0.957
Mahjourian et al. [33]	K	80m	0.163	1.240	6.220	0.250	0.762	0.916	0.968
Garg et al. [12]	K	80m	0.152	1.226	5.849	0.246	0.784	0.921	0.967
Godard et al. [14]	K	80m	0.148	1.344	5.927	0.247	0.803	0.922	0.964
Zhan et al. [53] (w/ video)	K	80m	0.144	1.391	5.869	0.241	0.803	0.928	0.969
Ours (Full Model)	K	80m	0.135	1.157	5.556	0.234	0.820	0.932	0.968
Ours (Full Model)*	K	80m	0.133	1.126	5.515	0.231	0.826	0.934	0.969
Zhou et al. [54]	CS+K	80m	0.198	1.836	6.565	0.275	0.718	0.901	0.960
Mahjourian et al. [33]	CS+K	80m	0.159	1.231	5.912	0.243	0.784	0.923	0.970
Godard et al. [14]	CS+K	80m	0.124	1.076	5.311	0.219	0.847	0.942	0.973
Ours (Full Model)*	CS+K	80m	0.118	0.996	5.134	0.215	0.849	0.945	0.975
Zhou et al. [54]	K	50m	0.201	1.391	5.181	0.264	0.696	0.900	0.966
Garg et al. [12]	K	50m	0.169	1.080	5.104	0.273	0.740	0.904	0.962
Godard et al. [14]	K	50m	0.140	0.976	4.471	0.232	0.818	0.931	0.969
Zhan et al. [53] (w/ video)	K	50m	0.135	0.905	4.366	0.225	0.818	0.937	0.973
Ours (Full Model)	K	50m	0.128	0.856	4.201	0.220	0.835	0.939	0.972
Ours (Full Model)*	K	50m	0.126	0.832	4.172	0.217	0.840	0.941	0.973

Table 3. Table 3: Quantitative comparison 1 1 {}^{\ref{eval_metrics}} amongst variants of our model on KITTI 2015 split proposed by [ 14 ] . Each variant is named according to its loss function. p ​ h 𝑝 ℎ ph and s ​ t 𝑠 𝑡 st denote data terms, s ​ m 𝑠 𝑚 sm local smoothness, α 𝛼 \alpha our adaptive weights, λ G superscript 𝜆 𝐺 \lambda^{G} image gradients [ 14 ] , λ L superscript 𝜆 𝐿 \lambda^{L} image Laplacian, l ​ r 𝑙 𝑟 lr left-right consistency [ 14 ] , and b ​ c 𝑏 𝑐 bc our bilateral cyclic consistency. We show the effectiveness of our adaptive regularization (Sec. 3.3 ) by applying it to [ 14 ] and improving their model. Our full model using a generic encoder-decoder outperforms all variants on every metric, including [ 2 ] which predicts disparities that generate photo-realistic images. Our full model using our proposed two-branch decoder (*) further improves the state-of-the-art.

	Error Metrics					Accuracy Metrics
Method	AbsRel	SqRel	RMS	logRMS	D1-all
[14] w/ Deep3D [49]	0.412	16.37	13.693	0.512	66.850	0.690	0.833	0.891
[14] w/ Deep3Ds [49]	0.151	1.312	6.344	0.239	59.640	0.781	0.931	0.976
$ph+st+{\lambda }^{G}sm$ ([14] w/o Left-Right Consistency)	0.123	1.417	6.315	0.220	30.318	0.841	0.937	0.973
$ph+st+{\lambda }^{G}sm+lr$ [14]	0.124	1.388	6.125	0.217	30.272	0.841	0.936	0.975
$ph+st+\alpha {\lambda }^{G}sm+\alpha lr$ ([14] w/ Our Adaptive Regularization)	0.120	1.367	6.013	0.211	30.132	0.849	0.942	0.975
Aleotti et al. [2]	0.119	1.239	5.998	0.212	29.864	0.846	0.940	0.976
$ph+st+{\lambda }^{L}sm+bc$ (Ours w/o Adaptive Regularization)	0.117	1.264	5.874	0.207	29.793	0.851	0.944	0.977
$ph+st+\alpha {\lambda }^{L}sm+\alpha lr$ (Ours w/o Bilateral Cyclic Consistency)	0.117	1.251	5.876	0.206	29.536	0.851	0.944	0.977
$ph+st+\alpha {\lambda }^{G}sm+\alpha bc$ (Ours w/o Bidirectional Edge-Awareness)	0.115	1.211	5.743	0.203	28.942	0.852	0.945	0.977
$ph+st+\alpha {\lambda }^{L}sm+\alpha bc$ (Ours Full Model)	0.114	1.172	5.651	0.202	28.142	0.855	0.947	0.979
$ph+st+\alpha {\lambda }^{L}sm+\alpha bc$ * (Ours Full Model w/ 2 Branch Decoder)	0.110	1.119	5.576	0.200	27.149	0.856	0.947	0.980

Table 4. Table 4: Ablation study on the KITTI Eigen split [ 12 ] . We compare each variant of our model to the top performing methods in the monocular depth prediction task. Our full model using a generic single-branch decoder consistently outperforms the best previous methods [ 14 , 53 ] in all metrics across both depth caps. Each of our partial models improves over the baseline [ 14 ] consistently across all metrics and depth caps. In fact, our model without using our bidirectionally informed edge-awareness is already able to exceed the performance of [ 53 ] on most metrics, despite not using temporal knowledge and multiple networks as [ 53 ] did, with the exception of δ < 1.25 3 𝛿 superscript 1.25 3 \delta<1.25^{3} , where [ 53 ] marginally beat us by approximately 0.1%. Our full model using our two-branch decoder (marked by *) outperforms all variants across all metrics and depth caps and is the state-of-the-art. We show the relative percentage boost in performance in all metrics in the two rows following the results of our full model using a single-branch decoder and our full model using a two-branch decoder(*).

	Error Metrics				Accuracy Metrics
Method	AbsRel	SqRel	RMS	logRMS
	80 Meter Depth Cap
$ph+st+{\lambda }^{G}sm+lr$ (Godard et al. [14])	0.148	1.344	5.927	0.247	0.803	0.922	0.964
Zhan et al. [53] (w/ video)	0.144	1.391	5.869	0.241	0.803	0.928	0.969
$ph+st+\alpha {\lambda }^{G}sm+\alpha lr$ ([14] w/ Our Adaptive Regularization)	0.145	1.302	5.790	0.245	0.807	0.923	0.965
$ph+st+{\lambda }^{L}sm+bc$ (Ours w/o Adaptive Regularization)	0.141	1.266	5.761	0.241	0.811	0.925	0.965
$ph+st+\alpha {\lambda }^{L}sm+\alpha lr$ (Ours w/o Bilateral Cyclic Consistency)	0.140	1.290	5.746	0.238	0.817	0.929	0.967
$ph+st+\alpha {\lambda }^{G}sm+\alpha bc$ (Ours w/o Bidirectional Edge-Awareness)	0.138	1.191	5.637	0.237	0.817	0.929	0.967
$ph+st+\alpha {\lambda }^{L}sm+\alpha bc$ (Ours Full Model)	0.135	1.157	5.556	0.234	0.820	0.932	0.968
Ours (Full Model) % Improvement over [14]	8.8%	13.9%	6.3%	5.3%	2.1%	1.1%	0.4%
Ours (Full Model) % Improvement over [53]	6.3%	16.8%	5.3%	2.9%	2.1%	0.4%	0.1%
$ph+st+\alpha {\lambda }^{L}sm+\alpha bc$ * (Ours Full Model w/ 2 Branch Decoder)	0.133	1.126	5.515	0.231	0.826	0.934	0.969
Ours (Full Model)* % Improvement over [14]	10.1%	16.2%	7.0%	6.5%	2.9%	1.3%	0.5%
Ours (Full Model)* % Improvement over [53]	7.6%	19.1%	6.0%	4.1%	2.9%	0.6%	0.0%
	50 Meter Depth Cap
$ph+st+{\lambda }^{G}sm+lr$ (Godard et al. [14])	0.140	0.976	4.471	0.232	0.818	0.931	0.969
Zhan et al. [53] (w/ video)	0.135	0.905	4.366	0.225	0.818	0.937	0.973
$ph+st+\alpha {\lambda }^{G}sm+\alpha lr$ ([14] w/ Our Adaptive Regularization)	0.138	0.957	4.417	0.230	0.824	0.933	0.970
$ph+st+{\lambda }^{L}sm+bc$ (Ours w/o Adaptive Regularization)	0.134	0.944	4.389	0.227	0.825	0.934	0.969
$ph+st+\alpha {\lambda }^{L}sm+\alpha lr$ (Ours w/o Bilateral Cyclic Consistency)	0.133	0.942	4.351	0.224	0.832	0.937	0.971
$ph+st+\alpha {\lambda }^{G}sm+\alpha bc$ (Ours w/o Bidirectional Edge-Awareness)	0.131	0.881	4.265	0.224	0.832	0.937	0.971
$ph+st+\alpha {\lambda }^{L}sm+\alpha bc$ (Ours Full Model)	0.128	0.856	4.201	0.220	0.835	0.939	0.972
Ours (Full Model) % Improvement over [14]	8.6%	12.3%	6.0%	5.2%	2.1%	0.9%	0.3%
Ours (Full Model) % Improvement over [53]	5.2%	5.4%	3.8%	2.2%	2.1%	0.2%	0.1%
$ph+st+\alpha {\lambda }^{L}sm+\alpha bc$ * (Ours Full Model w/ 2 Branch Decoder)	0.126	0.832	4.172	0.217	0.840	0.941	0.973
Ours (Full Model)* % Improvement over [14]	10.0%	14.7%	6.7%	6.5%	2.7%	1.1%	0.4%
Ours (Full Model)* % Improvement over [53]	6.7%	8.1%	4.4%	3.6%	2.7%	0.4%	0.0%

Table 5. Table 5: Our network architecture follows that of [ 14 ] and [ 34 ] and we are able to outperform the baseline [ 14 ] . “in” and “out” refers to the input and output channels and downscale factor due to striding for each layer. ∥ ∥ \| refers to the concatenation of multiple layers. ∗ * refers to up-sampling disparity predictions at a given resolution. Batch normalization was not used.

	kernel		channels		downscale
layer	size	stride	in	out	in	out	input
Encoder
conv1	7	2	3	32	1	2	left
conv1b	7	1	32	32	2	2	conv1
conv2	5	2	32	64	2	4	conv1b
conv2b	5	1	64	64	4	4	conv2
conv3	3	2	64	128	4	8	conv2b
conv3b	3	1	128	128	8	8	conv3
conv4	3	2	128	256	8	16	conv3b
conv4b	3	1	256	256	16	16	conv4
conv5	3	2	256	512	16	32	conv4b
conv5b	3	1	512	512	32	32	conv5
conv6	3	2	512	512	32	64	conv5b
conv6b	3	1	512	512	64	64	conv6
conv7	3	2	512	512	64	128	conv6b
conv7b	3	1	512	512	128	128	conv7
Decoder
upconv7	3	2	512	512	128	64	conv7b
iconv7	3	1	1024	512	64	64	upconv7$\parallel$conv6b
upconv6	3	2	512	512	64	32	iconv7
iconv6	3	1	1024	512	32	32	upconv6$\parallel$conv5b
upconv5	3	2	512	256	32	16	iconv6
iconv5	3	1	512	256	16	16	upconv5$\parallel$conv4b
upconv4	3	2	256	128	16	8	iconv5
iconv4	3	1	128	128	8	8	upconv4$\parallel$conv3b
disp4	3	1	128	2	8	8	iconv4
upconv3	3	2	128	64	8	4	iconv4
iconv3	3	1	130	64	4	4	upconv3$\parallel$conv2b$\parallel$disp4*
disp3	3	1	64	2	4	4	iconv3
upconv2	3	2	64	32	4	2	iconv3
iconv2	3	1	66	32	2	2	upconv2$\parallel$conv1b$\parallel$disp3*
disp2	3	1	32	2	2	2	iconv2
upconv1	3	2	32	16	2	1	iconv2
iconv1	3	1	18	16	1	1	upconv1$\parallel$disp2*
disp1	3	1	16	2	1	1	iconv1

Table 6. Table 6: Our proposed network architecture, which achieves state-of-the-art. “in” and “out” refers to the input and output channels and downscale factor due to striding for each layer. ∥ ∥ \| refers to the concatenation of multiple layers. ∗ * refers to up-sampling disparity predictions at a given resolution. The branch prefixed with ‘ i ’ makes the initial prediction and the branch prefixed with ‘ r ’ makes the final prediction.

	kernel		channels		downscale
layer	size	stride	in	out	in	out	input
Encoder
conv0	7	1	3	32	1	1	left
conv1	7	2	32	32	1	2	conv0
conv1b	7	1	32	32	2	2	conv1
conv2	5	2	32	64	2	4	conv1b
conv2b	5	1	64	64	4	4	conv2
conv3	3	2	64	128	4	8	conv2b
conv3b	3	1	128	128	8	8	conv3
conv4	3	2	128	256	8	16	conv3b
conv4b	3	1	256	256	16	16	conv4
conv5	3	2	256	512	16	32	conv4b
conv5b	3	1	512	512	32	32	conv5
conv6	3	2	512	512	32	64	conv5b
conv6b	3	1	512	512	64	64	conv6

	kernel		channels		downscale
layer	size	stride	in	out	in	out	input
Decoder
iupconv6	3	2	512	512	64	32	conv6b
iconv6	3	1	1024	512	32	32	iupconv6$\parallel$conv5b
iupconv5	3	2	512	256	32	16	iconv6
iconv5	3	1	512	256	16	16	iupconv5$\parallel$conv4b
iupconv4	3	2	256	128	16	8	iconv5
iconv4	3	1	256	128	8	8	iupconv4$\parallel$conv3b
idisp4	3	1	128	2	8	8	iconv4
sconv4	3	1	128	128	8	8	conv3b
sconv4b	3	1	128	128	8	8	sconv4
rskip4	3	1	128	128	8	8	conv3b+sconv4b
rconv4	3	1	258	128	8	8	iconv4$\parallel$idisp4$\parallel$rskip4
rdisp4	3	1	128	2	8	8	rconv4
iupconv3	3	2	128	64	8	4	iconv4
iconv3	3	1	130	64	4	4	iupconv3$\parallel$conv2b$\parallel$idisp4*
idisp3	3	1	64	2	4	4	iconv3
sconv3	3	1	64	64	4	4	conv2b
sconv3b	3	1	64	64	4	4	sconv3
rskip3	3	1	64	64	4	4	conv2b+sconv3b
rupconv3	3	2	128	64	8	4	rconv4
rconv3	3	1	196	64	4	4	iconv3$\parallel$idisp3$\parallel$rupconv3$\parallel$rskip3$\parallel$rdisp4*
rdisp3	3	1	64	2	4	4	rconv3
iupconv2	3	2	64	32	4	2	iconv3
iconv2	3	1	66	32	2	2	iupconv2$\parallel$conv1b$\parallel$idisp3*
idisp2	3	1	32	2	2	2	iconv2
sconv2	3	1	32	32	2	2	conv1b
sconv2b	3	1	32	32	2	2	sconv2
rskip2	3	1	32	32	2	2	conv1b+sconv2b
rupconv2	3	2	64	32	4	2	rconv3
rconv2	3	1	100	32	2	2	iconv2$\parallel$idisp2$\parallel$rupconv2$\parallel$rskip2$\parallel$rdisp3*
rdisp2	3	1	32	2	2	2	rconv2
iupconv1	3	2	32	16	2	1	iconv2
iconv1	3	1	18	16	1	1	iupconv1$\parallel$idisp2*
idisp1	3	1	16	2	1	1	iconv1
sconv1	3	1	32	32	1	1	conv0
sconv1b	3	1	32	32	1	1	sconv1
rskip1	3	1	32	32	1	1	conv0+sconv1b
rupconv1	3	2	64	32	2	1	rconv2
rconv1	3	1	68	16	1	1	iconv1$\parallel$idisp1$\parallel$rupconv1$\parallel$rskip1$\parallel$rdisp2*
rdisp1	5	1	16	2	1	1	rconv1

Equations

$$L=\underset{\text{data fidelity}}{\underbrace{w_{ph}{l}_{ph}+w_{st}{l}_{st}}}+\underset{\text{regularization}}{\underbrace{w_{sm}{l}_{sm}+w_{bc}{l}_{bc}}}$$

$${\hat{I}}^0(x)=I^1(x-d^0(x))\text{ and }{\hat{I}}^1(x)=I^0(x+d^1(x))$$

$$l_{ph}=\sum _{s\in S}\sum _{x\in \Omega }|I^s(x)-{\hat{I}}^s(x)|$$

$$l_{st}=\sum _{s\in S}\sum _{x\in \Omega }1-(\varphi (I^s(x),{\hat{I}}^s(x))$$

$$\mathcal{D}(d)+\alpha \mathcal{R}(d)$$

$$\alpha (x)$$

$$l_{sm}=\sum _{s\in S}\sum _{x\in \Omega }{\alpha }^s(x){\lambda }^s(x)(|{\partial }_X{d}^s(x)|+|{\partial }_Y{d}^s(x)|)$$

$$d^{0p}(x)=d^1(x-d^0(x))\text{ and }{d}^{1p}(x)=d^0(x+d^1(x))$$

$${\hat{d}}^0(x)=d^{1p}(x-d^0(x)\text{ and }{\hat{d}}^1(x)=d^{0p}(x+d^1(x))$$

$$l_{bc}=\sum _{s\in S}\sum _{x\in \Omega }{\alpha }^s(x)|d^s(x)-{\hat{d}}^s(s)|$$

$$L_0=w_{ph}{l}_{ph}+w_{st}{l}_{st}$$

$$p(d|I^0,I^1)\propto p(I^1|I^0,d)\cdot p(I^0,d)$$

$$p(I^1|I^0,d)\approx \exp (-\frac{g(I^0,I^1,d)}{a})$$

$$p(I^0,d)\approx \exp (-\frac{h(I^0,d)}{b})$$

$$-\log p(d|I^0,I^1)$$

$$\propto \frac{1}{a}g(I^0,I^1,d)+\frac{1}{b}h(I^0,d)$$

$$\propto \underset{\text{data fidelity}}{\underbrace{g(I^0,I^1,d)}}+\alpha \underset{\text{regularization}}{\underbrace{h(I^0,d)}}$$

$$g(I^0,I^1,d)=\sum _{x\in \Omega }|I^0(x)-{\hat{I}}^0(x)|$$

$$h(I^0,d)=\sum _{x\in \Omega }{\lambda }^0(x)(|{\partial }_X{d}^0(x)|+|{\partial }_Y{d}^0(x)|)$$

Full text

Code and pre-trained models available at:

https://github.com/alexklwong/adareg-monodispnet

1 Introduction

Estimating the 3-dimensional geometry of a scene is a fundamental problem in machine perception with a wide range of applications, including autonomous driving [22], robotics [30, 43], pose-estimation [40] and scene object composition [24]. It is well-known that 3-d scene geometry can be recovered from multiple images of a scene taken from different viewpoints, including stereo, under suitable conditions. Under no conditions, however, is a single image sufficient to recover 3-d scene structure, unless prior knowledge is available on the shape of objects populating the scene. Even in such cases, metric information is lost in the projection, so at best we can use a single image to generate hypotheses, as opposed to estimates, of scene geometry.

Recent works [3, 6, 29, 31, 32, 50, 51] sought to exploit such strong scene priors by using pixel-level depth annotation captured with a range sensor (e.g. depth camera, lidar) to regress depth from the RGB image. Cognizant of the intrinsic limitations of this endeavor, we exploit stereo imagery to train a network without ground-truth supervision for generating depth hypotheses, to be used as a reference for 3-d reconstruction. We evaluate our method against ground-truth depths via two benchmarks from the KITTI dataset [13] and show that it generalizes well by applying models trained on KITTI to Make3d [39].

Rather than attempting to learn a prior by associating the raw-pixel values with depth, we recast depth estimation as an image reconstruction problem [12, 14] and exploit the epipolar geometry between images in a rectified stereo pair to train a deep fully convolutional network. Our network learns to predict the dense pixel correspondences (disparity field) between the stereo pair, despite only having seen one of them. Hence, our network implicitly learns the relative pose of the cameras used in training and hallucinates the existence of a second image taken from the same relative pose when given a single image during testing. From the disparity predictions, we can synthesize depth using the known focal length and baseline of the cameras used in training.

While [12, 14, 49] follow a similar training scheme, [49] does not scale to high resolution, and [12] uses a non-differentiable objectives. [14] proposed using two uni-directional edge-aware disparity gradients and left-right disparity consistency as regularizers. However, edge-awareness should inform bidirectionally and left-right consistency suffers from occlusions and dis-occlusions. Moreover, regularity should not only be data-driven, but also model-driven.

Our contributions are three-fold: (i) A model-driven adaptive weighting scheme that is both space- and training-time varying and can be applied generically to regularizers. (ii) A bilateral consistency constraint that enforces the cyclic application of left and right disparity to be the identity. (iii) A two-branch decoder that specifically learns the features necessary to maximize data fidelity and utilizes such features to refine an initial prediction by enforcing regularity. We formulate our contributions as an objective function that, when realized even by a generic encoder-decoder, achieves state-of-the-art performance on two KITTI [13] benchmarks and exhibits generalizability to Make3d [39].

2 Related Works

Supervised Monocular Depth Estimation. [38] proposed a patch-based model that estimated a set of planes to explain each patch. The local estimates were then combined with Markov random fields (MRF) to estimate the global depth. Similarly, [18, 23, 27, 39] exploited local monocular features to make global predictions. However, local methods lack the global context needed to generate accurate depth estimates. [32] instead employed a convolutional neural network (CNN). [28] further improved monocular methods by incorporating semantic cues into their model.

[5, 6] introduced a two scale network to learn a representation from the images and regress depth directly. [29] proposed a residual network with up-sampling modules to produce higher resolution depth maps. [3] learned depth using crowd-sourced annotations of relative depths and [10] learned the ordinal relations of the scene using atrous spatial pyramid pooling. [37] explored a patch-based approach using neural forests and [25, 50, 51] used conditional random fields (CRF) jointly with a CNN to estimate depth.

Unsupervised Monocular Depth Estimation. Recently, [9] introduced novel view synthesis by predicting pixel values based on interpolation from nearby images. [49] minimized an image reconstruction loss to hallucinate the existence of a right view of a stereo pair given the left by producing the distribution of disparities for each pixel.

[12] trained a network for monocular depth prediction by reconstructing the right image of a stereo pair with the left and synthesizing disparity as an intermediate step. Yet, their image formation model is not fully differentiable, making their objective function difficult to optimize. Unsupervised methods [14, 36, 55, 56] utilized a bilinear sampler modeled after the Spatial Transformer Network [21] to allow for a fully differentiable loss and end-to-end training of their respective networks. Specifically, [14] used SSIM [46] as a loss in addition to the image reconstruction loss. Also, [14] predicted both left and right disparities and used them for regularization via a left-right consistency check along with an edge-aware smoothness term. [2] trains a Generative Adversarial Network (GAN) [15] to constrain the output to reconstruct a realistic image to reduce the artifacts seen from stereo reconstruction.

Self-supervised methods [33, 44, 54, 57] utilized a pose network to learn both ego-motion and depth from monocular videos sequences, while [45, 52] leveraged visual odometry from off-the-shelf methods [7, 42] and [8] gravity as supervisors. [53] followed both unsupervised and self-supervised paradigms by training multiple networks using stereo video streams and proposed a feature reconstruction loss. While additional supervision and data are used to improve predictions, [14] still remains as the state-of-the-art in the unsupervised setting. Our method follows the unsupervised paradigm and we show that it not only outperforms [14], but also [53] who leveraged techniques from both unsupervised and self-supervised domains.

Adaptive Regularization. A number of computer vision problems can be formulated as energy minimization in a variational framework with a data fidelity term and a regularizer weighted by a fixed scalar. The solution found by the minimal energy involves a trade-off between data fidelity and regularization. Finding the optimal parameter for regularity is a long studied problem as [11] explored methods to determine the regularization parameter in image de-noising, while [35] used cross-validation as a selection criterion for the weight. Others [14, 47, 48] used image gradients as cues for a data-driven weighting scheme. Recently, [19, 20] proposed that regularity should not only be data-driven, but also model driven. The amount of regularity imposed should adapt to the fitness of the model in relation to the data rather than being constant throughout the training process.

We propose a novel objective function using bilateral cyclic consistency constraint along with a spatial and temporal varying regularization modulator. We show that despite using the fewer parameters than [14], we outperform [14] and other unsupervised methods. We detail our loss function with adaptive regularization, in Sec. 3, present a two-branch decoder architecture in Sec. 4, and specify hyper-parameters and data augmentation procedures used in Sec. 5. We evaluate our model on the KITTI 2015, KITTI Eigen Split, and Make3d benchmarks in Sec. 6. Lastly, we end with a discussion of our work in Sec. 7.

3 Method Formulation

We learn a model to hypothesize or “estimate” the disparity field $d$ compatible with an image $I^{0}$ by exploiting the availability of stereo pairs $(I^{0},I^{1})$ during training. We then synthesize the depth $z=FB/d$ of the scene using the focal length $F$ and baseline $B$ during test time. Given $I^{0}$, we estimate a function $d\in\mathbb{R}_{+}$ that represents the disparity of $I^{0}$, which we formulate as a loss function $L$ (Eqn. 1), comprised of data terms and adaptive regularizers.

Our network, parameterized by $\omega$, takes a single image $I^{0}$ as input and estimates a function $d=f(I^{0};\omega)$, where $d$ represents the disparity (which is monotonically related to inverse-depth) corresponding to $I^{0}$. We drive the training process with $I^{1}$, which is only used in the loss function, by a surrogate loss that minimizes the reprojection error of $I^{0}$ to $I^{1}$ and vice versa. We will refer to the disparity estimated by $L$ as $d^{0}$ and $d^{1}$ for $I^{0}$ and $I^{1}$, respectively. Interested readers may refer to Supplementary Materials (Supp. Mat.) for more details on our formulation.

[TABLE]

where each individual term $l$ will be described in the next sections and their weights $w$ in Sec. 5.

3.1 Data Fidelity

Our data fidelity terms seek to minimize the discrepancy between the observed stereo pair $(I^{0},I^{1})$ and their reconstructions $(\hat{I}^{0},\hat{I}^{1})$. We generate each $\hat{I}$ term by applying a 1-d horizontal disparity shift to $I$ at each position $x\in\Omega$:

[TABLE]

We do so by using a 1-d horizontal bilinear sampler modeled after the image sampler from the Spatial Transformer Network [21] – instead of applying an affine transformation to activations, we warp an image to the domain of its stereo-counterpart using disparities. Our sampler is locally fully differentiable and each output pixel is the weighted sum of two (left and right) pixels. We propose to minimize the reprojection residuals as a two-part loss, which measures the standard color constancy (photometric) and the difference in illumination, contrast and image quality (structural).

Photometric loss. We model the image formation process via a photometric loss $l_{ph}$, which measures the $L_{1}$ penalty of the reprojection residual for each $I$ and $\hat{I}$ on each channel at every position $x\in\Omega$ for ${s\in S\doteq\{0,1\}}$ denoting the left and right images:

[TABLE]

Structural loss. In order to make inference invariant to local illumination changes, we use a perceptual metric (SSIM) that discounts such variability. We apply SSIM ($\phi$) to image patches of size $3\times 3$ at corresponding $x$ in $I$ and $\hat{I}$. Since two similar images give a SSIM score close to 1, we subtract 1 by the score to represent a distance:

[TABLE]

3.2 Residual-Based Adaptive Weighting Scheme

A point estimate $d$ can be obtained by maximizing the Bayesian criterion with a data fidelity term (energy) $\mathcal{D}(d)$ and a Bayesian or Tikhonov regularizer $\mathcal{R}(d)$ in the form:

[TABLE]

where the weight $\alpha$ is a pre-defined positive scalar parameter that controls the regularity to impose on the model, leading to a trade-off between data fidelity and regularization.

The weight $\alpha$ modulates between data-fidelity and regularization, constraining the solution space. Yet, subjecting the entire solution, a dense disparity field, to the same regularity fails to address cases where the assumptions do not hold. Suppose one enforces a smoothness constraint to the output disparity field by simply taking the disparity gradient $\nabla d$. This constraint would incorrectly penalize object boundaries (regions of high image gradients) and hence [14, 17] apply an edge-aware term to reduce the effects of regularization on edge regions. Although the edge-awareness term gives a data-driven approach on regularization, it is still static (the same image will always have the same weights) and independent of the performance of the model. Instead, we propose a space- and training-time varying weighting scheme based on the performance of our model measured by reprojection residuals.

Model-driven adaptive weight. We propose an adaptive weight $\alpha(x)$ that varies in space and training time for every position $x\in\Omega$ of the solution based on the local residual $\rho(x)=|I(x)-\hat{I}(x)|$ and the global residual, represented by the average per-pixel residual, $\sigma=\displaystyle\frac{1}{\frac{1}{|\Omega|}\displaystyle\sum_{x\in\Omega}|I(x)-\hat{I}(x)|}$:

[TABLE]

$\alpha$ is controlled by the local residual between an image $I$ and its reprojection $\hat{I}$ at each position while taking into account of the global residual $\sigma$, which correlates to the training time step and decreases over time. $c$ is a scale factor for the range of $\alpha$. $\alpha$ is naturally small when residuals are large and tends to 1 as training converges.

Local adaptation. Consider a pair of poorly matched pixels, $(I(x),\hat{I}(x))$, where the residual $|I(x)-\hat{I}(x)|$ is large. By reducing the regularity on the solution $d(x)$, we effectively allow for exploration in the solution space to find a better match and hence a $d(x)$ that minimizes the data fidelity terms. Alternatively, consider a pair of perfectly matched pixels, $(I(x),\hat{I}(x))$, where $|I(x)-\hat{I}(x)|=0$. We should apply regularization to decrease the scope of the solution space such that we can allow for convergence and propagate the solution. Hence, a spatially adaptive $\alpha(x)$ must vary inversely to the local residual $\rho(x)$ such that we impose regularization when the residual is small and reduce it when the residual is large.

Global adaptation. Consider a solution $d(x)$ proposed at the first training time step $t=1$. Imposing regularity effectively reduces the solution space based on an assumption about $d(x)$ and biases the final solution. We propose that a weighting scheme $\alpha(x)\rightarrow 1$ as $t\rightarrow\infty$. However, if $\alpha(x)$ is directly dependent on the $t$, then $\alpha(x)$ will change if we continue to train even after convergence – causing the model to be unstable. Instead, let $\alpha(x)$ be inversely proportional to the global residual $\sigma$ such that $\alpha(x)$ is small when the $\sigma$ is large (generally corresponding to early time steps) and $\alpha(x)\rightarrow 1$ as $\sigma\rightarrow 0$. When training converges (i.e. the global residual has stabilized), $\alpha(x)$ likewise will be stable. This naturally lends to an annealing schedule where $\alpha(x)\rightarrow 1$ as time progresses in training steps.

3.3 Adaptive Regularization

Our regularizers assume local smoothness and consistency between the left and right disparities estimated. We propose to minimize the disparity gradient (smoothness) and the disparity reprojection error (bilateral cyclic consistency) while adaptively weighting both with $\alpha$ (Sec. 3.2).

Smoothness loss. We encourage the predicted disparities to be locally smooth by applying an $L_{1}$ penalty to the disparity gradients in the x ($\partial_{X}$) and y ($\partial_{Y}$) directions. However, such an assumption does not hold at object boundaries, which generally correspond to regions of high changes in pixel intensities; hence, we include an edge-aware term $\lambda$ to allow for discontinuities in the disparity gradient. We also weigh this term adaptively with $\alpha$:

[TABLE]

where $\lambda^{s}(x)=\exp({-|\nabla^{2}I^{s}(x)|})$ and the $\nabla^{2}$ operator denotes the image Laplacian. We use the image Laplacian over the first order image gradients because it allows the disparity gradients to be aware of intensity changes in both directions. However, we regularize the disparity field using the disparity gradient so that we can allow for independent movement in each direction. Prior to computing the image Laplacian for $\lambda$, we smooth the image with a Gaussian kernel to reduce noise.

Bilateral cyclic consistency loss. A common regularization technique in stereo-vision is to maintain the consistency between the left ($d^{0}$) and right ($d^{1}$) disparities by reconstructing each disparity through projecting its counter-part with its disparity shifts:

[TABLE]

However, in doing so, the projected disparities suffer from the unresolved correspondences of both the disparity ramps, occlusions and dis-occlusions. We, propose a bilateral cyclic consistency check that is designed to specifically reason about occlusions while removing the effects of stereo dis-occlusions. We follow the intuition that the disparities $d$ should have an identity mapping when projected to the domain of its stereo-counterpart and back-projected to the original domain as a reconstruction $\hat{d}$ so reconstruction of dis-occlusion is ignored.

[TABLE]

By applying an $L_{1}$ penalty on the disparity field and its reconstruction, we are constraining that the cyclic transformations should be the identity transform, which keeps $d^{0}$ and $d^{1}$ consistent with each other in co-visible regions. If there exists an occluded region, the region in the reconstruction would be inconsistent with the original – yielding reprojection error. To avoid penalizing a model for an unresolvable correspondence due to the nature of the data, we propose to adaptively regularize the bilateral cyclic constraint using our residual-based weighting scheme (Eqn. 6). Unsurprisingly, local regions of high reprojection residual often correspond to occluded regions.

[TABLE]

4 A Two-Branch Decoder

As our adaptive weighting scheme (Sec. 3.2) is function of the data fidelity residuals, we seek to ensure that the network learns a sufficient representation to minimize the data fidelity loss (Sec. 3.1). We propose a two-branch decoder (Fig. 2) with one branch (prefixed with ‘i‘) dedicated to learning the features, iconv, necessary to make a prediction that minimizes data fidelity loss:

[TABLE]

using the reconstructed features via up-convolution and the corresponding skip connection from the encoder. We use a residual block [16] to learn the skip connection residual, rskip, necessary to minimize Eqn. 1 – both data fidelity and regularity loss. By concatenating iconv and rskip with the initial prediction (idisp) as features for the second branch (prefixed with ‘r‘), we have provided the decoder branch with a prediction that satisfies data fidelity along with features necessary to impose regularity. The branch can now utilize such information to refine the initial prediction by adaptively applying regularization based on the data fidelity residual. To maintain a similar network size and run-time, we reduce the depth of the network by 1 and added a single convolution as the first layer to enable a skip connection to the last layer. This, in fact, resulted in our network having $\approx 10$ million fewer parameters than [14]. We show qualitative results in Fig. 3 and 4 where we observe the benefits of learning the features that satisfy data fidelity as we recover more details about the scene geometry. Quantitatively, we show in Table 2 and 3 that this structure improves over the state-of-the-art performance on all metrics achieved by our generic encoder with a single branch decoder, where the final predictions of both decoders minimize our objective function (Eqn. 1).

5 Implementation Details

Our approach was implemented using TensorFlow [1]. There are $\approx 31$ million trainable parameters in the generic encoder-decoder [14] and $\approx 21$ million in our proposed structure (more details can be found in Supp. Mat. Table 2 and 3). Training takes $\approx$ 18 hours using an Nvidia GTX 1080Ti. Inference takes $\approx$ 32 ms per image. We used Adam [26] to optimize our network with a base learning rate of $1.8\times 10^{-4}$, $\beta_{1}=0.9$, $\beta_{2}=0.999$. We then increase the learning rate to $2\times 10^{-4}$ after 1 epoch, decrease it by half after 46 epochs and by a quarter after 48 epochs for a total of 50 epochs. We use a batch size of 8 with a $512\times 256$ resolution and 4 levels in our loss pyramid. We are able to achieve our results using the following set of weights for each term in our loss function: $w_{ph}=0.15$, $w_{st}=0.425$, $w_{sm}=0.10$ and $w_{bc}=1.05$. We choose the scale factor $c=5.0$ for the adaptive weight $\alpha$. For our smoothness term, we decrease it by a factor of $2^{r}$ for each $r$-th resolution in the loss pyramid where $r=0$ refers to our highest resolution at $512\times 256$ and $r=3$ the lowest.

Data augmentation is performed online during training. We perform a horizontal flip (with a swap to maintain correct relative positions) on the stereo pairs with $50\%$ probability. Color augmentations on brightness, gamma and color shifts of each channel also occur with $50\%$ chance. We uniformly sample from $[0.5,1.5]$ for brightness, and $[0.8,1.2]$ for gamma and each color channel separately.

6 Experiments and Results

We present our results on the KITTI dataset [13] under two different training and testing schemes, the KITTI 2015 split [14] and the KITTI Eigen split [6, 12]. The KITTI dataset contains 42,382 rectified stereo pairs from 61 scenes with approximate resolutions of $1242\times 375$. We evaluate our method on the monocular depth estimation task on KITTI Eigen split and compare our approach with similar variants on a disparity error metric as an ablation study using the KITTI 2015 split. We show that our method outperforms state-of-the-art unsupervised monocular approaches and even supervised approaches on KITTI benchmarks, while generalizing to Make3d [39].

6.1 KITTI Eigen Split

We evaluate our method using the KITTI Eigen split [6], which has 697 test images from 29 scenes. The remaining 32 scenes contain 23,488 stereo pairs, of which 22,600 pairs are used for training and the rest for validation, following [12]. We project the velodyne points into the left input color camera frame to generate ground-truth depths. The ground-truth depth maps are sparse ($\approx 5\%$ of the entire image) and prone to errors from rotation of the velodyne and motion of the vehicle and surrounding objects along with occlusions. As a result, we use the cropping scheme proposed by [12], which contains approximately $58\%$ in height and $93\%$ in width of the image dimensions.

We compare our approach with the recent monocular depth estimation methods at 80 and 50 meters caps in Table 2. Fig. 3 provides a qualitative comparison between our method and the baseline. We note that [53] trained two networks using stereo video streams (as opposed to a single network with stereo pairs like ours and [14]), which allows their networks to learn a depth prior in both spatial and temporal domains. Using the network of [14] (generic encoder with a single branch decoder), we outperforms all competing methods in all metrics under both depth caps except for $\delta<1.25^{3}$ where we are comparable to [53]. We improve consistently over [14] and [53] by an average of 8.7% and 5.75% in AbsRel, 13.1% and 10.5% in SqRel and even 5.25% and 2.55% in logRMS, respectively. Furthermore, we score significantly higher in $\delta<1.25$ (the hardest accuracy metric), which suggests that our model produces more correct and realistically detailed depths than all competing methods. In addition, our two-branch decoder improves over the said results across all metrics and depth caps and is the current state-of-the-art. Table 2 shows that our model also beats [14] when pretraining on Cityscape [4] and fine-tuning on KITTI. An ablation study on Eigen Split examining the effects of each of our contributions (Sec. 3.3) can be found in our Supp. Mat.

6.2 KITTI 2015 Split

We evaluate our method on 200 high quality disparity maps provided as part of the official KITTI training set [13]. These 200 stereo pairs cover 28 of the total 61 scenes. From 30,159 stereo pairs covering the remaining 33 scenes, we choose 29,000 for training and the rest for validation. While typical training and evaluation schemes project velodyne laser values to depth, we choose to use the provided disparity maps as they are less erroneous than velodyne data points. In addition, we also use the official KITTI disparity metric of end-point-error (D1-all) to measure our performance as it is a more appropriate metric on our class of approach that outputs disparity and synthesizes depth from the output using camera focal length and baseline.

We show qualitative comparisons in Fig. 4 and quantitative comparisons in Table 3. Table 3 also serves as an ablation study on variants belonging to the stereo unsupervised paradigm using different image formation model and regularization terms. We show that by simply applying our adaptive regularization to [14], we achieve improvement over their model. We also study the effects of substituting our bilateral cyclic consistency with the left-right consistency regularizer [14]. We also substitute image Laplacian with image gradients for edge-aware weights. In addition, we find that adaptive regularization and bilateral cyclic consistency contribute similarly to the improvements of the models. However, when combined they achieve significantly improvements over the baseline method (and all variants) in every metric. Furthermore, when using our proposed decoder, we again surpass all variants on every metric. We additionally outperform [2], who uses a GAN to constrain the output disparities to produce photo-realistic images during reconstruction. This result aligns with our performance on accuracy metrics – our method produces accurate and realistic depths.

6.3 Generalizing to Different Datasets: Make3d

To show that our model generalizes, we present our qualitative and quantitative results in Fig. 5 on the Make3d dataset [39] containing 134 test images with $2272\times 1707$ resolution. Make3d provides range maps (resolution of $305\times 55$) for ground-truth depths, which must be rescaled and interpolated. We use the central cropping proposed by [14] where we generate a $852\times 1707$ crop centered on the image. We use the standard $C1$ evaluation metrics${}^{\ref{eval_metrics}}$ proposed for Make3d and limit the maximum depth to 70 meters. The results of the supervised methods are taken from [14]. Because Make3d does not provide stereo pairs, we are unable to train on it. However, we find that despite having trained our model on KITTI Eigen split, our performance is comparable to that of supervised methods trained on Make3d and is better than the baseline across all metrics.

7 Discussion

In this work, we proposed an adaptive weighting scheme (Sec. 3.3) that is both spatially and time varying, allowing for not only a data-driven, but also model-driven approach to regularization. Moreover, we introduce a bilateral cyclic consistency constraint that not only enforces consistency between the left and right disparities, but also removes stereo dis-occlusions while discounting unresolved occlusions when combined with our weighting scheme. Finally, we propose a two-branch decoder that achieves the state-of-the-art by learning features to improve data residual for imposing our adaptive regularity. We achieve state-of-the-art performance on two KITTI benchmarks and show that our method generalizes to Make3d. Our two-branch decoder further improves over those results. Our experiments (Table 2 and 3) show that our approach produces depth maps with more details while maintaining global correctness.

In future work, we plan to improve robustness to specular and transparent surfaces as these regions tend to produce inconsistent depths. We are also exploring more sophisticated regularizers in place of the simple disparity gradient. Finally, we believe that the task should drive the network architecture. Rather than using a generic network, finding a better architectural fit could prove to be ground-breaking and further push the state-of-the-art.

Acknowledgements. This work was supported by NRF-2017R1A2B4006023, NRF-2018R1A4A1059731, ONR N00014-17-1-2072, ARO W911NF-17-1-0304.

Appendix A Problem Formulation

In this section, we give the formulation for predicting the disparities for a single view using stereo imagery as supervision. Given a single image $I^{0}$, our goal is to estimate a function $d=f(I^{0},\omega)\in\mathbb{R}_{+}$ that represents the disparity of $I^{0}$, where $f$ is a network parameterized by $\omega$. We assume $I^{0}$ belongs to a stereo-pair $(I^{0},I^{1})$ with which we exploit $I^{1}$ to learn a representation $d$ for predicting scene geometry from $I^{0}$ by maximizing the posterior distribution:

[TABLE]

We assume that both the likelihood $p(I^{1}|I^{0},d)$ and the prior $p(I^{0},d)$ follow a Laplacian distribution. The likelihood can be approximated by a data fidelity term $g(I^{0},I^{1},d)$ and the prior by a regularization term $h(I^{0},d)$ and will have the form:

[TABLE]

[TABLE]

We then take the negative log to form our data and regularization terms:

[TABLE]

Given $I^{1}$ and $d$, we can derive $\hat{I}^{0}=I^{1}(x+d(x))$. We substitute $g(I^{0},I^{1},d)$ with a generic image reconstruction function:

[TABLE]

We can similarly substitute $h(I^{0},d)$ with a generic prior such as local smoothness with edge-awareness:

[TABLE]

Appendix B Adaptive Regularization

Our adaptive regularization weighting scheme $\alpha$ (Sec. 3.2 from main text) allows us to have a model-driven approach to regularization. While a number of literature have exploited a data-driven approach to regularization by weighting the amount of regularity imposed by the structure of the data (e.g. gradients of an image [18, 14]), this class of approaches are still static in terms of weights for a given example as the same image will always give the same weights. Our approach is both model-driven as well as data-driven as our regularization weighting scheme (Eqn. 6 from main text) is a function of the output of the model and the data-fidelity residual (as determined by reconstruction of the images).

Traditionally, the weight of the regularization terms is a static scalar. However, we argue that imposing the same amount of regularity to the entire solution fails to address corner cases. We propose that $\alpha$ should be spatially varying and inversely proportional to the local residual. While the notion of “trusting” the prior (or the regularizers) when data-fidelity fails to explain the scene is intuitive, this assumption is only valid once we are able to sufficiently satisfy the data-fidelity term; otherwise we are restricting our model to a biased set of solutions without having fully explored the solution space. This is apparent in the example given in Sec. 3.2 of the main text regarding the training time varying property of $\alpha$ – a solution proposed at the first time step cannot be trusted in terms of its data-fidelity and hence we should not impose regularity. Therefore, we propose that our weighting scheme $\alpha\rightarrow 0$ when residual is large and $\alpha\rightarrow 1$ as the residual tends to 0. Naturally the data-fidelity residual decreases over time as the training progresses, which we exploit instead of directly making $\alpha$ a function of training time. Thus, when the model converges, $\alpha$ will also converge.

We apply our adaptive weighting scheme to each of the regularization terms (Sec. 3.3 from main text) at each level of the loss pyramid for a total of four levels beginning from the full resolution to one-eighth resolution. Fig. 6 shows the behavior of the adaptive weights on each level of the loss pyramid. The figure was taken from a training process. The recorded value in dark orange is the trend line representing the mean of the weights that is being applied to our solution. We see that as the model improves our adaptive weights proportionally increase, which equivalently impose regularity on the model.

Appendix C Bilateral Cyclic Consistency

In this work, we propose using a bilateral cyclic constraint as a way of regularizing the behavior of the predicted disparities. Our model enforces bilateral cyclic consistency (Sec. 3.3 from main text) by projecting the set of disparities of a given image in a stereo pair to its counter-part and back-projected to itself as a reconstruction (Eqn. 9 from main text). We then apply an $L1$ penalty to the difference between the initial disparities and its reconstruction. By doing so, we are imposing regularity on the disparity map in its original frame of reference as opposed to a relative frame of reference (i.e. left-right consistency). By enforcing the cyclic application of the disparities to be the identity, we constrain that the correspondences found in both images are co-visible regions. In the case of occlusions, the constraint will be violated, yielding high loss. While a solution would be to discount such errors by setting an arbitrary threshold (as attempting to reconstruct a region that does not exist can never yield a correct solution), our adaptive weighting scheme (Sec. 3.2 from main text) provide an elegant solution to such scenarios. As one can never find correct correspondences for occluded regions of two images, this naturally lends to a high data-fidelity residual with which we adaptively discount using $\alpha$.

We illustrate the cyclic application of the left and right disparities in Fig. 7. Although we are never given the right image (whitened image) of the stereo pair, our network successfully hallucinates its existence and predicts the corresponding disparities to enable our bilateral cyclic consistency check. The areas of inconsistency between the initial disparities and their reconstructions (last row of Fig. 7) exist near the occlusion boundaries, which we use $\alpha$ to effectively guide our model to regularize these regions to improve depth consistency.

Appendix D Ablation Studies on Eigen Split

Table 4 shows an ablation study on the KITTI Eigen split benchmark. The two rows following our full model and our full modeling using the proposed two-branch decoder (Sec. 4 of main paper) denotes the percentage improvement over [14] and [53]. Our full model using a generic encoder with a single-branch decoder outperforms the top performing methods [14, 53] across all metrics under both depth caps. Notably, we improve over [14] and [53] by an average of 8.7% and 5.75% in AbsRel, 13.1% and 11.1% in SqRel and even 5.25% and 2.55% in logRMS, respectively. Furthermore, we improve 2.1% over both in $\delta<1.25$ (the hardest accuracy metric). [53] is only able to outperform our full model marginally in the $\delta<1.25^{3}$ metric by 0.1% despite using multiple networks and stereo video streams for training as opposed to stereo pairs.

Moreover, each of our partial models using the generic encoder with the single-branch decoder (same network as [14]) shows improvement over the baseline [14]. Even by simply applying our adaptive regularization to [14], we improve consistently across all metrics. More importantly, our model without bidirectionally informed edge-awareness is already able to outperform [53] on most metrics across both depth caps with the exception of $\delta<1.25^{2}$ and $\delta<1.25^{3}$ where we are comparable. Based on Table 4, we can see that each of our individual contribution improves the model. There is a significant performance gain when multiple contributions are applied to the model (e.g. adaptive regularization with bilateral cyclic consistency versus [14] with adaptive regularization). The strongest model is produced when all of the contributions are combined as each contribution complements the others to resolve inconsistencies in object boundaries, co-visible and occluded regions.

Furthermore when applying our full model using the proposed two-branch decoder, we further improve over all methods. Specifically, we improve over [14] and [53] by an average of 10.05% and 7.15% in AbsRel, 15.45% and 13.6% in SqRel, 6.85% and 5.2% in RMS, and 6.5% and 3.85% in logRMS, respectively. We even improve 2.8% over both in $\delta<1.25$. [53] is comparably to us in $\delta<1.25^{3}$ metric. Our full model using the proposed two-branch decoder is the state-of-the-art in the unsupervised single image depth prediction task.

Appendix E Qualitative Comparison Between Single-Branch and Two-Branch Decoder

It is well-known that geometry can be recovered in co-visible regions (barring texture-less regions) simply by establishing correspondence between two views of the scene. Our proposed decoder (Fig. 1 from main text) dedicates one branch to learning the necessary features to satisfy data-fidelity, which in this case is the reconstruction between the stereo pairs. In doing so, we also produce an initial solution that satisfies data-fidelity. The second branch then aims to refine such a solution by learning the residual features from the skip connection necessary for adaptively imposing regularity. Fig. 8 gives a qualitative comparison between the single-branch decoder (row 3) and the proposed two-branch decoder (row 4). We see that the two-branch decoder consistently recovers more of the scene geometry, particularly thin structures and distant structures. In cases where a thin structure (e.g. pole) lies close to a larger structure (e.g. walls of building) or a structure is located far away, the single branch decoder often fail to recover their geometry. The two-branch decoder, however, is able to recover distant structures and distinguish thin structures from larger nearby structures.

Appendix F Network Architectures

We trained our model using two architectures: 1) a generic encoder (Table 5) based on the VGGnet [41] architecture with a single branch decoder 2) a generic encoder (same as the aforementioned) with our proposed two-branch decoder (Table 6, Sec 4. from main paper).