# AA3DNet: Attention Augmented Real Time 3D Object Detection

Abhinav Sagar
Vellore Institute of Technology
Vellore, India
<EMAIL_ADDRESS>

###### Abstract

In this work, we address the problem of 3D object detection from point cloud
data in real time. For autonomous vehicles to work, it is very important for
the perception component to detect the real world objects with both high
accuracy and fast inference. We propose a novel neural network architecture
along with the training and optimization details for detecting 3D objects
using point cloud data. We present anchor design along with custom loss
functions used in this work. A combination of spatial and channel wise
attention module is used in this work. We use the Kitti 3D Bird’s Eye View
dataset for benchmarking and validating our results. Our method surpasses
previous state of the art in this domain both in terms of average precision
and speed running at > 30 FPS. Finally, we present the ablation study to
demonstrate that the performance of our network is generalizable. This makes
it a feasible option to be deployed in real time applications like self
driving cars.

##  1 Introduction

A lot of work has been done in 2D object detection using convolutional neural
networks. The object detection algorithms can be broadly grouped into the
following two types:

1\. Single stage detector - Yolo (Redmon et al., 2016), SSD (Liu et al.,
2016).

2\. Two stage detector - RCNN (Girshick et al., 2014), Fast RCNN (Girshick,
2015), Faster RCNN (Ren et al., 2015).

The difference between the two is that in the two stage detectors, the first
stage uses region proposal networks to generate regions of interest and the
second stage uses these regions of interest for object classification and
bounding box regression. These are proven to have achieved better accuracy
than the one stage architecture but comes at a tradeoff of more computational
burden and time taken. On the other hand, a single stage detector uses the
input image to directly learn the class wise probability and bounding box
coordinates. Thus these architectures treat the object detection as a simple
regression problem and thus are faster but less accurate.

There has also been a lot of work done on 3D object detection. Some of them
use a camera based approach using either monocular or stereo images. Also work
has been done by fusing the depth information on RGBD images taken from the
camera. The main problem with camera based approach is the low accuracy
achieved. Therefore lidar data has been proven to be a better alternative
achieving higher accuracy and thus safety which is a primary concern for self
driving cars. The challenge with using lidar data is that it produces data in
the form of point clouds which have millions of points thus increasing the
computational cost and processing time.

Point cloud data are of many types, of which the main type is 3D voxel grid.
However, monocular 3D object detection is a difficult problem due to the depth
information loss in 2D image planes. Recent networks have been proposed to
first predict the pixel-level depth and convert the monocular image to 3D
point cloud representations. These methods although achieves good performance
but it introduces additional expensive computational cost for predicting high-
resolution depth maps from images, making them challenging to be deployed in
real time settings like self driving cars.

In this work, our approach uses only the bird’s eye view for 3D object
detection in real time. The context of our work is in self driving cars but
can be deployed in other settings as well. To validate our work, we benchmark
our results on the publicly available 3D Kitti dataset (Geiger et al., 2012).
We use spatial and channel attention modules in one branch for finding out
where is an informative part in the image and finding out what feature is
meaningful in the image respectively. The second branch locates the 2d
bounding box co-ordinates while the third branch is used to get the deviations
between the predicted and actual co-ordinates. The individual features are
summed to give the refined 3d bounding box co-ordinates. For the evaluation
metric, we use the class wise average precision. Our work beats the previous
state of the art approaches for 3D object detection while also running at
greater than 30 FPS. We also further show the learning and optimization
aspects along with ablation study of this approach and present how it could
potentially be generalized to other real world settings.

A sample of the predicted 3D detection from the KITTI validation dataset is
shown in Figure 1:

Figure 1: 3D detection from the KITTI validation dataset projected onto an
image

##  2 Related Work

Recently there have been a surge of papers on 3D object detection from various
kinds of data like LIDAR, stereo etc. VOTE 3D (Qi et al., 2019) uses a sliding
window on a 3D voxel grid to detect objects. The pre-trained model is fed to a
SVM classifier later. VELOFCN (li20173d) projects 3D point cloud data to a
perspective in the front view and gets a 2D depth map. The objects are
detected by running a convolutional neural network on the depth map. MV3D (Qi
et al., 2018) architecture also used a similar approach by combining the
features extracted from multiple views like front view, birds eye view and
camera view. These extracted features are passed through a CNN to detect 3D
objects.

PointNet (Qi et al., 2017) proposed an end-to-end classification neural
network that directly takes a point cloud as input without any preprocessing
and outputs class scores. (Zhou and Tuzel, 2018) subdivides the point cloud
into 3D voxels and then transforms points within each voxel to a trainable
feature vector that characterizes the shape information of the contained
points. The representation vectors for each voxel stacks together and passes
to a region proposal network to detect the objects. (Chen et al., 2020a)
proposed and anchor free method using firing of different hotspots. (Ge et
al., 2020) used anchor free one stage network for 3d object detection.
Pairwise spatial relationship of features was used for monocular 3D object
detection (Chen et al., 2020c). A learnable depth guided convolution was used
to tackle monocular 3D object detection problem (Ding et al., 2020).

Triple attention module was used (Liu et al., 2020) for 3d object detection
from point clouds. A comprehensive study of various localization errors
involved while detecting 3d objects was presented (Ma et al., 2021). A new
voting algorithm was individually proposed for improving the robustness of 3d
object detector (Qi et al., 2020) and (Xie et al., 2020). (Zhou et al., 2020)
used an end to end learnable network using multi view feature fusion from
lidar data. (Vora et al., 2020) similarly used sequential fusion approach. A
more generalizable method taking into account different shapes and sizes of
objects present in image was proposed by (Zhang et al., 2021). Both 3d object
detection and tracking problem was tackled using a single network (Yin et al.,
2021).

We summarize our main contributions as follows:

• A novel approach using spatial and channel attention mechanism to
simultaneously detect and regress 3D bounding box over all the objects present
in the image.

• A thorough analysis of backbone, optimization, anchors and loss function
used in our network which is end to end trainable.

• Evaluation on the KITTI dataset shows we outperform all previous state-of-
the-art methods in terms of average precision while running at >30 FPS.

##  3 Model

###  3.1 Dataset

For this work, we have used the Kitti dataset (Geiger et al., 2012) which
contains LIDAR data taken from a sensor mounted in front of the car. Since the
data contains millions of points and is of quite high resolution, processing
is a challenge especially in real world situations. The task is to detect and
regress a bounding box for 3D objects detected in real time. The dataset has
7481 training images and 7518 test point clouds comprising a total of labelled
objects. The object detection performance is measured through average
precision and IOU (Intersection over union) with threshold 0.7 for car class.
The 3D object KITTI benchmark provides 3D bounding boxes for object classes
including cars, vans, trucks, pedestrians and cyclists which are labelled
manually in 3D point clouds on the basis of information from the camera. KITTI
also provides three detection evaluation levels: easy, moderate and hard,
according to the object size, occlusion state and truncation level. The
minimal pixel height for easy objects is 40px, which approximately corresponds
to vehicles within 28m. For moderate and hard level objects are 25px,
corresponding to a minimal distance of 47m.

###  3.2 Problem Definition

Given a RGB images and the corresponding camera parameters, our goal is to
classify and localize the objects of interest in 3D space. Each object is
represented by its category, 2D bounding box $B_{2D}$, and 3D bounding box
$B_{3D}$. $B_{2D}$ is represented by its center $c_{i}$ = $[x_{0},y_{0}]_{2D}$
and size $[h_{0},w_{0}]_{2D}$ in the image plane, while $B_{3D}$ is defined by
its center $[x,y,z]_{3D}$, size $[h,w,l]_{3D}$ and heading angle $\gamma$ in
the 3D world space.

The 3D bounding box $B_{3D}$ is the final goal of prediction. The first task
is 2D object detection in which the goal is to predict the 2D bounding box
$B_{2D}$ of the object and its class. $B_{2D}=(w_{2D},h_{2D},u_{b},v_{b})$
where $(w_{2D},h_{2D})$ indicates the size of $B_{2D}$ and $(u_{b},v_{b})$
represents the center of $B_{2D}$ on the image plane.

###  3.3 Spatial Attention Module

The spatial attention module is used for capturing the spatial dependencies of
the feature maps. The spatial attention (SA) module used in our network is
defined below:

$f_{{SA}}(x)=f_{sigmoid}\left({W}_{2}\left(f_{{ReLU}}\left({W}_{1}(x)\right)\right)\right)$
(1)

where $W_{1}$ and $W_{2}$ denotes the first and second $1\times 1$ convolution
layer respectively, $x$ denotes the input data, $f_{Sigmoid}$ denotes the
sigmoid function, $f_{ReLU}$ denotes the ReLu activation function.

The spatial attention module used in this work is shown in Figure 2:

Figure 2: Illustration of our spatial attention module

.

###  3.4 Channel Attention Module

The channel attention module is used for extracting high level multi-scale
semantic information. The channel attention (CA) module used in our network is
defined below:

$f_{{CA}}(x)=f_{sigmoid}({W}_{2}(f_{{ReLU}}({W}_{1}f_{{AvgPool}}^{1}(x))))$
(2)

where $W_{1}$ and $W_{2}$ denotes the first and second $1\times 1$ convolution
layer, $x$ denotes the input data. $f^{1}_{AvgPool}$ denotes the global
average pooling function, $f_{Sigmoid}$ denotes the Sigmoid function,
$f_{ReLU}$ denotes ReLU activation function.

The channel attention module used in this work is shown in Figure 3:

Figure 3: Illustration of our channel attention module

.

###  3.5 Network Architecture

We divide the point cloud data into 3D voxel grid cells. Our CNN backbone
takes as input the image in the form of voxel and outputs a feature vector. We
use Resnet as backbone for our network. Residual blocks are used for locating
the 2d bounding box co-ordinates which is then propagated to a Roi Align
operator which is then sent to a fully connected layer. In parallel, spatial
and channel attention mechanism are used for finding out where is an
informative part in the image and finding out what feature is meaningful given
in the image. the individual features are summed up which is in turn summed up
with the first block to produce the 3d bounding box co-ordinates. In parallel,
a third block uses Roi Align and fully connected layers to find out the
deviations between the actual and predicted co-ordinates. Anchors are used in
these deltas blocks to adjust the coordinates according to the size and shape
of the object detected. This block is learnable thus improving the hyper-
parameters in every iteration. The learned deviations are finally summed up
with the 3d bounding box co-ordinates to give the refined 3d bounding box co-
ordinates.

The residual blocks are made up of: a fully connected layer followed by a non
linearity activation function which is ReLU used in this case and a batch
normalization layer. These layers are used for transforming each point in the
voxel to a point wise feature vector. Element wise max-pooling layer is also
used which extracts the maximum value from all the neighbouring pixel values
when the filter is applied on the image. This operation is used for getting
the locally aggregated features. Also a point wise concatenation operator is
used which concatenates each point wise feature vector with the locally
aggregated features. For our detector there are in total 7 parameters - three
for the offset center coordinates, three for the offset dimensions and the
last is for offset rotation angle. The network architecture is shown in Figure
4:

Figure 4: Illustration of our network architecture. SA denotes spatial
attention module, CA denotes channel attention module, FC denotes fully
connected layer and + denotes summation operator.

##  4 Experiments

###  4.1 Anchors

Anchors are very important for efficient object detection. These are basically
prior beliefs containing information of the size for the detected object, its
position is the image, its pose, its orientation etc. Anchors of multiple
shape, size are more stable, also helps in reducing the computational burden
and time taken by the model. We have chosen two anchors for each of the
classes as shown in Table 1, Table 2 and Table 3 respectively:

Table 1: Car anchors Height(m) | Width(m) | Length(m) | Rotation(Theta)
---|---|---|---
1.6 | 1.6 | 4 | 0
1.6 | 1.6 | 1.6 | 90
Table 2: Pedestrian anchors Height(m) | Width(m) | Length(m) | Rotation(Theta)
---|---|---|---
1.7 | 0.5 | 0.7 | 0
1.7 | 1.5 | 0.7 | 90
Table 3: Cyclist anchors Height(m) | Width(m) | Length(m) | Rotation(Theta)
---|---|---|---
1.6 | 0.7 | 2 | 0
1.6 | 0.7 | 2 | 90

###  4.2 Loss Functions

A vector $s=(x,y,z,l,h,w,\theta)$ represents 3D bounding box center
coordinates, height, width, length and yaw respectively. The geometric
relations between various parameters is illustrated in the equation below
where $s$ represents the ground truth vector and $a$ represents the anchor
vector. The localization regression between ground truth and anchors are
defined using set of Equations 3-10:

$\Delta x=\frac{x_{s}-x_{a}}{\sqrt{l^{2}+w^{2}}}$ (3)

$\Delta z_{b}=z_{s}-\frac{h_{s}}{2}-z_{a}+\frac{h_{a}}{2}$ (4)

$\Delta y=\frac{y_{s}-y_{a}}{\sqrt{l^{2}+w^{2}}}$ (5)

$\Delta z_{t}=z_{s}+\frac{h_{s}}{2}-z_{a}-\frac{h_{a}}{2}$ (6)

$\Delta l=\log\frac{l_{s}}{l_{a}}$ (7)

$\Delta w=\log\frac{w_{s}}{w_{a}}$ (8)

$\Delta\zeta=\left|\sin\left(\theta_{s}-\theta_{a}\right)\right|$ (9)

$\Delta\eta=\cos\left(\theta_{s}-\theta_{a}\right)$ (10)

Since the angle localization loss cannot distinguish the bounding boxes which
are flipped, we use a softmax classification loss as shown for both positive
and negative anchors. For the object classification, we have used focal loss
as shown in Equation 11 and Equation 12 respectively:

$\mathcal{L}_{pos}=-\alpha_{a}\left(1-p^{a}\right)^{\gamma}\log p^{a}$ (11)

$\mathcal{L}_{neg}=-\alpha_{a}\left(1-p^{a}\right)^{\gamma}\log p^{a}$ (12)

We used Intersection Over Union (IOU) for evaluating the performance of our
network. All the positive anchors have an IOU value above 0.60 while those
with less than 0.45 are treated as negative anchors. We used binary cross
entropy loss for detection and a variant of huber loss for regression.

Let $i$ and $j$ denote the positive and negative anchors and let $p$ denote
the sigmoid activation for the classification network. Let $pos$ represent the
positive regression anchors and $neg$ the negative regression anchors. The
individual loss terms can be denoted using set of Equations 13-15.

$L_{1}=\frac{1}{N}\sum_{i}L_{pos}\left(p_{i}^{pos},1\right)$ (13)

$L_{2}=\frac{1}{N}\sum_{j}L_{neg}\left(p_{j}^{neg},0\right)$ (14)

$L_{3}=\frac{1}{N}\sum_{k}\left(L_{r}\left(l,l^{*}\right)+L\left(h,h^{*}\right)+L_{c}\left(w,w^{*}\right)\right)$
(15)

The overall loss function is shown in Equation 16:

$L_{total}=\alpha L_{1}+\beta L_{2}+\gamma L_{3}$ (16)

Here $\alpha$, $\beta$ and $\gamma$ are the hyper-parameters with values set
as 0.5, 0.5 and 1.0 respectively.

###  4.3 Evaluation Metrics

We use the Average Precision with 40 recall positions ($AP_{40}$) under three
difficult settings (easy, moderate, and hard) for those tasks. We present the
performances of the Car, Pedestrian and Cyclist categories as reference. The
default IoU threshold values are 0.7, 0.5, 0.5 for these three categories
respectively. Each manually annotated object is divided into easy, moderate,
and hard level according to the occlusion, truncation, and box height. The
metrics used extensively in the literature are Average precisions (AP) on the
car class for bird’s-eye-view (BEV) and 3D boxes with 0.5/0.7 IoU thresholds.
We present both $AP_{11}$ and $AP_{40}$ results to make comprehensive
comparisons as has been studied in literature.

###  4.4 Implementation Details

We train our model on a GTX 1080Ti GPU with a batch size of 16 for 100 epochs.
We use Adam optimizer with an initial learning rate of 0.001, and decay it by
ten times at every 100 epochs. The weight decay is set to 0.0001. We use Non-
Maximum Suppression (NMS) on center detection results. We use 3D bounding
boxes score of center detection as the confidence of predicted results. We
discard predictions with confidence value less than 0.1. All input images are
padded to the same size of $384\times 1280$. The prediction head of the
backbone consists of one $3\times 3\times 256$ conv layer, BatchNorm, ReLU,
and $1\times 1\times op$ conv layer where $op$ is the output size.

##  5 Results

We report our results of the Car category on KITTI test set as shown in Table
4. Overall, our method achieves superior results over previous methods.
Compared with the methods with extra data, our network still get comparable
performances, which further proves the effectiveness of our model. Our method
is also much faster than most existing methods, allowing for real-time
inference which is important in the context of autonomous driving.

Table 4: Quantitative results for Car on KITTI test sets, evaluated by AP3D. “Extra” lists the required extra information for each method. We divide existing methods into two groups considering whether they utilize extra information and sort them according to their performance on the moderate level of the test set within each group. The three sets of Easy, Mod and Hard denotes Val $AP_{11}$, Val $AP_{40}$ Test $AP_{40}$ respectively. Method | Extra | Time(ms) | $Easy_{1}$ | $Mod_{1}$ | $Hard_{1}$ | $Easy_{2}$ | $Mod_{2}$ | $Hard_{2}$ | $Easy_{3}$ | $Mod_{3}$ | $Hard_{3}$
---|---|---|---|---|---|---|---|---|---|---|---
MonoPSR | depth, LiDAR | 120 | 12.75 | 11.48 | 8.59 | - | - | - | 10.76 | 7.25 | 5.85
UR3D | depth | 120 | 28.05 | 18.76 | 16.55 | 23.24 | 13.35 | 10.15 | 15.58 | 8.61 | 6.00
AM3D | depth | - | 32.23 | 21.09 | 17.26 | 28.31 | 15.76 | 12.24 | 16.50 | 10.74 | 9.52
PatchNet | depth | - | 35.10 | 22.00 | 19.60 | 31.60 | 16.80 | 13.80 | 15.68 | 11.12 | 10.17
DA-3Ddet | depth, LiDAR | - | 33.40 | 24.00 | 19.90 | - | - | - | 16.80 | 11.50 | 8.90
D4LCN | depth | - | 26.97 | 21.71 | 18.22 | 22.32 | 16.20 | 12.30 | 16.65 | 11.72 | 9.51
Kinem3D | multi-frames | 120 | - | - | - | 19.76 | 14.10 | 10.47 | 19.07 | 12.72 | 9.17
FQNet | - | - | 5.98 | 5.50 | 4.75 | - | - | - | 2.77 | 1.51 | 1.01
MonoGRNet | - | 60 | 13.88 | 10.19 | 7.62 | - | - | - | 9.61 | 5.74 | 4.25
MonoDIS | - | 100 | 18.05 | 14.98 | 13.42 | - | - | - | 10.37 | 7.94 | 6.40
M3D-RPN | - | 160 | 20.27 | 17.06 | 15.21 | 14.53 | 11.07 | 8.65 | 14.76 | 9.71 | 7.42
MonoPair | - | 57 | - | - | - | 16.28 | 12.30 | 10.42 | 13.04 | 9.99 | 8.65
RTM3D | - | 55 | 20.77 | 16.86 | 16.63 | - | - | - | 14.41 | 10.34 | 8.77
Movi3D | - | 45 | - | - | - | 14.28 | 11.13 | 9.68 | 15.19 | 10.90 | 9.26
Zhang et al. (2021) | - | 35 | 28.17 | 21.92 | 19.07 | 23.64 | 17.51 | 14.83 | 19.94 | 13.89 | 12.07
AA3DNet | - | 26 | 30.22 | 22.54 | 18.38 | 24.01 | 17.81 | 14.31 | 21.62 | 14.90 | 11.82

We present our model’s performance on the KITTI validation set in Table 5. Our
approach shows better performance consistency between the validation set and
test set. This indicates that our method has better generalization ability,
which is important in autonomous driving.

Table 5: Performance of the Car category on the KITTI validation set. Methods are ranked by moderate setting (same as KITTI leaderboard). We highlight the best results in bold. The four sets of Easy, Mod and Hard denotes $3D_{IOU}$=0.7, $BEV_{IOU}$=0.7, $3D_{IOU}$=0.5 and $BEV_{IOU}$=0.5 respectively. Method | $Easy_{1}$ | $Mod_{1}$ | $Hard{1}$ | $Easy_{2}$ | $Mod_{2}$ | $Hard_{2}$ | $Easy_{3}$ | $Mod_{3}$ | $Hard_{3}$ | $Easy_{4}$ | $Mod_{4}$ | $Hard_{4}$
---|---|---|---|---|---|---|---|---|---|---|---|---
CenterNet | 0.60 | 0.66 | 0.77 | 3.46 | 3.31 | 3.21 | 20.00 | 17.50 | 15.57 | 34.36 | 27.91 | 24.65
MonoGRNet | 11.90 | 7.56 | 5.76 | 19.72 | 12.81 | 10.15 | 47.59 | 32.28 | 25.50 | 48.53 | 35.94 | 28.59
MonoDIS | 11.06 | 7.60 | 6.37 | 18.45 | 12.58 | 10.66 | - | - | - | - |  |
M3D-RPN | 14.53 | 11.07 | 8.65 | 20.85 | 15.62 | 11.88 | 48.53 | 35.94 | 28.59 | 53.35 | 39.60 | 31.76
MonoPair | 16.28 | 12.30 | 10.42 | 24.12 | 18.17 | 15.76 | 55.38 | 42.39 | 37.99 | 61.06 | 47.63 | 41.92
(Ma et al., 2021) | 17.45 | 13.66 | 11.68 | 24.97 | 19.33 | 17.01 | 55.41 | 43.42 | 37.81 | 60.73 | 46.87 | 41.89
AA3DNet | 18.06 | 14.27 | 11.51 | 25.68 | 19.83 | 16.64 | 57.24 | 44.90 | 37.15 | 62.18 | 47.55 | 41.24

Our results are considerably better than the previous state of the art
approaches.

###  5.1 Average Precision

The ideal value of precision and recall is 1. Since it is not possible to get
perfect values, the closer the metrics ie precision and recall is to 1, the
better our model is performing, It’s often seen that there is a tradeoff
between precision and recall ie if we are optimizing for precision, recall
value gets less and if we are trying to improve recall, precision value
becomes less. So our task is to balance both and note that threshold point.
Average precision is the average value of precision for the sampled points at
various recall threshold values. The precision - recall curve for 3D object
detection for the 3 classes i.e. cars, pedestrians and cyclists for all the
three categories i.e. easy, moderate and hard are shown in Figure 5. The
closer the curve is to (1,1), the higher performance of the model is.

Figure 5: Precision-recall curve for 3D detection in a) Cars b) Pedestrian c)
Cyclists.

Finally we present the results for 3D object detection results on KITTI
validation set in Figure 6. The ground truth bounding boxes are shown in blue
and the predicted bounding boxes are shown in orange.

Figure 6: Predicted 3D bounding boxes are drawn in orange, while ground truths
are in blue.

Note that our model is based only on LiDAR data. For better visualization the
3D bounding boxes are projected on to the bird’s eye view and the images.

###  5.2 Ablation Study

The compared results with different backbones on Average Precision metric is
shown in Table 6:

Table 6: Ablation study of different backbone networks on $AP_{3D}$ (IoU=0.3). Backbone Network | Easy | Moderate | Hard
---|---|---|---
VGG16 | 53.68 | 41.45 | 34.08
InceptionV3 | 54.32 | 41.60 | 34.66
DenseNet169 | 54.26 | 40.04 | 35.06
ResNet50 | 56.16 | 42.61 | 35.36

The best results are achieved using ResNet50 as the backbone on our network.

A study of with and without using channel and spatial attention module on
Average Precision metric is shown in Table 7:

Table 7: Ablation study using variations of spatial and channel attention modules on $AP_{3D}$ (IoU=0.3). Attention Module | Easy | Moderate | Hard
---|---|---|---
No attention | 53.59 | 40.06 | 32.18
Only SA | 55.05 | 42.06 | 34.58
Only CA | 55.51 | 40.49 | 34.46
Both | 56.16 | 42.61 | 35.36

The best results are achieved using both spatial and channel attention modules
in our network.

A study of using individual loss function terms used while training our
network on Average Precision metric is shown in Table 8:

Table 8: Ablation study using individual loss function terms on $AP_{3D}$ (IoU=0.3). $L_{1}$ | $L_{2}$ | $L_{3}$ | Easy | Moderate | Hard
---|---|---|---|---|---
$\times$ | $\times$ | $\checkmark$ | 44.50 | 32.33 | 29.10
$\checkmark$ | $\checkmark$ | $\times$ | 52.72 | 40.59 | 33.71
$\checkmark$ | $\checkmark$ | $\checkmark$ | 56.16 | 42.61 | 35.36

The best results are achieved using all the loss functions ie $L_{1}$, $L_{2}$
and $L_{3}$ combined.

##  6 Conclusions

In this paper, we proposed a real time 3D object detection network using
spatial and channel attention mechanism using LIDAR point cloud data. For
making efficient computation, our architecture uses a single stage type neural
network with bird’s view representation. We evaluate our network on the KITTI
benchmark dataset and show that our approach outperforms previous state of the
art methids. As for the evaluation metric, we chose class wise average
precision. The model runs at faster than 30 FPS and hence can be used in
autonomous driving applications where safety is a major challenge. In the
future, we would be interested in studying attention mechanism in the context
of 3D semantic segmentation.

#### Acknowledgments

We would like to thank Nvidia for providing the GPUs.

## References

  * Chen et al. (2020a) Q. Chen, L. Sun, Z. Wang, K. Jia, and A. Yuille.  Object as hotspots: An anchor-free 3d object detection approach via firing of hotspots.  In _European Conference on Computer Vision_ , pages 68–84. Springer, 2020a.
  * Chen et al. (2016) X. Chen, K. Kundu, Z. Zhang, H. Ma, S. Fidler, and R. Urtasun.  Monocular 3d object detection for autonomous driving.  In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition_ , pages 2147–2156, 2016.
  * Chen et al. (2017) X. Chen, H. Ma, J. Wan, B. Li, and T. Xia.  Multi-view 3d object detection network for autonomous driving.  In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition_ , pages 1907–1915, 2017.
  * Chen et al. (2020b) Y. Chen, S. Liu, X. Shen, and J. Jia.  Dsgn: Deep stereo geometry network for 3d object detection.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 12536–12545, 2020b.
  * Chen et al. (2020c) Y. Chen, L. Tai, K. Sun, and M. Li.  Monopair: Monocular 3d object detection using pairwise spatial relationships.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 12093–12102, 2020c.
  * Dai et al. (2016) J. Dai, Y. Li, K. He, and J. Sun.  R-fcn: Object detection via region-based fully convolutional networks.  In _Advances in neural information processing systems_ , pages 379–387, 2016.
  * Ding et al. (2020) M. Ding, Y. Huo, H. Yi, Z. Wang, J. Shi, Z. Lu, and P. Luo.  Learning depth-guided convolutions for monocular 3d object detection.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops_ , pages 1000–1001, 2020.
  * Engelcke et al. (2017) M. Engelcke, D. Rao, D. Z. Wang, C. H. Tong, and I. Posner.  Vote3deep: Fast object detection in 3d point clouds using efficient convolutional neural networks.  In _2017 IEEE International Conference on Robotics and Automation (ICRA)_ , pages 1355–1361. IEEE, 2017.
  * Ge et al. (2020) R. Ge, Z. Ding, Y. Hu, Y. Wang, S. Chen, L. Huang, and Y. Li.  Afdet: Anchor free one stage 3d object detection.  _arXiv preprint arXiv:2006.12671_ , 2020.
  * Geiger et al. (2012) A. Geiger, P. Lenz, and R. Urtasun.  Are we ready for autonomous driving? the kitti vision benchmark suite.  In _2012 IEEE Conference on Computer Vision and Pattern Recognition_ , pages 3354–3361. IEEE, 2012.
  * Girshick (2015) R. Girshick.  Fast r-cnn.  In _Proceedings of the IEEE international conference on computer vision_ , pages 1440–1448, 2015.
  * Girshick et al. (2014) R. Girshick, J. Donahue, T. Darrell, and J. Malik.  Rich feature hierarchies for accurate object detection and semantic segmentation.  In _Proceedings of the IEEE conference on computer vision and pattern recognition_ , pages 580–587, 2014.
  * He et al. (2020) C. He, H. Zeng, J. Huang, X.-S. Hua, and L. Zhang.  Structure aware single-stage 3d object detection from point cloud.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 11873–11882, 2020.
  * Huang et al. (2020) T. Huang, Z. Liu, X. Chen, and X. Bai.  Epnet: Enhancing point features with image semantics for 3d object detection.  In _European Conference on Computer Vision_ , pages 35–52. Springer, 2020.
  * Ku et al. (2018) J. Ku, M. Mozifian, J. Lee, A. Harakeh, and S. L. Waslander.  Joint 3d proposal generation and object detection from view aggregation.  In _2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)_ , pages 1–8. IEEE, 2018.
  * Li et al. (2016) B. Li, T. Zhang, and T. Xia.  Vehicle detection from 3d lidar using fully convolutional network.  _arXiv preprint arXiv:1608.07916_ , 2016.
  * Liang et al. (2019) M. Liang, B. Yang, Y. Chen, R. Hu, and R. Urtasun.  Multi-task multi-sensor fusion for 3d object detection.  In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition_ , pages 7345–7353, 2019.
  * Lin et al. (2017a) T.-Y. Lin, P. Dollár, R. Girshick, K. He, B. Hariharan, and S. Belongie.  Feature pyramid networks for object detection.  In _Proceedings of the IEEE conference on computer vision and pattern recognition_ , pages 2117–2125, 2017a.
  * Lin et al. (2017b) T.-Y. Lin, P. Goyal, R. Girshick, K. He, and P. Dollár.  Focal loss for dense object detection.  In _Proceedings of the IEEE international conference on computer vision_ , pages 2980–2988, 2017b.
  * Liu et al. (2016) W. Liu, D. Anguelov, D. Erhan, C. Szegedy, S. Reed, C.-Y. Fu, and A. C. Berg.  Ssd: Single shot multibox detector.  In _European conference on computer vision_ , pages 21–37. Springer, 2016.
  * Liu et al. (2020) Z. Liu, X. Zhao, T. Huang, R. Hu, Y. Zhou, and X. Bai.  Tanet: Robust 3d object detection from point clouds with triple attention.  In _Proceedings of the AAAI Conference on Artificial Intelligence_ , volume 34, pages 11677–11684, 2020.
  * Ma et al. (2021) X. Ma, Y. Zhang, D. Xu, D. Zhou, S. Yi, H. Li, and W. Ouyang.  Delving into localization errors for monocular 3d object detection.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 4721–4730, 2021.
  * Peng et al. (2021) L. Peng, F. Liu, Z. Yu, S. Yan, D. Deng, and D. Cai.  Lidar point cloud guided monocular 3d object detection.  _arXiv preprint arXiv:2104.09035_ , 2021.
  * Qi et al. (2017) C. R. Qi, H. Su, K. Mo, and L. J. Guibas.  Pointnet: Deep learning on point sets for 3d classification and segmentation.  In _Proceedings of the IEEE conference on computer vision and pattern recognition_ , pages 652–660, 2017.
  * Qi et al. (2018) C. R. Qi, W. Liu, C. Wu, H. Su, and L. J. Guibas.  Frustum pointnets for 3d object detection from rgb-d data.  In _Proceedings of the IEEE conference on computer vision and pattern recognition_ , pages 918–927, 2018.
  * Qi et al. (2019) C. R. Qi, O. Litany, K. He, and L. J. Guibas.  Deep hough voting for 3d object detection in point clouds.  In _Proceedings of the IEEE International Conference on Computer Vision_ , pages 9277–9286, 2019.
  * Qi et al. (2020) C. R. Qi, X. Chen, O. Litany, and L. J. Guibas.  Imvotenet: Boosting 3d object detection in point clouds with image votes.  In _Proceedings of the IEEE/CVF conference on computer vision and pattern recognition_ , pages 4404–4413, 2020.
  * Qian et al. (2020) R. Qian, D. Garg, Y. Wang, Y. You, S. Belongie, B. Hariharan, M. Campbell, K. Q. Weinberger, and W.-L. Chao.  End-to-end pseudo-lidar for image-based 3d object detection.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 5881–5890, 2020.
  * Qin et al. (2021) Z. Qin, J. Wang, and Y. Lu.  Monogrnet: A general framework for monocular 3d object detection.  _IEEE Transactions on Pattern Analysis and Machine Intelligence_ , 2021.
  * Redmon et al. (2016) J. Redmon, S. Divvala, R. Girshick, and A. Farhadi.  You only look once: Unified, real-time object detection.  In _Proceedings of the IEEE conference on computer vision and pattern recognition_ , pages 779–788, 2016.
  * Ren et al. (2015) S. Ren, K. He, R. Girshick, and J. Sun.  Faster r-cnn: Towards real-time object detection with region proposal networks.  In _Advances in neural information processing systems_ , pages 91–99, 2015.
  * Sagar (2021) A. Sagar.  Dmsanet: Dual multi scale attention network.  _arXiv preprint arXiv:2106.08382_ , 2021.
  * Sagar and Soundrapandiyan (2020) A. Sagar and R. Soundrapandiyan.  Semantic segmentation with multi scale spatial attention for self driving cars.  _arXiv preprint arXiv:2007.12685_ , 2020.
  * Shi et al. (2019) S. Shi, X. Wang, and H. Li.  Pointrcnn: 3d object proposal generation and detection from point cloud.  In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition_ , pages 770–779, 2019.
  * Shi et al. (2020a) S. Shi, C. Guo, L. Jiang, Z. Wang, J. Shi, X. Wang, and H. Li.  Pv-rcnn: Point-voxel feature set abstraction for 3d object detection.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 10529–10538, 2020a.
  * Shi et al. (2020b) S. Shi, Z. Wang, J. Shi, X. Wang, and H. Li.  From points to parts: 3d object detection from point cloud with part-aware and part-aggregation network.  _IEEE transactions on pattern analysis and machine intelligence_ , 2020b.
  * Vora et al. (2020) S. Vora, A. H. Lang, B. Helou, and O. Beijbom.  Pointpainting: Sequential fusion for 3d object detection.  In _Proceedings of the IEEE/CVF conference on computer vision and pattern recognition_ , pages 4604–4612, 2020.
  * Xie et al. (2020) Q. Xie, Y.-K. Lai, J. Wu, Z. Wang, Y. Zhang, K. Xu, and J. Wang.  Mlcvnet: Multi-level context votenet for 3d object detection.  In _Proceedings of the IEEE/CVF conference on computer vision and pattern recognition_ , pages 10447–10456, 2020.
  * Yang et al. (2018) B. Yang, W. Luo, and R. Urtasun.  Pixor: Real-time 3d object detection from point clouds.  In _Proceedings of the IEEE conference on Computer Vision and Pattern Recognition_ , pages 7652–7660, 2018.
  * Ye et al. (2020) M. Ye, S. Xu, and T. Cao.  Hvnet: Hybrid voxel network for lidar based 3d object detection.  In _Proceedings of the IEEE/CVF conference on computer vision and pattern recognition_ , pages 1631–1640, 2020.
  * Yin et al. (2021) T. Yin, X. Zhou, and P. Krahenbuhl.  Center-based 3d object detection and tracking.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 11784–11793, 2021.
  * Zhang et al. (2021) Y. Zhang, J. Lu, and J. Zhou.  Objects are different: Flexible monocular 3d object detection.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 3289–3298, 2021.
  * Zhou and Tuzel (2018) Y. Zhou and O. Tuzel.  Voxelnet: End-to-end learning for point cloud based 3d object detection.  In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition_ , pages 4490–4499, 2018.
  * Zhou et al. (2020) Y. Zhou, P. Sun, Y. Zhang, D. Anguelov, J. Gao, T. Ouyang, J. Guo, J. Ngiam, and V. Vasudevan.  End-to-end multi-view fusion for 3d object detection in lidar point clouds.  In _Conference on Robot Learning_ , pages 923–932. PMLR, 2020.


Neuro-Symbolic VQA: A review from the perspective of AGI desiderata
Ian Berlot-Attwell

An ultimate goal of the AI and ML fields is artificial general intelligence
(AGI); although such systems remain science fiction, various models exhibit
aspects of AGI. In this work, we look at neuro-symbolic (NS) approaches to
visual question answering (VQA) from the perspective of AGI desiderata. We see
how well these systems meet these desiderata, and how the desiderata often
pull the scientist in opposing directions. It is my hope that through this
work we can temper model evaluation on benchmarks with a discussion of the
properties of these systems and their potential for future extension.

## 1 Introduction

VQA is the task of answering a natural language question about a given image.
NS approaches combine neural networks with a symbolic component (e.g.,
symbolic reasoning, symbolic representations, or exploiting pre-existing
symbolic knowledge). NS approaches to VQA are of particular interest as they
may promote compositional generalization [31, 4, 10] (i.e., the ability to
understand new combinations of previously acquired concepts; for instance,
Buzz Aldrin wielded a glass hammer). NS approaches also promise to be more
interpretable [19, 23], and may allow for simpler skill transfer between
tasks.

Of the AGI desiderata identified by Bieger et al. [17], we discuss: natural
growth (the ability to continue learning without human re-design),
traceability (the ability to give step-by-step explanations of decisions, even
if step execution cannot be explained), transfer-learning (the ability to
exploit previous knowledge when learning new knowledge), few-shot learning,
and self-awareness of limitations. For few-shot learning, we mostly consider
compositional generalization (the ability to understand previously learned
concepts in new combinations). These desiderata were chosen as they can be
found in neuro-symbolic VQA models. As these desiderata are meaningless if we
do not take practical considerations into account, we also discuss
performance, scalability, and training data when they become particularly
relevant.

In this work: Attribute refers to properties of an object (e.g., colour, or
shape), Concept refers to possible values of an Attribute (e.g., red, or
circle), and Relations are possible relations between two or more objects
(e.g., besides, under, or is wearing). A Domain Specific Language (DSL) is a
symbolic language that can be used to represent any question in the domain.
For instance, the DSL {sphere, cube, left_of($\cdot,\cdot$)} can represent Is
there a cube left of a sphere? as left_of(cube, sphere). We call the
representation of a question in a given DSL, the Program.

Some frequently used datasets are: the VQA 1.0 dataset [5] of natural images
with human-created questions (see Fig 4), the synthetic SHAPES dataset [4] of
shapes on a $3\times 3$ grid with compositional questions (see Fig 2, 5), the
CLEVR dataset [14] which is similar to SHAPES but using 3D figures (see Fig
6), and the GQA dataset [27] of natural images with synthetic compositional
questions (see Fig 7). A variant of CLEVR, CLEVR-CoGenT [14], is also used to
test compositional generalization; in this dataset, cubes and cylinders are
different colours and swap colour palettes between train and test time.

## 2 Module Networks

In the module network approach, the model learns a set of small networks
(i.e., modules) and assembles them based on the question [4]. The modules are
described by a DSL, which specifies the arity and input/output types of the
modules that the network has.

### 2.1 NMN Architecture

The Neural Module Network (NMN) [4] was the first module network for VQA. The
NMN DSL lists 5 modules types (e.g., attend), each with distinct architectures
(see Fig 1). Most modules create or modify heatmaps of the image. Each module
type has a unique instance per specific task. The sample execution in Fig 2
shows two such instances: attend[circle] and attend[red]. To produce the
program, the NMN lemmatizes the question, applies the Stanford dependency
parser [2], and applies fixed rules.

Figure 1: Graphic describing four of the five module types used by the NMN.
Not shown is the measure module, which, given an attention map, returns a
measurement (e.g., measure[exists], or measure[count]). Modified from Andreas
et al. [4] Figure 2: Visualization of NMN execution on a SHAPES problem. The
question is “Is there a red shape above a circle?”, and the corresponding
program is measure[is](combine[and](attend[red], re-
attend[above](attend[circle]))). Figure from Andreas et al. [4]

To overcome the limitations of the program generator and to incorporate a
linguistic prior into the responses, the architecture above is ensembled with
a blind LSTM model (i.e., predicts the answer based on the question alone).
Specifically, the weighted geometric mean of the distributions is calculated;
weights are determined by the text and image features. The system is trained
end-to-end [4].

### 2.2 NMN: Strengths & Weaknesses

The natural growth of this architecture is critically limited by the immutable
rules-based parser. The authors note that the parser has problems; it
aggressively simplifies the question (e.g., replacing plural nouns with
singular nouns), and it introduces spurious predicates in roughly 10-20% of
VQA 1.0 questions (e.g., parsing are these people most likely experiencing a
work day? as be(people, likely)). However, they perform no tests with ground-
truth programs, even though SHAPES has ground-truth programs.

In principle, the traceability is good as the program is a trace, but there
are caveats (see Section 2.6). Transfer learning to another task by re-using
modules is promising but untested. As each concept has its own independent
module weights, the model cannot internally transfer acquired knowledge (e.g.,
learning find[wolf] using find[dog]), or exploit prior linguistic knowledge
(e.g., via GloVe [3] or BERT [26] embeddings).

The NMN exhibits compositional generalization through new combinations of the
learned modules. Andreas et al. [4] tested the model’s ability with the SHAPES
dataset. However, although SHAPES tests complex compositional questions, all
shapes are of the same size and aligned on a $3\times 3$ grid (see Fig 5).
This compensates for one of NMN’s flaws, that reasoning steps, such as look at
the shape to the left, are executed by a fixed re-attend[left] module without
access to the input question or image, only the previous modules’ outputs.
Using a fixed grid simplifies this, e.g., attend[above] need not concern
itself with objects that are above and of a different size, or occluded. The
authors demonstrate that the model can generalize to SHAPES questions who’s
programs are one more module longer than seen at train time, but do not try
combinations of subtasks that are new at test time (we discuss further in
Section 2.5).

The NMN [4] has no limitation awareness; in fact, a common failure mode was to
return a plausible response that is disconnected from the image. Although the
NMN has no explicit confidence in its response, it indicates relative
confidence between the module network and LSTM via the weights used in the
ensemble. The model achieved SOTA performance on VQA 1.0 at the time of
publication ($55.1\%$ accuracy). Although we now know that the dataset suffers
from strong language priors [9, 11], these priors were addressed through a
blind baseline.

### 2.3 N2NMN: Improving the NMN

The End-to-End Module Network (N2NMN) [13] followed the NMN. Primarily, it
removed the blind model and produced programs (in reverse Polish notation)
with a seq2seq encoder-decoder LSTM architecture. Additionally, each module
type (e.g., attend) has exactly one instance and is provided a text-context
vector, $x_{txt}$, (an attention over input tokens), and image features,
$x_{vis}$, (extracted by VGG-16 [6]). The modules and their architectures are
in Fig 3, and Fig 10 illustrates model execution.

Figure 3: Table 1 of Hu et al. [13] describing the N2NMN’s modules, and their
implementations.

Evaluation of the N2NMN on VQA 1.0 and SHAPES demonstrates increased
performance over NMN. However, end-to-end training of the program generator
through the modules via backpropagation is impossible. Executing the N2NMN
requires arranging the modules; thus we must sample a discrete program from
the program parser, and we cannot backpropagate through the sampling
operation. REINFORCE can be used but causes a drop in performance ($4\%$ on
SHAPES and $14\%$ on CLEVR). Instead, the N2NMN is trained in two stages:
initially the generator is encouraged to mimic a provided expert parser,
afterwards it is fine-tuned with REINFORCE. Thus training requires an expert
parser to mimic.

### 2.4 N2NMN: Strengths & Weaknesses

As the N2NMN’s [13] parser is trained on examples instead of being rule-based,
the N2NMN improves on the natural growth of the NMN. However, the N2NMN
modules are still low-capacity, with architectures designed for the modules’
intended role – some modules such as and and or have no learnable parameters
(see Fig 3). Unless we violate compositionality by using multiple modules to
implement a single operation, then each operation’s capacity is severely
limited.

The $x_{txt}$ vector passed to each module improves within-task transfer
learning, as each operation has a single module. Thus, for example, the find
module can learn to find wolves based on its knowledge of dogs. However,
$x_{txt}$ complicates transfer learning to a different task; we require a
mechanism to provide $x_{txt}$. $x_{txt}$ also reduces traceability, as the
program is coarser, and the user must interpret the attention defining
$x_{txt}$ to guess what each module does. Furthermore, Subramanian et al. [33]
suggest that using $x_{txt}$ may damage compositional generalization and
traceability, as it can leak information, causing hybrid operations. For
instance, red objects left of the cube may correspond to
filter[red](relate[left](find[cube])). However, through $x_{txt}$,
relate[left] may learn to find objects that are to the left and red. This
damages compositionality (as relate will not behave as it should), and
traceability (as the name relate becomes misleading if relate also does
filtering); possible solutions, such as supervising intermediary modules
outputs, are discussed in Section 2.6.

The compositionality is tested by evaluation on CLEVR and SHAPES, however the
authors do not test scenarios where the question distribution varies between
train and test time. Other minor methodological flaws are that Hu et al. [13]
omitted the performance when training without program supervision on VQA 1.0,
and they augmented CLEVR image features with two channels for position data,
without an ablation test. Like the NMN, the N2NMN has no limitation awareness.

### 2.5 Compositional Generalization and Few-Shot Learning in Module Networks

Underpinning module networks is the idea that we can solve new combinations of
concepts with new combinations of modules. We can test this assertion through
CLOSURE [24], a dataset for testing the compositional generalization of models
trained on CLEVR. Where CLEVR’s test questions are generated from one of 90
templates seen at train time [14], CLOSURE is generated from five new
templates created by replacing spatial comparisons with attribute comparisons.

The authors used CLOSURE to test the compositional generalization of various
SOTA models, and the effectiveness of few-shot learning. Critically, the NMN-
type model tested (dubbed Tensor-NMN [15]) failed to generalize, even with
ground-truth programs. The Tensor-NMN architecture’s modules take and return
tensors of fixed dimensions; all modules are residual blocks of two $3\times
3$ convolutions, with higher arity modules first merging input channels with
$1\times 1$ convolution. A program parser similar to the N2NMN’s is used. The
Tensor-NMN DSL is similar to NMN’s, with multiple types that have different
instantiations (e.g., filter_colour[blue], filter_colour[red], etc…). This
demonstrates that the N2NMN parser is problematic, and that the N2NMN and NMN
modules may not function as intended when rearranged.

The authors speculated that reducing the dimensionality of the intermediary
features would improve generalization. They thus developed Vector-NMN, which
only passes vectors between modules. Vector-NMN uses the same program parser
as Tensor-NMN and a different module architecture. All modules are two
consecutive FiLM [20] blocks applied to ResNet101 features of the input image,
followed by max-pooling to reduce them to a vector. The FiLM blocks contain
convolutional filters shared among all modules, which are modulated with
additive and multiplicative weights produced by a MLP. This MLP processes the
vector outputs of any previous modules along with a learned module-embedding
representing the module’s role. Bahdanau et al.[24] found that Vector-NMN had
near perfect generalization to CLOSURE when given the ground-truth programs,
with the exception of one family of questions. Here, Vector-NMN still
outperformed Tensor-NMN. However, we cannot conclude that dimensionality alone
determines generalization; the authors overlook key differences between the
models. Notably: Vector-NMN uses weight sharing, is architecturally more
similar to FiLM than Tensor-NMN, and its modules get image features as an
argument. Comparison with other models using lower dimensional intermediary
values such as TbD [19] (mostly matrices) and Visual-NMN [33] (vectors) would
help with the confounding variables.

Although self-evident, the largest limitation of CLOSURE is that it is a
necessary, but insufficient, condition for compositional generalization on
CLEVR. For instance, all CLOSURE questions contain the same number of
referring expressions as some CLEVR question. Consequently, CLOSURE only tests
compositional generalization on questions that are at most as complex as CLEVR
questions.

The authors also test few-shot learning by training Vector-NMN on 36 questions
from each CLOSURE template without program annotations. The findings were that
in six of the seven families the model performed well after training,
demonstrating that the seq2seq LSTM program-parser can exhibit few-shot
learning using REINFORCE only. However, fine-tuning failed on the seventh
family; the authors concluded that it was because REINFORCE was not sampling
good programs. This suggests that there may be scalability issues as more
complex DSLs are used.

### 2.6 Fidelity in Module Networks

Failure to generalize with ground truth programs calls into question the
faithfulness of modules’ behaviour to the program DSL, and thus the
traceability. Liu et al. [29] found that Tensor-NMN modified for image
segmentation exhibited good fidelity, and that the shared tensor output
dimensions of all modules facilitated transfer-learning (see Fig 11).
Specifically, they could apply the last module, which produces the output
segmentation heatmap, to any intermediate module, thus producing an
intermediate image segmentation. The modules’ fidelity was not perfect; one
module ultimately functioned as a preprocessing step instead of the desired
behaviour. Similarly, Subramanian et al. [33] found poor fidelity in a module
network using probabilistic sets as intermediary values. They found that
restricting module architectures or supervising module outputs improved
fidelity; this creates a tradeoff between improving traceability through
fidelity, and reducing natural growth due to lower capacity modules, or
training requiring additional annotations.

## 3 Addressing the Problems of Discrete Programs

### 3.1 Reducing model capacity

The Neuro-Symbolic Concept Learner (NS-CL) resolves the module composition and
fidelity issues by using fixed implementations for most elements of the DSL
(see Fig 9). This ensures perfect traceability, and some limitation awareness
to the model; ambiguous or invalid questions cause the execution engine to
throw an error. However, this comes at the cost natural growth; the DSL’s
execution is fixed.

Instead of processing attention maps, the NS-CL [30] identifies objects with a
pre-trained Mask R-CNN [12] and processes probabilistic sets of objects. Each
object has a vector representation of ResNet-34 features. The execution
engine’s learned components are: i) networks for projecting an object’s
feature vector into an attribute space, and ii) a vector in said attribute
space for each concept specified by the user (see Fig 8). This structured
representation allows for some transfer learning to other tasks. The authors
demonstrated this by freezing the attribute embedding networks and using them
with a different DSL for CLEVR image retrieval.

The parser architecture is also changed, and a rule-based preprocessing step
is added. Concepts & attributes in the question are replaced with
placeholders, thus allowing new attributes to be recognized by updating the
list of attributes. This combined with the disentangled attribute
representations facilitates few-shot learning; Mao et al. [30] show that when
learning a new colour from $100$ example images, the NS-CL has a test accuracy
of 93.9%, outperforming TbD [19] and Tensor-NMN by $6.1\%$ and $4.6\%$
respectively. Furthermore, if attribute detection could be automated, then
this would facilitate natural growth to learn new attributes and concepts. The
authors do not report a seq2seq baseline.

Like module networks, the design promises compositional generalization. The
authors test on CLEVR and CLEVR-CoGenT, demonstrating the NS-CL is capable of
answering compositional questions and exhibits compositional generalization
under a change of attribute combinations. The authors claim that NS-CL can
generalize to new questions, and support this by training and testing on a
split of CLEVR based on program depth. This implicitly splits by CLEVR
question template, and is thus similar to CLOSURE.

On a practical note, the additional structure improves performance on CLEVR
compared to the SOTA module network approaches such as TbD [19]. Furthermore,
the NS-CL does not require program annotations at train time and is more data-
efficient than TbD. Curriculum learning is used to train the model, and an
ablation demonstrated that removing curriculum learning resulted in either
non-convergent training, or performance on-par with random guessing [30]. The
first stage of training consists of short questions about attributes, the
second stage adds short relational questions, and the third stage adds all
remaining questions. During the first two stages, REINFORCE is used to train
the program parser. In stage three, the exact REINFORCE gradient is calculated
by finding $\mathbb{Q}$, the set of programs returning the correct response.
The attribute embedding networks and concept vectors are trained
simultaneously through backpropagation, although they are initially frozen in
stage 3. However, finding the true $\mathbb{Q}$ is intractable. After writing
to the authors, I determined that they restricted their search to programs
from templates extracted from ground-truth programs. This indicates that
scalability with DSL complexity is problematic, and the severity is unclear as
the authors do not report performance when using normal REINFORCE in stage 3.

### 3.2 Continuous Programs

Where the NS-CL addresses the issues arising from discrete programs with a
(mostly) fixed execution engine, the Neural State Machine (NSM) instead
resolves these issues by using continuous programs. Although it doesn’t use a
DSL, the NSM still incorporates prior knowledge in the form of the object-
types, concepts, attributes, and binary relationships that can occur in an
image. Specifically, NSM performs soft reasoning over a graph representation
of the image (see Fig 13). This design hurts traceability, as the reasoning
steps are now vectors. At best, the meaning of these reasoning instructions
can be guessed based on the attention over the question tokens that created
them.

To create this graph representation, the NSM requires: the set of object-
types, the attributes, a set of concepts for each attribute, and the set of
binary relationships. First, a node is created in the graph for each object
detected by a Mask R-CNN. This Mask R-CNN also produces distributions over
object type and attributes; this requires scene graphs at train time. Next,
for all objects that are sufficiently close in the image a directed edge is
created in each direction between the corresponding nodes. A graph attention
network [21] then produces a distribution over binary relationships for each
edge. Each distribution is summarized as a weighted average over learned
concept/object/relationship embeddings, initialized with GloVe. This graph is
the final representation of the image that the NSM reasons over. The NSM
redistributes attention over the nodes based on the reasoning instruction,
sometimes through edges.

This design severely limits the natural growth of the model compared to the
approaches seen thus far. Previously, another attribute or concept could be
added by the addition of a module (e.g., NMN), or the updating of a list
(e.g., NS-CL); for the NSM this requires changing the model’s architecture to
alter the arity of various networks. However, the discrete scene graph
representation does allow for the NSM to be cleanly divided into two
components that can be reused in other tasks, potentially allowing for
transfer learning, albeit in a manner that is coarser than module reuse in a
module network. The fixed edge creation heuristic is also problematic as the
model cannot reason about long-distance relationships (e.g., between a thrower
and catcher on a game field).

The flow of attention through the graph is controlled by reasoning
instructions that are generated from the question, somewhat analogous to the
N2NMN’s $x_{txt}$ vectors. The reasoning instructions are weighted averages of
vectors representing the input tokens of the question, and are produced by an
encoder-decoder model. However, where the N2NMN learns token embeddings, the
NSM represents each token as a weighted average between the GloVe embedding
and the learned object, concept, and relationship embeddings. Ablation
indicates that representing both the question and image as weighted averages
of the same embeddings improves performance. Furthermore, the NSM always
decodes a fixed number of reasoning instructions, thus allowing the parser to
be trained through backpropagation.

Starting from uniform attention over nodes, the NSM sequentially updates the
attention based on each reasoning instruction. The update is a linear
combination of two mechanisms; one assigns attention based on attributes and
object-type, the other shifts attention along edges based on binary relation.
Final classification is done by a 2-layer MLP given the encoded question (from
the encoder-decoder reasoning instruction parser), and a vector representation
of the graph. The graph representation is produced by first averaging each
node’s attribute vectors based on the last reasoning instruction, and then
averaging these vectors based on the final attention over nodes.

The authors demonstrate the NSM’s compositional generalization through splits
of GQA where object types are removed at train time and introduced at test
time. Note that object detector is trained on all objects. However, GQA
questions are generated from templates, and the authors do not have a CLOSURE-
like test for generalization to new question structures.

## 4 Achieving Desiderata via Regularization

The previous models incorporated prior symbolic knowledge directly into their
reasoning processes; an alternative approach is to instead leverage this
knowledge in model optimization. Xie et al. [32] defines a regularizer,
$\ell_{logic}$, that encodes propositional logic describing the domain (e.g.,
wear(person,hat) $\implies$ exists(person) $\wedge$ exists(hat)). Note that
unlike the previously discussed models, the authors tested on the related task
of visual relationship prediction (VRP): given an image, the bounding boxes of
two objects, and their respective object-type, VRP seeks the relationship
between the objects.

The regularizer uses a trained Logic Embedding Network with Semantic
Regularization (LENSR). To train a VRP model, $h$, the first step is to train
LENSR, $q$, on the given rules, and then freeze the LENSR weights. LENSR is a
modified graph convolutional network [16] that encodes propositional logic
formulas as a vector. To encourage the encoding of assignments to be closer to
formulas that they satisfy, LENSR is trained with a regularized triplet loss
(details in Appendix 6.4). $h$ is then trained with cross entropy loss
regularized with
$\mathopen{}\mathclose{{}\left\|{q(F)-q(\bigwedge_{i}p_{i})}}\right\|_{2}^{2}$.
$F$ is the formula of rules (in d-DNNF form) that apply to this batch of
training examples, and $p_{i}$ is the weighted average of the LENSR embeddings
of all possible solutions for the $i$th example in the batch, weighted by $h$
(see Fig 14).

LENSR demonstrates an approach for transfer learning by which pre-existing
symbolic knowledge guides training. Systems that automatically extract
symbolic knowledge from text, such as COMET [25], may thus allow natural
growth from unstructured data. However, there are limitations. LENSR encodes
propositions by summing the GloVe embeddings of their components (e.g.,
on(sphere, block) $\rightarrow$ block+on+sphere), thus loosing order
information. Furthermore, LENSR may not scale well as compiling the rules into
d-DNNF form is an NP-Hard task.

As to practical considerations, the authors demonstrated that the
regularization increases model performance on VRP when $h$ is a two-layer MLP,
and that their logic loss outperforms semantic loss [22]; they speculate this
due to the more complex constraints. They also compare with a TreeLSTM
encoder, however previous work using TreeLSTM for logical entailment was under
different conditions (see Appendix 6.5).

## 5 Discussion and Conclusions

In this work, we discuss how various neuro-symbolic VQA models meet a set of
AGI desiderata. We find that, in principle, module networks satisfy all the
desiderata except for limitation awareness. However, transfer to significantly
different tasks is untested, and traceability is closely tied to program
fidelity, as is compositionality. Yet, approaches that encourage program
fidelity, such as parameter-free modules, often harm natural growth – with the
extreme example being the NS-CL. Furthermore, CLOSURE indicates that encoder-
decoder program parsers do not exhibit compositional generalization to new
combinations of sub-tasks. The NSM avoids the program parser generalization
and program supervision problems and achieves the best GQA performance, but at
the cost concessions on traceability, transfer learning and natural growth.
LENSR suggests that the choice of training procedure may be able to encourage
AGI desiderata.

If we seek to overcome the limitations of module networks, then we may be able
to improve parser generalization through the training procedure. In addition
to NS-CL style curriculum learning, we may be able to apply techniques from
domain-generalization by framing families of questions from specific templates
as domains. A significant open question about a module network’s natural
growth is whether the DSL can be learned from data; it’s possible that a more
structured intermediary representation like the NSM may simplify this task –
although it may be a lateral move, placing the onus of growth on the scene
graph.

Overall, the existence of models exhibiting subsets of the desiderata,
combined with the nice interpretation of many of the desiderata in VQA
(compositionality as new combinations of old ideas, natural growth as adaption
to new questions and domains, traceability as the production of accurate
traces, transfer learning within-task as exploiting old knowledge to learn new
concepts, and out of task in the usual sense, and self awareness of
limitations as identifying invalid questions, or indicating confidence),
indicates that VQA may be a rich task for the purposes of developing models
that exhibit all of these desiderata. Such work will not bring us AGI, but can
provide a clearer image of the challenges that lie on the road there.

## 6 Appendix

### 6.1 Sample Questions from VQA Datasets

Figure 4: A sample image from the VQA 1.0 dataset [5]; the corresponding
questions include “What color are her eyes?” and “What is the mustache made
of?”  Figure 5: A sample image from the SHAPES dataset [4]; the corresponding
question is “is there a red shape above a circle?” Figure 6: A sample image
from the CLEVR dataset [4]; the corresponding questions include “Are there
fewer metallic objects that are on the left side of the large cube than
cylinders to the left of the cyan shiny block?” and “There is a green rubber
thing that is left of the rubber thing that is right of the rubber cylinder
behind the gray shiny block; what is its size?” Figure 7: A sample image from
the GQA dataset [27]; the corresponding questions include “Is there any fruit
to the left of the tray the cup is on top of?” and “Are there any cups to the
left of the tray on top of the table?”

### 6.2 DSLs

Figure 8: Illustration of the learned components of the NS-CL’s exector. The
only components of the executor that are learned are concept embeddings (e.g.,
the cube, sphere, and cylinder embeddings for the shape attribute), and MLP’s
that project object representations from the Mask R-CNN into the same
attribute space as the corresponding concepts (in this case, projecting object
representations into shape space). Figure from Mao et al. [30] Figure 9: Table
describing the NS-CL’s DSL and implementation. Note that $\tau_{c}=0.25$ and
$\gamma_{c}=0.5$ are hyperparameters. Note that given the set of all
attributes, $A$, then for every concept $oc$ (e.g., red), we must be given a
1-hot vector $b^{oc}\in\mathbb{R}^{|A|}$ indicating the attribute $a\in A$
that this concept belongs to. With this given constant, then for objects $i$
and $j$, and attribute $a$ (e.g., colour) with concept $oc$ then the
probability that object $i$ is $oc$ is estimated by
$\text{ObjClassify}(oc)_{i}=\sigma\mathopen{}\mathclose{{}\left(\sum_{a\in
A}\mathopen{}\mathclose{{}\left(b_{a}^{oc}\frac{\langle
u^{a}(o_{i}),v_{oc}\rangle-\gamma}{\tau}}\right)}\right)$ where $u^{a}$ is the
embedding MLP for the attribute $a$, $o_{i}$ is the feature vector for object
$i$, and $v_{oc}$ is the learned vector representation of the concept $oc$.
Similarly, the probability that $i$ and $j$ have the same attribute $a$ is
estimated by
$\text{AEClassify}(a)_{ij}=\sigma\mathopen{}\mathclose{{}\left(\frac{\langle
u^{a}(o_{i}),u^{a}(o_{j})\rangle-\gamma}{\tau}}\right)$. The probability that
objects $i$ and $j$ are related by the binary relationship $rc$ is estimated
by $RelClassify(rc)_{ij}=\sigma\mathopen{}\mathclose{{}\left(\frac{\langle
u^{r}(o_{i},o_{j}),v_{rc}\rangle-\gamma}{\tau}}\right)$ where $u^{r}$ is the
embedding MLP for all binary relationships, and $v_{rc}$ is the learned vector
representation of the binary relation $rc$. Note $\gamma$ and $\tau$ are again
hyperparameters. Table from Mao et al. [30]

### 6.3 Sample Execution

Figure 10: Illustration of N2NMN execution. Note that unlike the NMN which has
separate instantiations for attend[red] and attend[circle], the equivalent
module in N2NMN, find, has only one instantiation. find chooses what to search
for based on an $x_{txt}$ vector passed into the module; in this case
$x_{txt}$ is a weighted average of the input tokens with most of the weight on
“green matte ball”. Figure from Hu et al. [13] Figure 11: Figure illustrating
execution of Liu et al.’s [29] Tensor-NMN modified for image segmentation.
Note that not shown is a final module, postprocess, that creates the final
segmentation. Note also, that the segmentations shown are not the features
passed from module to module; Tensor-NMN’s pass tensors between modules. The
shown images are the results of passing these intermediary tensors into the
postprocess module. Note the high fidelity to what we would expect to see out
of the partial operations. Note also that the blue boxes are not arguments.
Like the NMN, the Tensor-NMN and it’s variants have a separate instantiation
of each module for each possible value in the blue boxes. Figure from Liu et
al. [29] Figure 12: Illustration of NS-CL execution and training. First the
Mask R-CNN identifies the objects in the image and produces object
representations. Independently the program parser converts the natural
language question into a program. This program and the object representations
are then passed into the deterministic program executor. The only learned
components of the executor are the concept embeddings, and attribute embedding
networks that project object representations into the same attribute space as
the concept embeddings corresponding to the attribute. Figure from Mao et al.
[30] Figure 13: Illustration of NSM execution. First, the question is
converted into a fixed number of continous reasoning instructions (in this
case $r_{0},r_{1},\dots r_{4}$), and the image is converted into a scene
graph. Next, a uniform attention is placed over the nodes, and sequentially
updated using the reasoning instructions. Updates are a linear combination of
an updated based on node similarity (e.g., finding the coffee machine when
executing $r_{0}$), and edge similarity (e.g., following the edge from the
coffee machine to the bowl when executing $r_{1}$). Figure from Hudson &
Manning [28] Figure 14: Illustration of the training of a VRP model $h$ using
the logic loss regularizer, $L_{logic}$, defined w.r.t. LENSR, $q$. The logic
loss regularizer is the squared Euclidean distance between $q(\mathcal{G})$
(the LENSR encoding of the logical formula describing the domain), and
$q(h(x))$ (the average over the LENSR encodings of all possible solutions,
weighted by the model undergoing training, $h$). At this point LENSR is
frozen, and has already been trained to reduce the distance between the
encodings of formulas and their satisfying assignments. Figure from Xie et al.
[32]

### 6.4 LENSR Details

The LENSR logic loss is dependent on encoding prepositional logic expressions
as vectors [32]. The first step is to convert the expression into d-DNNF form.
This form is attractive as it allows for clausal entailment, model counting,
model enumeration, model minimization based on cardinality, and probabilistic
equivalence testing to be solvable in time polynomial with the size of the
d-DNNF formula [1]. Note that as a consequence, conversion from CNF to d-DNNF
is NP-Hard [1]. d-DNNF form is both deterministic (the arguments of any
disjunction, $\vee$, are mutually inconsistent) and decomposable (the
arguments of any conjunction, $\wedge$, are over disjoint sets of variables)
[1].

Once the formula is in d-DNNF form, it is encoded into a vector by LENSR.
LENSR is a modified graph convolutional network (GCN) [16]. Before processing
by LENSR, the d-DNNF formula is converted into a non-binary expression tree
(see $\mathcal{G}$ in Fig 14), the edges are made undirected, and a “global”
node is created that connects to all other nodes. This graph is then processed
by the LENSR, and the final LENSR embedding of the global node is used as the
final embedding of the formula.

Where a standard GCN shares the same weight matrix across all nodes, LENSR is
modified to use heterogeneous node embedding. In other words, there is a
distinct weight matrix used for $\vee$ nodes, $\wedge$ nodes, leaf nodes, and
the global node. To train LENSR, the loss function
$\sum_{F}\sum_{\tau_{f},\tau_{t}}\ell_{t}(F,\tau_{f},\tau_{t})+\lambda\ell_{r}(F)$
is used, where $\lambda$ is a hyperparameter, $F$ is a d-DNNF formula in the
training data, $\tau_{f}$ is a non-satisfying assignment (expressed as the
conjunction of literals for all variables in $F$) and $\tau_{t}$ is a
satisfying assignment. For example, we could have $F=(A\wedge B)\vee(\neg
A\wedge\neg B)$, $\tau_{t}=A\wedge B$, and $\tau_{f}=A\wedge\neg B$. The term
$\ell_{t}$ is a triplet loss encouraging satisfying assignments to be closer
to the formula than non-satisfying assignments. Specifically,
$\ell_{t}=\max\\{\mathopen{}\mathclose{{}\left\|{q(F)-q(\tau_{t})}}\right\|_{2}^{2}-\mathopen{}\mathclose{{}\left\|{q(F)-q(\tau_{f})}}\right\|_{2}^{2}+m,0\\}$
where the margin, $m$, is a hyperparameter, and $q$ is the LENSR network. The
other term ($\ell_{r}$) is the semantic regularization component, which
encourages properties in the latent space analogous to properties of the
d-DNNF. At a high-level, the embeddings of the children of an $\vee$ node
should add to $\mathbf{1}$ (as an analogue to mutual exclusivity), and the
embeddings of the children of an $\wedge$ node should be orthogonal (as an
analogue to operating on disjoint sets of variables). Specifically,
$\ell_{r}=\sum_{v_{i}\in\mathcal{N}_{O}}\mathopen{}\mathclose{{}\left\|{\mathbf{1}-\sum_{v_{j}\in\mathcal{C}_{i}}q(v_{j})}}\right\|_{2}^{2}+\sum_{v_{k}\in\mathcal{N}_{A}}\mathopen{}\mathclose{{}\left\|{V_{k}^{T}V_{k}-\text{diag}(V_{k}^{T}V_{k})}}\right\|_{2}^{2}$,
where $\mathcal{N}_{O}$ is the set of $\vee$ nodes, $\mathcal{N}_{A}$ is the
set of $\wedge$ nodes, $\mathcal{C}_{i}$ is the set of children nodes of
$v_{i}$ in the directed expression tree, and $V_{k}:=[q(v_{1}),\dots
q(v_{l_{k}})]$ s.t. $v_{i}\in\mathcal{C}_{k}$ and $l_{k}=|\mathcal{C}_{k}|$, .

Note that the graph convolutional network requires initial embeddings for all
nodes. Non-leaf nodes are given an initial embedding based on their type
($\vee$, $\wedge$, or global), which is shared among all nodes of the same
type. The initial embeddings for leaf-nodes are created by taking the sum of
the GloVe embeddings of the words comprising the proposition. For example, the
proposition wear(person,glasses) is represented as the sum of the GloVe
embeddings for wear, person, and glasses.

### 6.5 LENSR Methodological Flaw

Xie et al. [32] test their model on the VRD dataset [8], and compare against
TreeLSTM [7] encoding. They state that TreeLSTM [7] is state-of-the-art.
However, to the best of my knowledge, TreeLSTM has never been used on VRD
before. Furthermore, the paper they cite concerns encoding natural language
rather than logic. Reviewing the references, I found a paper (not cited within
the body) demonstrating that for the task of logical entailment, TreeLSTM was
the best performing encoding-type model [18]. From this, I assume that authors
intended to convey that TreeLSTM was SOTA for determining entailment using
embeddings. However, Evans et al. [18] used a modified variant of TreeLSTM
where parameters at each node are determined by the corresponding logical
operators, and it is unclear whether Xie et al. [32] used the modified or
unmodified TreeLSTM. Furthermore, the cited paper used a MLP to determine
entailment based on the encodings, as opposed to squared euclidean distance
used with the LENSR embeddings. It is unclear how the LENSR authors used the
TreeLSTM embeddings, which may make their comparison unfair.

## References

  * [1] Adnan Darwiche  “New Advances in Compiling CNF to Decomposable Negation Normal Form”  In _IN ECAI_ , 2004, pp. 328–332
  * [2] Marie-Catherine Marneffe and Christopher D. Manning  “The Stanford Typed Dependencies Representation”  In _Coling 2008: Proceedings of the Workshop on Cross-Framework and Cross-Domain Parser Evaluation_ , CrossParser ’08  Manchester, United Kingdom: Association for Computational Linguistics, 2008, pp. 1–8  URL: https://dl.acm.org/doi/10.5555/1608858.1608859
  * [3] Jeffrey Pennington, Richard Socher and Christopher D. Manning  “GloVe: Global Vectors for Word Representation”  In _Empirical Methods in Natural Language Processing (EMNLP)_ , 2014, pp. 1532–1543  URL: http://www.aclweb.org/anthology/D14-1162
  * [4] Jacob Andreas, Marcus Rohrbach, Trevor Darrell and Dan Klein  “Neural Module Networks”, 2015  arXiv:1511.02799 [cs.CV]
  * [5] Stanislaw Antol et al.  “VQA: Visual Question Answering”  In _International Conference on Computer Vision (ICCV)_ , 2015
  * [6] Karen Simonyan and Andrew Zisserman  “Very Deep Convolutional Networks for Large-Scale Image Recognition”  In _3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings_ , 2015  URL: http://arxiv.org/abs/1409.1556
  * [7] Kai Sheng Tai, Richard Socher and Christopher D. Manning  “Improved Semantic Representations From Tree-Structured Long Short-Term Memory Networks”  In _Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 1: Long Papers)_ Beijing, China: Association for Computational Linguistics, 2015, pp. 1556–1566  DOI: 10.3115/v1/P15-1150
  * [8] Cewu Lu, Ranjay Krishna, Michael Bernstein and Li Fei-Fei  “Visual Relationship Detection with Language Priors”  In _European Conference on Computer Vision_ , 2016  URL: https://cs.stanford.edu/people/ranjaykrishna/vrd/
  * [9] Peng Zhang et al.  “Yin and Yang: Balancing and Answering Binary Visual Questions”  In _Conference on Computer Vision and Pattern Recognition (CVPR)_ , 2016
  * [10] Tarek R. Besold et al.  “Neural-Symbolic Learning and Reasoning: A Survey and Interpretation”  In _CoRR_ abs/1711.03902, 2017  arXiv: http://arxiv.org/abs/1711.03902
  * [11] Yash Goyal et al.  “Making the V in VQA Matter: Elevating the Role of Image Understanding in Visual Question Answering”  In _Conference on Computer Vision and Pattern Recognition (CVPR)_ , 2017
  * [12] K. He, G. Gkioxari, P. Dollár and R. Girshick  “Mask R-CNN”  In _2017 IEEE International Conference on Computer Vision (ICCV)_ , 2017, pp. 2980–2988
  * [13] Ronghang Hu et al.  “Learning to Reason: End-To-End Module Networks for Visual Question Answering”  In _Proceedings of the IEEE International Conference on Computer Vision (ICCV)_ , 2017
  * [14] Justin Johnson et al.  “CLEVR: A Diagnostic Dataset for Compositional Language and Elementary Visual Reasoning”  In _CVPR_ , 2017
  * [15] Justin Johnson et al.  “Inferring and Executing Programs for Visual Reasoning”  In _ICCV_ , 2017
  * [16] Thomas N. Kipf and Max Welling  “Semi-Supervised Classification with Graph Convolutional Networks”  In _5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings_ OpenReview.net, 2017  URL: https://openreview.net/forum?id=SJU4ayYgl
  * [17] Jordi Bieger and Kristinn Thórisson  “Requirements for General Intelligence: A Case Study in Trustworthy Cumulative Learning for Air Traffic Control”  In _Proceedings of the 1st International FAIM Workshop on Architectures and Evaluation for Generality, Autonomy & Progress in AI (AEGAP 2018)_, 2018
  * [18] Richard Evans et al.  “Can Neural Networks Understand Logical Entailment?”  In _International Conference on Learning Representations_ , 2018  URL: https://openreview.net/forum?id=SkZxCk-0Z
  * [19] David Mascharka, Philip Tran, Ryan Soklaski and Arjun Majumdar  “Transparency by Design: Closing the Gap Between Performance and Interpretability in Visual Reasoning”  In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)_ , 2018  URL: https://openaccess.thecvf.com/content_cvpr_2018/html/Mascharka_Transparency_by_Design_CVPR_2018_paper.html
  * [20] Ethan Perez et al.  “FiLM: Visual Reasoning with a General Conditioning Layer”  In _AAAI_ , 2018
  * [21] Petar Veličković et al.  “Graph Attention Networks”  In _International Conference on Learning Representations_ , 2018  URL: https://openreview.net/forum?id=rJXMpikCZ
  * [22] Jingyi Xu et al.  “A Semantic Loss Function for Deep Learning with Symbolic Knowledge”  In _Proceedings of the 35th International Conference on Machine Learning_ 80, Proceedings of Machine Learning Research  Stockholmsmassan, Stockholm Sweden: PMLR, 2018, pp. 5502–5511  URL: http://proceedings.mlr.press/v80/xu18h.html
  * [23] Kexin Yi et al.  “Neural-Symbolic VQA: Disentangling Reasoning from Vision and Language Understanding”  In _Advances in Neural Information Processing Systems (NIPS)_ , 2018
  * [24] Dzmitry Bahdanau et al.  “CLOSURE: Assessing Systematic Generalization of CLEVR Models”, 2019  arXiv:1912.05783 [cs.AI]
  * [25] Antoine Bosselut et al.  “COMET: Commonsense Transformers for Automatic Knowledge Graph Construction”  In _Proceedings of the 57th Conference of the Association for Computational Linguistics, ACL 2019, Florence, Italy, July 28- August 2, 2019, Volume 1: Long Papers_ Association for Computational Linguistics, 2019, pp. 4762–4779  DOI: 10.18653/v1/p19-1470
  * [26] Jacob Devlin, Ming-Wei Chang, Kenton Lee and Kristina Toutanova  “BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding”  In _Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers)_ Minneapolis, Minnesota: Association for Computational Linguistics, 2019, pp. 4171–4186  DOI: 10.18653/v1/N19-1423
  * [27] Drew A Hudson and Christopher D Manning  “GQA: A New Dataset for Real-World Visual Reasoning and Compositional Question Answering”  In _Conference on Computer Vision and Pattern Recognition (CVPR)_ , 2019
  * [28] Drew Hudson and Christopher D Manning  “Learning by Abstraction: The Neural State Machine”  In _Advances in Neural Information Processing Systems 32_ Curran Associates, Inc., 2019, pp. 5903–5916  URL: http://papers.nips.cc/paper/8825-learning-by-abstraction-the-neural-state-machine.pdf
  * [29] Runtao Liu, Chenxi Liu, Yutong Bai and Alan L. Yuille  “CLEVR-Ref+: Diagnosing Visual Reasoning With Referring Expressions”  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)_ , 2019
  * [30] Jiayuan Mao et al.  “The Neuro-Symbolic Concept Learner: Interpreting Scenes, Words, and Sentences From Natural Supervision”  In _International Conference on Learning Representations_ , 2019  URL: https://openreview.net/forum?id=rJgMlhRctm
  * [31] Ramakrishna Vedantam et al.  “Probabilistic Neural Symbolic Models for Interpretable Visual Question Answering”  In _Proceedings of the 36th International Conference on Machine Learning_ 97, Proceedings of Machine Learning Research  PMLR, 2019, pp. 6428–6437  URL: http://proceedings.mlr.press/v97/vedantam19a.html
  * [32] Yaqi Xie et al.  “Embedding Symbolic Knowledge into Deep Networks”  In _Advances in Neural Information Processing Systems 32_ Curran Associates, Inc., 2019, pp. 4233–4243  URL: http://papers.nips.cc/paper/8676-embedding-symbolic-knowledge-into-deep-networks.pdf
  * [33] Sanjay Subramanian et al.  “Obtaining Faithful Interpretations from Compositional Neural Networks” Preprint of work accepted for publication at ACL 2020 https://acl2020.org/program/accepted/, 2020  arXiv:2005.00724 [cs.CL]