| 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.
+
+| Method | AP (↑) | Miou (↑) | Recall(↑) | Recall@3s (↑) |
| Random guess | 8.2 | 26.8 | 49.8 | 54.2 |
| Rasheed et al., GraphCut [18] | 14.1 | 29.7 | 53.7 | 57.2 |
| Chasanis et al., SCSA [4] | 14.7 | 30.5 | 54.9 | 58.0 |
| Han et al., DP [10] | 15.5 | 32.0 | 55.6 | 58.4 |
| Rotman et al., Grouping [21] | 17.6 | 33.1 | 56.6 | 58.7 |
| Tapaswi et al., StoryGraph [24] | 25.1 | 35.7 | 58.4 | 59.7 |
| Baraldi et al., Siamese [1] | 28.1 | 36.0 | 60.1 | 61.2 |
| LGSS (Base) | 19.5 | 34.0 | 57.1 | 58.9 |
| LGSS (Multi-Semantics) | 24.3 | 34.8 | 57.6 | 59.4 |
| LGSS (Multi-Semantics+BNet) | 42.2 | 44.7 | 67.5 | 78.1 |
| LGSS (Multi-Semantics+BNet+Local Seq) | 44.9 | 46.5 | 71.4 | 77.5 |
| LGSS (all, Multi-Semantics+BNet+Local Seq+Global) | 47.1 | 48.8 | 73.6 | 79.8 |
| Human upper-bound | 81.0 | 91.0 | 94.1 | 99.5 |
+
+Table 4. Multiple semantic elements scene segmentation ablation results, where four elements are studied including place, cast, action and audio.
+
+| Feature | Range |
| Weather | Neutral, Clear, Extrasunny, Smog, Clouds, Overcast, Rain, Thunder, Clearing, Xmas, Foggy, Snowlight, Blizzard, Snow |
| Time | [00:00, 24:00) |
| Car Model | Blisha, Bus, Ninef, Asea, Baller, Bison, Buffalo, Bob-catxl, Dominator, Granger, Jackal, Oracle, Patriot, Pranger |
| Car Color | R = [0, 255], G = [0, 255], B = [0, 255] |
| Car Heading | [0, 360) deg |
| Car Position | Anywhere on a road on GTA-V's map |
+
+Table 1: Environment features and their ranges in GTA-V
+
+used in autonomous driving.
+
+# 2. Background
+
+SCENIC is a probabilistic programming language for scenario specification and scene generation. The language can be used to describe environments for various autonomous systems such as autonomous cars or robots. The environments are scenes, i.e. configurations of objects and agents. SCENIC allows assigning distributions to the features of the scenes, as well as hard and soft mathematical constraints over the features in the scene. Generating scenes from a SCENIC program requires sampling from the distributions defined in the program. SCENIC comes with efficient sampling techniques that take advantage of the structure of the SCENIC program, to perform sampling efficiently, using aggressive pruning of the sampling space. The generated scenes are rendered into images with the help of a simulator. In this paper (and similar to [9]) we use the Grand Theft Auto V (GTA-V) game engine [10] to create realistic images with a case study that uses SqueezeDet [30], a convolutional neural network for object detection in autonomous cars. Note that the framework we put forth is not specific to this network, and can be used with other object detectors as well.
+
+The semantic features that we use in our case study are described in Table 1. These features are determined and limited by the environment parameters that the simulator allows users to control. If distributions over these environment features are not specified in a SCENIC program, then, by default, they are uniformly randomly selected from ranges shown in Table 1. Note that for a different application domain, we would have a different set of features.
+
+SCENIC is designed to be easily understandable, with simple and intuitive syntax. We illustrate it via an example, shown in Figure 2. The formal syntax and semantics can be found in [9].
+
+As shown in Figure 2, the program describes a rare situation where a car is illegally intruding over a white striped traffic island to either cut in or belatedly avoid entering elevated highway. In line 1, "param time = (6*60, 18*60)"
+
+```txt
+1 param time $=$ (6\*60, 18\*60)
+2 ego $=$ Car at -209.091 @ -686.231
+3
+4 spot $=$ OrientedPoint on visible curb
+5 badAngle $=$ (-90,90) deg
+6
+7 otherCar $=$ Car at spot,
+8 facing badAngle relative to egoheading
+9
+10 require otherCar in egovisibleRegion
+11 require ((angle to otherCar) - egoheading) < 0
+12 require (distance from ego.position to otherCar) >= 5
+13 require (distance from ego.position to otherCar) <= 20
+```
+
+Figure 2: Example SCENIC program
+
+means that time of the day is uniformly randomly sampled from 6:00 to 18:00. In line 2, an ego car is placed at specific x @ y coordinate on GTA-V's map. In line 4, a spot on a traffic island (in SCENIC, we referred to it as a curb) that is within a visible region from a camera mounted on ego car is selected. Of all visible region of the traffic island, a spot is uniformly randomly sampled. In line 7 and 8, otherCar is placed on the spot facing -90 to 90 degree off of where ego car is facing, simulating cases when a car may be protruding into a traffic flow. Lastly, SCENIC allows users to define hard and soft constraints using require statements. In this scenario, all four require statements define hard constraints. In line 10, the entire surface of the otherCar must be within the view region of the ego car. So, a scene where only front half of the otherCar is visible is not allowed. In line 11, the otherCar must be positioned in the right half of the ego car's visible region. In line 12 and 13, the distance of the otherCar from ego car should be 5 to 20 meters.
+
+# 3. Related Work
+
+Most techniques that aim to provide explainability and interpretability for deep neural networks (DNNs) in the field of computer vision focus on attributing the network's decisions to portions of the input images ([16, 19, 25, 26, 31]). GradCAM [23] is a popular approach for interpreting CNN models that visualizes how parts of the image affect the neural network's output by looking into class activation maps (CAM). Other techniques focus on understanding the internal layers by visualizing their activation patterns [5, 17]. Our approach, on the other hand, aims to provide characterizations at a higher level than raw image pixels, namely at the level of abstract features defined in a SCENIC program.
+
+Rule extraction techniques either aim to represent the entire functionality of the network as a set of rules making it too complex [32] or require the presence of pre-mined set of rules [15] which would be difficult to obtain for the object detection scenario. Anchors [22], which improves on LIME [21], is closest to our work (and we discuss it in more detail later).
+
+Recent work aims to explain the decisions of DNNs in
+
+terms of higher-level concepts. The technique in [13] introduces the idea of concept activation vectors, which provide an interpretation of a neural network's internal state in terms of human-friendly concepts. Feature Guided Exploration [29] aims to analyze the robustness of networks used in computer vision applications by applying perturbations over high-level input features extracted from raw images. They use object detection techniques (such as SIFT – Scale Invariant Feature Transform) to extract the features from an image. In contrast to these techniques we directly leverage SCENIC which defines the high-level features in a way that is already understandable for humans. Existing approaches typically use classification networks whose output directly corresponds to the decision being made and rely on the derivative of the output with respect to the input to calculate importance. In our application, there is no direct correlation between the output of the object detector network and the validity of the bounding boxes. Furthermore, unlike all previous work, we can use the synthesized rules to automatically generate more input instances, by refining the original SCENIC program and then using it to generate data. These instances can be used to test, debug and retrain the network.
+
+# 4. Approach
+
+The key idea of our approach is to leverage the high-level semantic features formally encoded in a SCENIC program to derive rules (sufficient conditions) that explain the behavior of a detection module in terms of those features. Our hypothesis is that since these features describe the important characteristics that should be present in an image and furthermore they are much fewer than the raw, low-level pixels, they should lead to small, compact rules that have a clear meaning for the developer.
+
+The problem that our technique aims to address can be formalized as follows. Suppose a function $\mathbf{g}$ defines a mapping from a feature vector, $[f_1, f_2, \dots, f_n] \in D_1 \times D_2 \times \dots \times D_n$ , to a matrix of pixels, $m \in M$ , of an image, where each $D_i$ represents the feature domain of feature $f_i$ and $M$ is a domain of $m$ . Let function $h$ denote the given perception module. Finally, let $e$ be an evaluation function which compares the perception module's prediction to the ground truths, and outputs a boolean class (correct or incorrect) based on a certain performance threshold. Given a SCENIC program, according to its feature dependencies and hard and soft constraints, the feature space, $D_1 \times D_2 \times \dots \times D_n$ , is defined. The problem is to find the subset feature space, $d_1 \times d_2 \times \dots \times d_n \subseteq D_1 \times D_2 \times \dots \times D_n$ such that when we sample a certain number of features $[f_1, f_2, \dots, f_n] \in d_1 \times d_2 \times \dots \times d_n$ , the probability that $e(h(g([f_1, f_2, \dots, f_n]))$ is equal to a target class (correct or incorrect) is maximized.
+
+A high-level overview of our analysis pipeline is illus
+
+trated in Figure 3. We start with a SCENIC program that encodes constraints (and distributions) over high-level semantic features that are relevant for a particular application domain, in our case object detection for autonomous driving. Intuitively, the program (henceforth called scenario) encodes the environments that the user wants to focus on in order to test the module. Based on this scenario, SCENIC generates a set of feature vectors by sampling from the specified distributions. A simulator is then used to generate a set of realistic, synthetic images (i.e. raw low-level pixel values) based on those features.
+
+The images are fed to the object detector. Each image is assigned a binary label, correct or incorrect, based on the performance of the object detector on the image (see Section 4.1). The labels obtained for the images are mapped back to the feature vectors that led to the generation of the respective images. The result is a labeled data set that maps each high-level feature vector to the the respective label.
+
+We then use off-the-shelf methods to extract rules from this data set. The rule extraction is described in more detail in Sec. 4.2. The result is a set of rules encoding the conditions on high-level features that lead to likely correct or incorrect detection. The obtained rules can be used to refine the SCENIC program, which in turn can be sampled to generate more images that can be used to test, debug or retrain the detection module. This iterative process can continue until one obtains refined rules, and SCENIC programs, of desired precision. In the following we provide more details about our approach.
+
+# 4.1. Labelling
+
+Obtaining the label (correct/incorrect) for an image is performed using the F1 score metric (harmonic mean of the precision and recall). This metric is commonly used in statistical analysis of binary classification. The F1 score is computed in the following way. For each image, the true positive (TP) is the number of ground truth bounding boxes correctly predicted by the detection module. Correctly predicted here means intersection-over-union (IoU for object detection) is greater than 0.5. The false positive (FP) is the number of predicted bounding boxes that falsely predicted ground truths. This false prediction includes duplicate predictions on one ground truth box. The false negative (FN) is the number of ground truth boxes that is not detected correctly. We computed the F1 score for each image, and if it is greater than a threshold, we assigned correct label; if not, incorrect. The threshold used in our experiments was 0.8.
+
+# 4.2. Rule Extraction
+
+Methods: We experimented with two methods, decision tree (DT) learning for classification [20] and anchors [22], to extract rules capturing the subspace of the feature space defined in the given SCENIC program.
+
+
+Figure 3: Analysis Pipeline
+
+Decision tree learning is commonly used to extract rules explaining the global behavior of a complex system while the anchors method is a state-of-the-art technique for extracting explanation rules that are locally faithful.
+
+Decision trees encode decisions (and their consequences) in a tree-like structure. They are highly interpretable, provided that the trees are short. One can easily extract rules for explaining different classes, by simply following the paths through the trees and conjuncting the decisions encoded in the tree nodes. We used the rpart [27] package in R software, which implements corresponding algorithm in [4], with default parameters.
+
+The anchor method is a state-of-the-art technique that aims to explain the behavior of complex ML models with high-precision rules called anchors, representing local, sufficient conditions for predictions. The system can efficiently compute these explanations for any black-box model with high-probability guarantees. We used the code from [1] with the default parameters. Applying the method to the object detector directly would result in anchors describing conditions on low-level pixel values, which would be difficult to interpret and use. Instead what we want is to extract anchors in terms of high-level features. While one can use the simulator together with the object detector as the black-box model, this would be very inefficient. Instead we built a surrogate model mapping high-level SCENIC features to output labels; we used a random forest learning algorithm for this purpose as in the code. This surrogate model was then passed to the anchor method to extract the rules.
+
+Blackbox vs Whitebox Analysis: So far we explained how we can obtain rules when treating the detection module as a black box. We also investigated a white-box analysis, to determine whether we can exploit the information about the internal workings of the module to improve the rule inference. The white-box analysis is one of our novel contributions in this paper. We leverage recent work [12] which aims to infer likely properties of neural networks. The properties are in terms of on/off activation patterns (at different internal layers) that lead to the same predictions. These pat
+
+terns are computed by applying decision-tree learning over the activations observed during the execution of the network on the training or testing set.
+
+We analyzed the architecture of the SqueezeDet network and we determined that there are three maxpool layers which provide a natural decomposition of the network. Furthermore they have relatively low dimensionality making them a good target for property inference.
+
+We consider activation patterns over maxpool neurons based on whether the neuron output is greater or equal to zero. A decision tree can then be learned over these patterns to fit the prediction labels. For our experiments we selected patterns from the maxpool layer 5, which turned out to be highly correlated to images that lead to correct/in-correct predictions.
+
+Then, we augmented the assigned correct and incorrect labels with corresponding decision pattern in the following way. For example, using a decision pattern for correct labels (i.e. the decision pattern that most correlated to images with correct label), we created two sub-classes for correct class. By feeding in only images with correct label to the perception module, the images satisfying the decision pattern is re-labelled as "correct-decision-pattern," otherwise, "correct-unlabelled." Likewise, the incorrect class is augmented using a decision pattern that is most correlated to images with incorrect label. It is our intuition that the decision pattern captures more focused properties (or rules) among images belonging to a target class. Hence, we hypothesize that this label augmentation would help anchor and decision tree methods to better identify rules.
+
+Rule Selection Criteria: Once we extracted rules with either DT or anchors, we selected the best rule using following criteria. To best achieve our objective, first, we chose the rule with highest precision on a held-out testset of feature vectors. If there are more than one rule with equal high precision, then we chose the rule with the highest coverage (i.e. the number of feature vectors satisfying the rules). Finally, if there is still more than one rule left, then we broke the tie by choosing the most compact rule which has the
+
+| Scenario # (Baseline→Rule Precision) | Rules |
| Scenario 1 (65.3% → 89.4%) | x coordinate ≥ -198.1 |
| Scenario 2 (72.3% → 82.3%) | hour ≥ 7.5 ∧ weather = all except neutral ∧ car0 distance from ego ≥ 11.3m ∧ car0 model = {Asea, Bison, Bista, Buffalo, Dominator, Jackal, Ninef, Oracle} |
| Scenario 3 (61.7% → 79.4%) | car0 red color ≥ 74.5 ∧ car0 heading ≥ 220.3 deg |
| Scenario 4 (89.6% → 96.2%) | car0 model = {Asea, Baller, Bista, Buffalo, Dominator, Jackal, Ninef, Oracle} |
+
+Table 2: Rules for correct behaviors of the detection module with the highest precision from Table 6
+
+| Scenario # (Baseline→Rule Precision) | Rules |
| Scenario 1 (34.7% → 87.2%) | x coordinate ≤ -200.76 ∧ distance ≤ 8.84 ∧ car model = PRANGER |
| Scenario 2 (27.7% → 44.9%) | hour ≥ 7.5 ∧ weather = all except Neutral ∧ car0 distance from ego < 11.3 |
| Scenario 3 (38.3% → 83.4%) | weather = neutral ∧ agent0 heading = ≤ 218.08 deg ∧ hour ≤ 8.00 ∧ car2 red color ≤ 95.00 |
| Scenario 4 (10.4% → 57.3%) | car0 model = PATRIOT ∧ car1 model = NINEF ∧ car2 model = BALLER ∧ 92.25 < car0 green color ≤ 158 ∧ car0 blue color ≤ 84.25 ∧ 178.00 < car2 red color ≤ 224 |
+
+Table 3: Rules for incorrect behaviors of detection module with the highest precision from Table 7
+
+least number of features. The last two criteria are established to select the most general high-precision rule.
+
+# 5. Experiments
+
+In this section we report on our experiments with the proposed approach on the object detector. We investigate whether we can synthesize rules that are effective in generating test inputs that increase the probability of correct/incorrect detection, thus explaining the correct/incorrect behavior of the analyzed module. We evaluate the proposed techniques along the following dimensions: decision tree (DT) vs anchor, black-box (BB) vs white-box (WB).
+
+# 5.1. Scenarios
+
+We experimented with our approach on four different scenarios. Images generated from these scenarios are shown in Figure 4. Scenario 1 (Figure 2) describes the situation where a car is illegally intruding over a white striped traffic island at the entrance of an elevated highway. Scenario 2 describes two-car scenario where one car occludes the ego car's view of another car at a T-junction intersection on an elevated road. describes scenes where other cars are merging into ego car's lane. The location in this scenario is carefully chosen such that the sun rises in front of ego car, causing a glare. describes a set of scenes when nearest car is abruptly switching into ego car's lane while another car on the opposite traffic direction lane is slightly intruding over the middle yellow line into ego car's lane.
+
+# 5.2. Setup
+
+The object detector was trained on a separate set of 10,000 GTA images with one to four cars in various locations of the map producing different background scenes. The GTA-V simulator provided images, ground truth boxes, and values of the environment features.
+
+For each scenario, we generated 950 new images as a train set and another 950 new images as a test set. We denote the labels corresponding to the maxpool layer 5 decision pattern as p5c.correct) and p5.ic Incorrect) and the remaining as correct_unlabelled and incorrect_unlabelled, respectively. We augmented the feature vector with some extra features that are not part of the feature values provided by the simulator but could help with extracting meaningful rules. For example, in Scenario 1, the distance from ego to otherCar is not part of the feature values provided by GTAV. However, it can be computed with Euclidean distance metric using $(\mathrm{x},\mathrm{y})$ location coordinates of ego and otherCar. Also, the difference in heading angle between ego and otherCar is also added as extra feature to represent "badAngle" variable in the program.
+
+From the train set, we extracted rules to predict each label based on the feature vectors. These rules were evaluated on the test set based on precision, recall, and F1 score metrics. For DT learning we adjusted the label weight to account for the uneven ratio among labels for both black-box and white-box labels. For the Anchors method, we applied it on each instance of the training set until we had covered a maximum of 50 instances for every label (correct, incorrect for Black Box, and p5c, p5 ic, correct_unlabelled, incorrect_unlabelled for White Box). The best anchor rule for every label is selected based on the rule selection criteria mentioned in section 4.2.
+
+
+
+
+
+
+Figure 4: From top-left one-car image, each image corresponds to scenario 1, 2, 3, and 4 in a clockwise manner. The scenario number is the number of cars
+
+
+
+# 5.3. Results
+
+Tables 2 and 3 show the best rules (wrt. precision) extracted with our proposed framework, along with the baseline correct/incorrect detection rate for each given scenario and the detection rate for the generated rules. The results indicate that indeed our framework can generate rules that increase significantly the correct and incorrect detection rate of the module. Furthermore, the generated rules are compact and easily interpretable.
+
+For example, the rule for correct behavior for Scenario 1 is "x coordinate $\geqslant -198.1$ ." In GTA-V, at ego car's specific location, the condition on x coordinate was equivalent to the otherCar's distance from ego being greater than $11\mathrm{m}$ . On the other hand, the rule for incorrect behavior for Scenario 1 requires the otherCar to be within $8.84\mathrm{m}$ and its car model to be PRANGER. These rules, counter-intuitively, indicate that the object detector fails when the otherCar is close by, and performs well when located further away.
+
+Results for Correct Behavior: Tables 5 and 6 summarize the results for the rules explaining correct behavior. The results indicate that there are clear signals in the heavily abstracted feature space and they can be used effectively for scenario characterization via the generated high-precision rules.
+
+The results also indicate that DT learning extracts rules with better F1 scores for all scenarios as compared to anchors. This could be attributed to the difference in the nature of the techniques. The anchor approach aims to construct rules that have high precision in the locality of a given instance. Decision-trees on the other hand aim to construct global rules that discriminate one label from another. Given that a large proportion of instances were detected correctly by the analyzed module, the decision tree was able to build rules with high precision and coverage for correct behavior.
+
+| Problem | Our | Original* | [29] | GFan [32] | (#GB) | Heuristic [32] |
| Rel. pose F+λ 8pt(‡)(8 sols.) | 7 × 16 | 12 × 24 [22] | 11 × 19 | 11 × 19 | (10) | 7 × 15 |
| Rel. pose E+f 6pt (9 sols.) | 11 × 20 | 21 × 30 [3] | 21 × 30 | 11 × 20 | (66) | 11 × 20 |
| Rel. pose f+E+f 6pt (15 sols.) | 12 × 30 | 31 × 46 [24] | 31 × 46 | 31 × 46 | (218) | 21 × 36 |
| Rel. pose E+λ 6pt (26 sols.) | 14 × 40 | 48 × 70 [22] | 34 × 60 | 34 × 60 | (846) | 14 × 40 |
| Stitching fλ+R+fλ 3pt (18 sols.) | 18 × 36 | 54 × 77 [34] | 48 × 66 | 48 × 66 | (26) | 18 × 36 |
| Abs. Pose P4Pfr (16 sols.) | 52 × 68 | 136 × 152 [4] | 140 × 156 | 54 × 70 | (1745) | 54 × 70 |
| Abs. Pose P4Pfr (elim. f) (12 sols.) | 28 × 40 | 28 × 40 [31] | 48 × 60 | 28 × 40 | (699) | 28 × 40 |
| Rel. pose λ+E+λ 6pt(‡)(52 sols.) | 39 × 95 | 238 × 290 [24] | 149 × 201 | - | ? | 53 × 105 |
| Rel. pose λ1+F+λ2 9pt (24 sols.) | 90 × 117 | 179 × 203 [24] | 189 × 213 | 87 × 111 | (6896) | 87 × 111 |
| Rel. pose E+fλ 7pt (19 sols.) | 61 × 80 | 200 × 231[22] | 181 × 200 | 69 × 88 | (3190) | 69 × 88 |
| Rel. pose E+fλ 7pt (elim. λ) (19 sols.) | 22 × 41 | - | 52 × 71 | 37 × 56 | (332) | 24 × 43 |
| Rel. pose E+fλ 7pt (elim. fλ) (19 sols.) | 51 × 70 | 51 × 70 [27] | 51 × 70 | 51 × 70 | (3416) | 51 × 70 |
| Abs. pose quivers(†)(20 sols.) | 68 × 92 | 372 × 386 [21] | 203 × 223 | - | ? | 68 × 88 |
| Rel. pose E angle+4pt (20 sols.) | - | 270 × 290 [33] | 266 × 286 | - | ? | 183 × 203 |
| Abs. pose refractive P5P(†)(16 sols.) | 68 × 93 | 280 × 399 [15] | 199 × 215 | 112 × 128 | (8659) | 199 × 215 |
| Unsynch. Rel. pose (16 sols.) | 150 × 168 | 633 × 649[2] | 467 × 483 | - | ? | 299 × 315 |
+
+Table 1. Comparison of solver sizes for some minimal problems. Missing entries are when we failed to generate a solver. $(\ast)$ : Sizes for the original formulations. $(\dagger)$ : Input polynomials were eliminated using G-J elimination before generating a solver using our resultant method as well as solvers based on [29], the Gröbner fan-based solver [32] and the heuristic-based solver [32]. $(\ddagger)$ :Solved using the alternate eigenvalue formulation (16).
+
+