Unsupervised Learning of Depth and Deep Representation for Visual Odometry from Monocular Videos in a Metric Space

TL;DR

This paper introduces DFO, an unsupervised framework for depth estimation and hierarchical feature learning from monocular videos, improving visual odometry by directly estimating camera motion in a metric space.

Contribution

It proposes a novel direct feature odometry framework that learns hierarchical features without supervision and estimates pose directly, enhancing compatibility with traditional SLAM systems.

Findings

Effective depth and feature learning demonstrated on KITTI dataset

Direct pose estimation improves scale consistency

Compatible with existing SLAM pipelines

Abstract

For ego-motion estimation, the feature representation of the scenes is crucial. Previous methods indicate that both the low-level and semantic feature-based methods can achieve promising results. Therefore, the incorporation of hierarchical feature representation may benefit from both methods. From this perspective, we propose a novel direct feature odometry framework, named DFO, for depth estimation and hierarchical feature representation learning from monocular videos. By exploiting the metric distance, our framework is able to learn the hierarchical feature representation without supervision. The pose is obtained with a coarse-to-fine approach from high-level to low-level features in enlarged feature maps. The pixel-level attention mask can be self-learned to provide the prior information. In contrast to the previous methods, our proposed method calculates the camera motion with a direct method rather than regressing the ego-motion from the pose network. With this approach, the consistency of the scale factor of translation can be constrained. Additionally, the proposed method is thus compatible with the traditional SLAM pipeline. Experiments on the KITTI dataset demonstrate the effectiveness of our method.

Tables

Table 1. Table 1: Monocular depth results on KITTI 2015 [ 27 ] with the split of Eigen et al. [ 10 ] . For the dataset column, K and CS denote training on the KITTI [ 13 ] and Cityscapes datasets [ 9 ] respectively. DN is an acronym for depth normalization, and PS represents point selection. The results for other methods are taken from [ 14 , 42 , 44 , 25 , 36 ] . Note that in the results from Wang et al . [ 36 ] , DN eliminates the scale of depth maps.

Method	Supervised	Dataset	Error metric				Accuracy metric
			Abs Rel	Sq Rel	RMSE	RMSE log
Eigen et al. [10]	Depth	K	0.203	1.548	6.307	0.282	0.702	0.890	0.958
Liu et al. [22]	Depth	K	0.202	1.614	6.523	0.275	0.678	0.895	0.965
Godard et al. [14]	Pose	K	0.148	1.344	5.927	0.247	0.803	0.922	0.964
Zhou et al. [44]	No	K	0.208	1.768	6.856	0.283	0.678	0.885	0.957
Yin et al. [42] VGG	No	K	0.164	1.303	6.090	0.247	0.765	0.919	0.968
Mahjourian et al. [25]	No	K	0.163	1.240	6.220	0.250	0.762	0.916	0.968
Wang et al. [36]	No	K	0.213	3.770	6.925	0.294	0.758	0.909	0.958
Wang et al. [36] DN	No	K	0.151	1.257	5.583	0.228	0.810	0.936	0.974
Our method (Image only)	No	K	0.247	2.003	7.239	0.318	0.612	0.855	0.943
Our method (w/o PS)	No	K	0.156	1.151	5.580	0.228	0.789	0.930	0.974
Our method	No	K	0.152	1.172	5.576	0.226	0.797	0.933	0.975
Godard et al. [14]	Pose	CS+K	0.124	1.076	5.311	0.219	0.847	0.942	0.973
Zhou et al. [44]	No	CS+K	0.198	1.836	6.565	0.275	0.718	0.901	0.960
Mahjourian et al. [25]	No	CS+K	0.159	1.231	5.912	0.243	0.784	0.923	0.970
Our method	No	CS+K	0.152	1.151	5.577	0.226	0.794	0.933	0.976

Table 2. Table 2: Absolute Trajectory Error (ATE) on the KITTI odometry dataset. The results of other baselines are taken from [ 44 , 42 , 36 ] . For the type column, F denotes the feature-based method, R denotes the CNN regression method and D denotes the direct method. The DSO results are taken from [ 20 ] . Zhou†denotes the pose estimation results that take both forward and backward as inputs in the training process. For our method, we evaluate the integrated poses of 3-frame and 5-frame snippets.

Method	Type	Seq. 09	Seq. 10
ORB-SLAM (full)	F	0.014 $\pm$ 0.008	0.012 $\pm$ 0.011
ORB-SLAM (short)	F	0.064 $\pm$ 0.141	0.064 $\pm$ 0.130
Zhou et al. [44]	R	0.021 $\pm$ 0.017	0.020 $\pm$ 0.015
Zhou et al. [44] †	R	0.665 $\pm$ 0.150	0.467 $\pm$ 0.202
DSO (full)	D	0.065 $\pm$ 0.059	0.047 $\pm$ 0.043
Wang et al. [36]	R+D	0.045 $\pm$0.108	0.033 $\pm$ 0.074
Our method (3-frame)	D	0.017 $\pm$ 0.017	0.011 $\pm$ 0.010
Our method (5-frame)	D	0.025 $\pm$ 0.020	0.016 $\pm$ 0.014

Equations

$$\mathbf{\xi }=\arg \underset{\mathbf{\xi }}{\min }{\Vert {\mathbf{W}}_t({\mathcal{I}}_t)\odot \left({\tilde{\Phi }}_s({\mathcal{I}}_s)-{\Phi }_t({\mathcal{I}}_t)\right)\Vert }^2$$

$$f_d,f_{\varphi }=\arg \underset{f_d,f_{\varphi }}{\min }\Vert {\tilde{\mathcal{I}}}_s-{\mathcal{I}}_t{\Vert }^2.$$

$${\mathbf{u}}_s\sim \mathbf{K}{\mathbf{T}}_{t\to s}{\mathbf{Z}}_t\left({\mathbf{u}}_t\right){\mathbf{K}}^{-1}{\mathbf{u}}_t$$

$$E(\mathbf{\xi })=\sum _i{w}_t({\mathbf{u}}_i)\Vert {\mathbf{r}}_i(\mathbf{\xi },d_i,{\mathbf{u}}_i){\Vert }_2^2$$

$${\mathbf{r}}_i={\varphi }_t({\mathbf{u}}_i)-{\varphi }_s(\omega ({\mathbf{u}}_i,d_i,\mathbf{\xi }))$$

$$\begin{array}{rl}\underset{\mathbf{\xi }}{\min }& \Vert \left({\mathbf{w}}_t^{\mathsf{T}}\otimes 1_{(C\cdot K\cdot K)\times 1}\right)\circ \left(\Phi ({\mathcal{I}}_t)-\Phi ({\mathcal{I}}_s)\mathcal{W}(\mathbf{D},\mathbf{\xi })\right){\Vert }_F^2\end{array}$$

$$\sum _i{w}_{t,i}{\mathbf{J}}_i^T{\mathbf{J}}_i\delta \mathbf{\xi }=-\sum _i{w}_{t,i}{\mathbf{J}}_i^T{\mathbf{r}}_i(\mathbf{\xi })$$

$${\mathbf{T}}_{i\to j}^{new}\leftarrow \mathbf{G}(\delta \mathbf{\xi })\cdot {\mathbf{T}}_{i\to j}$$

$$w_{t,i}=softmax\left(\left(\log \left(p)+m\right)\right)/\tau \right)$$

$${\mathcal{L}}_{sp}=KL(\rho ||\hat{\rho })=\rho \log (\frac{\rho }{\hat{\rho }})+(1-\rho )\log (\frac{1-\rho }{1-\hat{\rho }})$$

$${\mathbf{t}}^{(l-1)}=\frac{\overline{z^{(l-1)}}}{\overline{z^{(l)}}}{\mathbf{t}}^{(l)}$$

$${\mathcal{L}}_{ap}=\alpha \frac{1-SSIM({\mathcal{I}}_t,\widetilde{{\mathcal{I}}_s})}{2}+(1-\alpha )\Vert {\mathcal{I}}_t-\widetilde{{\mathcal{I}}_s}{\Vert }_1$$

$$f(x)=\{\begin{array}{ll}x& x<ϵ\\ 0.1x+0.9ϵ& x>=ϵ\end{array}$$

$${\mathcal{L}}_{smooth}(Z_i)=|{\partial }_x{Z}_i|e^{-\Vert {\partial }_x{\mathcal{I}}_i\Vert }+|{\partial }_y{Z}_i|e^{-\Vert {\partial }_y{\mathcal{I}}_i\Vert }$$

$$\begin{array}{rl}\mathcal{L}=& \sum _l^4\sum _{i\ne j\in \{1,2,\dots ,n\}}{\mathcal{L}}_{ap}(D_i^{(l)},{\mathbf{T}}_{i\to j},{\mathcal{I}}_i^{(l)},{\mathcal{I}}_j^{(l)})\\ & +\sum _i^n\frac{{\lambda }_{sm}}{2^{l-1}}{\mathcal{L}}_{smooth}(Z_i^{(l)})+{\lambda }_{sp}{\mathcal{L}}_{sp}+{\lambda }_{ae}{\mathcal{L}}_{ae}\end{array}$$

Full text

1 Introduction

Inferring the structure of scenes and ego-motion through motion is a basic capability of humans. It is also one of the essential research topics in robotics fields, known as the simultaneous localization and mapping (SLAM) problem. This module has become one of the fundamental building blocks for many emerging technologies – from autonomous cars and unmanned aerial vehicles (UAVs) to virtual and augmented reality.

The central idea for a visual odometry method is to calculate the camera motion by locating and aligning the corresponding parts in different viewpoints. Nevertheless, the natural images lie on a nonlinear manifold [40], and the nonlinear manifolds of pixel space are locally Euclidean, but globally non-Euclidean. Hence, the selection of valid features and the metric for comparison are crucial for pose estimation. For feature-based methods, camera pose is calculated from the sparse set of keypoints that are extracted and matched between two consecutive images. For direct methods, the ego-motion can be obtained by minimizing the photometric errors of two consecutive images. For learning-based pose estimation methods, especially unsupervised deep learning ones, the poses are regressed from the CNNs directly with the forward movement assumption implicitly (see Section 4.3 for details).

In this work, we present a conceptually simple and unified framework to learn the depth and feature representation from monocular videos. Previous SLAM methods suggest that feature points, structural information and objects can all contribute to the visual odometry problem. On the other hand, visualization of deep neural networks reveals the hierarchical nature of the features in the neural networks: the lower layers of a CNN model capture basic features (e.g., corners, edges) and the higher layers tend to extract high-level task-specific abstractions [43]. Therefore, we construct hierarchical feature pyramids for pose estimation using CNN. We utilize the object-related features to obtain a rough estimate of the ego-motion, and then the pose is refined with low-level local features. The pose is calculated by aligning the features of different viewpoints. A feature selection mask is also obtained to locate the valid features with a self-attention mechanism. Our method can be considered as a unification of different visual odometry methods in the aspect of feature representation. In addition, the ability to abstract and locate features along the multiscale feature pyramid allows the integration with the traditional pipelines, such as marginalization or keyframe selection.

In this paper, we propose a novel unsupervised learning framework to learn the feature representation and depth for the visual odometry problem. Specifically, we make the following contributions:

We can learn the hierarchical feature representation by the metric space for ego-motion estimation. The attention mechanism is applied to provide prior information at different levels for valid feature selection. 2. 2.

We present a novel unsupervised pose and depth estimation framework using a direct method without a forward motion assumption. 3. 3.

We propose to use the 3-frame snippets to maintain the scale consistency of translation and depth.

Our unsupervised approach outperforms previous unsupervised methods and achieves comparable results with supervised techniques for the depth estimation task. Compared with other visual odometry methods, the effectiveness of our feature representation learning paradigm are manifested in the pose estimation experiments.

2 Related Work

Traditional SLAM methods Acknowledging the environment’s structure through motion is a well-studied problem in the robotics community. The SLAM methods can be mainly divided into three categories: feature-based (indirect) methods, direct methods and learning-based methods.

The SLAM field was dominated by feature-based (indirect) methods for a long time. In recent years, a number of different approaches have gained in popularity, such as direct methods and semantic SLAM [7]. Unlike feature-based (indirect) visual odometry methods (e.g., ORB-SLAM [28]), direct visual odometry methods use the image intensities information directly to predict the motion and geometry of the scenes. Hence, feature points do not need to be extracted and matched, and the data association and pose estimation are expressed as a photometric loss function. The direct visual odometry methods can achieve higher accuracy and robustness for scenes with few feature points. Semantic SLAM, on the other hand, attempts to locate the robots and map the environments with objects or geometric information.

These methods may fail under certain conditions such as low texture, stereo ambiguities and occlusions. The quality of feature points is essential for the feature-based SLAM method. Agrawal et al. [1] show that features learned from a convolution neural network outperform the traditional hand-designed features. Learning-based slam may become a promising direction.

Unsupervised pose and depth estimation from videos using deep learning Although depth estimation [10, 22], pose prediction or combined tasks have made great progress with ground truth structural information collected from sensors such as stereo cameras and LIDAR [34, 41], it is still meaningful to learn the pose and structure of surroundings from monocular videos without supervision. By doing this, large quantities of data can be collected and utilized directly.

Zhou et al. [44] propose a framework that jointly trains the pose estimation and depth prediction networks. In addition to the depth maps and camera poses, the work of Vijayanarasimhan et al. [35] can predict scene motion from an additional subnetwork. To improve the quality of estimated depth values, several constraints are introduced. In [42], optical flow estimation is included as an additional module to segment the scenes with rigid structure and nonrigid objects. Mahjourian et al. [25], on the other hand, incorporate the estimated point clouds of two consecutive images as additional constraints. Due to a lack of supervised signals (e.g., the ground truth depth values, poses and stereo images), scale variance of translation and depths may induce vanishing depth problem during training. Wang et al. [36] observe this phenomenon and alleviate it by normalizing the inverse depth maps. The depth normalization trick can greatly improve the performance of relative depth estimation at the expense of the scale factor.

Currently, determining the approach to incorporate the traditional SLAM methods with deep neural networks is still an open problem. The depth prediction neural network can be used in a variety of scenarios, such as keyframe initialization [33], scale recovery and virtual stereo constraints [41]. CodeSLAM [6] has been proposed as a framework for dense representation of scene geometry using a variational autoencoder. The pose network, however, cannot tightly integrate with the widely applied modules in traditional visual odometry methods (e.g., bundle adjustment, keyframe selection and loop closure) because it cannot locate the corresponding features in the feature maps.

3 Method

In this section, we first present an overview of our direct feature odometry method, and then we describe the details of each module and loss function in our algorithm.

3.1 Framework Overview

Our framework consists of two subnetworks. One VGG-based network is used to predict the depth pyramid of one input image. The other network aims to produce two feature pyramids of two consecutive input images for pose estimation. The structure of the feature representation network is shown in Figure 3, and an autoencoder network is used to encode the inputs through nonlinear dimensionality reduction [38]. Due to the ReLU activation in our network, all dimensions in feature space are nonnegative. A Gaussian smoothing kernel (kernel size= $3\times 3$) is applied to smooth the feature maps in every channel.

Without loss of generality, we use the pose calculation at the 1-st level to describe the details of our pipeline, which is depicted in Figure 2. The procedure of our method can be summarized in three main steps:

We map the consecutive images into the deep feature representation through the feature representation network. Additionally, the feature point selection masks of the target image $\mathbf{W}_{t}(\mathcal{I}_{t})\in\{0,1\}$ are generated from the separate branches with a self-attention mechanism. The corresponding depth pyramid is obtained through the depth prediction network.

To obtain the feature maps of two views for comparison, a Siamese architecture [8] is applied for the feature generation network, and the shared weights ensure the input images are projected into the same latent space. 2. 2.

We compute the relative pose from multiscale features and depth maps using the direct method. The pose $\bm{\xi}$ is calculated by warping the feature $\widetilde{\Phi}_{s}$ and $\Phi_{t}$ in the selected positions. The pose is initialized with the results from the high-level layer.

[TABLE]

In each iteration, outliers are removed before calculating the incrementation of the pose. The final egomotion of the camera is obtained through several rounds of iteration. 3. 3.

We warp the source image $\mathcal{I}_{s}$ to the target image $\mathcal{I}_{t}$ using the obtained depth and pose to construct the loss function. By minimizing the view synthesis errors between the warped source image $\widetilde{\mathcal{I}_{s}}$ and the target image, the parameters of the depth estimation network and feature learning networks, $f_{d}$ and $f_{\phi}$, are updated

[TABLE]

View synthesis from different points of view as supervision is applied for our unsupervised learning system [44, 32]. The core idea of this view synthesis pipeline is to reconstruct the target view by sampling pixels from source view given the depth map $\mathbf{Z}$ and relative transformation matrix $\mathbf{T}$.

The differentiable bilinear sampling mechanism [17] is used to interpolate the source feature map $\Phi_{s}$ and source image $\mathcal{I}_{s}(\mathbf{u}_{s})$. The homogeneous coordinates of a point in the source view $\mathbf{u}_{s}$ can be obtained by projecting the point in the target view $\mathbf{u}_{t}$, which can be formulated as:

[TABLE]

where $\mathbf{K}$ denotes the camera intrinsics matrix in the corresponding level in the pyramid.

These three steps demonstrate the whole training pipeline of our method. In the inference stage, we only need the first two steps to obtain the depth maps and camera pose (see Figure 1). In the following, we will describe the details of each module in these three procedures.

3.2 Direct Feature Odometry

Visual odometry is a process to estimate the ego-motion of the camera by minimizing the energy function. The energy function is designed to minimize the difference between the feature point $\mathbf{u}$ in the target feature map $\phi_{t}(\mathbf{u})$ and the corresponding point in the source feature map $\phi_{s}(\omega(\mathbf{u},d,\bm{\xi}))$. The projective warp function $\omega(\mathbf{u},d,\bm{\xi})$ projects the point $\mathbf{u}$ in the feature map with the inverse depth $d=z^{-1}$ and transformation $\bm{\xi}$ to the target frame. Lie algebra $\mathfrak{se}(3)$ is chosen as the minimal representation of the camera transformation, which is the tangent space of $SE(3)$ at the identity. The elements of lie algebra $\bm{\xi}$ are mapped to $SE(3)$ by the exponential map $\mathbf{G}=\exp_{\mathfrak{se}(3)}(\bm{\xi})$ [23].

One of the major contributions of this work is the unsupervised feature representation learning by the metric space. For deep metric learning, the distance of the feature points is obtained by calculating the Euclidean distance in the projected space [16, 2, 38].

The distance between two aligned feature maps is:

[TABLE]

where $w_{t}(\mathbf{u}_{i})\in\{0,1\}$ denotes the selection of the feature vector, and $\mathbf{r}_{i}$ denotes the residual feature vector, which has the following expression:

[TABLE]

where $\phi(\bm{u}_{i})$ denotes the small $K\cdot K$ feature patches around the feature point $\bm{u}_{i}$. Note that $K$ and $C$ denote kernel and channel sizes, respectively, and $H$ and $W$ denote height and width of feature maps, respectively. This energy function is the maximum likelihood estimate of the rigid body transformation $\bm{\xi}$ between two consecutive frames by assuming i.i.d Gaussian residuals.

Because there are no labels for feature representation learning, we can not locate the corresponding features in different feature maps directly. Therefore, the alignment of the feature map in each view is performed to minimize the distance in each dimension. We measure the cosine similarity between different viewpoints in each dimension. In order to integrate the similarity measurements with direct method and network training, the features at each level are z-score normalized ($E(\phi_{s})=\mathbf{0}$, $E(\phi_{t})=\mathbf{0}$, $Var(\phi_{s})=\mathbf{1}$ and $Var(\phi_{t})=\mathbf{1}$) before comparison. After data normalization, we can calculate the pose by feature comparison because Euclidean distance, Pearson correlation coefficient and cosine similarity are equivalent [5]. The warping features of two views can be expressed in a compact matrix form as follows:

[TABLE]

where $\mathbf{w}_{t}\in\{0,1\}^{(H\cdot W)\times 1}$ denotes the vectorization of the point selection mask, $\Phi(\mathcal{I})\in\mathbb{R}^{(C\cdot K\cdot K)\times(H\cdot W)}$ denote the horizontal concatenation of the feature vector $\phi(\mathbf{u})$, $\mathcal{W}(\mathbf{D},\bm{\xi})\in\{0,1\}^{(H\cdot W)\times(H\cdot W)}$ denotes the warping matrix for feature alignment, and the summation of all the elements in each column of $\mathcal{W}(\mathbf{D},\bm{\xi})$ is $1$. Additionally, $\otimes$ and $\circ$ denote the Kronecker product and Hadamard product of matrices respectively, $\mathbf{1}_{m\times n}\in\mathbb{R}^{m\times n}$ is a matrix of ones. $\|\cdot\|_{F}$ denotes the Frobenius norm.

Given the feature representation and depth values, the pose of the camera is solved in an iterative Gauss-Newton procedure. The increment of the pose can be obtained by minimizing the second-order approximation of $E(\bm{\xi})$:

[TABLE]

where $\mathbf{J}_{i}:=\nabla r_{i}(\bm{\xi}^{(0)},\mathbf{u}_{i})$ is the Jacobian of the residual with respect to the initial pose $\bm{\xi}^{(0)}$. The updated $\delta\bm{\xi}$ is obtained by using the inverse compositional algorithm [3], and the Jacobian matrix is computed once per iteration to accelerate the calculation. Accumulated residual errors are decreasing during this process.

The updated relative transformation is computed as:

[TABLE]

After several rounds of iteration, we can obtain the final estimated pose.

Point Selection There are two schemes of point selection: sparse methods and dense methods. Sparse methods use a selected set of points for pose estimation, and dense methods use all pixels with the addition of a geometry prior [11]. In this work, a sparse feature mask is learned to select feature points for pose calculation. We apply the pixelwise attention layer to output the per-feature point mask. The probability that selection variable $w_{t,i}$ follows a Bernoulli distribution is $P(w_{t,i}=1)=p$. Label $1$ in the mask indicates that the feature point $i$ in the corresponding location is involved for pose calculation, with label [math] otherwise. The hard threshold for the feature point selection is nondifferential. Therefore, to achieve the continuous relaxation, the Gumbel Sampling Trick [18, 24, 21] is applied to address this issue:

[TABLE]

where $m$ follows the standard Gumbel distribution and $\tau$ is the temperature parameter. As $\tau\mapsto 0$, the sigmoid function approaches the argmax function. The temperature parameter is initialized to $1$ and decreased to $0.1$ during training, as suggested in [21].

The sparsity of the feature selection mask is constrained by the KL divergence:

[TABLE]

where $\rho$ is the target distribution of feature points, and $\hat{\rho}=\sum_{i}^{H\cdot W}w_{t,i}/(H\cdot W)$ is the probability of valid points.

Outlier Removal. Outliers will worsen the calculation of ego-motion. Therefore, outlier removal is an essential procedure for a visual odometry algorithm. In traditional visual odometry methods, the effects of outliers are reduced by updating the covariance matrix using iteratively reweighted least squares (IRLS). However, in our framework, the deep feature representation is learned rather than using the photometric error of the image’s intensity directly. Similar to the DSO method [11], the outliers and occlusion are detected and removed by setting the adapted threshold. If the feature code error surpasses the threshold, the feature points in the corresponding location are removed. The threshold is set as $Threshold=\frac{1}{2}\left(median(\|\mathbf{r}\|_{2}^{2})+max(\|\mathbf{r}\|_{2}^{2})\right)$ to remove approximately $10\%$ of the feature points.

Scale consistency. The scale of depth values is proportional to that of the translation. Our method can calculate the transformation matrix directly. In this way, the scale factor of translation is affected by the magnitude of depth only. We assume that the depth prediction network can maintain the relative depths through the dataset. The inconsistency of the scale factor comes from two sources: (i) depth scale inconsistency through sequences and (ii) scale inconsistency through the depth pyramid.

(i). Pose network regresses the poses and depths directly from two subnetworks which takes three-frame snippets as inputs. The scale factor only depends on the scale of depth in the middle frame. Decreasing the scale of the inverse depth and updating the pose accordingly will lead to the same appearance loss [36]. For our method, we replace the pose regression network with the traditional direct visual odometry pipeline. Therefore, the consistency of the depth scale is preserved by using the constrains from three consecutive images. The constraints of depths and poses in 3-frame snippets are shown in Figure 4.

(ii). Scale inconsistency through the depth pyramid (see Figure 5). For the pose calculation process, both the depth pyramid and the corresponding feature pyramids are used. To ensure the scale consistency for each level, the translation at the $l-1$-th level is initialized with rescaled translation at the $l$-th level in a larger resolution:

[TABLE]

where $\mathbf{t}^{(l)}$ denotes the translation calculated at the $l$-th level, and $\overline{z^{(l)}}$ denotes the mean depth value at the $l$-th depth map. The initial translation at the $4$-th level is set to $\mathbf{t}^{(4)}=\mathbf{0}$, and the rotation matrix is set to the identity matrix $\mathbf{R}^{(4)}=I_{3}$.

3.3 Training Loss

Appearance Loss Similar to previous methods, we use a combination of $L1$ and the structural similarity index (SSIM) [39] losses to measure the similarity between two images. The $L1$ term captures the low-frequency structure of the images. The SSIM term, on the other hand, maintains the perceptual similarity. The appearance loss is defined as follows:

[TABLE]

where $\alpha$ is set to $0.85$ and we use $3\times 3$ filter blocks for the SSIM term. The first term is also known as the structural dissimilarity (DSSIM).

In urban environments, such as in the KITTI dataset, the moving objects and occlusions are considered as outliers. Lowering the weight of the outliers will improve the regression results [4]. We directly set the hard threshold to penalize both the DSSIM and $L1$ error term by:

[TABLE]

where $\epsilon$ is the threshold, and $\epsilon$ is set to 0.15 and 0.3 for the DSSIM and $L1$ term, respectively.

Edge-aware Depth Smoothness Loss. The smoothness of the depth map is introduced by the $L_{1}$ penalty on the depth gradients $\partial Z$. The depth gradients are weighted by image gradients because the discontinuities of depth coincide with the edges of input images.

[TABLE]

The smoothness constraint of the depth may help the training process. The vanishing disparity is observed in [30, 36] for penalizing the gradients of disparity.

To summarize, our final objective function becomes:

[TABLE]

where $\lambda_{sm}$, $\lambda_{sp}$ and $\lambda_{ae}$ denote the weight of smoothness, sparsity and the autoencoder loss term, respectively, $l$ indicates the scale of the image pyramid, and $n$ is number of images as sequence inputs. The autoencoder loss function $\mathcal{L}_{ae}$ is to ensure the outputs can reconstruct the input images by minimizing the $L2$ error.

4 Experiments

In this section, we first describe our network architecture and training details, and then we evaluate the performance of our system on single-view depth and ego-motion prediction tasks.

4.1 Implementation Details

Network Architecture For the depth estimation task, we apply the same DispNet network as in [26, 44, 36, 42] for comparison. Given a single view input image, multiscale inverse depth maps can be predicted. We use $1/(10x+0.01)$ to obtain the depth map. For the feature representation learning network, the residual attention block [37] is used to extract features of different scales and levels for further calculation. The advantage of the residual attention block is that the spatial attention and channel attention are mixed using the bottom-up and top-down feed-forward structure. The spatial information may be lost with the enlarged receptive field in the deeper layers. We concatenate the image intensities together with the deep features to maintain the spatial information. We apply the U-Net structure for feature representation learning. The skip connections in U-Net will accelerate the training process.

Training Details Our experiment is conducted using the PyTorch framework [29]. There are two subnetworks that need to be trained for our method. We adopt a stagewise training strategy. We first train the autoencoder network to obtain the features of different levels. For the depth estimation network, the initialization of this network is crucial. It can be obtained either from [44] or from our methods trained with images only. Then, the two networks are jointly trained in an end-to-end fashion.

During training, we resize the image sequences to a resolution of $128\times 416$ and remove the static frames. We also perform random resizing, cropping, and other color augmentations to prevent overfitting during training with a $50\%$ chance. For color augmentations, we perform the random gamma, brightness, and color shifts by sampling from uniform distributions in the range $[0.9,1.1]$ with a $50\%$ chance. The two subnetworks are initialized with [15]. The kernel size of the small patch, the channel size of the output features and the probability of selected points at each level of the feature representation learning network are shown in Figure 5. The network is optimized by Adam [19], where $\beta_{1}=0.9,\beta_{2}=0.999$. We use an initial learning rate of $1\times 10^{-5}$ and drop to $1\times 10^{-6}$. The weights of the loss terms are set to $\lambda_{sm}=0.1$, $\lambda_{sp}=0.01$ and $\lambda_{ae}=0.01$. The training process typically takes approximately 30 epochs to converge.

4.2 Visualization of the Feature Maps

We construct multiscale feature and depth pyramids for our method. Different resolutions of the feature and depth maps are learned separately. The feature regions involved in the pose estimation are illustrated using Grad-CAM [31]. As shown in Figure 6, different levels of feature maps can learn the feature representations in a hierarchical way. The pose is calculated through high-level to low-level features in enlarged feature maps.

4.3 Monocular Depth Estimation

We implement the same split of Eigen et al. [10] to evaluate the performance of our DFO framework with others in the single-view depth estimation task. We use the same VGG-based network and follow the same training protocol as in [44, 42, 25, 36]. Note that the modification of the neural network architecture and resolution of input images will affect the performance of the algorithm. The length of image sequences is set to 3. The ground truth depth maps are projected from point clouds using LiDAR for evaluation.

As shown in Table 1, our method performs better than supervised methods (i.e., Eigen et al. [10], Liu et al. [22] and Godard et al. [14]) and unsupervised methods (i.e., Yin et al. [42], Zhou et al. [44] and Mahjourian et al. [25]). Our method does not use other constraints such as ICP (i.e., Mahjourian et al. [25]) and optical flow (i.e., Yin et al. [42]). Therefore, the performances of our method could be further improved by incorporating these loss functions.

Our method performs comparably to the results that consider the depth normalization trick ($\tilde{d_{i}}=\frac{Nd_{i}}{\sum_{j=1}^{N}d_{j}}$) in [36]. The normalization of the disparity trick is applied to solve the scale ambiguity between translation and depth, which is also used for key frame selection in LSD-SLAM [12]. It can significantly improve the depth estimation results by eliminating the scale of the estimated depth map. Therefore, the relative depth estimation networks are obtained. The experimental results of DDVO [36] without the depth normalization are shown in Table 1. The proposed method, on the other hand, can preserve the scale of the depth map.

We also train our model on the Cityscapes dataset (10 epochs) and then fine tune it on the KITTI dataset (5 epochs). The results show that the supervised methods (i.e., Godard et al. [14]) can notably benefit from the enlarged training set. The moving objects that appear in the Cityscapes dataset hamper the further improvement of our method even when more training data are involved.

We perform an ablation study of our method. The results manifest that the learned feature representation can greatly improve the performances. The sparse visual odometry achieved by point selection in the feature map can also benefit the accuracy of the estimated depth values.

4.4 Camera Pose Estimation

The pose estimation method in our framework is evaluated with the official KITTI odometry split. The dataset contains 11 driving sequences with the ground truth pose captured with IMU/GPS. We follow the same training and testing split as in [44, 42, 25, 36]; the 00-08 sequences are used for training and the 09-10 sequences for testing. The ORB-SLAM [28] (feature-based monocular visual odometry method) and the DSO method [11] (direct method) are compared with our method. There are two variants of the ORB-SLAM for comparison. The ORB-SLAM (short) version takes 5-frame snippets as inputs. The ORB-SLAM (full) version, on the other hand, takes the entire trajectory as inputs, and the calculated poses are optimized with postprocessing procedures such as loop closure, bundle adjustment and relocalization. The DOS (full) also takes full sequences and postprocessing steps. Our method calculates the ego-motion from feature maps of two input images, and the scale factor of the translation is consistent. We simply integrate the relative pose of two consecutive views for pose evaluation. The pose estimation results are shown in Table 2.

As shown in Table 2, our method outperforms other direct visual odometry methods by a large margin even without postprocessing. As shown in Table 2, we compare the results with vary length of inputs. It shows that the accumulated errors will worsen the performance of our method. Our results can be further improved by involving postprocessing steps in the traditional visual odometry pipeline.

Comparison with the pose network The pose network takes a sequence of images as inputs and outputs the corresponding poses. As shown in Table 2, the estimated poses using our method outperform both the feature-based and the direct visual odometry methods. Our method falls short of the pose regression methods in Seq. 9. The pose regression network implicitly integrate the feature selection, matching for pose estimation with the forward movement assumption. To verify this limitation, we shuffle or duplicate the input images using the pretrained networks from [44, 30], the pose estimation network still outputs the forward motion and the speed of the vehicle is relatively stable. The result indicates that only forward movement is learned. The reason of this phenomenon is that there is no constrains between the output poses. We also train the pose network with both forward and backward sequences using [44] (see Table 2), and the results indicate that the pose network cannot differentiate the varieties of motions, while maintaining the similar depth estimation results (see Table 1). No such movement assumption is applicable to our method. Our method can deal with different kinds of movements because the ego-motion of the camera is calculated with the feature selection and comparison in an explicit way.

5 Conclusion

We propose an end-to-end unsupervised learning framework for monocular visual odometry with the direct method. Our scheme can tightly incorporate features at different levels for pose estimation by constructing the multiscale feature and depth pyramids. The scale factor can be constrained with our method; furthermore, our scheme does not need the forward motion constraints. This work reveals the capability of the deep learning method to contribute to the direct visual odometry pipeline. It can be extended by incorporating it with other widely applied modules, such as marginalization and keyframe selection, to construct a complete SLAM system, which is out of the scope of this paper.

There are some interesting directions for follow-up works. In particular, our method can benefit from the incorporation of nonrigid object removal using optical flow prediction (e.g., [35, 42]) and tracking.