Multi-Scale Continuous CRFs as Sequential Deep Networks for Monocular Depth Estimation

Introduction

While estimating the depth of a scene from a single image is a natural ability for humans, devising computational models for accurately predicting depth information from RGB data is a challenging task. Many attempts have been made to address this problem in the past. In particular, recent works have achieved remarkable performance thanks to powerful deep learning models . Assuming the availability of a large training set of RGB-depth pairs, monocular depth prediction is casted as a pixel-level regression problem and Convolutional Neural Network (CNN) architectures are typically employed.

In the last few years significant effort have been made in the research community to improve the performance of CNN models for pixel-level prediction tasks (e.g. semantic segmentation, contour detection). Previous works have shown that, for depth estimation as well as for other pixel-level classification/regression problems, more accurate estimates can be obtained by combining information from multiple scales . This can be achieved in different ways, e.g. fusing feature maps corresponding to different network layers or designing an architecture with multiple inputs corresponding to images at different resolutions. Other works have demonstrated that, by adding a Conditional Random Field (CRF) in cascade to a convolutional neural architecture, the performance can be greatly enhanced and the CRF can be fully integrated within the deep model enabling end-to-end training with back-propagation . However, these works mainly focus on pixel-level prediction problems in the discrete domain (e.g. semantic segmentation). While complementary, so far these strategies have been only considered in isolation and no previous works have exploited multi-scale information within a CRF inference framework.

In this paper we argue that, benefiting from the flexibility and the representational power of graphical models, we can optimally fuse representations derived from multiple CNN side output layers, improving performance over traditional multi-scale strategies. By exploiting this idea, we introduce a novel framework to estimate depth maps from single still images. Opposite to previous work fusing multi-scale features by averaging or concatenation, we propose to integrate multi-layer side output information by devising a novel approach based on continuous CRFs. Specifically, we present two different methods. The first approach is based on a single multi-scale CRF model, while the other considers a cascade of scale-specific CRFs. We also show that, by introducing a common CNN implementation for mean-fields updates in continuous CRFs, both models are equivalent to sequential deep networks and an end-to-end approach can be devised for training. Through extensive experimental evaluation we demonstrate that the proposed CRF-based method produces more accurate depth maps than traditional multi-scale approaches for pixel-level prediction tasks (Fig.1). Moreover, by performing experiments on the publicly available NYU Depth V2 and on the Make3D datasets, we show that our approach outperforms state of the art methods for monocular depth estimation.

To summarize, the contributions of this paper are threefold. First, we propose a novel approach for predicting depth maps from RGB inputs which exploits multi-scale estimations derived from CNN inner layers by fusing them within a CRF framework. Second, as the task of pixel-level depth prediction implies inferring a set of continuous values, we show how mean field (MF) updates can be implemented as sequential deep models, enabling end-to-end training of the whole network. We believe that our MF implementation will be useful not only to researchers working on depth prediction, but also to those interested in other problems involving continuous variables. Therefore, our code is made publicly availablehttps://github.com/danxuhk/ContinuousCRF-CNN.git. Third, our experiments demonstrate that the proposed multi-scale CRF framework is superior to previous methods integrating information from intermediate network layers by combining multiple losses or by adopting feature concatenations . We also show that our approach outperforms state of the art depth estimation methods on public benchmarks and that the proposed CRF-based models can be employed in combination with different pre-trained CNN architectures, consistently enhancing their performance.

Related work

Previous approaches for depth estimation from single images can be categorized into three main groups: (i) methods operating on hand crafted features, (ii) methods based on graphical models and (iii) methods adopting deep networks.

Earlier works addressing the depth prediction task belong to the first category. Hoiem et al. introduced photo pop-up, a fully automatic method for creating a basic 3D model from a single photograph. Karsch et al. developed Depth Transfer, a non parametric approach where the depth of an input image is reconstructed by transferring the depth of multiple similar images and then applying some warping and optimizing procedures. Ladicky demonstrated the benefit of combining semantic object labels with depth features.

Other works exploited the flexibility of graphical models to reconstruct depth information. For instance, Delage et al. proposed a dynamic Bayesian framework for recovering 3D information from indoor scenes. A discriminatively-trained multiscale Markov Random Field (MRF) was introduced in , in order to optimally fuse local and global features. Depth estimation was treated as an inference problem in a discrete-continuous CRF in . However, these works did not employ deep networks.

More recent approaches for depth estimation are based on CNNs . For instance, Eigen et al. proposed a multi-scale approach for depth prediction, considering two deep networks, one performing a coarse global prediction based on the entire image, and the other refining predictions locally. This approach was extended in to handle multiple tasks (e.g. semantic segmentation, surface normal estimation). Wang et al. introduced a CNN for joint depth estimation and semantic segmentation. The obtained estimates were further refined with a Hierarchical CRF. The most similar work to ours is , where the representational power of deep CNN and continuous CRF is jointly exploited for depth prediction. However, the method proposed in is based on superpixels and the information associated to multiple scales is not exploited.

Multi-scale CNNs.

The problem of combining informations from multiple scales for pixel-level prediction tasks have received considerable interest lately. In a deeply supervised fully convolutional neural network was proposed for edge detection. Skip-layer networks, where the feature maps derived from different levels of a primary network are jointly considered in an output layer, have also become very popular . Other works considered multi-stream architectures, where multiple parallel networks receiving inputs at different scale are fused . Dilated convolutions (e.g. dilation or à trous) have been also employed in different deep network models in order to aggregate multi-scale contextual information . We are not aware of previous works exploiting multi-scale representations into a continuous CRF framework.

Multi-Scale Models for Depth Estimation

In this section we introduce our approach for depth estimation from single images. We first formalize the problem of depth prediction. Then, we describe two variations of the proposed multi-scale model, one based on a cascade of CRFs and the other on a single multi-scale CRFs. Finally, we show how our whole deep network can be trained end-to-end, introducing a novel CNN implementation for mean-field iterations in continuous CRFs.

Following previous works we formulate the task of depth prediction from monocular RGB input as the problem of learning a non-linear mapping $F:\mathcal{I}\rightarrow\mathcal{D}$ from the image space $\mathcal{I}$ to the output depth space $\mathcal{D}$. More formally, let $\mathcal{Q}=\{(\mathbf{r}_{i},\bar{\mathbf{d}}_{i})\}_{i=1}^{Q}$ be a training set of $Q$ pairs, where $\mathbf{r}_{i}\in~{}\mathcal{I}$ denotes an input RGB image with $N$ pixels and $\bar{\mathbf{d}}_{i}\in\mathcal{D}$ represents its corresponding real-valued depth map.

For learning $F$ we consider a deep model made of two main building blocks (Fig. 2). The first component is a CNN architecture with a set of intermediate side outputs $\mathcal{S}=\{\mathbf{s}_{l}\}_{l=1}^{L}$, $\mathbf{s}_{l}\in R^{N}$, produced from $L$ different layers with a mapping function $f_{s}(\mathbf{r};\mathbf{\Theta},\boldsymbol{\theta}_{l})\rightarrow\mathbf{s}_{l}$. For simplicity, we denote with $\mathbf{\Theta}$ the set of all network layer parameters and with $\boldsymbol{\theta}_{l}$ the parameters of the network branch producing the side output associated to the $l$-th layer (see Section 4.1 for details of our implementation). In the following we denote this network as the front-end CNN.

The second component of our model is a fusion block. As shown in previous works , features generated from different CNN layers capture complementary information. The main idea behind the proposed fusion block is to use CRFs to effectively integrate the side output maps of our front-end CNN for robust depth prediction. Our approach develops from the intuition that these representations can be combined within a sequential framework, i.e. performing depth estimation at a certain scale and then refining the obtained estimates in the subsequent level. Specifically, we introduce and compare two different multi-scale models, both based on CRFs, and corresponding to two different version of the fusion block. The first model is based on a single multi-scale CRFs, which integrates information available from different scales and simultaneously enforces smoothness constraints between the estimated depth values of neighboring pixels and neighboring scales. The second model implements a cascade of scale-specific CRFs: at each scale $l$ a CRF is employed to recover the depth information from side output maps $\mathbf{s}_{l}$ and the outputs of each CRF model are used as additional observations for the subsequent model. In Section 3.2 we describe the two models in details, while in Section 3.3 we show how they can be implemented as sequential deep networks by stacking several elementary blocks. We call these blocks C-MF blocks, as they implement Mean Field updates for Continuous CRFs (Fig. 2).

2 Fusing side outputs with continuous CRFs

We now describe the proposed CRF-based models for fusing multi-scale representations.

Given an $LN$-dimensional vector $\hat{\mathbf{s}}$ obtained by concatenating the side output score maps $\{\mathbf{s}_{1},\dots,\mathbf{s}_{L}\}$ and an $LN$-dimensional vector $\mathbf{d}$ of real-valued output variables, we define a CRF modeling the conditional distribution:

where $Z(\hat{\mathbf{s}})=\int_{\mathbf{d}}\exp{-E(\mathbf{d},\hat{\mathbf{s}})}{d\mathbf{d}}$ is the partition function. The energy function is defined as:

and $d_{i}^{l}$ indicates the hidden variable associated to scale $l$ and pixel $i$. The first term is the sum of quadratic unary terms defined as:

where $s^{l}_{i}$ is the regressed depth value at pixel $i$ and scale $l$ obtained with $f_{s}(\mathbf{r};\mathbf{\Theta},\boldsymbol{\theta}_{l})$. The second term is the sum of pairwise potentials describing the relationship between pairs of hidden variables $d_{i}^{l}$ and $d_{j}^{k}$ and is defined as follows:

where $w_{m}(i,j,l,k,\mathbf{r})$ is a weight which specifies the relationship between the estimated depth of the pixels $i$ and $j$ at scale $l$ and $k$, respectively.

To perform inference we rely on mean-field approximation, i.e. $Q(\mathbf{d}|\hat{\mathbf{s}})=\prod_{i=1}^{N}\prod_{l=1}^{L}Q_{i,l}(d_{i}^{l}|\hat{\mathbf{s}})$. Following , by considering $J_{i,l}=\log Q_{i,l}(d_{i}^{l}|\hat{\mathbf{s}})$ and rearranging its expression into an exponential form, the following mean-field updates can be derived:

To define the weights $w_{m}(i,j,l,k,\mathbf{r})$ we introduce the following assumptions. First, we assume that the estimated depth at scale $l$ only depends on the depth estimated at previous scale. Second, for relating pixels at the same and at previous scale, we set weights depending on $m$ Gaussian kernels K_{m}^{ij}=\exp\big{(}-\frac{\|\mathbf{h}_{i}^{m}-\mathbf{h}_{j}^{m}\|^{2}_{2}}{2\theta_{m}^{2}}\big{)}. Here, $\mathbf{h}_{i}^{m}$ and $\mathbf{h}_{j}^{m}$ indicate some features derived from the input image $\mathbf{r}$ for pixels $i$ and $j$. $\theta_{m}$ are user defined parameters. Following previous works , we use pixel position and color values as features, leading to two Gaussian kernels (i.e. an appearance and a smoothness kernel) for modeling dependencies of pixels at scale $l$ and other two for relating pixels at neighboring scales. Under these assumptions, the mean-field updates (5) and (6) can be rewritten as:

Cascade CRFs.

The unary and pairwise terms can be defined analogously to the unified model. In particular the unary term, reflecting the similarity between the observation $o^{i}_{l}$ and the hidden depth value $d_{i}^{l}$, is:

where we consider $M=2$ Gaussian kernels, one for appearance features, the other accounting for pixel positions. Similarly to the multi-scale model, under mean-field approximation, the following updates can be derived:

At test time, we use the estimated variables corresponding to the CRF model of the finer scale $L$ as our predicted depth map $\mathbf{d}^{\star}$.

3 Multi-scale models as sequential deep networks

In this section, we describe how the two proposed CRFs-based models can be implemented as sequential deep networks, enabling end-to-end training of our whole network model (front-end CNN and fusion module). We first show how the mean-field iterations derived for the multi-scale and the cascade models can be implemented by defining a common structure, the C-MF block, consisting into a stack of CNN layers. Then, we present the resulting sequential network structures and detail the training phase.

By analyzing the two proposed CRF models, we can observe that the mean-field updates derived for the cascade and for the multi-scale models share common terms. As stated above, the main difference between the two is the way the estimated depth at previous scale is handled at the current scale. In the multi-scale CRFs, the relationship among neighboring scales is modeled in the hidden variable space, while in the cascade CRFs the depth estimated at previous scale acts as an observed variable.

In the cascade CRF model, differently from the multi-scale CRF, $\boldsymbol{\mu}_{l-1}^{t}$ acts as an observed variable. To design a common C-MF block among the two models, we introduce two gate functions G1 and G2 (Fig. 3) controlling the computing flow and allowing to easily switch between the two approaches. Both gate functions accept a user-defined boolean parameter (here 1 corresponds to the multi-scale CRF and 0 to the cascade model). Specifically, if G1 is equal to 1, the gate function G1 passes $\boldsymbol{\mu}_{l-1}^{t}$ to the Gaussian filtering block, otherwise to the addition block with unary term. Similarly, G2 controls the computation of the normalization terms and switches between the computation of (7) and (12). Importantly, for each step in the C-MF block we implement the calculation of error differentials for the back-propogation as in . For optimizing the CRF parameters, similar to , the bandwidth values $\theta_{m}$ are fixed and we implement the differential computation for the weights of Gaussian kernels $\beta_{m}$. In this way $\beta_{m}$ are learned automatically with back-propagation.

From mean-field updates to sequential deep networks.

Figure 4 illustrates the implementation of the proposed two CRF-based models using the C-MF block described above. In the figure, each blue box is associated to a mean-field iteration. The cascade model (Fig. 4-left) consists of $L$ single-scale CRFs. At the $l$-th scale, $t_{l}$ mean-field iterations are performed and then the estimated outputs are passed to the CRF model of the subsequent scale after a Rectified Linear Unit (ReLU) operation. To implement a single CRF, we stack $t_{l}$ C-MF blocks and make them share the parameters, while we learn different parameters for different CRFs. For the multi-scale model, one full mean-field updates involves $L$ scales simultaneously, obtained by combining $L$ C-MF blocks. We further stack $T$ iterations for learning and inference. The parameters corresponding to different scales and different mean-field iterations are shared. In this way, by using the common C-MF layer, we implement the two proposed CRFs models as deep sequential networks enabling end-to-end training with the front-end network.

Training the whole network.

We train the network using a two phase scheme. In the first phase (pretraining), the parameters $\mathbf{\Theta}$ and $\{\boldsymbol{\theta}_{l}\}_{l=1}^{L}$ of the front-end network are learned by minimizing the sum of $L$ distinct side losses as in , corresponding to $L$ side outputs. We use a square loss over $Q$ training samples: $\mathcal{L}_{P}=\sum_{l=1}^{L}\sum_{i=1}^{Q}\|\mathbf{s}_{l,i}-\bar{\mathbf{d}}_{i}\|_{2}^{2}$. In the second phase (fine tuning), we initialize the front-end network with the learned parameters in the first phase, and jointly fine-tune with the proposed multi-scale CRF models to compute the optimal value of the parameters $\mathbf{\Theta},\{\boldsymbol{\theta}_{l}\}_{l=1}^{L}$ and $\boldsymbol{\beta}$, with $\boldsymbol{\beta}=\{\beta_{m}\}_{m=1}^{M}$. The entire network is learned with Stochastic Gradient Descent (SGD) by minimizing a square loss $\mathcal{L}_{F}=\sum_{i=1}^{Q}\|F(\mathbf{r}_{i};\mathbf{\Theta},\boldsymbol{\theta}_{l},\boldsymbol{\beta})-\mathbf{d}_{i}^{l}\|_{2}^{2}$.

Experiments

To demonstrate the effectiveness of the proposed multi-scale CRF models for monocular depth prediction, we performed experiments on two publicly available datasets: the NYU Depth V2 and the Make3D datasets. In the following we describe the details of our evaluation.

Datasets. The NYU Depth V2 dataset contains 120K unique pairs of RGB and depth images captured with a Microsoft Kinect. The datasets consists of 249 scenes for training and 215 scenes for testing. The images have a resolution of $640\times 480$. To speed up the training phase, following previous works we consider only a small subset of images. This subset has 1449 aligned RGB-depth pairs: 795 pairs are used for training, 654 for testing. Following , we perform data augmentation for the training samples. The RGB and depth images are scaled with a ratio $\rho\in\{1,1.2,1.5\}$ and the depths are divided by $\rho$. Additionally, we horizontally flip all the samples and bilinearly down-sample them to $320\times 240$ pixels. The data augmentation phase produces 4770 training pairs in total.

The Make3D dataset contains 534 RGB-depth pairs, split into 400 pairs for training and 134 for testing. We resize all the images to a resolution of $460\times 345$ as done in to preserve the aspect ratio of the original images. We adopted the same data augmentation scheme used for NYU Depth V2 dataset but, for $\rho=\{1.2,1.5\}$ we generate two samples each, obtaining 4K training samples.

Front-end CNN Architectures. To study the influence of the frond-end CNN, we consider several network architectures including: (i) AlexNet , (ii) VGG16 , (iii) an encoder-decoder network derived from VGG (VGG-ED) , (iv) VGG Convolution-Deconvolution (VGG-CD) , and (v) ResNet50 . For AlexNet, VGG16 and ResNet50, we obtain the side outputs from different convolutional blocks in which each convolutional layer outputs feature maps with the same size using a similar scheme as in . The number of side-outputs is 5, 5 and 4 for AlexNet, VGG16 and ResNet50, respectively. As VGG-ED and VGG-CD have been widely used for pixel-level prediction tasks, we also consider them in our analysis. Both VGG-ED and VGG-CD have a symmetric structure, and we use the corresponding part of VGG16 for their encoder/convolutional block. Five side-outputs are then extracted from the convolutional blocks of the decoder/deconvolutional part.

Evaluation Metrics. Following previous works , we adopt the following evaluation metrics to quantitatively assess the performance of our depth prediction model. Specifically, we consider: (i) mean relative error (rel): $\frac{1}{N}\sum_{i}\frac{|\bar{d}_{i}-d_{i}^{\star}|}{d_{i}^{\star}}$; (ii) root mean squared error (rms): $\sqrt{\frac{1}{N}\sum_{i}(\bar{d}_{i}-d_{i}^{\star})^{2}}$; (iii) mean log10 error (log10): $\frac{1}{N}\sum_{i}\|\log_{10}(\bar{d}_{i})-\log_{10}(d_{i}^{\star})\|$ and (iv) accuracy with threshold $t$: percentage (%) of $d_{i}^{\star}$ subject to $\max(\frac{d_{i}^{\star}}{\bar{d}_{i}},\frac{\bar{d}_{i}}{d_{i}^{\star}})=\delta<t~{}(t\in[1.25,1.25^{2},1.25^{3}])$.

Implementation Details. We implement the proposed deep model using the popular Caffe framework on a single Nvidia Tesla K80 GPU with 12 GB memory. As described in Section 3.3, training consists of a pretraining and a fine tuning phase. In the first phase, we train the front-end CNN with parameters initialized with the corresponding ImageNet pretrained models. For AlexNet, VGG16, VGG-ED and VGG-CD, the batch size is set to 12 and for ResNet50 to 8. The learning rate is initialized at $10^{-11}$ and decreases by 10 times around every 50 epochs. 80 epochs are performed for pretraining in total. The momentum and the weight decay are set to 0.9 and 0.0005, respectively. When the pretraining is finished, we connect all the side outputs of the front-end CNN to our CRFs-based multi-scale deep models for end-to-end training of the whole network. In this phase, the batch size is reduced to 6 and a fixed learning rate of $10^{-12}$ is used. The same parameters of the pre-training phase are used for momentum and weight decay. The bandwidth weights for the Gaussian kernels are obtained through cross validation. The number of mean-field iterations is set to 5 for efficient training for both the cascade CRFs and multi-scale CRFs. We do not observe significant improvement using more than 5 iterations. Training the whole network takes around 25 hours on the Make3D dataset and $\sim 31$ hours on the NYU v2 dataset.

2 Experimental Results

Analysis of different multi-scale fusion methods. In the first series of experiments we consider the NYU Depth V2 dataset. We evaluate the proposed CRF-based models and compare them with other methods for fusing multi-scale CNN representations. Specifically, we consider: (i) the HED method in , where the sum of multiple side output losses is jointly minimized with a fusion loss (we use the square loss, rather than the cross-entropy, as our problem involves continuous variables), (ii) Hypercolumn , where multiple score maps are concatenated and (iii) a CRF applied on the prediction of the front-end network (last layer) a posteriori (no end-to-end training). In these experiments we consider VGG-CD as front-end CNN.

The results of our comparison are shown in Table 1. It is evident that with our CRFs-based models more accurate depth maps can be obtained, confirming our idea that integrating complementary information derived from CNN side output maps within a graphical model framework is more effective than traditional fusion schemes. The table also compares the proposed cascade and multi-scale models. As expected, the multi-scale model produces more accurate depth maps, at the price of an increased computational cost. Finally, we analyze the impact of adopting multiple scales and compare our complete models (5 scales) with their version when only a single and three side output layers are used. It is evident that the performance improves by increasing the number of scales.

As the proposed models are based on the idea of progressively refining the obtained prediction results from previous layers, we also analyze the influence of the stacking order on the performance of the cascade model (Table 2). We compare two different schemes: the first indicating that the cascade model operates from the inner to the outer layers and the other representing the reverse order. Our results confirm the validity of our original assumption: a coarse to fine approach leads to more accurate depth maps.

Evaluation of different front-end deep architectures. As discussed above, the proposed multi-scale fusion models are general and different deep neural architectures can be employed in the front end network. In this section, we evaluate the impact of this choice on the depth estimation performance. The results of our analysis are shown in Table 3, where we consider both the case of pretrained model (i.e. only side losses are employed but not CRF models), indicated with P, and the fine-tuned model with the cascade CRFs (CRF). Similar results are obtained in the case of the multi-scale CRF. As expected, in both cases deeper models produced more accurate predictions and ResNet50 outperforms other models. Moreover, VGG-CD is slightly better than VGG-ED, and both these models outperforms VGG16. Importantly, for all considered networks there is a significant increase in performance when applying the proposed CRF-based models.

Figure 5 depicts some examples of predicted depth maps on the NYU Depth V2 dataset. As shown in the figure, the proposed approach is able to generate robust depth predictions. By comparing the reconstructed depth images obtained with pretrained models (e.g. using VGG-CD and ResNet50 as front-end networks) with those computed with our models, it is clear that our multi-scale approach significantly improves prediction accuracy.

Comparison with state of the art. We also compare our approach with state of the art methods on both datasets. For previous works we directly report results taken from the original papers. Table 4 shows the results of the comparison on the NYU Depth V2 dataset. For our approach we consider the cascade model and use two different training sets for pretraining: the small set of 4.7K pairs employed in all our experiments and a larger set of 95K images as in . Note that for fine tuning we only use the small set. As shown in the table, our approach outperforms all baseline methods and it is the second best model when we use only 4.7K images. This is remarkable considering that, for instance, in 120K image pairs are used for training.

We also perform a comparison with state of the art on the Make3D dataset (Table 5). Following , the error metrics are computed in two different settings, i.e. considering (C1) only the regions with ground-truth depth less than 70 and (C2) the entire image. It is clear that the proposed approach is significantly better than previous methods. In particular, comparing with Laina et al. , the best performing method in the literature, it is evident that our approach, both in case of the cascade and the multi-scale models, outperforms by a significant margin when Laina et al. also adopt a square loss. It is worth noting that in a training set of 15K image pairs is considered, while we employ much less training samples. By increasing our training data (i.e. $\sim 10$K in the pretraining phase), our multi-scale CRF model also outperforms with Huber loss (log10 and rms metrics). Finally, it is very interesting to compare the proposed method with the approach in Liu et al. , since in a CRF model is also employed within a deep network trained end-to-end. Our method significantly outperforms in terms of accuracy. Moreover, in a time of 1.1sec is reported for performing inference on a test image but the time required by superpixels calculations is not taken into account. Oppositely, with our method computing the depth map for a single image takes about 1 sec in total.

Conclusions

We introduced a novel approach for predicting depth images from a single RGB input, which is also particularly useful for other cross-modal tasks . The core of the method is a novel framework based on continuous CRFs for fusing multi-scale representations derived from CNN side outputs. We demonstrated that this framework can be used in combination with several common CNN architectures and is suitable for end-to-end training. The extensive experiments confirmed the validity of the proposed multi-scale fusion approach. While this paper specifically addresses the problem of depth prediction, we believe that other tasks in computer vision involving pixel-level predictions of continuous variables, can also benefit from our implementation of mean-fields updates within the CNN framework.

References