SGANVO: Unsupervised Deep Visual Odometry and Depth Estimation with Stacked Generative Adversarial Networks

TL;DR

SGANVO introduces a novel unsupervised deep learning framework using stacked GANs for improved visual depth and ego-motion estimation, demonstrating superior or comparable results on the KITTI dataset.

Contribution

The paper presents a new stacked GAN architecture that jointly estimates depth and ego-motion, incorporating temporal dynamics for enhanced accuracy.

Findings

Achieves better or comparable depth estimation results on KITTI dataset.

Demonstrates improved ego-motion estimation accuracy.

Effectively captures temporal dynamics in visual odometry.

Abstract

Recently end-to-end unsupervised deep learning methods have achieved an effect beyond geometric methods for visual depth and ego-motion estimation tasks. These data-based learning methods perform more robustly and accurately in some of the challenging scenes. The encoder-decoder network has been widely used in the depth estimation and the RCNN has brought significant improvements in the ego-motion estimation. Furthermore, the latest use of Generative Adversarial Nets(GANs) in depth and ego-motion estimation has demonstrated that the estimation could be further improved by generating pictures in the game learning process. This paper proposes a novel unsupervised network system for visual depth and ego-motion estimation: Stacked Generative Adversarial Network(SGANVO). It consists of a stack of GAN layers, of which the lowest layer estimates the depth and ego-motion while the higher layers estimate the spatial features. It can also capture the temporal dynamic due to the use of a recurrent representation across the layers. See Fig.1 for details. We select the most commonly used KITTI [1] data set for evaluation. The evaluation results show that our proposed method can produce better or comparable results in depth and ego-motion estimation.

Tables

Table 1. TABLE I: Discriminator Network Architecture

Block Type	Kernel Size	Strides	Filters	Input
Conv1	$5\times 5$	2	16	Image
SELU1	none	none	none	Conv1
Conv2	$5\times 5$	2	32	SELU1
SELU2	none	none	none	Conv2
Conv3	$5\times 5$	2	64	SELU2
SELU3	none	none	none	Conv3
Conv4	$5\times 5$	2	128	SELU3
SELU4	none	none	none	Conv4
Conv5	$4\times 4$	1	1	SELU4

Table 2. TABLE II: Depth estimation results on KITTI dataset using the split of Eigen et al. [ 21 ] . For training data, K = KITTI, CS = Cityscapes [ 27 ] , M = Monocular and S = Stereo. For testing data, our SGANVO uses the monocular dataset like others’ work and our view reconstruction component uses this left image sequence to generate the right view image sequence like [ 26 ] .

Method	Datasize	Dataset	Train	Abs Rel	Sq Rel	RMSE	RMSE $\log$	$\delta$ <1.25	$\delta$ <${1.25}^2$	$\delta$ <${1.25}^3$
Garg et al.[3]	620 $\times$ 188	K	M	0.169	1.080	5.104	0.273	0.740	0.904	0.962
SfMLearner [5]	416 $\times$ 128	K	M	0.208	1.768	6.856	0.283	0.678	0.885	0.957
SfMLearner [5]	416 $\times$ 128	CS+K	M	0.198	1.836	6.565	0.275	0.718	0.901	0.960
GeoNet [6]	416 $\times$ 128	K	M	0.155	1.296	5.857	0.233	0.793	0.931	0.973
GeoNet [6]	416 $\times$ 128	CS+K	M	0.153	1.328	5.737	0.232	0.802	0.934	0.972
Vid2Depth [22]	416 $\times$ 128	K	M	0.163	1.240	6.220	0.250	0.762	0.916	0.968
Vid2Depth [22]	416 $\times$ 128	CS+K	M	0.159	1.231	5.912	0.243	0.784	0.923	0.970
GANVO [16]	416 $\times$ 128	K	M	0.150	1.414	5.448	0.216	0.808	0.939	0.975
UnDeepVO [9]	416 $\times$ 128	K	S	0.183	1.730	6.570	0.268	-	-	-
Godard et al.[4]	640 $\times$ 192	K	S	0.129	1.112	5.180	0.205	0.851	0.952	0.978
SGANVO	416 $\times$ 128	K	S	0.065	0.673	4.003	0.136	0.944	0.979	0.991

Table 3. TABLE III: Ego-motion estimation results on KITTI dataset with our proposed SGANVO. We also compare with the four learning methods ( Monocular: ESP-VO [ 24 ] , SfMlearner [ 5 ] ; Stereo: UndeepVO [ 9 ] , Undepthflow [ 11 ] ), and one geometric based methods (ORB-SLAM). Our SGANVO, SfMLearner, and UndeepVO use images with 416 × \times 128. ESP-VO and ORB-SLAM use 1242 × \times 376 images. Undepthflow uses 832 × \times 256 images. The best results among the learning methods are made in bold.

Seq.	Monocular								Stereo
	SGANVO		ESP-VO [24]		SfMLearner [5]		ORB-SLAM [25]		UndeepVO [9]		Undepthflow[11]
	(416$\times$128)		(1242$\times$376)		(416$\times$128)		(1242$\times$376)		(416$\times$128)		(832$\times$256)
	$t_{\text{rel}}(\%)$	$r_{\text{rel}}{(}^{\circ })$	$t_{\text{rel}}(\%)$	$r_{\text{rel}}{(}^{\circ })$	$t_{\text{rel}}(\%)$	$r_{\text{rel}}{(}^{\circ })$	$t_{\text{rel}}(\%)$	$r_{\text{rel}}{(}^{\circ })$	$t_{\text{rel}}(\%)$	$r_{\text{rel}}{(}^{\circ })$	$t_{\text{rel}}(\%)$	$r_{\text{rel}}{(}^{\circ })$
03	10.56	6.30	6.72	6.46	13.08	3.79	0.67	0.18	5.00	6.17	-	-
04	2.40	0.77	6.33	6.08	10.68	5.13	0.65	0.18	4.49	2.13	-	-
05	3.25	1.31	3.35	4.93	16.76	4.06	3.28	0.46	3.40	1.50	-	-
06	3.99	1.46	7.24	7.29	23.53	4.80	6.14	0.17	6.20	1.98	-	-
07	4.67	1.83	3.52	5.02	17.52	5.38	1.23	0.22	3.15	2.48	-	-
${09}^{\ast }$	4.95	2.37	-	-	18.77	3.21	15.30	0.26	7.01	3.61	13.98	5.36
${10}^{\ast }$	5.89	3.56	9.77	10.2	14.36	3.98	3.68	0.48	10.63	4.65	19.67	9.13

Table 4. TABLE IV: Absolute Trajectory Error (ATE) on KITTI odometry dataset. The results of other baselines are taken from [ 11 ] .

Method	frames	Sequence 09	Sequence 10
ORB-SLAM(Full)	All	$0.014\pm 0.008$	$0.012\pm 0.011$
SfMLearner [5]	$5$	$0.016\pm 0.009$	$0.013\pm 0.009$
GeoNet [6]	$5$	$0.012\pm 0.007$	$0.012\pm 0.009$
Undepthflow[11]	2	$0.023\pm 0.010$	$0.022\pm 0.016$
SGANVO	$3$	$0.015\pm 0.006$	$0.014\pm 0.009$

Table 5. TABLE V: Performance for different number of layers and window frame. NL = number of layers, NF = number of frames. Sq.09 and Sq.10 Absolute Trajectory Error(ATE) are the ego-motion testing results. From Abs Rel to δ 𝛿 \delta < 1.25 3 superscript 1.25 3 1.25^{3} are the depth testing results.

NL	NF	Sq.09 (ATE)	Sq.10 (ATE)	Abs Rel	Sq Rel	RMSE	RMSE $\log$	$\delta$ <1.25	$\delta$ <${1.25}^2$	$\delta$ <${1.25}^3$
2	2	$0.0178\pm 0.0083$	$0.0180\pm 0.0107$	0.0991	0.873	4.483	0.184	0.902	0.959	0.979
2	3	$0.0152\pm 0.0067$	$0.0149\pm 0.0094$	0.0973	0.733	4.623	0.167	0.903	0.969	0.988
3	3	$0.0153\pm 0.0061$	$0.0147\pm 0.0085$	0.0651	0.673	4.003	0.136	0.944	0.979	0.991

Equations

$$R_t^l=ConvLSTM(E_{t-1}^l,R_{t-1}^l,UpSample(R_t^{l+1}))$$

$${\hat{I}}_t(i,j)=K{\hat{T}}_{t-1,t}{d}_{t-1}^{-1}(i,j)K^{-1}{I}_{t-1}(i,j)$$

$$E_t^0$$

$$E_t^l$$

$$A_t^l=Maxpool(ReLU(Conv(E_t^{l-1})))$$

$${\hat{A}}_t^l=ReLU(Conv(R_t^l))$$

$$L_g^D=\sum _l{\lambda }_{l}E[D({\hat{x}}^l)]$$

$$L_g^N=\sum _{t=1}^N{\lambda }_t\sum _l\frac{{\lambda }_l}{n_l}\sum _{n_l}\Vert E_t^l{\Vert }_1$$

$$L_g^d=\sum _{t=1}^N\sum _{i,j}\Vert d_t^l(i,j)-d_t^r(i,j){\Vert }_1$$

$$L_g^{final}=\alpha L_g^D+\beta L_g^N+\gamma L_g^d$$

$$L_d^D=\sum _l{\lambda }_l\arg \underset{D}{\max }{D}_d^l$$

$$D_d^l=E[D(x^l)]-E[D({\hat{x}}^l)]+{\lambda }_{D}E[(||▽D({x^{\prime }}^l)|{|}_2-1{)}^2]$$

$$x^{\prime }=x\ast ϵ+\hat{x}\ast (1-ϵ)$$

$$W(x,\hat{x})=\arg \underset{D}{\min }{L}_d^D$$

Full text

I INTRODUCTION

Object’s depth estimation and camera’s ego-motion estimation are two essential tasks in autonomous robotic applications. Impressive progress has been achieved by using various geometric based methods. Recently, unsupervised deep learning based methods have demonstrated a certain level of robustness and accuracy in some challenging scenes without the need of labeled training data set.

Inspired by the image wrapping technique - spatial transformer[2], Garg et al.[3] proposed an unsupervised Convolutional Neural Network (CNN) to estimate the depth by using the left-right photo-metric constraint of stereo image pairs. Godard[4] further extended this method by employing a loss function with the left and right images wrapping across each other. Because both left and right photo-metric losses are penalized, this method improved the accuracy of depth estimation. Zhou et al.[5] proposed two separate networks to infer the depth and ego-motion estimation over three temporal consecutive monocular image frames. The middle frame performs as the target frame and the previous and the following frames as the source frames. Yin[6] proposed the GeoNet which not only estimates the depth and ego-motion but also the optical flow for dynamic objects. Similarly, Godard et al.[7] proceeded to merge the pose network with the depth network through sharing the network weights. Furthermore, benefit from the recent advance of deep learning methods for single-image super-resolution, Pillai et al.[8] proposed the sub-pixel convolutional layer extension for obtaining depth super-resolution. Their superior pose network is bootstrapped with much more accurate depth estimation.

Most of recent work are all based on the encoder-decoder neural networks, but with different loss functions based on view reconstruction approach. Li et al.[9] designed their loss functions not only combining the loss functions defined in [4] and [5] but also adding the 3D points transformation loss. However, their results perform not very well in the scenes where dynamic and occluded objects occupy a large part of the field of view due to artificially designed rigid transformation used. To deal with dynamic and occluded objects in the scenes, Ranjan [10] and Wang [11] introduced additional networks to estimate the optical flow jointly with the depth and pose networks from videos. Ranjan used two networks to learn the optical flow and dynamic object masks, and jointly compute the flow and mask loss functions to refine the depth and pose networks. Wang added the optical flow estimation network to deal with the dynamic objects and refine the depth network. Due to the use of a PWC network[12] to handle the stereo depth estimation, Wang’s Undepthflow improved the unsupervised depth estimation by an order of magnitude and its pose estimation also reached the optimal rank. Almalioglu[13] introduced a visual odometry (GANVO) to estimate the depth map using Generative Adversarial Network[14]. Its Generator network generates the depth map and the pose regressor infers the ego-motion. Together they build up the view reconstruction. Then its Discriminator network games the original target image and the reconstructed image to refine the depth and pose networks. This work is similar with [15] [16] [17] [18], which use the Generator to generate the depth map instead of using estimation networks. From these work, it can be seen that the generative nature in GAN networks is beneficial to the scenes with dynamic objects. However, these visual odometry related GANs focus on the depth estimation, but not on the ego-motion estimation.

In this paper, we propose a novel unsupervised deep visual odometry system with Stacked Generative Adversarial Networks (SGANVO) (see Fig. 1). Our main contributions are as follows:

• •

To the best of our knowledge, this is the first time to use the stacked generative and adversarial learning approach for joint ego-motion and depth map estimation.

• •

Our learning system is based on a novel unsupervised GAN scheme without the need for ground truth.

• •

Our system possesses a recurrent representation which can capture the temporal dynamic features.

The outline of this paper is organized as follows: Section II gives an overview of our proposed SGANVO system. Section III describes various loss functions used for the Generator and Discriminator. Section IV presents our experimental results of depth and ego-motion estimation. Finally, conclusion and future work are drawn in Section V.

II SYSTEM OVERVIEW

We address the depth and the ego-motion estimation as a whole visual odometry system in Fig.1. The system consists of an ego-motion representation layer for ego-motion estimation, and multiple feature extraction layers for feature estimation. The error image $A^{l}$ from error unit $E^{l-1}$ in current layer is propagated up to higher layer as the input. The hidden state in recurrent representation layer $R^{l}$ is propagated down to lower layer for capturing the temporal dynamic. There are mainly two units, Generator ($G^{l}$) and Discriminator ($D^{l}$), in each layer.

Fig.2 shows the network unfolding in time step. After initial states $S^{l}$ are set to the network. A current frame is fed to the network input. This is run for a sequence of $N$ consecutive frames. After $N$ steps, The initial states are set to the network again.

II-A Generator

In the bottom layer, the Generator consists of depth estimator $d$, ego-motion estimator $p$, and view reconstructor $V$. It takes the hidden state from recurrent representation $R^{0}$ as its input and generates an estimated image from view reconstructor $V$ for current input image. In the higher layer ($l>0$), the Generator is a convolutional layer which takes the hidden state from recurrent representation $R^{l}$ as its input and generates an estimated error image $\hat{A}^{l}$ for the input $A^{l}$ from lower layer. The recurrent representation $R^{l}$ is a Long Short Term Memory network (LSTM) and connected top down between layers. The hidden state $R^{l}_{t}$ is updated according to $R^{l}_{t-1},R^{l+1}_{t},E^{l}_{t-1}$. It is used to store the temporal dynamic from consecutive video which is defined as:

[TABLE]

The hidden state $R^{l}_{t}$ is updated through two passes: a top down pass from the UpSample of $R^{l+1}$, and then a level pass calculated by previous hidden state $R^{l}_{t-1}$ and previous error $E^{l}_{t-1}$.

The depth estimator is an encoder-decoder network to generate the multi-scale dense depth map, like the one used in [4]. Inspired by [8], we replace the UpSample branches in the depth decoder with the sub-pixel convolutional branches used in [19] to generate the up-scaled features. Sub-pixel convolutional branches consist of a sequence of three consecutive 2D convolutional layers with 64, 32, 4 output channels with 1 pixel stride. The depth estimator directly generates the dense depth map by using a pair of stereo images separately concatenating the features from unit $R^{0}_{t}$ along with the image channel to train the network.

The ego-motion estimator is a VGG-based CNN architecture. It takes current image and the hidden state representing the information in previous frame as the input, and generates the 6-DoF ego-motion estimation between current frame and previous frame. We decouple the translation and the rotation with two separate groups of fully-connected layers after the last convolutional layer for better performance. We feed the input data concatenating two continuous images and the features from unit $R^{0}_{t}$ along with image channel to train the ego-motion estimator.

The view reconstructor $V$ takes the depth estimate, ego-motion estimate, and previous frame $I_{t-1}$ as the input and generates a predicted image $\hat{I}_{t}$ for the current frame $I_{t}$. By using the spatial transformer network [2] and the homogeneous coordinate of the pixel $I_{t-1}(i,j)$ in the $(t-1)$th frame, we can derive its corresponding pixel $\hat{I}_{t}(i,j)$ in the $t$th frame through

[TABLE]

where $K$ is the camera intrinsic matrix, $d_{t}(i,j)$ is the estimated disparity, $\hat{T}_{t-1,t}$ is the camera coordinate transformation matrix from the $(t-1)$th frame to the $t$th frame generated by the ego-motion estimator.

Based on this, $\hat{I}_{t-1}$ and $\hat{I}_{t}$ can be constructed from ${I}_{t}$ and ${I}_{t-1}$, respectively. The error units in the bottom layer or higher layers are computed as below:

[TABLE]

where $E_{t}^{0}$ is the error image between the generated from the view reconstructor and the current frame at $t$ time, $E_{t}^{l}$ is the error image at the higher layer ($l>0$), $ReLU$ is an activation function operation. The input error image $A^{l}_{t}$ is defined as:

[TABLE]

where $Conv$ denotes the convolutional operation. The Generator in the higher layer ($l>0$) consists of one convolutional unit with 3 dimension filters to generate error feature image $\hat{A}^{l}_{t}$:

[TABLE]

II-B Discriminator

The Discriminator is a convolutional network that can categorize the images fed to it. In the bottom layer, we feed the generated image $\hat{I}_{t}$ and original image $I_{t}$ into it. In the higher layer ($l>0$), the inputs to the Discriminator are the generated error image $\hat{A}^{l}_{t}$ and the error image $A^{l}_{t}$ from the lower layer. We used WGAN in our architecture, which employs the Wasserstein distance instead of Kullback-Leibler (KL) divergence or Jensen-Shannon (JS) divergence for stabilizing the training process using gradient descents. The Discriminator architecture is shown in Table 1. Considering the GPU’s memory space, we set all the Discriminators five simple convolutional layers connected by four SELU block units as provided in [20].

III TRAINING PROCEDURE

The SGANVO training follows the improved WGAN training procedure [23]. We jointly compute the losses of Generators and Discriminators in all the layers and take the weighted sum as the final G loss and D loss. We feed the stereo data sequence of KITTI dataset into the depth estimator, and the monocular data sequences of KITTI dataset into the ego-motion estimator. The loss functions are defined as below:

III-A Generator Loss

Our G losses mainly include three parts. The first one is from the Discriminator and defined as:

[TABLE]

where $\lambda_{l}$ is the weight at $l$th layer, and $D(\hat{x}^{l})$ is the output from the Discriminator when its input is from generated image $\hat{x}^{l}$ in its layer. $E$ is the mean operation.

The second one is the weighted sum of all the error images within a sequence of $N$ consecutive frames.

[TABLE]

where $\lambda_{t}$ is the temporal weight factor, $\lambda_{l}$ is the layer weight factor, $n_{l}$ is the total number of ReLU units of the $l$th layer, and $\|\cdot\|_{1}$ is the $L_{1}$ norm.

The last one is the disparity consistency loss which is used to improve the depth smoothness. Denote $d^{l}_{t}$ and $d^{r}_{t}$ the left and right disparity maps, respectively. The disparity consistency loss is defined as:

[TABLE]

The final G loss is the weighted sum of above three parts.

[TABLE]

where $\alpha$, $\beta$ and $\gamma$ are the weight parameters.

III-B Discriminator Loss

The D loss is defined as:

[TABLE]

where $D^{l}_{d}$ is the Discriminator loss in the $l$th layer when its inputs are real image $x$ and generated image $\hat{x}$. Afterwards the $D^{l}_{d}$ is defined as :

[TABLE]

where $E$ is the mean operation and $\triangledown{}$ is the solving gradient operation. The innovation of WGAN-GP is on the last item of the above loss function where the $x^{\prime}$ is the random interpolation samples between real value and generated value defined as:

[TABLE]

In our implementation, we choose $\lambda_{D}=10$ and $\epsilon$ is a random number from uniform distribution between 0 and 1.

III-C Adversarial Training Procedure

To sum up, our SGANVO generates the features of temporal field over a time window and of spatial field over stacked layers. It can estimate the depth and the ego-motion at current time step from previous frame in the bottom layer.

Initially, the first frame in the first temporal window is fed to the network. This frame is also used as the initial previous frame to resolve the initial matrix irreversible problem. Thus our system can generate one depth estimation and one ego-motion estimation at each time step of the window. We set all the initial states $S^{l}$ to zeroes. They are passed to the recurrent representation $R^{l}$. The synthetic error image $\hat{A}^{l}$ are generated as zero matrices. And the initial estimate of ego-motion is zero as the initial current input and initial previous image are the same. But an initial depth map can be estimated from the depth estimator.

After the initialization, the first frame is fed to the system, and the system begins to generate the results in each layer.

After completing the feeding of current temporal window to the network, the system computes all the G the D losses over all the temporal steps ($N$). At the same time, it can generate both the depth and ego-motion estimate. Then the final G and D losses are applied to back propagate the Generators and Discriminators. The min-max training of our SGANVO is described as:

[TABLE]

The Discriminator training procedure is to make the $W(x,\hat{x})$ convergent to the minimum. The above procedure is repeated for next temporal window until all the frames in the data set are used.

IV EXPERIMENTS

We implemented the proposed SGANVO architecture with the publicly available Tensorflow framework and trained with NVIDIA GTX 1080TI GPUs. The Adam optimizer was employed to speed up the network convergence for up to 30 epochs with parameters $\beta_{1}=0.9$ and $\beta_{2}=0.999$. The learning rate started from 0.0001 and decreased by half for every 1/5 of total iterations. For the ease of training and data preparation, we used a temporal window size of $N=3$ and two higher layers $L=2$ and one bottom layer, but it is possible to use longer sequences and more higher layers for training and testing. The size of input image to the network was $416\times 128$ with the consideration of comparison with other systems. To fine-tune the network, we used the original image size in computing the losses. For data prepossessing, different kinds of data augmentation methods were used to enhance the performance and mitigate possible over-fitting, such as image color augmentation[5], rotational data augmentation[24] and left-right pose estimation augmentation[4]. We increased the weight parameter of rotational data to achieve better performance because the magnitude of rotation is very small compared to that of translation. We set $\alpha=10^{-4}$, $\beta=1.0$ and $\gamma=0.1$ in the final G loss (10). To test our SGANVO’s depth estimation on the monocular dataset, we built a stereo view reconstruction component like [26] to generate the stereo frames from the monocular dataset ( see the testing inputs in Fig.1). Our SGANVO can test directly on the monocular dataset.

IV-A Depth Estimation Evaluation

We evaluate the performance of our SGANVO depth estimation on the KITTI dataset with a benchmark split from [5]. Fig. 3 shows some raw RGB images from sequence 10 and their corresponding depth estimates from Monodepth [4], and our system. As shown in Fig. 3, the different depths of cars and trees are explicitly generated, even the depth of trunks and street lights are generated clearly. Compared with the others, our SGANVO can generate more details and clearer textures.

The quantitative depth estimation results are listed in Table II, where $M$ stands for using monocular image sequence training and $S$ stands for using stereo image sequence training. Compared with the existing unsupervised learning-based methods (see the smallest values in Abs Rel, Sq Rel, RMSE, and RMSE log columns in the table with the highest $\delta$), our SGANVO performs better in terms of the metrics used. And it even outperforms some methods with larger image input.

IV-B Ego-motion Estimation Evaluation

We used the KITTI dataset[1] to test the performance of the SGANVO ego-motion estimation. The KITTI dataset only provides the ground-truth of 6-DoF poses for Sequence 00-10. We used Sequence 00-08 for training and Sequence 09-10 for testing.

The metrics are the average translational root-mean-square error (RMSE) drift and average rotational RMSE drift $(\textopenbullet/100m)$ on length of $100m-800m$. The results are shown in Table III. We compare the results with ESP-VO [24], SfMLearner[5], ORB-SLAM (without loop closure), UndeepVO [9], and Undepthflow[11]. It can be seen that our SGANVO shows a better performance in the testing sequences (09, 10) with these state-of-the-art methods in terms of the ATE metric.

The other metrics used are the absolute trajectory error (ATE) averaged over all overlapping 5-frame snippets. We concatenated all of left and right estimations together for the entire sequences without any post-processing. The estimated trajectory of sequences 9 and 10 from our SGANVO and its ground truth are shown in Fig. 4. Although the estimated result includes some drift, our SGANVO can estimate all the features of the trajectory and performs well in terms of odometry estimation without loop closure detection. The quantitative results are shown in Table IV where we compare our results with ORB-SLAM(Full), SfMLearner[5], GeoNet [6], and Undepthflow[11]. Our SGANVO produced a comparable result.

IV-C Ablation Analysis for Spatial Layers and Temporal Frames

To demonstrate the importance of the high level spatial features and temporal recurrent window, we conducted three contrast experiments for an ablation analysis. In Table V, we set the same network and training parameters, but configured the system with different number of high level layers and size of temporal window to explore the influence of high level spatial features and temporal recurrent window on the learning results. The main evaluation is focused on the ego-motion and depth test for sequence 09 and sequence 10. Considering the GPU’s memory and training time, we just tested the system configuration with 2 layers or 3 layers combining with 2 frames or 3 frames.

It can be seen from the data in the first two rows that the ego-motion performs much better when the window size increases from 2 to 3 when the number of high level layers are kept unchanged. In addition, the depth estimation also has a little bit improvement. Then we fixed the same temporal window size as 3 frames to explore the influence of different number of high level layers. It can be seen from the data in the last two rows of Table V that the number of high level layers can make a significant improvement on the depth estimation, although its influence on the ego-motion estimation is limited.

From these results, we can conclude that the size of temporal recurrent window can make a significant improvement on the ego-motion estimation while the number of high level layers can make a significant improvement on the depth estimation.

V CONCLUSIONS

In this paper, we propose a novel stacked GAN network for depth estimation and ego-motion estimation from videos. Because the higher layers of our network can learn spatial features with different abstraction levels and the recurrent representation of our network can learn the temporal dynamics between consecutive frames, our SGANVO can generate more accurate depth estimation result and comparable ego-motion estimation result comparing with other existing unsupervised learning networks. It is the learning mechanism between the Generator and Discriminator that is able to improve the quality of the generated depth and ego-motion estimation.

In the future, we will extend our system to a visual SLAM system to reduce the drift by adding a loop closure detection. And also more data sets will be used for training and testing to further improve the performance.