Sparse Representations for Object and Ego-motion Estimation in Dynamic Scenes

TL;DR

This paper introduces a learning-based method that uses sparse representations to estimate camera and object motion in dynamic scenes from monocular visual data, achieving state-of-the-art results.

Contribution

It proposes a novel autoencoder-based approach with a sparse egomotion basis to improve motion estimation accuracy and robustness in monocular visual odometry.

Findings

Achieves state-of-the-art trajectory and rotation prediction on KITTI datasets.

Uses only 5% of hidden neurons for accurate egomotion representation.

Demonstrates accurate object velocity prediction with depth information.

Abstract

Dynamic scenes that contain both object motion and egomotion are a challenge for monocular visual odometry (VO). Another issue with monocular VO is the scale ambiguity, i.e. these methods cannot estimate scene depth and camera motion in real scale. Here, we propose a learning based approach to predict camera motion parameters directly from optic flow, by marginalizing depthmap variations and outliers. This is achieved by learning a sparse overcomplete basis set of egomotion in an autoencoder network, which is able to eliminate irrelevant components of optic flow for the task of camera parameter or motionfield estimation. The model is trained using a sparsity regularizer and a supervised egomotion loss, and achieves the state-of-the-art performances on trajectory prediction and camera rotation prediction tasks on KITTI and Virtual KITTI datasets, respectively. The sparse latent space egomotion representation learned by the model is robust and requires only 5% of the hidden layer neurons to maintain the best trajectory prediction accuracy on KITTI dataset. Additionally, in presence of depth information, the proposed method demonstrates faithful object velocity prediction for wide range of object sizes and speeds by global compensation of predicted egomotion and a divisive normalization procedure.

Tables

Table 1. Table 1: ATE on the KITTI visual odometry split averaged over all five frame snippets (except for Mahjourian et al.  [ 24 ] three frame snippets). * The sequence length is equal to five during test. ‡ ‡ \ddagger The sequence length during test is unknown. † † \dagger Frame-by-frame egomotion are combined to form local five frame trajectories during test. ⊗ tensor-product \otimes The sequence length is equal to three. The k 𝑘 k value denotes the percentage of hidden layer neurons used for egomotion prediction.

Method	Seq 09	Seq 10
ORB-SLAM (full) [26]	0.014$\pm$0.008	0.012$\pm$0.011
ORB-SLAM (short) [26]*	0.064$\pm$0.141	0.064$\pm$0.130
Zhou et al. [45]*	0.021$\pm$0.017	0.020$\pm$0.015
Lee and Fowlkes [22]$†$	0.019$\pm$0.014	0.018$\pm$0.013
Yin et al. [42]$‡$	0.012$\pm$0.007	0.012$\pm$0.009
Mahjourian et al. [24]$\otimes$	0.013$\pm$0.010	0.012$\pm$0.011
Godard et al. [13]$†$	0.023$\pm$0.013	0.018$\pm$0.014
Ours*	0.020$\pm$0.015	0.023$\pm$0.015
Ours$†$	0.012$\pm$0.006	0.013$\pm$0.008
Ours (Sparse $k=10\%$)$†$	0.012$\pm$0.006	0.013$\pm$0.008
Ours (Sparse $k=5\%$)$†$	0.012$\pm$0.006	0.013$\pm$0.008
Ours (Sparse $k=4\%$)$†$	0.013$\pm$0.006	0.013$\pm$0.008
Ours (Sparse $k=3\%$)$†$	0.014$\pm$0.007	0.014$\pm$0.008
Ours (Sparse $k=2\%$)$†$	0.018$\pm$0.008	0.017$\pm$0.010
Ours (Sparse $k=1\%$)$†$	0.049$\pm$0.066	0.034$\pm$0.046
Ours (Sparse $k=0.5\%$)$†$	0.120$\pm$0.170	0.076$\pm$0.120

Table 2. Table 2: RPE comparison on the VKITTI egomotion split.

Method	Trans. error	Rot. error
Jaegle et al. [16]	0.4588	0.0014
Tung et al [37]	0.1294	0.0014
Lee and Fowlkes [22]	0.0878	0.0781
Ours	0.1769	0.0011
Ours (Sparse $k=25\%$)	0.1769	0.0011
Ours (Sparse $k=20\%$)	0.1788	0.0011
Ours (Sparse $k=15\%$)	0.1900	0.0011
Ours (Sparse $k=10\%$)	0.2849	0.0018
Ours (Sparse $k=5\%$)	0.6973	0.0026

Equations

$$v(p_i)=\rho (p_i)A(p_i)t+B(p_i)\omega$$

$$A(p_i)=\left[\begin{array}{ccc}f& 0& -x_i\\ 0& f& -y_i\end{array}\right]$$

$$B(p_i)=\left[\begin{array}{ccc}-x_i{y}_i& f+x_i^2& -y_i\\ -f-y_i^2& x_i{y}_i& x_i\end{array}\right]$$

$$v=\rho At+B\omega$$

$$v=\left[\begin{array}{c}v(p_1)\\ v(p_2)\\ ⋮\\ v(p_N)\end{array}\right]\in R^{2N\times 1},\rho At=\left[\begin{array}{c}{\rho }_{1}A(p_1)t\\ {\rho }_{2}A(p_2)t\\ ⋮\\ {\rho }_{N}A(p_N)t\end{array}\right]\in R^{2N\times 1}$$

$$B\omega =\left[\begin{array}{c}B(p_1)\omega \\ B(p_2)\omega \\ ⋮\\ B(p_N)\omega \end{array}\right]\in R^{2N\times 1}$$

$$t^{\ast },{\omega }^{\ast },{\rho }^{\ast }=\underset{t,\omega ,\rho }{\mathrm{argmin}}{\Vert \rho At+B\omega -\hat{v}\Vert }^2$$

$$t^{\ast },{\omega }^{\ast },{\rho }^{\ast }$$

$$t^{\ast },{\omega }^{\ast }$$

$$\widetilde{v_{\omega }},\widetilde{v_t}=MFG(\hat{v})$$

$$L_t=\sum _p{\Vert v_t-\widetilde{v_t}\Vert }^1,L_{\omega }=\sum _p{\Vert v_{\omega }-\widetilde{v_{\omega }}\Vert }^1$$

$$w_t=max(\frac{{\Vert v_{\omega }\Vert }^2}{{\Vert v_t\Vert }^2},1),w_{\omega }=max(\frac{{\Vert v_t\Vert }^2}{{\Vert v_{\omega }\Vert }^2},1)$$

$$L_s=\sum _{i=1}^{M}g(h_i)$$

$$g(h_i)=\frac{1}{1+Q{e}^{-B{h}_i}}$$

$$L=w_t{L}_t+w_{\omega }{L}_{\omega }+w_s{L}_s$$

$$\tilde{t}={\tilde{v}}_t/A\mid \rho =1,\tilde{\omega }={\tilde{v}}_{\omega }/B$$

$$F_1={\Vert r\Vert }^2>{\theta }_d\times avg(tanh({\Vert r\Vert }^2))$$

$$1)$$

$$3)$$

$$F_2$$

$$F_{obj}=F_1\circ F_2$$

$${\tilde{v}}_{obj}=r\circ F_{obj}$$

Full text

1 Introduction

The VO schemes to compute 6DoF camera motion based on motion of rigid features underperform in presence of independently moving objects [12, 15]. Particularly outdoor environments and a monocular setup create additional challenges to the existing online VO computation methods, due to noisy optic flow and depth information [32]. Therefore, a robust method to compute the 6DoF egomotion parameters in dynamic outdoor scenes from noisy optic flow input is needed.

Not only is estimating egomotion parameters in a dynamic scene important, many applications such as autonomous navigation and tracking, require computation of velocities of the independently moving objects online while the observer is also moving. In order to compute object velocity, the observer’s egomotion needs to be compensated [1]. The state-of-the-art tracking by detection approaches cannot derive the actual velocity of the objects without egomotion estimate [18, 39, 14]. Recent deep learning based structure-from-motion (SfM) methods do not estimate object velocity [45, 24, 13]. Other similar approaches that distinguish static and dynamic segments do not explicitly separate egomotion and object motion velocity components for the dynamic regions [22, 42, 41, 38].

The goal of this work is to separate optic flow into image velocity components due to egomotion and object motion across the entire image. We propose a sparse autoencoder network that learns to predict the image velocity components due to camera translation and rotation from optic flow input, marginalizing scene depth and noise. The predicted egomotion components are then converted to 6DoF camera motion parameters in closed form using the geometry of instantaneous rigid body motion under perspective projection [5]. For object motion prediction, the predicted egomotion is first scaled by scene depth, which is then compensated from optic flow and processed through multi stage max-pooling normalization to compute object motion [6].

We train the neural network using a supervised loss from egomotion field constructed from GT pose information, such that the training conforms with the geometry of instantaneous rigid body motion [22]. On the KITTI visual odometry dataset [11], the proposed model achieves the state-of-art performance for camera trajectory prediction. On the Virtual KITTI dataset [10], the proposed model achieves the state-of-the-art performance in terms of rotational error and comparable performance for translational error in the camera movement prediction task.

An additional advantage of the proposed approach over the existing methods is that the sparse autoencoder learns an overcomplete set of meaningful basis motion fields for camera translation and rotation when trained with a regularizer for sparsity. Sparse representation of data has many benefits, such as, i) eliminating irrelevant variabilities in input data and making the network robust to outliers, ii) finding hidden structures that are more suitable as input for machine learning applications due to increased separability, and iii) fewer active neurons, which leads to fewer downstream computations [4, 29, 27]. The proposed model learns a sparse egomotion representation that successfully marginalizes object velocities (outliers) and scene depth variations in the input optic flow data to learn basis motion fields related to camera translation and rotation.

The learned sparse egomotion representation generalizes well to test data and the network achieves good egomotion prediction accuracy in presence of independently moving objects and in novel scene structures. Further, only 5% of the hidden layer neurons are required on the KITTI test set for predicting rotation and translation of the camera without any drop in performance. Finally, the learned egomotion representations by individual hidden neurons are meaningful in terms of their selectivity for a particular type of camera translation and rotation.

2 Related work

Monocular continuous methods for VO

Most of the existing methods for monocular continuous VO cannot handle noise or the presence of independently moving objects [44]. Fredriksson et al. recently proposed branch and bound methods that are able to compute translational velocity in presence of outliers [9, 8]. Jaegle et al. estimated general camera motion from noisy optic flow input using confidence score and an iterative optimization procedure on sparse optic flow [16]. Lee and Fowlkes solved for dense optic flow for static and dynamic segments and then formulate for egomotion recovery using static flow segment and scene depth input [22]. The proposed approach is related to this class of approaches, however is focused on direct egomotion prediction from optic flow by marginalizing outliers and scene structure variations using a sparse representation of egomotion components.

Structure-from-motion prediction

The traditional Structure-from-motion(SfM) methods rely on accurate feature matching, which requires good photo consistency promise [30, 36]. Recent development in deep neural networks have allowed formulation of the SfM as a prediction problem and many new methods have been proposed in the recent years on this theme. Zhou et al. proposed a network that learns to predict depth and camera motion and is trained using self supervised image warping loss between the source and the target frames [45]. This self supervised training has since been adopted by many other approaches [24, 13, 42, 41]. Vijayanarasimhan et al. added a separate network to predict a predetermined number of object layers during camera movement [38]. However, their training procedure does not explicitly separate individual velocity components from egomotion and object motion. Tung et al. formulate the same problem in an adversarial framework where the generator is trained to synthesize camera motion and scene structure that minimize the warping cost to a target frame [37].

Sparse representation

Sparse representation was initially used as a preprocessing step for classification tasks, because sparse features were found to be more separable than the input data itself [27]. Since a small population of features are used to represent the variability among large set of data points, these sparse representation methods were found to be learning hidden structures common across a large subset of data and ignoring variabilities inconsistent across datapoints, i.e. noise [29, 4]. Applications that use the learned sparse representation of data benefit from sparsity by performing fewer computations. So far, multiple schemes of learning sparse representations have been proposed, such as sparse coding [20], sparse autoencoder [7], sparse winner-take-all circuits [27, 25] and sparse RBMs [21] for learning components of faces, handwritten digits, edges in natural scenes etc.

Compared to these approaches, our data is sequential and highly skewed towards some particular types of motion. Therefore, some of the common sparsity constructs, such as lifetime sparsity [27], do not apply to our case.

3 Continuous egomotion formulation

The continuous egomotion formulation has been used by previous methods to estimate camera motion and/or rigid scene structure from optic flow of monocular visual input [5, 17, 43]. Given the instantaneous camera translation velocity $t=(t_{x},t_{y},t_{z})^{T}\in R^{3}$, the instantaneous camera rotation velocity $\omega\in(\omega_{x},\omega_{y},\omega_{z})^{T}\in R^{3}$, and the inverse of scene depth $\rho(p_{i})=\frac{1}{Z(p_{i})}\in R$, the image velocity $v(p_{i})=(v_{i},u_{i})^{T}\in R^{2}$ at an image location $p_{i}=(x_{i},y_{i})^{T}\in R^{2}$ of an calibrated camera image due to camera motion is given by,

[TABLE]

where,

[TABLE]

[TABLE]

If $p_{i}$ is normalized by the focal length $f$, then it is possible to replace $f$ with $1$ in the expressions for $A(p_{i})$ and $B(p_{i})$.

If the image size is N pixels, then the full expression of instantaneous velocity at all the points, termed as motion field (MF), can be expressed in a compressed form as

[TABLE]

where, $A$, $B$, and $\rho$ entails the expressions $A(p_{i})$, $B(p_{i})$, and $\rho(p_{i})$ respectively for all the N points in the image as follows.

[TABLE]

[TABLE]

The monocular visual egomotion computation uses this formulation to estimate the unknown parameters $t$ and $\omega$ and the $N$ values of depth given the point velocities $v$ generated by camera motion. However, instantaneous image velocities obtained from the standard optic flow methods on real data are usually different from the real pixel velocities due to camera motion and scene structure, known as motion field (MF) [22]. The presence of moving objects further deviates the optic flow away from the true MF. Let us call the input optic flow as $\hat{v}$, which is different from $v$. Therefore, monocular continuous methods on real data solve the following minimization objective to find $t$, $\omega$, and $\rho$.

[TABLE]

As found in [43, 16], without loss of generality, the objective function can be first minimized for $\rho$ as,

[TABLE]

where ${A^{\perp}t}$ is orthogonal complement of ${At}$. This resulting expression does not depend on $\rho$ and can be optimized directly to find optimal $t^{*}$ and $\omega^{*}$.

4 The motion field generator network

Herein, we propose Motion Field Generator (MFG), a neural network model, that learns to predict egomotion fields due to rotation and translation from optic flow input of dynamic scenes. These are converted to 6DoF egomotion parameters in closed form using constructs of rigid body motion. A secondary multi-stage max-pooling normalization module extracts the object motion after compensating for egomotion field scaled by scene depth. We train the MFG network using ground truth pose information and a sparsity penalty, to learn meaningful representations of egomotion that are sparsely activated and robust to noise in the input optic flow.

Figure 2 depicts the architecture of the proposed MFG network. The network is an asymmetric autoencoder that has a multilayer fully convolutional (FC) encoder and a single layer linear decoder. The output neurons of the FC Block 1X-4 layer at the end of the encoder learns a latent space representation of egomotion. We will refer to this layer of $M=1000$ neurons as the hidden layer of the MFG network. The activations of all FC layer outputs in the encoder, including the hidden layer neurons, are non-negative due to relu operations.

Egomotion prediction loss

For an optic flow input $\hat{v}$, the MFG network generates a rotational MF prediction$\tilde{v_{\omega}}$ and a depth marginalized translational MF prediction $\tilde{v_{t}}$.

[TABLE]

We can obtain the translational prediction error and the rotation prediction error as,

[TABLE]

where, $v_{t}$ is GT translational MF with $\rho=1$ and $v_{\omega}$ is GT rotational MF, obtained using Equation 2.

We use L1 norm to calculate prediction error to avoid biases from large outliers.

Between rotation and translation, some datasets disproportionately represent one type of egomotion over the other, such as $\mathinner{\!\left\lVert v_{w}\right\rVert}$ is often small compared to $\mathinner{\!\left\lVert v_{t}\right\rVert}$ averaged over a real dataset resulting in significantly smaller rotational losses. In order to remove such biases and let the MFG network learn representations of both translation and rotation equally, we normalize $L_{t}$ and $L_{\omega}$ by scaling them using the following coefficients:

[TABLE]

Sparsity loss

The MFG network is regularized during training for sparsity of activation of the hidden layer neurons. This is implemented by calculating a sparsity loss ($L_{s}$) for each batch of data and backpropagating it along with the egomotion prediction loss during training. The value of $L_{s}$ is calculated for each batch of data as the number of non-zero activations of the hidden layer neurons, also known as population sparsity. Although, to make this loss differentiable, we approximate a number of activations using a generalized logistic activation $g$ with a sharp saturation. The expression for $L_{s}$ is given as,

[TABLE]

where $h_{i}$ is the instantaneous activation of the $i$-th hidden layer neuron and $g(h_{i})$ is given by,

[TABLE]

The coefficients $Q$ and $B$ are set to 25 and 10, respectively to approximate the “$>0$” function.

Therefore, the total loss for training the MFG is given by,

[TABLE]

where, $w_{s}$ is a user selected hyperparameter for the coefficient of sparsity loss. It affects the sparsity of the representation learned by MFG for egomotion prediction.

Egomotion parameter estimation

The predicted translation and rotation parameters can be computed directly from $\tilde{v}_{t}$ and $\tilde{v}_{\omega}$ following the continuous egomotion formulation.

[TABLE]

Object motion extraction

Scene depth $d$ (or its inverse$\rho$) is required to compute object velocity after compensating egomotion field from optic flow. The residual image velocity $r=\hat{v}-\tilde{v}$ calculated using the predicted MF as $\tilde{v}=\rho\tilde{v_{t}}+\tilde{v_{\omega}}$ results in additional residue other than object velocity, we call them residue noise. They may be due to i) inaccurate prediction by MFG $\tilde{v}\neq v$, ii) noisy input optic flow $\hat{v}\neq v+v_{obj}$, and/or iii)inaccurate depth map or $\rho$ etc. We observe that nearby static objects cause large residue noise. A simple thresholding operation fails since that removes slowly moving objects.

In order to find masks for only the moving objects in $r$, we employ the conjunction of two types of filters, discussed below:

Filter 1: Average thresholding

The first filter is simple thresholding based on average, which keeps the objects as well as large residues from static parts.

The first filter $F_{1}$ is derived as,

[TABLE]

where $\theta_{d}$ is a constant parameter.

Filter 2: Multistage max pooling

The second filter is a multistage divisive max-pooling normalization scheme based on depth marginalized residue values. This filter assigns high probability to independent object movements at all depths. however, due to depth marginalization, the distant residues get multiplicatively scaled to large values.

In order to calculate the second filter $F_{2}$, we first normalize the depth $d=\frac{1}{\rho}$ to range 0-1. Then we perform non maximal suppression on $r$ by performing the following steps,

[TABLE]

From $F_{1}$ and $F_{2}$, the binary object motion mask is calculated as

[TABLE]

This object motion mask is then multiplied pixelwise with the residue to find object velocity.

[TABLE]

5 Experiments

We evaluate the performance of the proposed MFG network model in i) egomotion prediction from optic flow and ii) object motion extraction tasks. Further, we analyze the latent space representation learned by the proposed model for rotational and translational basis flow fields and the sparsity of egomotion representation on unseen data.

5.1 Datasets

KITTI visual odometry split

We use the KITTI visual odometry dataset [11] to evaluate egomotion prediction performance by the proposed model. This dataset provides eleven driving sequences (00-10) with RGB frames (we use only the left camera frames) and the ground truth pose for each frame. Of these eleven sequences, we use sequences 00-08 for training our model and sequences 09, 10 for testing, similar to Zhou et al. [45]. This amounts to approximately 20.4K frames in the training set and 2792 frames in the test set. As ground truth optic flow is not available for this dataset, we use a pretrained PWC-Net [34] model to generate optic flow from the pairs of consecutive RGB frames for both training and testing.

Virtual KITTI split

We use the Virtual KITTI dataset [10] to evaluate egomotion prediction performance, as well as object-motion extraction. The dataset provides ground truth optic flow, depth, and pose for five driving sequences that clone the real KITTI scenes and camera viewpoints [11]. The advantages of Virtual KITTI dataset are precise ground truth camera motion than the KITTI dataset for short subsequences [37] and the presence of more moving objects per frame than KITTI. For the egomotion prediction task from optic flow, we use the first sequence as the test set and the rest four sequences as the training set, for direct comparison with the existing methods on this dataset [37, 22]. This will be referred to as VKITTI egomotion split. However, the first sequence has comparatively few frames with large components of both egomotion and object motion. In order to test object motion perception for a wide range of egomotion, we use sequences 0002 and 0018 for testing and the sequences 0001, 0006, and 0020 for training the MFG network. We will refer to this as VKITTI object-motion split.

5.2 Training

All the models are trained and tested using PyTorch 0.4.1 on a dual GeForce 960 GPU based system or a single 1080Ti GPU based system. We use Adam optimizer [19] and the same set of training hyper-parameters to train the MFG network on all training sets. A fixed learning rate $\eta$ of $10^{-5}$ is used in all experiments. We observe that full stochastic optimization, i.e. batch size 1 with random shuffling, paired with high values of the forgetting factors for gradients and second moment of gradients (the $\beta$ parameters of Adam) results in better generalization to the test set. Similar observation was made for training Fully Convolutional Networks earlier [31], where they use stochastic gradient descent optimization with batch size 1 and momentum 0.99. This mode of parameter search helps to come out of local minima, while still avoiding deviations caused by outliers. Therefore, we use batch size 1 with random shuffling and $\beta_{1}=0.99$ and $\beta_{2}=0.999$ in all experiments. The sparsity coefficient $\alpha_{s}$ for training is set to $10^{2}$.

5.3 Evaluation method for sparsity

We study the sparsity of the representation learned by the MFG network by measuring the performance of the network for egomotion prediction on the test set using as few hidden layer neurons as possible. In order to measure the sparsity of the representation learned, during test, we find the top $k\%$ active neurons in the hidden layer for each input frame sequence and set the rest of the hidden layer activations to zero. Then we observe how the performance of the network degrades as we lower the value of $k$. Similar evaluation of sparsity was used in [25]. The training is still done the same way with the sparsity penalty added to the error term for backpropagation, and without any hard reset of the hidden layer neurons, unlike [25]. This is to find a latent space during optimization that naturally represents egomotion using a sparse set of components.

5.4 Egomotion prediction

KITTI

Following the egomotion evaluation protocol by Zhou et al. [45] and others, each driving sequence of the training and test data of the KITTI visual odometry split is divided into overlapping snippets of five consecutive frames. The sequence length is set to be five during training. Absolute Trajectory Error (ATE) is used as the metric for evaluation, which measures the difference between the corresponding points of the ground truth and the predicted trajectories. For each test sequence, ATE is computed individually for each of the five frame snippets and then averaged over all the snippets in the sequence. In Table 1, we compare the proposed model against the existing methods that use the same input setting for egomotion evaluation on the KITTI odometry split. For reference, we also compare against a traditional SLAM method ORB-SLAM [26] that receives the whole sequence as input, referred to as ORB-SLAM(full). The performance of the same method using the same five frame snippet input setting as ours is referred to as ORB-SLAM(short).

The existing methods vary on the formation of the local five frame trajectory from the predicted egomotion during test. This is outlined in the caption of Table 1. We present our results when the local five frame trajectories are formed by i) egomotion predictions from the central frame of the five frame snippet [45] and ii) combination of frame-by-frame egomotion predictions [13]. For the latter, the proposed model performs similar to the state of the art [42] and achieves the lowest ATE for Sequence 09 of the KITTI odometry split test set. When testing for robustness of the learned sparse representation, the proposed method achieves state-of-the-art egomotion prediction on Sequence 09 using only 5% of the hidden layer neurons. It should be noted that despite using only local five frame snippets as input, the proposed model outperforms (Sequence 09) the ORB-SLAM (full) method that uses the complete sequence for pose estimation using global optimization steps.

Virtual KITTI

The VKITTI egomotion split has 1679 training frames and 447 test frames. We use the relative pose error (RPE) [33] metric for evaluation of egomotion prediction, in accordance with the state of the art on the same split [37].

Table 2 compares the proposed model against the existing methods in terms of RPE on the complete sequence of VKITTI egomotion split. The proposed model outperforms the state of art in terms of rotation error. The robust continuous egomotion estimation method by Jaegle et al. [16] serves as the baseline. The relatively large translation error maybe due to the fact that small VKITTI egomotion training set does not provide enough variations of egomotion to learn sparse features that generalize well to unseen test data. This reflects in the sparsity evaluation, as at least 20% hidden neurons are required to predict egomotion without translation performance drop, whereas the basis learnt from KITTI data requires only 5% active neurons to maintain performance. However, rotation accuracy is still better than the existing methods using only 15% of the hidden neurons. This implies the usefulness of sparse representation for prediction accuracy.

Lee and Fowlkes solves a similar formulation, including depth into the optimization procedure for egomotion prediction [22]. Tung et al. [37] proposed an adversarial framework to probabilistically predict depth and camera pose. Notably, all of these methods use optic flow for egomotion prediction, either as input or using a separate optic flow prediction network. Additionally, the methods by Tung et al. [37] and Lee and Fowlkes [22] require depth and camera pose input for training. The proposed MFG network model uses ground truth camera pose for training.

5.5 Object motion perception

The VKITTI object-motion split has 1554 training frames and 572 test frames. The training procedure for this task is identical to the egomotion tasks. For the object mask prediction pipeline from the residual flow, we tune $\theta_{d}$ parameter to 1.5 and $\theta_{p}$ parameter to 0.5. The value of $Threshold_{D}$ parameter is set to 0.2, i.e. objects closer than 20% of the maximum depth (655 meters) will be detected. These are held fixed for all frames.

Figure 4 depicts the predicted object motion masks and the extracted object motion flow vectors for five different frames of the VKITTI object-motion split. The results show that the proposed object motion extraction method is effective in finding moving objects by automatically suppressing the background residual flow vectors, even when the background residual flow is large. For instance, in frames i, iii, and v, nearby background objects (i.e. stationary) create significant residue flow. Although, the proposed object velocity extraction method is affected when the velocity differences between the moving objects are too large, which can be seen in frame v.

5.6 Egomotion basis

During training, the hidden layer neurons of the MFG network learns to selectively respond to specific combinations of observer translation and rotation. Simultaneously, the decoder network learns the egomotion fields corresponding to the selectivity of individual neurons. The decoder weights of the hidden neurons form a basis to represent egomotion.

Figure 5 depicts the representation of egomotion using a sparse population of hidden layer neurons on the KITTI odometry split test set. We select four frames 840, 865, 890,and 920 of Sequence 09, where the car is prominently going forward, left, forward, and right. Figure 5(b) shows translation-only and rotation-only motion fields predicted by the network and Figure 5(c) shows the activation maps of the hidden layers for each of these frames.

For frames 840 and 890, where the car is mainly going forward, the translational component of motion is more prominent and the activation map for these two frames are almost identical. We show this further by picking out the five most active hidden layer neurons for both frames (Figure 5(d-h)), which shows that the exact same five neurons are the most active for both frames. The decoder weights connected to these neurons represent a large forward translation along the Z-axis and little rotation representation. The similarity of activation maps for frames 840 and 890 show the consistency of the representation learned by the MFG network for similar types of egomotion. It also implies that the learned basis vectors are not redundant.

For frame 865, where rotation of the car toward left is more prominent than frames 840 and 890, the activation map of the hidden layer neurons changes to a new state. The five most active neurons for this frame are more selective for anticlockwise rotation about the Y-axis and have little translation representation. For frame 920, where the car is slowly turning right, the activation map changes to be largely different. The five most active neurons for this source frame represent clockwise rotation about the Y-axis and have little translation representation. Although, in both frames 865 and 920, the car is still translating in the forward direction, and observedly, the most active neurons of frame 840/890 representing forward translation, map to the some subordinate activations for frames 865 and 920.

6 Conclusion

In this work, we present a sparse asymmetric autoencoder with a fully convolutional encoder and a linear decoder that learns to predict egomotion with high accuracy from noisy optic flow input in dynamic scenes, while simultaneously perceiving object motion. The network is trained with constraints to learn a sparse latent space representation of egomotion with meaningful basis motion fields for camera translation and rotation. The contributions of the proposed approach regarding the existing state of the art are i) a method to directly predict camera rotation and translation from noisy optic flow marginalizing motion discontinuities from dynamic objects and variations of scene depth, ii) a sparse latent space representation of egomotion that uses only about 5% of the hidden layer neurons for state-of-the-art egomotion prediction, and iii) dissociation of ego and object motion components across the entire image to predict fine image velocities due to independent object motion.

These contributions are useful for monocular VO estimation in dynamic scenes. Monocular VO methods that incorporate depth in the prediction loop for egomotion have scale ambiguity issues [28, 16]. Our approach eliminates the need for simultaneous depth computation for egomotion prediction by using sparse representations that marginalize the depth component of input flow. It also demonstrates that marginalization of the depth component does not adversely affect the accuracy of egomotion prediction. Another advantage of our approach is that sparse representations are robust to outliers, such as independent object motion. While robust optimization procedures mask the outliers [16], our approach constructs egomotion component for dynamic regions of the scene as well, which enables computation of image velocities due to object motion.

The hidden layer neurons learn selectivity to a particular translation and rotation. It is not only a useful feature representation for machine learning, but it might be also efficient for computations as the brain uses sparse representations for many different tasks [23]. Previously sparse representations of egomotion components were found in the motion processing pathway of the monkey visual cortex [3]. There are two other similarities between our model and what is known about visual motion processing in the brain, i) use of vestibular (pose) information for representation of egomotion [35] and ii) compensation of egomotion in the visual cortex to extract independent object velocities [40]. It is important that the proposed approach shares some of the computational principles of visual motion processing in the brain and achieves state-of-the-art egomotion performance on real/realistic datasets.

Acknowledgement

This work was supported in part by NSF grants IIS-1813785, CNS-1730158, and IIS-1253538.