V ISUAL R EPRESENTATION L EARNING WITH 3D V IEWC ONTRASTIVE I NVERSE G RAPHICS N ETWORKS
Anonymous authors
Paper under double-blind review
A BSTRACT
Predictive coding theories suggest that the brain learns by predicting observations at various levels of abstraction.
One of the most basic prediction tasks is view prediction: how would a given scene look from an alternative viewpoint?
Humans excel at this task.
Our ability to imagine and ﬁll in missing visual information is tightly coupled with perception: we feel as if we see the world in 3 dimensions, while in fact, information from only the front surface of the world hits our (2D) retinas.
This paper explores the connection between view-predictive representation learning and its role in the development of 3D visual recognition.
We propose inverse graphics networks, which take as input 2.5D video streams captured by a moving camera, and map to stable 3D feature maps of the scene, by disentangling the scene content from the motion of the camera.
The model can also project its 3D feature maps to novel viewpoints, to predict and match against target views.
We propose contrastive prediction losses that can handle stochasticity of the visual input and can scale view-predictive learning to more photorealistic scenes than those considered in previous works.
We show that the proposed model learns 3D visual representations useful for (1) semi-supervised learning of 3D object detectors, and (2) unsupervised learning of 3D moving object detectors, by estimating motion of the inferred 3D feature maps in videos of dynamic scenes.
To the best of our knowledge, this is the ﬁrst work that empirically shows view prediction to be a useful and scalable self-supervised task beneﬁcial to 3D object detection.
I NTRODUCTION
Predictive coding theories (Rao & Ballard, 1999; Friston, 2003) suggest that the brain learns by predicting observations at various levels of abstraction.
These theories currently have extensive empirical support: stimuli are processed more quickly if they are predictable (McClelland & Rumelhart, 1981;
Pinto et al., 2015), prediction error is reﬂected in increased neural activity (Rao & Ballard, 1999; Brodski et al., 2015), and disproven expectations lead to learning (Schultz et al., 1997).
A basic prediction task is view prediction: from one viewpoint, predict what the scene would look like from another viewpoint.
Learning this task does not require supervision from any annotations; supervision is freely available to a mobile agent in a 3D world who can estimate its egomotion (Patla, 1991).
Humans excel at this task: we can effortlessly imagine plausible hypotheses for the occluded side of objects in a photograph, or guess what we would see if we walked around our ofﬁce desks.
Our ability to imagine information missing from the current image view—and necessary for predicting alternative views—is tightly coupled with visual perception.
We infer a mental representation of the world that is 3-dimensional, in which the objects are distinct, have 3D extent, occlude one another, and so on.
Despite our 2-dimensional visual input, and despite never having been supplied a 3D bounding box or 3D segmentation mask as supervision, our ability for 3D perception emerges early in infancy (Spelke et al., 1982; Soska & Johnson, 2008).
In this paper, we explore the link between view predictive learning and the emergence of 3D perception in computational models of perception, on mobile agents in static and dynamic scenes.
Our models are trained to predict views of static scenes given 2.5D video streams as input, and are evaluated on their ability to detect objects in 3D. Our models map 2.5D input streams into 3D feature volumes of the depicted scene.
At every frame, the architecture estimates and accounts for the motion of the camera, so that the internal 3D representation remains stable.
The model projects its inferred 3D feature maps to novel viewpoints, and matches them against visual representations
[Figure]
Pre-training with view-contrastive prediction improves results, especially when there are few ob- extracted from the target view.
We propose contrastive losses to measure the match error, and backpropagate gradients end-to-end in our differentiable modular architecture.
At test time, our model forms plausible 3D completions of the scene given RGB-D (2.5D) video streams or even a single RGB-D image as input: it learns to inpaint information behind occlusions, and infer the 3D extents of objects.
We evaluate the trained 3D representations in two tasks.
(1) Semi-supervised learning of 3D object detectors (Figure 1): We show that view
contrastive pretraining helps detect objects in 3D, especially in the low-annotations regime.
(2) Unsupervised 3D moving object detection (Figure 3 right): Our model can detect moving objects in 3D without any human annotations, by forming a 3D feature volume per timestep, then estimating the motion ﬁeld between volumes, and clustering the motion into objects.
View prediction has been the center of much recent research effort.
Most methods test their models in single object scenes, and aim to generate beautiful images for graphics applications (Kar et al., 2017; Sitzmann et al., 2019;
Tatarchenko et al., 2016;
Saito et al., 2019), as opposed to learning general-purpose visual representations.
In this work, we use view prediction to help object detection, not the inverse.
The work of Eslami et al.
(2018) attempted view prediction in full scenes, yet only experimented with toy data containing a few colored 3D shapes.
Their model cannot effectively generalize beyond the training distribution, e.g., cannot generalize across scenes of variable number of objects.
The work of Tung et al.
(2019) is the closest to our work.
Their model is also an inverse graphics network equipped with a 3-dimensional feature bottleneck, and was trained for view prediction; it showed strong generalization across scenes, number of objects, and arrangements.
However, the authors demonstrated its abilities only in toy simulated scenes, similar to those used in Eslami et al.
Furthermore, they did not evaluate the usefulness of the learned features for a downstream semantic task, beyond view prediction.
This raises questions on the scalability and usefulness of view prediction as an objective for self-supervised visual representation learning, which our work aims to address.
We compare against the state-of-the-art model of Tung et al.
and show that the features learned under our proposed view-contrastive losses are more semantically meaningful (Figure 1).
To the best of our knowledge, this is the ﬁrst work that can discover objects in 3D from a single camera viewpoint, without any human annotations of object boxes or masks.
Summarizing, we have the following contributions over prior works: (1) Novel view-contrastive prediction objectives.
We show that these losses outperform RGB regression (Dosovitskiy et al., 2017;
Tung et al., 2019) and VAE alternatives (Eslami et al., 2018) in semi-supervised 3D object detection.
(2) A novel unsupervised 3D moving object detection method, by estimating 3D motion of egomotion-stabilized 3D feature maps.
We show that we outperform 2.5D baselines and iterative generative what-where VAEs of previous works (Kosiorek et al., 2018; Hsieh et al., 2018).
Simulation-to-real transfer of the acquired view-predictive 3D feature representations.
We show 3D features (pre)trained with view contrastive prediction in a simulated environment boost the performance of 3D detectors trained from 3D object box annotations on real-world images.
Our code and data will be made publicly available upon publication.
R ELATED W ORK
Predictive visual feature learning Predictive coding theories suggest that much of the learning in the brain is of a predictive nature (Rao & Ballard, 1999; Friston, 2003).
Recent work in unsupervised learning of word representations has successfully used ideas of predictive coding to learn word representations by predicting neighboring words (Mikolov et al., 2013).
Many challenges emerge in going from a ﬁnite-word vocabulary to the continuous high-dimensional image data manifold.
Unimodal losses such as mean squared error are not very useful when predicting high dimensional data, due to the stochasticity of the output space.
Researchers have tried to handle such stochasticity using latent variable models (Loehlin, 1987) or autoregressive prediction of the output pixel space, which involves sampling each pixel value from a categorical distribution conditioned on the output thus far (Van den Oord et al., 2016).
Another option is to make predictions in a latent feature space.
Recently, Oord et al.
(2018) followed this direction and used an objective that preserves mutual information between the future bottom-up extracted features and the predicted contextual latent features, applying it in speech, text and image patches in single images.
The view contrastive loss proposed in this work is a non-probabilistic version of their contrastive objective.
However, our work focuses on the video domain as opposed to image patches, and uses drastically different architectures for both the contextual and bottom-up representations, using a 3D representation bottleneck.
V IEW - CONTRASTIVE 3D FEATURE LEARNING
We consider a mobile agent that can move about the scene at will.
The agent has an RGB camera with known intrinsics, and a depth sensor registered to the camera’s coordinate frame.
At training time, the agent has access to its camera pose, and it learns in this stage to imagine full 3D scenes (via view prediction), and to estimate egomotion (from ground-truth poses).
It is reasonable to assume that a mobile agent who moves at will has access to its approximate egomotion, since it chooses where to move and what to look at (Patla, 1991).
Active vision is outside the scope of this work, so our agent simply chooses viewpoints randomly.
At test time, the model estimates egomotion on-theﬂy from its RGB-D inputs.
We use groundtruth depth provided by the simulation environment, and we will show in Sec. 4 that the learned models generalize to the real world, where (sparser) depth is provided by a LiDAR unit.
We describe our model architecture in Sec.
3.1, our view-contrastive prediction objectives in Sec. 3.2, and our unsupervised 3D object segmentation in Sec.
3. I NVERSE GRAPHICS 3D- BOTTLENECKED RNN S
Our model’s architecture is illustrated in Figure 2-left.
It is a recurrent neural network (RNN) with a memory state tensor M
[Equation]
d × c , which has three spatial dimensions (width w , height h , and depth d ) and a feature dimension ( c channels per grid location).
The latent state aims to capture an informative and geometrically-consistent 3D deep feature map of the world space.
Therefore, the spatial extents correspond to a large cuboid of world space, deﬁned with respect to the camera’s position at the ﬁrst timestep.
We refer to the latent state as the model’s imagination to emphasize that most of the grid locations in M ( t ) will not be observed by any sensor, and so the feature content must be “imagined” by the model.
Our model is made up of differentiable modules that go back and forth between 3D feature imagination space and 2D image space.
It builds on the recently proposed geometry-aware recurrent neural networks (GRNNs) of Tung et al.
(2019), which also have a 3D egomotion-stabilized latent space, and are trained for RGB prediction.
Our model can be considered a type of GRNN.
In comparison to Tung et al.
(2019): (i) our egomotion module can handle general camera motion, as opposed to a 2-degree-of-freedom sphere-locked camera.
This is a critical requirement for handling data that comes from freely-moving cameras, such as those mounted on mobile vehicles, as opposed to only orbiting cameras.
(ii) Our 3D-to-2D projection module decodes the 3D map into 2D feature maps, as opposed to RGB images, and uses view-contrastive prediction as our objective, as opposed to regression.
In Table 3 and Figure 8, we show that nearest neighbors in our learned featurespace are more accurate and appear more semantically related than neighbors delivered by RGB regression.
We brieﬂy describe each neural module of our architecture next.
Further implementation details are in the appendix.
2D-to-3D unprojection
This module converts the input RGB image
I ( t ) ∈
R w × h × 3 and pointcloud D ( t ) ∈
R n × 3 into 3D tensors.
The RGB is “unprojected” into a 3D tensor U ( t ) ∈
R w × h ×
d
×by ﬁlling each 3D grid location with the RGB value of its corresponding subpixel.
The pointcloud is converted to a 3D occupancy grid
O ( t ) ∈
R w × h ×
d
× 1 , by assigning each voxel a value of 1 or 0, depending on whether or not a point lands in the voxel.
We then convert the concatenation of these tensors into a 3D feature tensor F ( t ) ∈
R w × h × d × c , via a 3D convolutional encoder-decoder network with skip connections.
We L 2 -normalize the feature in each grid cell.
Egomotion estimation
This module computes the relative 3D rotation and translation between the current camera pose (at time t ) and the reference pose (from time 1 ), allowing us to warp the feature tensor F ( t ) into a registered version F ( t ) reg .
In principle any egomotion estimator could be used here, but we ﬁnd that our 3D feature tensors are well-suited to a 3D coarse-to-ﬁne alignment search, similar to the 2D process in the state-of-the-art optical ﬂow model
PWC-Net (Sun et al.,
[Figure]
Given the 3D tensors of the two timesteps, F (1) and F ( t ) , we incrementally warp F ( t ) into alignment with F (1) , by estimating the approximate transformation at a coarse scale, then estimating residual transformations at ﬁner scales.
This is done efﬁciently with 6D cross correlations and cost volumes.
Following PWC-Net, we use fully-connected layers to convert the cost volumes into motion estimates.
While our neural architecture is trained end-to-end to optimize a view prediction objective, our egomotion module by exception is trained supervised using pairs of frames with annotated egomotion.
In this way, it learns to be invariant to moving objects in the scene
Latent map update This module aggregates egomotion-stabilized (registered) feature tensors into the memory tensor M ( t ) .
On the ﬁrst timestep, we set M (1) =
F (1) .
On later timesteps, we update the memory with a simple running average.
3D-to-2D projection
This module “renders” the 3D feature state M ( t ) into a 2D feature map of a desired viewpoint V ( k ) .
We ﬁrst warp the 3D feature map M ( t ) into a view-aligned version M ( t ) view k , then map it to a 2D feature map M ( t ) view k with a 2-block 2D ResNet (He et al., 2016).
3D object detection
Given images with annotated 3D object boxes, we train a 3D object detector that takes as input the 3D feature map M ( t ) , and outputs 3D bounding boxes for the objects present.
Our object detector is a 3D adaptation of the state-of-the-art 2D object detector, Faster-RCNN (Ren et al., 2015).
The model outputs 3D axis-aligned boxes with objectness conﬁdences.
3. V IEW - CONTRASTIVE RENDERING
Given a set of input RGBs, pointclouds, and camera poses ( I (1) , D (1) , V (1) ) , . . .
, ( I ( n ) , D ( n ) , V ( n ) ) , we train our model to predict feature abstractions of an unseen input ( I ( n +1) , D ( n +1) , V ( n +1) ) , as shown in Figure 2-left.
We consider two types of representations for the target view: a topdown one, T = f
[( I (1) , D (1) , V (1) ) , . . .
, ( I ( n ) , D ( n ) , V ( n ) ) , V ( n +1) ] , and a bottom-up one, B = g
[ I ( n +1) , D ( n +1) ] .
Note that the top-down representation has access to the viewpoint V ( n +1) but not to observations from that viewpoint ( I ( n +1) , D ( n +1) ) , while the bottom-up representation is only a function of those observations.
We construct 2D and 3D versions of these representation types, using our architecture modules:
• We obtain T 3D =
M ( n ) by encoding the set of inputs 1 , . . . , n .
• We obtain B 3D =
F ( n +1) by encoding the single input n + 1 . • We obtain T 2D =
M ( n ) view n +1 by rendering M ( n ) from viewpoint V ( n +1) .
• We obtain B 2D = F ( n +1) by convolving I ( n +1) with a 3-block 2D ResNet (He et al., 2016).
Finally, the contrastive losses pull corresponding (top-down and bottom-up) features close together in embedding space, and push non-corresponding ones beyond a margin of distance:
[Equation]
where α is the margin size, and Y is 1 at indices where T corresponds to B , and − 1 everywhere else.
The losses ask tensors depicting the same scene, but acquired from different viewpoints, to contain the same features.
The performance of a metric learning loss depends heavily on the sampling strategy used (Schroff et al., 2015; Song et al., 2016; Sohn, 2016).
We use the distance-weighted sampling strategy proposed by Wu et al.
(2017) which uniformly samples “easy” and “hard” negatives; we ﬁnd this outperforms both random sampling and semi-hard (Schroff et al., 2015) sampling.
3. U NSUPERVISED 3D MOVING OBJECT DETECTION
Upon training, our model learns to map even a single RGB-D input to a complete 3D imagination, as we show in Figure 2-right.
Given two temporally consecutive and registered 3D maps F ( t ) , F ( t +1) reg , predicted independently using inputs ( I ( t ) , D ( t ) ) and ( I ( t +1) , D ( t +1) ), we train a motion estimation module to predict the 3D motion ﬁeld W ( t ) between them, which we call 3D imagination ﬂow.
Since we have accounted for camera motion, this 3D motion ﬁeld should only be non-zero for independently moving objects.
We obtain 3D object proposals by clustering the 3D ﬂow vectors, extending classic motion clustering methods (Brox & Malik, 2010; Ochs & Brox, 2011) to an egomotion-stabilized 3D feature space, as opposed to 2D pixel space.
3.3. E STIMATING 3D IMAGINATION FLOW
Our 3D FlowNet is a 3D adaptation of
the PWC-Net (2D) optical ﬂow model (Sun et al., 2018).
Note that our model only needs to estimate motion of the independently-moving part of the scene, since egomotion has been accounted for.
It works by iterating across scales in a coarse-to-ﬁne manner.
At each scale, we compute a 3D cost volume, convert these costs to 3D displacement vectors, and incrementally warp the two tensors to align them.
We train our 3D FlowNet using two tasks: (1) Synthetic transformation of feature maps: We apply random rotations and translations to F ( t ) and ask the model to recover the dense 3D ﬂow ﬁeld that corresponds to the transformation; (2) Unsupervised 3D temporal feature matching: L warp =
(cid:80) i,j,k || F ( t ) i,j,k − W ( F ( t +1) reg , W ( t ) )
i,j,k || , where
W ( F ( t +1) , W ( t ) ) back-warps F ( t +1) reg to align it with F ( t ) , using the estimated ﬂow W ( t ) .
We apply the warp with a differentiable 3D spatial transformer layer, which does trilinear interpolation to resample each voxel.
This extends self-supervised 2D optical ﬂow (Yu et al., 2016) to 3D feature constancy (instead of 2D brightness constancy).
We found that both types of supervision are essential for obtaining accurate 3D ﬂow ﬁeld estimates.
Since we are not interested in the 3D motion of empty air voxels, we additionally estimate 3D voxel occupancy, and supervise this using the input pointclouds; we set the 3D motion of all unoccupied voxels to zero.
We describe our 3D occupancy estimation in more detail in the appendix.
The proposed 3D imagination ﬂow enjoys signiﬁcant beneﬁts over 2D optical ﬂow or 3D scene ﬂow.
It does not suffer from occlusions and dis-occlusions of image content or projection artifacts (Sun et al., 2010), which typically transform rigid 3D transformations into non-rigid 2D ﬂow ﬁelds.
In comparison to 3D scene ﬂow (Hornacek et al., 2014), which concerns visible 3D points, 3D imagination ﬂow is computed between visual features that may never have appeared in the ﬁeld of view, but are rather inpainted by imagination.
3.3. 3D MOVING OBJECT SEGMENTATION
We obtain 3D object segmentation proposals by thresholding the 3D imagination ﬂow magnitude, and clustering voxels using connected components.
We score each component using a 3D version of a center-surround motion saliency score employed by numerous works for 2D motion saliency detection (Gao et al., 2008; Mahadevan & Vasconcelos, 2010).
This score is high when the 3D box interior has lots of motion but the surrounding shell does not.
This results in a set of scored 3D segmentation proposals for each video scene.
E XPERIMENTS
We train our models in CARLA (Dosovitskiy et al., 2017), an open-source photorealistic simulator of urban driving scenes, which permits moving the camera to any desired viewpoint in the scene.
We obtain data from the simulator as follows.
We generate 1170 autopilot episodes of 50 frames each (at 30 FPS), spanning all weather conditions and all locations in both “towns” in the simulator.
We deﬁne 36 viewpoints placed regularly along a 20m-radius hemisphere in front of the ego-car.
This hemisphere is anchored to the ego-car (i.e., it moves with the car).
In each episode, we sample 6 random viewpoints from the 36 and randomly perturb their pose, and then capture each timestep of the episode from these 6 viewpoints.
We generate train/test examples from this, by assembling all combinations of viewpoints (e.g., N ≤ 5 viewpoints as input, and 1 unseen viewpoint as the target).
We ﬁlter out frames that have zero objects within the metric “in bounds” region of the
GRNN ( 32 m × 32 m × 4 m ).
This yields 172524 frames (each with multiple views): 124256 in
Town1, and 48268 in Town2.
We treat the Town1 data as the “training” set, and the Town2 data as the “test” set, so there is no overlap between the train and test images.
For additional testing with real-world data, we use the (single-view) object detection benchmark from the KITTI dataset (Geiger et al., 2013), with the ofﬁcial train/val split: 3712 training frames, and 3769 validation frames.
We evaluate our view-contrastive 3D feature representations in three tasks: (1) semi-supervised 3D object detection, (2) unsupervised 3D moving object detection, (3) 3D motion estimation.
We use Tung et al.
as a baseline representing the state-of-the-art, but evaluate additional related works in the appendix (Sec.
C.2, Sec. C.3).
4. S EMI - SUPERVISED LEARNING OF 3D OBJECT DETECTION
We use the proposed view-contrastive prediction as pretraining for 3D object detection 1 .
We pretrain the inverse graphics network weights, and then train a 3D object detector module supervised to map a 3D feature volume M to 3D object boxes, as described in Section 3.1.
We are interested in seeing the beneﬁt of this pre-training across different amounts of label supervision, so we ﬁrst use the full
CARLA train set for view prediction training (without using box labels), and then use a randomlysampled subset of the CARLA train set for box supervision; we evaluate on the CARLA validation set.
We varied the size of the box supervision subset across the following range: 100, 200, 500, 1000, 10000, 80000.
We show mean average precision (at an IoU of 0.75) for car detection as a function of the number of annotated 3D bounding box examples in Figure 1.
We compare our model against a version of our model that optimizes for RGB regression, similar to Tung et al.
but with a 6 DoF camera motion as opposed to 2 DoF, as well as a model trained from random weight initialization (i.e., without pretraining).
After pre-training, we freeze the feature layers after view predictive learning, and only supervise the detector module; for the fully supervised baseline (from random initialization), we train end-to-end.
As expected, the supervised model performs better with more labelled data.
In the low-data regime, pre-training greatly improves results, and more so for view-contrastive learning than RGB learning.
We could not compare against alternative view prediction models as the overwhelming majority
[Figure]
4.1. S IM - TO -R EAL (CARLA- TO -KITTI) TRANSFER
We evaluate whether the 3D predictive feature representations learned in the CARLA simulator are useful for learning 3D object detectors in the real world by testing on the real KITTI dataset (Geiger et al., 2013).
Speciﬁcally, we use view prediction pre-training in the CARLA train set, and box supervision from the KITTI train set, and evaluate 3D object detection in the KITTI validation set.
Existing real-world datasets do not provide enough camera viewpoints to support view-predictive learning.
Speciﬁcally, in KITTI, all the image sequences come from a moving car and thus all viewpoints lie on a near-straight trajectory.
Thus, simulation-to-real transferability of features is especially important for view predictive learning.
Method mAP@IOU 0.
[Table]
[Table] [Table]
[Table] [Table]
[Table] [Table]
[Table] [Table]
[Table] [Table]
[Table] [Table]
[Table] [Table]
- predictive 3D feature representations .
We train a 3D detector module on top of the inferred 3D feature maps M using KITTI 3D object box annotations
We show simulation-to-real transfer results in Table 1.
We compare the proposed view contrastive prediction pre-training, with view regression pre-training, and random weight initialization (no pretraining).
In all cases, we train a 3D object detection module supervised using KITTI 3D box annotations.
We also compare freezing versus ﬁnetuning the weights of the pretrained inverse graphics network.
The results are consistent with the CARLA tests: view-contrastive pretraining is best, view regression pretraining is second, and learning from human annotations alone is worst.
Note that depth in KITTI is acquired by a real velodyne LiDAR sensor, and therefore has lower density and more artifacts than
CARLA, yet our model generalizes across this distribution shift.
4. U NSUPERVISED 3D MOVING OBJECT DETECTION
In this section, we test our model’s ability to detect moving objects in 3D without any 3D object annotations , simply by clustering 3D motion vectors.
We use two-frame video sequences of dynamic scenes from the CARLA data, and we split the validation set into two parts for evaluation: scenes where the camera is stationary, and scenes where the camera is moving.
This splitting is based on the observation that moving object detection is made substantially more challenging under a moving camera.
We show precision-recall curves for 3D moving object detection under a stationary camera in Figure 4.
We compare our model against a model trained with RGB view regression (similar to Tung
[Figure] [Figure]
et al., 2019) and a 2.5D baseline.
The 2.5D baseline computes 2D optical ﬂow using PWC-Net (Sun et al., 2018), then proposes object masks by thresholding and clustering 2D ﬂow magnitudes; these 2D proposals are mapped to 3D boxes by segmenting the input pointcloud according to the proposed masks.
Our model outperforms the baselines.
Note that even with ground-truth 2D ﬂow, ground-truth depth, and an oracle threshold, a 2.5D baseline can at best only capture the portions of the objects that are in the pointcloud.
As a result, 3D proposals from PWC-Net often underestimate the extent of the objects by half or more.
Our model imagines the full 3D scene in each frame, so it does not have this issue.
We show precision-recall curves for 3D moving object detection under a moving camera in Figure 5.
We compare our model where egomotion is predicted by our neural egomotion module, against our model with ground-truth egomotion, as well as a 2.5D baseline, and a stabilized 2.5D baseline.
The 2.5D baseline uses optical ﬂow estimated from PWC-Net as before.
To stabilize the 2.5D ﬂow, we subtract the ground-truth scene ﬂow from the optical ﬂow estimate before generating proposals.
Our model’s performance is similar to its level in static scenes, suggesting that the egomotion module and stabilization mechanism effectively disentangles camera motion from the 3D feature maps.
The 2.5D baseline performs poorly in this setting, as expected.
Surprisingly, performance drops further after stabilizing the 2D ﬂows for egomotion.
We conﬁrmed this is due to the estimated scene ﬂow being imperfect: subtracting ground-truth scene ﬂow leaves many motion fragments in the background.
With ground-truth 2D ﬂow, the baseline performs similar to its static-scene level.
We have attempted to compare against the unsupervised object segmentation methods proposed in Kosiorek et al.
Hsieh et al.
(2018) by adapting the publicly available code accordingly.
These models use an inference network that takes as input the full video frame sequences to predict the locations of 2D object bounding boxes, as well as frame-to-frame displacements, in order to minimize view prediction error in 2D. We were not able to produce meaningful results from their inference networks.
The success of Hsieh et al.
(2018) may partially depend on carefully selected priors for 2D object bounding box location and object size parameters that match the moving MNIST dataset statistics used in the paper, as suggested by the publicly available code.
We do not assume knowledge or existence of such object location or size priors for our CARLA data.
4. 3D MOTION ESTIMATION
[Table]
In this section, we evaluate accuracy of our 3D FlowNet module.
The previous section evaluated this module indirectly since it plays a large part in unsupervised 3D moving object detection; here we evaluate its accuracy directly.
We use two-frame video sequences of dynamic scenes from our
CARLA test set.
We compare training our 3D FlowNet over (frozen) 3D feature representations obtained from the proposed viewcontrastive prediction and the baseline RGB regression of Tung et al.
We show 3D motion estimation results in Table 2.
We also compare against a zero-motion baseline that predicts zero motion everywhere.
Since approximately 97% of the voxels belong to the static scene, a zero-motion baseline is very competitive in an overall average.
We therefore evaluate error separately in static and moving parts of the scene.
Our method achieves dramatically lower error than the RGB generation baseline, which suggests the proposed view contrastive objectives in 3D and 2D result in learning of correspondent features across views even for moving objects, despite the fact features were learned only using static scenes.
Limitations
The proposed model has two important limitations.
First, our work assumes an embodied agent that can move around at will.
This is hard to realize in the real world, and indeed there are almost no existing datasets with enough camera views.
Second, our model architecture consumes a lot of GPU memory, due to its extra spatial dimension .
This severely limits either the resolution or the metric span of the latent map M .
On 12G Titan X GPUs we encode a space sized 32 m × 32 m × 8 m at a resolution of 128 × 128 × 32 , with a batch size of 4; iteration time is 0.2s/iter.
Supervised 3D object detectors typically cover twice this metric range.
Sparsifying our feature grid, or using points instead of voxels, are clear areas for future work.
C ONCLUSION
We propose models that learn space-aware 3D feature abstractions of the world given 2.5D input, by minimizing 3D and 2D view contrastive prediction objectives.
We show that view-contrastive prediction leads to features useful for 3D object detection, both in simulation and in the real world.
We further show that the ability to visually imagine full 3D scenes allows us to estimate dense 3D motion ﬁelds, where clustering non-zero motion allows 3D objects to emerge without any human supervision.
Our experiments suggest that the ability to imagine visual information in 3D can drive 3D object detection without any human annotations—instead, the model learns by moving and watching objects move (Gibson, 1979).
A A PPENDIX O VERVIEW
In Section B, we provide implementation details for our 3D-bottlenecked architecture, egomotion module, and 3D imagination FlowNet.
In Section C, we provide additional experiments, and additional visualizations of our output.
In Section D, we discuss additional related work.
B A RCHITECTURE DETAILS FOR 3D BOTTLENECKED RNN S Inputs
Our input images are 128 × 384 pixels.
We trim input pointclouds to a maximum of 100,000 points, and to a range of 80 meters, to simulate a velodyne LiDAR sensor.
2D-to-3D unprojection
This module converts the input 2D image
I ( t ) and pointcloud D ( t ) into a 4D tensor U ( t ) ∈
R w × h ×
d
× 4 , by ﬁlling the 3D imagination grid with samples from the 2D image grid, using perspective (un)projection.
Speciﬁcally, for each cell in the imagination grid, indexed by the coordinate ( i, j, k ) , we compute the ﬂoating-point 2D pixel location [ u, v ] T = KS
[ i, j, k ] T that it projects to from the current camera viewpoint, using the pinhole camera model (Hartley &
Zisserman, 2003), where S is the similarity transform that converts memory coordinates to camera coordinates and K is the camera intrinsics (transforming camera coordinates to pixel coordinates).
We ﬁll U ( t ) i,j,k with the bilinearly interpolated pixel value
I ( t ) u,v .
We transform our depth map D t in a similar way and obtain a binary occupancy grid O ( t ) ∈
R w × h ×
d
× 1 , by assigning each voxel a value of 1 or 0, depending on whether or not a point lands in the voxel.
We concatenate this to the unprojected RGB, making the tensor [ U ( t ) , O ( t ) ]
∈ R w × h ×
d × 4 .
We pass the tensors [ U ( t ) , O ( t ) ] through a 3D encoder-decoder network.
The 3D feature encoderdecoder has the following architecture, using the notation k - s - c for kernel-stride-channels: 4-2-64, 4-2-128, 4-2-256, 4-0.5-128, 4-0.5-64, 1-1- F , where F is the feature dimension.
We use F = 32 .
After each deconvolution (stride 0.5 layer) in the decoder, we concatenate the same-resolution featuremap from the encoder.
Every convolution layer (except the last in each net) is followed by a leaky ReLU activation and batch normalization.
Egomotion estimation
This module computes the relative 3D rotation and translation between the current camera viewpoint and the reference coordinate system of the map M (1) .
We signiﬁcantly changed the module of Tung et al.
(2019) which could only handle 2 degrees of camera motion.
We consider a general camera with full 6-DoF motion.
Our egomotion module is inspired by the state-of-the-art PWC-Net optical ﬂow method (Sun et al., 2018): it incorporates spatial pyramids, incremental warping, and cost volume estimation via cross-correlation.
While M (1) and M ( t ) can be used directly as input to the egomotion module, we ﬁnd better performance can be obtained by allowing the egomotion module to learn its own featurespace.
Thus, we begin by passing the (unregistered) 3D inputs through a 3D encoder-decoder, producing a reference tensor F (1) ∈
R w × h × d × c , and a query tensor F ( t ) ∈
R w × h × d × c .
We wish to ﬁnd the rigid transformation that aligns the two.
We use a coarse-to-ﬁne architecture, which estimates a coarse 6D answer at the coarse scale, and reﬁnes this answer in a ﬁner scale.
We iterate across scales in the following manner:
First, we downsample both feature tensors to the target scale (unless we are at the ﬁnest scale).
Then, we generate several 3D rotations of the second tensor, representing “candidate rotations”, making a set { F ( t ) θ i | θ i ∈ Θ } , where Θ is the discrete set of 3D rotations considered.
We then use 3D axis-aligned cross-correlations between F (1) and the F ( t ) θ i , which yields a cost volume of shape r × w × h × d × e , where e is the total number of spatial positions explored by cross-correlation.
We average across spatial dimensions, yielding a tensor shaped r × e , representing an average alignment score for each transform.
We then apply a small fully-connected network to convert these scores into a 6D vector.
We then warp F ( t ) according to the rigid transform speciﬁed by the 6D vector, to bring it into (closer) alignment with F (1) .
We repeat this process at each scale, accumulating increasingly ﬁne corrections to the initial 6D vector.
Similar to PWC-Net (Sun et al., 2018), since we compute egomotion in a coarse-to-ﬁne manner, we need only consider a small set of rotations and translations at each scale (when generating the cost volumes); the ﬁnal transform composes all incremental transforms together.
However, unlike PWCNet, we do not repeatedly warp our input tensors, because this accumulates interpolation error.
Instead, following the inverse compositional Lucas-Kanade algorithm (Baker & Matthews, 2004;
Lin & Lucey, 2017), and at each scale warp the original input tensor with the composed transform.
3D-to-2D projection
This module “renders” 2D feature maps given a desired viewpoint V ( k ) by projecting the 3D feature state M ( t ) .
We ﬁrst appropriately orient the state map by resampling the 3D featuremap M ( t ) into a view-aligned version M ( t ) view k .
The sampling is deﬁned by [ i (cid:48) , j (cid:48) , k (cid:48) ]
T = S − 1 V ( k ) S
[ i, j, k ] T , where S is (as before) the similarity transform that brings imagination coordinates into camera coordinates, V ( k ) is the transformation that relates the reference camera coordinates to the viewing camera coordinates, [ i, j, k ] are voxel indices in M ( t ) , and [ i (cid:48) , j (cid:48) , k (cid:48) ] are voxel indices in M ( t ) view k .
We then warp the view-oriented tensor M ( t ) view k such that perspective viewing rays become axis-aligned.
We implement this by sampling from the memory tensor with the correspondence [ u, v, d ] T =
KS [ i (cid:48) , j (cid:48) , k (cid:48) ] T , where the indices [ u, v ] span the image we wish to generate, and d spans the length of each ray.
We use logarithmic spacing for the increments of d , ﬁnding it far more effective than linear spacing (used in Tung et al., 2019), likely because our scenes cover a large metric space.
We call the perspective-transformed tensor M ( t ) proj k .
To avoid repeated interpolation, we actually compose the view transform with the perspective transform, and compute M ( t ) proj k from M ( t ) with a single trilinear sampling step.
Finally, we pass the perspective-transformed tensor through a CNN, converting it to a 2D feature map M ( t ) view k .
The CNN has the following architecture (using the notation k - s - c for kernel-stride-channels): max-pool along the depth axis with 1 × 8 × 1 kernel and 1 × 8 × 1 stride, to coarsely aggregate along each camera ray, 3D convolution with 3-1-32, reshape to place rays together with the channel axis, 2D convolution with 3-1-32, and ﬁnally 2D convolution with 1-1- e , where e is the channel dimension.
For predicting
RGB, e = 3 ; for metric learning, we use e = 32 .
We ﬁnd that with dimensionality e = 16 or less, the model underﬁts.
3D imagination FlowNet To train our 3D FlowNet, we generate supervised labels from synthetic transformations of the input, and an unsupervised loss based on the standard standard variational loss (Horn & Schunck, 1981; Yu et al., 2016).
For the synthetic transformations, we randomly sample from three uniform distributions of rigid transformations: (i) large motion , with rotation angles in the range [ − 6 , 6] (degrees) and translations in [ − 1 , 1] (meters), (ii) small motion , with angles from [ − 1 , 1] and translations from [ − 0 .
1] , (iii) zero motion .
We found that without sampling (additional) small and zero motions, the model does not accurately learn these ranges.
Still, since these synthetic transformations cause the entire tensor to move at once, a FlowNet learned from this supervision alone tends to produce overly-smooth ﬂow in scenes with real (non-rigid) motion.
The variational loss L warp , described in the main text, overcomes this issue.
We also apply a smoothness loss penalizing local ﬂow changes: L smooth =
(cid:80) i,j,k ||∇ W ( t ) i,j,k
|| , where W ( t ) is the estimated ﬂow ﬁeld and ∇ is the 3D spatial gradient.
This is a standard technique to prevent the model from only learning motion edges (Horn & Schunck, 1981; Yu et al., 2016).
3D occupancy estimation
The goal in this step is to estimate which voxels in the imagination grid are “occupied” (i.e., have something visible inside) and which are “free” (i.e., have nothing visible inside).
For supervision, we obtain (partial) labels for both “free” and “occupied” voxels using the input depth data.
Sparse “occupied” voxel labels are given by the voxelized pointcloud O ( t ) reg .
To obtain labels of “free” voxels, we trace the source-camera ray to each occupied observed voxel, and mark all voxels intersected by this ray as “free”.
Our occupancy module takes the memory tensor M ( t ) as input, and produces a new tensor P ( t ) , with a value in [0 , 1] at each voxel, representing the probability of the voxel being occupied.
This is achieved by a single 3D convolution layer with a 1 × 1 × 1 ﬁlter (or, equivalently, a fully-connected network applied at each grid location), followed by a sigmoid nonlinearity.
We train this network with the logistic loss, L occ =
(1 / (cid:80) ˆ I ( t ) )
(cid:80) ˆ
I ( t ) log(1 + exp( − ˆ P ( t ) P ( t ) )) , where ˆ P ( t ) is the label map, and ˆ I ( t ) is an indicator tensor, indicating which labels are valid.
Since there are far more “free” voxels than “occupied”, we balance this loss across classes within each minibatch.
2D CNN
The CNN that converts the target view into an embedding image is a residual network (He et al., 2016) with two residual blocks, with 3 convolutions in each block.
The convolution layers’ channel dimensions are 64, 64, 64, 128, 128, 128.
Finally there is one convolution layer with e channels, where e is the embedding dimension.
We use e = 32 .
Contrastive loss
For both the 2D and the 3D contrastive loss, for each example in the minibatch, we randomly sample a set of 960 pixel/voxel coordinates S for supervision.
Each coordinate i ∈ S gives a positive correspondence T i , B i , since the tensors are aligned.
For each T i , we sample a negative B k from the samples acquired across the entire batch, using the distance-weighted sampling strategy of Wu et al.
In this way, on every iteration we obtain an equal number of positive and negative samples, where the negative samples are spread out in distance.
We additionally apply an L 2 loss on the difference between the entire tensors, which penalizes distance at all positive correspondences (instead of merely the ones sampled for the metric loss).
We ﬁnd that this accelerates training.
We use a coefﬁcient of 0 .
1 for L 2Dcontrast , 1 . 0 for L 3Dcontrast , and 0 .
001 for the L 2 losses.
Code and training details Our model is implemented in Python/Tensorﬂow, with custom CUDA kernels for the 3D cross correlation (used in the egomotion module and the ﬂow module) and for the trilinear resampling (used in the 2D-to-3D and 3D-to-2D modules).
The CUDA operations use less memory than native-tensorﬂow equivalents, which facilitates training with large imagination tensors ( 128 × 128 × 32 × 32 ).
Training to convergence (approx.
200k iterations) takes 48 hours on a single GPU.
We use a learning rate of 0.001 for all modules except the 3D FlowNet, for which we use 0.0001.
We use the Adam optimizer, with β 1 = 0 .
9 , β 2 = 0 .
Code, data, and pre-trained models will be made publicly available upon publication.
C A DDITIONAL EXPERIMENTS C. D ATASETS
CARLA vs. other datasets We test our method on scenes we collected from the CARLA simulator (Dosovitskiy et al., 2017), an open-source driving simulator of urban scenes.
CARLA permits moving the camera to any desired viewpoint in the scene, which is necessary for our view-based learning strategy.
Previous view prediction works have considered highly synthetic datasets: The work of Eslami et al.
(2018) introduced the Shepard-Metzler dataset, which consists of seven colored cubes stuck together in random arrangements, and the Rooms-Ring-Camera dataset, which consists of a random ﬂoor and wall colors and textures with variable numbers of shapes in each room of different geometries and colors.
The work of Tung et al.
(2019) introduced a ShapeNet arrangements dataset, which consists of table arrangements of ShapeNet synthetic models (Chang et al., 2015).
The work of Tatarchenko et al.
(2016) considers scenes with a single car.
Such highly synthetic and limited-complexity datasets cast doubt on the usefulness and generality of view prediction for visual feature learning.
The CARLA simulation environments considered in this work have photorealistic rendering, and depict diverse weather conditions, shadows, and objects, and arguably are much closer to real world conditions, as shown in Figure 6.
While there exist real-world datasets which are visually similar (Geiger et al., 2013; Caesar et al., 2019), they only contain a small number viewpoints, which makes view-predictive training inapplicable.
Since occlusion is a major factor in a dataset’s difﬁculty, we provide occlusion statistics collected from our CARLA data.
Note that in a 2D or unrealistic 3D world, most of the scene would be fully visible in every image.
In CARLA, a single camera view reveals information on approximately 0.23 ( ± 0.03) of all voxels in the model’s 32 m × 32 m × 8 m “in bounds” space, leaving 0.77 totally occluded/unobserved.
This measure includes both “scene surface” voxels, and voxels lying on rays
[Table]
[Table] [Table]
satisfy the view prediction objective.
C. RGB VIEW PREDICTION
Images from the CARLA simulator have complex textures and specularities and are close to photorealism, which causes RGB view prediction methods to fail.
We illustrate this in Figure 7: given an input image and target viewpoint (i.e., pose), we show target views predicted by a 3D-bottlenecked
RNN trained for RGB generation (Tung et al., 2019), (ii) a VAE variant of that architecture, and (iii)
Generative Query Networks (GQN; Eslami et al., 2018, which does not have a 3D representation bottleneck, but rather concatenates 2D images and their poses in a 2D recurrent architecture.
Unlike these works, however, our model uses view prediction as a means of learning useful visual representation for 3D object detection, segmentation and motion estimation, not as the end task itself.
C. 2D AND 3D CORRESPONDENCE
We evaluate our model’s performance in estimating visual correspondences in 2D and in 3D, using a nearest-neighbor retrieval task.
In 2D, the task is as follows: we extract one “query” patch from a top-down render of a viewpoint, then extract 1000 candidate patches from bottom-up renders, with only one true correspondence (i.e., 999 negatives).
We then rank all bottom-up patches according to
L 2 distance from the query, and report the retrieval precision at several recall thresholds, averaged over 1000 queries.
In 3D the task is similar, but patches are feature cubes extracted from the 3D imagination; we generate queries from one viewpoint, and retrievals from other viewpoints and other scenes.
The 1000 samples are generated as follows: from 100 random test examples, we generate 10 samples from each, so that each sample has 9 negatives from the same viewpoint, and 990 others from different locations/scenes.
We compare the proposed model against (i) the RGB prediction baseline of Tung et al.
(2019), (ii)
Generative Query Networks (GQN) of Eslami et al.
(2018), which do not have a 3D representation bottleneck, and (iii) a VAE alternative of the (deterministic) model of Tung et al.
Quantitative results are shown in Table 3.
For 2D correspondence, the models learned through the
RGB prediction objectives obtain precision near zero at each recall threshold, illustrating that the model is not learning precise RGB predictions.
The proposed view contrastive losses perform better, and combining both the 2D and 3D contrastive losses is better than using only 2D. Interestingly, for 3D correspondence, the retrieval accuracy of the RGB-based models is relatively high.
Training 3D bottlenecked RNNs as a variational autoencoder, where stochasticity is added in the 3D bottleneck, improves its precision at lower ranks thresholds.
Contrastive learning outperforms all baselines.
Adding the 3D contrastive loss gives a large boost over using the 2D contrastive loss alone.
Note that 2D-bottlenecked architectures (Eslami et al., 2018) cannot perform 3D patch retrieval.
Qualitative retrieval results for our full model vs. Tung et al.
(2019) are shown in Figure 8.
C. U NSUPERVISED 3D OBJECT MOTION SEGMENTATION
Our method proposes 3D object segmentations, but labels are only available in the form of oriented 3D boxes; we therefore convert our segmentations into boxes by ﬁtting minimum-volume oriented 3D boxes to the segmentations.
The precision-recall curves presented in the paper are computed with an intersection-over-union (IOU) threshold of 0 . 5 .
Figure 9 shows sample visualizations of 3D box proposals projected onto input images.
C. O CCUPANCY PREDICTION
[Table]
Accuracy is nearly perfect in each region type.
We test our model’s ability to estimate occupied and free space.
Given a single view as input, the model outputs an occupancy probability for each voxel in the scene.
Then, given the aggregated labels computed from this view and a random next view, we compute accuracy at all voxels for which we have labels.
Voxels that are not intersected by either view’s camera rays are left unlabelled.
Table 4 shows the classiﬁcation accuracy, evaluated independently for free and occupied voxels, and for all voxels aggregated
[Figure]
together. Overall, accuracy is extremely high (97-98%) for both voxel types that part of the occupied space (i.e., the voxelized pointcloud of the ﬁrst frame) is an input to the network, so accuracy on this metric is expected to be high.
We show a visualization of the occupancy grids in Figure 9 (right).
We visualize the occupancy grids by converting them to heightmaps.
This is achieved by multiplying each voxel’s occupancy value by its height coordinate in the grid, and then taking a max along the grid’s height axis.
The visualizations show that the occupancy module learns to ﬁll the “holes” of the partial view, effectively imagining the complete 3D scene.
C. E GOMOTION ESTIMATION
Method
[Table]
We compare our egomotion module against
ORB-SLAM2 (Mur-Artal & Tard ´ os, 2017), a state-ofthe-art geometric SLAM method, and against the
SfM-Net (Zhou et al., 2017) architecture, which is a 2D CNN that takes pairs of frames and outputs egomotion.
We give ORB-SLAM2 access to ground-truth pointclouds, but note that it is being deployed merely as an egomotion module (rather than for SLAM).
We ran our own model and SfM-Net with images sized 128 × 384 , but found that ORB-SLAM2 performs best at 256 × 768 .
SfM-Net is designed to estimate depth and egomotion unsupervised, but since our egomotion module is supervised, we supervise SfM-Net here as well.
We evaluate two versions of it: one with RGB inputs (as designed), and one with RGB-D inputs (more similar to our model).
Table 5 shows the results.
Overall the models all perform similarly, suggesting that our egomotion method performs on par with the rest.
Note that the egomotion module of Tung et al.
(2019) is inapplicable to this task, since it assumes that the camera orbits about a ﬁxed point, with 2 degrees of freedom.
Here, the camera is free, with 6 degrees of freedom.
D A DDITIONAL R ELATED W ORK 3D
feature representations
A long-standing debate in Computer Vision is whether it is worth pursuing 3D models in the form of binary voxel grids, meshes, or 3D pointclouds as the output of visual recognition.
The “blocks world” of Roberts (1965) set as its goal to reconstruct the 3D scene depicted in the image in terms of 3D solids found in a database.
Pointing out that replicating the 3D world in one’s head is not enough to actually make decisions, Brooks (1991) argued for feature- based representations, as done by recent work in end-to-end deep learning (Levine et al., 2015).
Our work proposes learning-based 3D feature representations in place of previous human-engineered ones, reconciling the two sides of the debate.
Some recent works have attempted various forms of map-building (Gupta et al., 2017; Henriques &
Vedaldi, 2018) as a form of geometrically-consistent temporal integration of visual information, in place of geometry-unaware vanilla LSTM (Hochreiter & Schmidhuber, 1997) or GRU (Cho et al., 2014) models.
The closest to ours are Learned Stereo Machines (LSMs; Kar et al., 2017), DeepVoxels (Sitzmann et al., 2019), and Geometry-aware RNNs (GRNNs; Tung et al., 2019), which integrate images sampled from a viewing sphere into a latent 3D feature memory tensor, in an egomotionstabilized manner, and predict views.
All of these works consider very simplistic non-photorealistic environments and 2-DoF cameras (i.e., 2 degrees of freedom, which lock the camera to a pre-deﬁned viewing sphere).
None of these works evaluate the suitability of their learned features for a downstream task.
Rather, their main objective is to accurately predict views.
Motion estimation and object segmentation
Most motion segmentation methods operate in 2D image space, and use 2D optical ﬂow to segment moving objects.
While earlier approaches attempted motion segmentation completely unsupervised, by exploiting motion trajectories and integrating motion information over time (Brox & Malik, 2010; Ochs & Brox, 2011), recent works focus on learning to segment objects in videos, supervised by annotated video benchmarks (Fragkiadaki et al., 2015; Khoreva et al., 2017).
Our work differs in the fact that we address object detection and segmentation in 3D as opposed to 2D, by estimating 3D motion of the “imagined” (complete) scene, as opposed to 2D motion of the observed scene.