Embodied agents acting in the real world need to perceive both the 3D scene around them as well as how objects around them might behave. For instance, a self-driving car executing a lane change will need to know where the nearby cars are and how fast they are moving. Instead of relying on expensive sensors such as LiDAR to estimate this structure, a promising alternative is to use commodity cameras. This has motivated a long line of work on monocular depth estimation using neural networks.
While neural networks can learn to estimate depth, the dominant training approach requires expensive 3D sensors in the training phase. This limits the amount of training data we can capture, resulting in downstream generalization challenges. One would prefer to train these depth estimators without supervision, for e.g., using unlabeled videos captured from a driving car. This is possible to do if the videos are produced by a camera moving in a static scene, since the apparent motion (i.e., optical flow) of each pixel is then inversely proportional to the depth of the pixel. This provides a useful supervisory signal for learning depth estimation and has been used effectively in the past [48,36].
However, for unsupervised approaches to learn depth, dynamic scenes with moving objects pose a challenge. Here, the apparent pixels motion on the image plane is a combined effect of camera ego-motion (or rigid scene motion) and the independent motion of objects in the scene. Methods that ignore the presence of moving objects and treat the scene as static will then learn erroneous depth, where the depths of moving objects are altered to match their observed motion, as shown in Figure 1 (b). Past works have tried to overcome this issue by having another module predict independent object motion [31,24,15], but the presence of multiple equivalent solutions makes training difficult: even with sophisticated regularizers, the training can converge to the degenerate solution of either predicting the whole scene as static with incorrect depth, or predicting the entire scene as moving on a flat canvas. This results in depth error on moving objects at least 4 times as large as the error on static
(b) Monocular Depth (c) Rigid Flow (f) Independent Flow Dynamo-Depth (Ours) Static Scene Constraint Input (d) Monocular Depth (e) Rigid Flow (a) Input Frames background even for state-of-the-art methods. Since navigating safely around moving objects is a primary challenge in self-driving, poor depth estimation of moving objects is particularly problematic.
In this paper, we propose a new architecture and training formulation for this unsupervised learning problem that substantially improves depth accuracy for moving objects. Our key insight is that we need a good initial estimate for which pixels are independently moving (a "motion mask"). With this motion mask at hand, one can easily train depth estimation using the static pixels, and account for independent motion to correctly estimate the depth of the moving objects. However, the challenge is obtaining this motion mask in the first place: how do we identify which pixels are independently moving? First, we introduce two separate network modules that predict complete 3D scene flow and camera ego-motion. The difference between these can then be used to identify the moving objects. Second, we introduce a novel initialization scheme that stops depth training early to prevent the depth estimator from learning erroneous depth for the moving objects. This allows the motion estimation networks to learn the correct scene flow. In sum, we make the following contributions:
1. We propose a new approach, Dynamo-Depth, for learning depth estimation for dynamic scenes solely from unlabeled videos. In addition to monocular depth, Dynamo-Depth also predicts camera ego-motion, 3D independent flow, and motion segmentation. 2. We propose a new architecture that identifies independent object motion via the difference between the rigid flow field induced by camera ego-motion and a complete scene flow field to facilitate learning and regularization. 3. We propose a novel motion initialization technique that learns an early estimation of motion segmentation to explicitly resolve the ambiguity and disentangle independent motion from camera ego-motion (Figure 1). This allows the entire architecture to learn end-to-end without any additional supervision from auxiliary model predictions or ground-truth labels. 4. We evaluate on both nuScenes [3] and Waymo Open [34] and demonstrate not only state-of-theart performance in terms of overall depth accuracy and error, but also show large improvements on moving objects by up to 62% relative gain in accuracy and 68% relative reduction in error, while achieving up to 71.8% in F1 score in motion segmentation without any supervision.
2 Related Work
The framework for jointly learning monocular depth and ego-motion from unlabeled consecutive frames was first explored in [48,36], where the objective was posed as a novel-view synthesis problem.
Here, the monocular depth estimated from the target frame is coupled with the predicted ego-motion to warp the reference frame to be photometrically consistent with the target frame. Following these works, 3D geometric consistency [28] and depth prediction consistency [1] were imposed across consecutive frames to further constrain the unsupervised learning objective. Furthermore, discrete volumes [19], uncertainty estimation [30], optical flow based pose estimation [47], minimal projection loss with auto-masking [10], and multiple input frames during inference [40,25] were also proposed to improve depth predictions and mitigate influence of occlusion and relative stationary pixels.
Unsupervised Scene Flow. In addition to predicting depth from a single frame, a closely related task of scene flow estimation -obtaining both the 3D structure and 3D motion from two temporally consecutive images -can also be learned by leveraging the same novel-view reconstruction objective. When trained on sequences of stereo-frames, scene flow can be estimated from both stereo [18,41] and monocular [16,17] inputs during inference. Additionally, DRAFT [13] learned from monocular sequences only by utilizing synthetic data and multiple consecutive frames during inference.
In essence, the reconstruction objective encourages pixels to be predicted at an appropriate distance away to explain its apparent motion on the image plane, when coupled with the predicted ego-motion. This assumes that all pixel motion can be sufficiently modeled by depth and camera ego-motion alone, which implies an underlying static scene. However, since dynamical objects are common in the wild, such static scene assumption is often violated. To disambiguate independent motion, recent works were proposed to leverage stereo-view information [38,26,11], additional input modalities [45,8], synthetic data [13], supervised segmentation task [21], and auxiliary monocular depth network [33]. Extending from these methods, additional works proposed to mitigate the negative effects by modeling the behavior of dynamical objects without the use of additional modalities and labels.
Modeling Independent Motion via Optical Flow. Although an explainability mask [48] can be used to ignore the independently moving regions, recent works exploited the jointly learned optical flow to refine the depth prediction under non-rigid scene settings. This includes predicting a residual optical flow [43,35] to account for dynamical objects and enforcing forward-backward flow consistency [49] to discount dynamical regions. EPC++ [27] directly modeled the dynamical objects by integrating its depth, ego-motion, and optical flow predictions. Additionally, CC [31] proposed a coordinated learning framework for joint depth and optical flow estimation assisted by a segmentation branch.
Modeling Independent Motion via 3D Non-Rigid Flow Field. Instead of modeling dynamical objects via 2D optical flow, additional works proposed to explicitly model their 3D independent flow field to encourage accurate depth learning for dynamical objects. To facilitate independent motion learning, various methods [4,12,22,23,2,32] leveraged semantic priors from off-theshelf pretrained detection or segmentation models to estimate regions that are "possibly moving." Additionally, Dyna-DepthFormer [46] used multi-frame information to compute the depth map, while iteratively refining the residual 3D flow field via a jointly trained motion network. Finally, Li et al. [24] proposed to jointly learn monocular depth, ego-motion, and residual flow field via a sparsity loss and RM-Depth [15] improved upon it via an outlier-aware regularization loss. Unlike [24,15] where the residual/independent flow is predicted directly, we propose to model the 3D independent flow field via the complete scene flow, which facilitates training and effectively enforces sparsity.
When a camera moves in a rigid scene, the apparent motion of image pixels is entirely explained by (a) their 3D position relative to the camera, and (b) the motion of the camera. This fact is used by unsupervised techniques that learn to predict depth from unlabeled videos captured as a camera moves through the scene (as in driving footage). Concretely, one network predicts depth from a target frame and another predicts the motion of the camera from the source frame to the target frame. The two predictions are then used to reconstruct a target frame from the source frame, and a reconstruction loss would serve as the primary training objective.
What happens if there are moving objects in the scene? Clearly, depth and camera-motion are not sufficient to explain the apparent image motion of these objects, resulting in a high reconstruction loss for these dynamical regions. In principle, the motion of these objects are unpredictable from a single frame, and so even though the network sees a high loss for these objects, the best it can do is to fit the average case of a static object. As such, in principle, moving objects should not be a concern for learning-based techniques. However, in practical driving scenes, there is a large class of moving objects for which the network can in fact minimize the reconstruction loss by predicting an incorrect depth estimate. We describe this class below.
Consider the simple case of a pinhole camera moving forward along the Z axis (i.e., along its viewing direction). This is in fact the common case of a car driving down the road. In this case, the image location (x, y) and corresponding optical flow ( ẋ, ẏ) for a 3D point (X, Y, Z) in the world would be:
Consider what happens when this 3D point is on an object moving collinear to the camera (e.g., cars in front of the ego-car, or oncoming traffic). In this case, there are two contributions to Ż: the camera motion and the independent motion of the object. Thus, given ego-motion, one can produce the same optical flow by adding the appropriate amount of independent motion to Ż, or changing the depth Z.
For example, an object can appear to move faster if it is either closer and static (i.e., Z is smaller) or it is farther and moving towards the camera (i.e., Ż is larger). This is a special case of epipolar ambiguity [42]. This implies that it is possible to model independent motion under the static scene constraint using an erroneous depth estimation. Unfortunately, there are statistical regularities that enable such erroneous learning.
In self-driving scenes, there is often enough information in object appearance to predict its motion even from a single frame. The high capacity monocular depth network can learn to recover this information, and then alter its depth prediction to better reconstruct the target frame. For instance, in Figure 1 (b) the depth network may have learnt to recognize the backs of cars on the same or nearby lanes. In the training data, cars seen from the back often travel in the same direction with similar speed as the ego car, and thus have a very small optical flow in consecutive frames. The depth network therefore predicts that the car should be very far away; thus correctly predicting its optical flow, but incorrectly predicting its depth. A similar effect happens when the white van is recognized in its frontal view on the opposite lane, and the depth network predicts it to be closer to the ego-car. This allows the depth network to model the statistically-likely higher optical flow as a result of the object moving towards the camera. Furthermore, the speed of the object can also be roughly estimated from object identity (pedestrian < cyclist < car) and background context (residential < city < highway). Therefore, by recognizing the statistical regularities that give away object motion, the depth model can model the behavior of dynamical objects by predicting incorrect depth values to minimize the reconstruction objective.
This suggests that simply training a depth network on dynamic scenes is not a good solution, and an alternative framework is needed. However, we do note that learning these statistical regularities about object motion is much harder than learning the depth of the static background, since the background is a lot more consistent in its optical flow across videos and frames. Thus, we observe that this kind of overfitting to dynamical objects only happens later in training; a fact we use below.
Following past works, we formulate the learning objective as a novel-view synthesis where the target frame is reconstructed from the source frame. As shown in Section 3, modeling the rigid flow induced by camera motion alone is not sufficient for modeling the behavior of dynamical objects and causes performance degradation for moving objects. We address this by learning a separate 3D flow field that captures the independent motion of dynamical objects.
The proposed architecture (Figure 2) contains two components that collaborate together to explain the apparent pixels motion on the image plane. the 3D rigid flow field (motion induced by camera while assuming a static scene), which includes the depth network D and ego-motion pose network P. Section 4.1.2 details the independent motion networks that model the 3D independent flow field (motion of dynamical objects), which includes the complete flow network C and motion mask network M. 4.1.1 Rigid Motion Networks: Depth D & Pose P
Given a source frame I s and a target frame I t , we compute the 3D rigid flow induced by camera motion, F R (p t ), for each target pixel p t as follows. We first obtain the monocular depth map d t by passing I t to the depth network D (Eq. 2). We pass I s and I t to the ego-motion pose network P to obtain the relative camera pose T t !s (rotation and translation) (Eq. 3). We then use the depth and inverse camera intrinsics Kfoot_0 to back-project every target pixel p t to compute its 3D location P t , and transform P t into its corresponding 3D location, Ps , in the source frame via T t !s . (Eq. 4). The "rigid flow" induced by camera motion is then simply F R (p t ) = Ps P t .foot_1
In addition to the rigid flow F R , we also wish to model object motion via the 3D independent flow, denoted as F I . With independent motion explicitly modeled by F I , we reformulate Ps as Ps = (F I (p t ) + F R (p t ) + P t ) to integrate the contribution of the independent flow vector F I (p t ). However, directly estimating F I via a network turns out to be difficult for two reasons:
(a) Learning. During training, the network will need to fill in the missing independent motion vector that is appropriate for the current separately predicted monocular depth and ego-motion for a correct reconstruction: a "moving target" during training. Furthermore, it is intuitively much more difficult to learn and predict independent motion directly when the apparent motion in the input frames consists of both rigid and independent motion entangled together, especially in the ambiguous scenarios illustrated in Section 3.
(b) Regularization. Adding to this complexity, F I (p t ) should be non-zero if and only if the pixel I t (p t ) is independently moving. One could regularize this network to encourage sparsity, but early on when depth and ego-motion predictions are noisy, a high sparsity term would encourage this network to turn off entirely. At the other end of the spectrum, a weak sparsity regularization allows independent flow F I to be active on static regions of the scene, which would "explain away" the rigid motion F R (p t ) when computing Ps and corrupt the learning signal for depth estimation. Also, conventional sparsity regularization on F I (e.g., L 1/2 sparsity loss [24]) would dampen the magnitude of predicted motion, which reduces F I 's capacity to model fast or far-away moving objects.
To address these issues, we propose to decompose the prediction of independent flow F I (p t ) in two:
(1) predicting whether pixel I t (p t ) is independently moving and (2) predicting how it is moving. For (1), we model the probability of independent motion as a binary motion segmentation task where motion mask network M takes the consecutive frames I t and I s and predict a per-pixel motion mask M as shown in Eq. 5. For (2), instead of directly predicting the independent motion, we predict the complete scene flow F C (p t ) via a complete flow network C as shown in Eq. 6.
From these predictions, we formulate the independent flow field as
, the residual flow between F C and F R gated by the motion mask M . Intuitively, computing Ps = (F I (p t ) + F R (p t ) + P t ) can be thought of as combining the contribution of the complete flow F C (p t ) and rigid flow F R (p t ) as a weighted average via M (p t ) (Eq. 8).
) This formulation directly resolves the two aforementioned issues. For (a), C has a simpler learning objective of modeling the full scene flow with per-pixel predictions, i.e. Ps = F C (p t ) + P t . For (b), the sparsity regularization can be applied to M alone without any impact to the learning of C and its ability to learn the complete scene flow.
Finally, we compute the reconstruction Ît (p t ) by sampling I s at the corresponding pixel coordinate ps via ! ps ⌘ K Ps for every target pixel p t .
We present the overall loss function in Eq. 9. The photometric loss L recon in Eq. 10 serves as the main learning objective, which evaluates the reconstruction Ît via SSIM [39] and L1 weighted by ↵.
The smoothness loss L s in Eq. 11 regularizes the smoothness of the predicted depth map d t , complete flow F C , and motion mask M . The edge-aware smoothness loss l s (z,
) is weaker around pixels with high color variation. We also use the meannormalized inverse depth d ⇤ t to discourage shrinking of the estimated depth [37].
The motion consistency loss L c in Eq. 12 computes the flow discrepancy F D (p) between the complete scene flow F C (p) and rigid flow F R (p) for static pixels. The probability of pixel p being static is approximated by
The motion sparsity loss L m in Eq. 13 considers all pixels with flow discrepancy F D lower than the mean value over the frame as putative background, and encourages the motion mask to be 0 by using the cross entropy against label 0, which is denoted as g(•).
) Finally, the above-ground loss L g in Eq. 14 penalizes projected 3D points below the estimated ground plane (via RANSAC) where d g t denotes the mean-normalized inverse depth of the ground plane.
Since the reconstruction loss is the main learning signal in the unsupervised approach, the gradient from the reconstruction loss between I t and Ît at pixel p t would propagate through the computed sample coordinate
Here, although it may be ideal to jointly train all models end-to-end from start to finish, in practice, updating the rigid flow vector F R (p t ) and the independent flow vector F I (p t ) jointly from the start would cause the learning problem to be ill-posed, since each component has the capacity to overfit and explain away the other's prediction. Due to the ambiguity between camera motion and object motion as discussed in Section 3, the image reconstruction error alone is not a strong enough supervisory signal to enforce the accurate prediction of all underlying sub-tasks jointly, as a family of solutions of depth and object motion would all satisfy the training objective, ranging from predicting the whole scene as static with incorrect depth to predicting the scene as moving objects on a flat canvas.
Here, we offer our key insight that a good initial estimate of motion segmentation M would allow the system to properly converge without arising degenerate solutions. As shown in Eq. 8,
For any pixel p t , Ps ⇡ F C (p t ) + P t if M (p t ) is near 1, and approximates F R (p t ) + P t if M (p t ) is near 0. From this, it is clear that a good motion mask would route the back-propagating gradient to the complete flow network C via F C if p t is moving and route the gradient to the rigid motion networks D and P via F R (p t ) if p t is static.
Of course, the question is how one can initialize a good motion mask, since it requires identifying the moving objects. Ideally, moving objects would be identified as the pixels that are poorly reconstructed based on depth and ego-motion alone, but as discussed in Section 3, the depth network has the capacity to alter its depth predictions and reconstruct even the moving objects. Nevertheless, we observe that overfitting to the moving objects in this way is difficult, and only happens in later iterations. In earlier training iterations, reconstruction errors for dynamical pixels are ignored (Appendix B.5).
To ensure a good motion mask M , we first train a depth network assuming a static scene, but stop updates to the depth network at an early stage. We then initialize the independent motion networks C and M from a coarse depth sketch predicted by this frozen early-stage depth network. Thus, without access to any labels or auxiliary pretrained networks, we obtain an initialization for motion mask M that helps in disambiguating and accurately estimating the rigid flow F R and independent flow F I .
Dataset. While Dynamo-Depth is proposed for general applications where camera motion is informative for scene geometry, we focus our attention on the challenging self-driving setting, where the epipolar ambiguity and the statistical regularities mentioned in Section 3 that lead to erroneous depth predictions are highly prevalent. Specifically, we evaluate on three datasets -Waymo Open [34], nuScenes [3], and KITTI [9] with Eigen split [6].
On all datasets, we only use the unlabeled video frames for training; ground truth LiDAR depth is only used for evaluation. We evaluate both overall depth estimation accuracy, as well as accuracy computed separately for static scene and moving objects. For the latter evaluation, we use Waymo Open and nuScenes and identify moving objects by rectifying the panoptic labels with 3D box labels to obtain masks for static/moving objects. It is worth quantifying the number of moveable objects per frame in each dataset. Waymo Open has a mean of 12.12 with a median of 9. In nuScenes, the mean is 7.78 with a median of 7. In KITTI, due to lack of per-frame labels, we approximate using its curated object detection dataset, which only has a mean of 5.26 with a median of 4. Additional dataset information and distribution histograms are found in Appendix C.
Model and Training setup. The proposed method is trained on four NVIDIA 2080 Ti with a total batch size of 12 and an epoch size of 8000 sampled batches. Adam optimizer [20] is used with an initial learning rate of 5e-5 and drops to 2.5e-5 after 10 epochs. Motion Initialization lasts 5 epochs and takes place after the depth network and complete flow network have been trained for 1 epoch each. After initialization, the system is trained for 20 epochs, totalling approximately 20 hours. The hyperparameter values are the same for all experiments and are provided in Appendix B.1, along with the rest of the details of the model architecture. To demonstrate the generality of the proposed framework, we adopt two architectures for the depth network D, one with a ResNet18 [14] backbone from Monodepth2 [10] and another with a CNN/Transformer hybrid backbone from LiteMono [44], denoted as Dynamo-Depth (MD2) and Dynamo-Depth, respectively. To be commensurate with baselines, the encoders are initialized with ImageNet [5] pretrained weights.
Metrics. Depth performance is reported via commonly used metrics proposed in [7], including 4 error metrics (Abs Rel, Sq Rel, RMSE, and RMSE log) and 3 accuracy metrics ( < 1.25, < 1.25 2 , and < 1.25 3 ). We also report precision-recall curve for evaluating binary motion segmentation.
As shown in Table 1, our proposed approach outperforms prior arts on both nuScenes and Waymo Open across all metrics, with over 57% and 21% reduction in overall Abs Rel for nuScenes and Waymo Open, respectively. This improvement is significant: we repeat the experiment for Dynamo-Depth on Waymo Open 3 times and obtained a 95% confidence interval of 0.119 ± 0.003 for Abs Rel and 0.874 ± 0.004 for < 1.25. This suggests the challenge and importance of estimating accurate depth for moving objects in realistic scenes. On KITTI, our approach is competitive with prior art. However, KITTI has fewer moveable objects, which better conforms to the static scene constraint and diminishes the importance in modeling independent motion. For instance, LiteMono [44], which does not model independent motion, demonstrates superior performance on KITTI but drastically underperforms in nuScenes and Waymo Open, with both datasets having many more moving objects.
To further evaluate the effectiveness of our approach in modeling independent motion, we split nuScenes and Waymo Open into static background, static objects and moving objects and evaluate depth estimation performance on each partition. As we adopt our depth model from Monodepth2 [10] and LiteMono [44], in Table 2, we compare our approach against the respective baseline with the same depth architecture. For simplicity, we report Abs Rel and < 1.25. Notably, by explicitly modeling (a) Input Frames (b) Monocular Depth (c) Rigid Flow (d) Independent Flow (e) Motion Mask independent motion, we observe a consistent and significant improvement on moving objects (M.O.) across both architectures and both datasets, with over 48% relative improvement in accuracy and over 67% relative reduction in error for both architectures on Waymo Open. Additionally, we see a substantial improvement on both static moveable objects (S.O.) and static background (S.B.) for both datasets and both architectures. Interestingly, the large reduction in error on static background in nuScenes does not match the corresponding improvement in accuracy, as the large errors on background mainly come from night-time instances where all methods fail, but differ in their respective artifacts (discussed further in Appendix D.2). [2] 0.136 0.132 0.177 0.201 0.833 0.839 0.778 0.730 0.116 0.110 0.155 0.194 0.878 0.891 0.812 0.750
In sum, by explicitly modeling independent motion, we are able to outperform the baselines and achieve state-of-the-art performances on both Waymo Open and nuScenes Dataset. Qualitative results are found in Figure 1 and Figure 3, where "Static Scene Constraint" refers to performance of LiteMono [44] in Figure 1. Figure 4 evaluates the quality of the jointly learned binary motion mask network using precision and recall. We observe a high precision with increasing recall, achieving a F1 score of 71.8% on Waymo Open [34]. Note that this segmentation quality is achieved without any labels. On nuScenes, Dynamo-Depth achieves a F1 score of 42.8% with 57.2% on day-clear conditions and 21.1% on all other conditions. Notably, the motion mask network is able to segment out small dynamical objects, such as the cyclist in the first row of Figure 3.
In addition, we show our ablation results on Waymo Open in Table 3. First, we found that ablating the motion consistency loss removes the regularization on the complete flow prediction, which causes the degenerate solution of moving objects on a flat canvas, as indicated by the poor segmentation performance in Figure 4. Similarly, by ablating motion initialization, initial independent motion prediction lead to large reconstruction errors, which diverges depth training. In addition, we observe that ablating the above ground prior preserves the performance of motion segmentation and depth of moving objects, but degrades the performance of depth on static background. Intuitively, this prior regularizes the structural integrity of the ground plane. Finally, we observed that the original set of hyperparameter values leads to training divergence when ablating the ImageNet pretrained weights. To compensate, we increase the initial number of epochs for depth learning from 1 to 2 (marked as 7 [2] ) without performing any hyperparameter sweeps.
In this work, we identify the effects of dynamical objects in unsupervised monocular depth estimation with static scene constraint. To mitigate the negative impacts, we propose to jointly learn depth, ego-motion, 3D independent motion and motion segmentation from unlabeled videos. Our key insight is that a good initial estimation of motion segmentation encourages joint depth and independent motion learning and prevents degenerate solutions from arising. As a result, our approach is able to achieve state-of-the-art performance on both Waymo Open and nuScenes Dataset.
Limitations and Societal Impact. Our work makes a brightness consistency assumption, where the brightness of a pixel will remain the same. Although common in optical flow, this assumption limits the our method's ability to model scenes with dynamical shadows, multiple moving light sources, and lighting phenomenons (e.g., lens flare). In addition, our work does not introduce any foreseeable societal impacts, but will generally promote more label-efficient and robust computer vision models.
In Figure 5
Please refer to Table 4 for the hyperparameters used for training. The values are found via Waymo Open and kept the same for other datasets. The trade-off coefficient ↵ and depth smoothness coefficient sd are set to 0.85 and 0.001, respectively, as in [10]. The motion smoothness coefficient sc is set to 0.001 to be consistent with sd and was not tuned further. The mask smoothness coefficient sm is set to a much higher value of 0.1 to remove sporadic false positives induced by high frequency image features such as trees and buildings. Since both rigid motion F R and complete motion F C have relatively small magnitudes, we set the motion consistency coefficient c to be 5.0 to properly enforce consistency. Due to the high loss values outputted by binary cross entropy, we set the mask sparsity coefficient to be 0.04 to accommodate. The above ground coefficient g is set to 0.1 after searching across the values 0.01, 0.1, and 1.0.
The depth network D is adopted from two architectures, one with a ResNet18 [14] backbone from Monodepth2 [10] and another with a CNN/Transformer hybrid backbone from LiteMono [44], denoted as Dynamo-Depth (MD2) and Dynamo-Depth, respectively. For both versions of our model, the pose network P is adopted from Monodepth2 [10]. The encoders of the complete flow network C and motion mask network M are shared and have the same architecture as P. To obtain per-pixel predictions, the features of the shared encoder are fed into the the separate decoders with the same architecture as the depth decoder in Monodepth2 [10] and with output per-pixel dimension of 3 and 1 for C and M, respectively.
For notational simplicity, Figure 2 only considers the case of a single source frame I s , while in practice, Dynamo-Depth is trained with two source frames: one frame previous and one frame after the target I t . Here, the two respective reconstructions are rectified via a minimal projection loss proposed in [10] to obtain Ît . To enforce forward-backward consistency, the independent motion networks C and M predict a single independent flow field F I that is used to warp both source frames into the target frame, with the appropriate sign change.
Following Monodepth2 [10] and LiteMono [44], we perform auto-masking to facilitate learning during depth initialization. Afterwards, auto-masking is turned off as the apparently static pixels may belong to dynamical objects traveling with the ego-camera, in which case auto-masking would mask out the corresponding reconstruction loss essential for independent motion learning.
There is a linear weight ramp for all loss terms that include F C and M at the beginning of each training stage, with the length of 2666 iterations for Waymo and nuScenes, and 8000 iterations for KITTI due to the its limited number of moving objects.
Concretely, 3D projected points (P t in Eq. 4) belonging to the bottom half of the image are sampled to construct the ground plane d g t via RANSAC (5 points are selected per iteration, for a total of 100 iterations). This assumption does break under cases of traffic jams, but due to the rare occurrence of these scenarios for this learning task assuming a moving camera, the negative effects are limited.
In Figure 6, we show a qualitative example where a depth network learned with static scene constraint (LiteMono [44] in this case) would ignore the high reconstruction loss in earlier iterations in (b) and overfit to the moving objects via erroneous depth predictions only in later iterations in (c)-(f).
We provide additional information of the three datasets used for evaluation.
For the Waymo Open Dataset [34], 76,852 front camera image-triplets from the provided train set containing 798 video sequences are used for training while 2,216 front camera images uniformly sampled from the provided validation set containing 202 video sequences are used for evaluation.
During training, frames are downsampled to 480 ⇥ 320. We rectify the panoptic labels [29] with 3D box labels to obtain the corresponding masks for static and moving objects. For the nuScenes Dataset [3], 79,760 front camera image-triplets from the provided train set containing 700 video sequences are used for training while 6019 front camera images from the official validation set containing 150 video sequences are used for evaluation (of which 4449 are day-clear). Following [8], we consider a sequence to be in the day-clear subset if its description does not contain "night" or "rain". During training, frames are downsampled to 512 ⇥ 288. We rectify the panoptic LiDAR labels with annotated 3D bounding boxes to obtain motion attributes for LiDAR points.
Notably, as our method learns to explicitly model independent motion, there is no filtering based on camera velocity recordings when constructing the training dataset.
For the KITTI Dataset [9], we follow the Eigen split [6] with 39,180 image-triplets used for training and 697 images used for evaluation. During training, frames are downsampled to 640 ⇥ 192.
Finally, we plot the histogram of the number of moveable objects per frame for all three datasets. Shown in Figure 7, Waymo Open Dataset has the most moveable objects with a mean of 12.12, followed by nuScenes with a mean of 7.78. Due to the lack of per-frame object labels in KITTI, we evaluate on its curated object detection dataset, which has a mean of 5.26. We note that the real distribution should be much tighter near 0, compared to the detection dataset with all images containing at least 1 moveable object. (b) Monocular Depth (c) Rigid Flow (f) Independent Flow Dynamo-Depth (Ours) Static Scene Constraint Input (d) Monocular Depth (e) Rigid Flow (a) Input Frames D.3 Odometry Evaluation Please refer to Table 8 for odometry evaluation for Dynamo-Depth and Dynamo-Depth (MD2) on both nuScenes day-clear subset and Waymo Open Dataset.
We were not able to compare against the mentioned related works in unsupervised scene flow estimation due to the large difference in methodology (stereo-view during training [18,41,16,17]) and lack of codebase for reproducibility [13].
As shown in Figure 10, dynamical shadows and moving light sources in low-light conditions violate the brightness consistency assumption, which results in erroneous predictions of motion segmentation and monocular depth, respectively.
(a) Input Frames (b) Monocular Depth (c) Rigid Flow (d) Independent Flow (e) Motion Mask
F C , F R , F I and F I + F R are all 3D flow fields visualized as optical flow on the image plane.
! • denotes the conversion from Cartesian to homogeneous coordinate.
All motion segmentation in (e) are uniformly visualized with a range of [0, 1], and corresponding video sequences that contain each example are found in https://dynamo-depth.github.io.