| Layer Description | K | Output Tensor Dim. |
| #0 | Input RGB image | | 3×H×W |
| Encoding Layers |
| #1 | Conv2d | 5 | 64×H×W |
| #2 | Conv2d → Packing | 7 | 64×H/2×W/2 |
| #3 | ResidualBlock (x2) → Packing | 3 | 64×H/4×W/4 |
| #4 | ResidualBlock (x2) → Packing | 3 | 128×H/8×W/8 |
| #5 | ResidualBlock (x3) → Packing | 3 | 256×H/16×W/16 |
| #6 | ResidualBlock (x3) → Packing | 3 | 512×H/32×W/32 |
| Decoding Layers |
| #7 | Unpacking (#6) → Conv2d (⊕ #5) | 3 | 512×H/16×W/16 |
| #8 | Unpacking (#7) → Conv2d (⊕ #4) | 3 | 256×H/8×W/8 |
| #9 | InvDepth (#8) | 3 | 1×H/8×W/8 |
| #10 | Unpacking (#8) → Conv2d (⊕ #3 ⊕ Upsample(#9)) | 3 | 128×H/4×W/4 |
| #11 | InvDepth (#10) | 3 | 1×H/4×W/4 |
| #12 | Unpacking (#10) → Conv2d (⊕ #2 ⊕ Upsample(#11)) | 3 | 64×H/2×W/2 |
| #13 | InvDepth (#12) | 3 | 1×H/2×W/2 |
| #14 | Unpacking (#12) → Conv2d (⊕ #1 ⊕ Upsample(#13)) | 3 | 64×H×W |
| #15 | InvDepth (#14) | 3 | 1×H×W |
Table 1: Summary of our PackNet architecture for self-supervised monocular depth estimation. The Packing and Unpacking blocks are described in Fig. 3, with kernel size $K = 3$ and $D = 8$ . Conv2d blocks include Group-Norm [45] with $G = 16$ and ELU non-linearities [7]. In-vDepth blocks include a 2D convolutional layer with $K = 3$ and sigmoid non-linearities. Each ResidualBlock is a sequence of 3 2D convolutional layers with $K = 3/3/1$ and ELU non-linearities, followed by GroupNorm with $G = 16$ and Dropout [40] of 0.5 in the final layer. Upsample is a nearest-neighbor resizing operation. Numbers in parentheses indicate input layers, with $\oplus$ as channel concatenation. Bold numbers indicate the four inverse depth output scales.
representation via a 3D convolutional layer. The resulting higher dimensional feature space is then flattened (by simple reshaping) before a final 2D convolutional contraction layer. This structured feature expansion-contraction, inspired by invertible networks [3, 21] although we do not ensure invertibility, allows our architecture to dedicate more parameters to learn how to compress key spatial details that need to be preserved for high resolution depth decoding.
# 4.2. Unpacking Block
Symmetrically, the unpacking block (Fig. 3b) learns to decompress and unfold packed convolutional feature channels back into higher resolution spatial dimensions during the decoding process. The unpacking block replaces convolutional feature upsampling, typically performed via nearest-neighbor or with learnable transposed convolutional weights. It is inspired by sub-pixel convolutions [39], but adapted to reverse the 3D packing process that the features went through in the encoder. First, we use a 2D convolutional layer to produce the required number of feature channels for a following 3D convolutional layer. Second, this 3D convolution learns to expand back the compressed spatial features. Third, these unpacked features are converted back to spatial details via a reshape and Depth2Space operation [39] to obtain a tensor with the desired number of output channels and target higher resolution.
(a) Input Image
(b) Max Pooling + Bilinear Upsample
Figure 4: Image reconstruction using different encoder-decoders: (b) standard max pooling and bilinear upsampling, each followed by 2D convolutions; (c) one packing-unpacking combination (cf. Fig. 3) with $D = 2$ . All kernel sizes are $K = 3$ and $C = 4$ for intermediate channels.
(c) Pack + Unpack
# 4.3. Detail-Preserving Properties
In Fig. 4, we illustrate the detail-preserving properties of our packing / unpacking combination, showing we can get a near-lossless encoder-decoder for single image reconstruction by minimizing the L1 loss. We train a simple network composed of one packing layer followed by a symmetrical unpacking one and show it is able to almost exactly reconstruct the input image (final loss of 0.0079), including sharp edges and finer details. In contrast, a comparable baseline replacing packing / unpacking with max pooling / bilinear upsampling (and keeping the 2D convolutions) is only able to learn a blurry reconstruction (final loss of 0.063). This highlights how PackNet is able to learn more complex features by preserving spatial and appearance information end-to-end throughout the network.
# 4.4. Model Architecture
Our PackNet architecture for self-supervised monocular depth estimation is detailed in Table 1. Our symmetrical encoder-decoder architecture incorporates several packing and unpacking blocks, and is supplemented with skip connections [35] to facilitate the flow of information and gradients throughout the network. The decoder produces intermediate inverse depth maps that are upsampled before being concatenated with their corresponding skip connections and unpacked feature maps. These intermediate inverse depth maps are also used at training time in the loss calculation, after being upsampled to the full output resolution using nearest neighbors interpolation.
# 5. Experiments
# 5.1. Datasets
KITTI [16]. The KITTI benchmark is the de facto standard for depth evaluation. More specifically, we adopt the training protocol used in Eigen et al. [13], with Zhou et al.'s [52] pre-processing to remove static frames. This results in 39810 images for training, 4424 for validation and 697 for evaluation. We also consider the improved ground-truth depth maps from [41] for evaluation, which uses 5 consecutive frames to accumulate LiDAR points and stereo
information to handle moving objects, resulting in 652 high-quality depth maps.
DDAD (Dense Depth for Automated Driving). As one of our contributions, we release a diverse dataset of urban, highway, and residential scenes curated from a global fleet of self-driving cars. It contains 17,050 training and 4,150 evaluation frames with ground-truth depth maps generated from dense LiDAR measurements using the Luminar-H2 sensor. This new dataset is a more realistic and challenging benchmark for depth estimation, as it is diverse and captures precise structure across images (30k points per frame) at longer ranges (up to $200m$ vs $80m$ for previous datasets). See supplementary material for more details.
NuScenes [4]. To assess the generalization capability of our approach w.r.t. previous ones, we evaluate KITTI models (without fine-tuning) on the official NuScenes validation dataset of 6019 front-facing images with ground-truth depth maps generated by LiDAR reprojection.
CityScapes [8]. We also experiment with pretraining our monocular networks on the CityScapes dataset, before finetuning on the KITTI dataset. This also allows us to explore the scalability and generalization performance of different models, as they are trained with increasing amounts of unlabeled data. A total of 88250 images were considered as the training split for the CityScapes dataset, using the same training parameters as KITTI for 20 epochs.
# 5.2. Implementation Details
We use PyTorch [37] with all models trained across 8 Titan V100 GPUs. We use the Adam optimizer [24], with $\beta_{1} = 0.9$ and $\beta_{2} = 0.999$ . The monocular depth and pose networks are trained for 100 epochs, with a batch size of 4 and initial depth and pose learning rates of $2 \cdot 10^{-4}$ and $5 \cdot 10^{-4}$ respectively. Training sequences are generated using a stride of 1, meaning that the previous $t - 1$ , current $t$ , and posterior $t + 1$ images are used in the loss calculation. As training proceeds, the learning rate is decayed every 40 epochs by a factor of 2. We set the SSIM weight to $\alpha = 0.85$ , the depth regularization weight to $\lambda_{1} = 0.001$ and, where applicable, the velocity-scaling weight to $\lambda_{2} = 0.05$ .
Depth Network. Unless noted otherwise, we use our PackNet architecture as specified in Table 1. During training, all four inverse depth output scales are used in the loss calculation, and at test-time only the final output scale is used, after being resized to the full ground-truth depth map resolution using nearest neighbor interpolation.
Pose Network. We use the architecture proposed by [52] without the explainability mask, which we found not to improve results. The pose network consists of 7 convolutional layers followed by a final $1 \times 1$ convolutional layer. The input to the network consists of the target view $I_{t}$ and the context views $I_{S}$ , and the output is the set of 6 DOF transformations between $I_{t}$ and $I_{s}$ , for $s \in S$ .
# 5.3. Depth Estimation Performance
First, we report the performance of our proposed monocular depth estimation method when considering longer distances, which is now possible due to the introduction of our new DDAD dataset. Depth estimation results using this dataset for training and evaluation, considering cumulative distances up to $200\mathrm{m}$ , can be found in Fig. 5 and Table 2. Additionally, in Fig. 6 we present results for different depth intervals calculated independently. From these results we can see that our PackNet-SfM approach significantly outperforms the state-of-the-art [18], based on the ResNet family, the performance gap consistently increasing when larger distances are considered.
Second, we evaluate depth predictions on KITTI using the metrics described in Eigen et al. [13]. We summarize our results in Table 3, for the original depth maps from [13] and the accumulated depth maps from [41], and illustrate their performance qualitatively in Fig. 7. In contrast to previous methods [5, 18] that predominantly focus on modifying the training objective, we show that our proposed Pack-Net architecture can by itself bolster performance and establish a new state of the art for the task of monocular depth estimation, trained in the self-supervised monocular setting.
Furthermore, we show that by simply introducing an additional source of unlabeled videos, such as the publicly available CityScapes dataset (CS+K) [8], we are able to further improve monocular depth estimation performance. As indicated by Pillai et al. [38], we also observe an improvement in performance at higher image resolutions, which we attribute to the proposed network's ability to properly preserve and process spatial information end-to-end. Our best results are achieved when injecting both more unlabeled data at training time and processing higher resolution input images, achieving performance comparable to semi-supervised [28] and fully supervised [14] methods.
# 5.4. Scale-Aware Depth Estimation Performance
Due to their inherent scale ambiguity, self-supervised monocular methods [18, 33, 52] evaluate depth by scaling their estimates to the median ground-truth as measured via LiDAR. In Section 3.2 we propose to also recover the metric scale of the scene from a single image by imposing a loss on the magnitude of the translation for the pose network output. Table 3 shows that introducing this weak velocity supervision at training time allows the generation of scale-aware depth models with similar performance as their unscaled counterparts, with the added benefit of not requiring ground-truth depth scaling (or even velocity information) at test-time. Another benefit of scale-awareness is that we can compose metrically accurate trajectories directly from the output of the pose network. Due to space constraints, we report pose estimation results in supplementary material.
Figure 5: PackNet pointcloud reconstructions on DDAD.