Structure Learning for Neural Module Networks

TL;DR

This paper introduces a method to learn the internal structure of neural modules and their sequencing in neural module networks, enabling automatic discovery of reasoning structures without extra supervision, achieving performance comparable to hand-designed modules.

Contribution

It presents a novel approach to learn both internal module structure and sequencing in neural module networks without additional supervision.

Findings

Achieves performance comparable to hand-designed modules.

Successfully learns internal structure and sequencing simultaneously.

No extra supervisory signals needed for module execution order.

Abstract

Neural Module Networks, originally proposed for the task of visual question answering, are a class of neural network architectures that involve human-specified neural modules, each designed for a specific form of reasoning. In current formulations of such networks only the parameters of the neural modules and/or the order of their execution is learned. In this work, we further expand this approach and also learn the underlying internal structure of modules in terms of the ordering and combination of simple and elementary arithmetic operators. Our results show that one is indeed able to simultaneously learn both internal module structure and module sequencing without extra supervisory signals for module execution sequencing. With this approach, we report performance comparable to models using hand-designed modules.

Tables

Table 1. Table 1: CLEVR and CLEVR-Humans Accuracy by baseline methods and our models. (*) denotes use of extra supervision through program labels. ( ‡ ) denotes training from raw pixels. † Accuracy figures for our implementation of Stack-NMN.

Model	CLEVR	Count	Exist	Compare	Query	Compare	CLEVR
	Overall			Numbers	Attribute	Attribute	Humans
Human [14]	92.6	86.7	96.6	86.5	95.0	96.0	-
Q-type baseline [14]	41.8	34.6	50.2	51.0	36.0	51.3	-
LSTM [14]	46.8	41.7	61.1	69.8	36.8	51.8	36.5
CNN+LSTM [14]	52.3	43.7	65.2	67.1	49.3	53.0	43.2
CNN+LSTM+SA+MLP [13]	73.2	59.7	77.9	75.1	80.9	70.8	57.6
N2NMN* [9]	83.7	68.5	85.7	84.9	90.0	88.7	-
PG+EE (700K prog.)* [14]	96.9	92.7	97.1	98.7	98.1	98.9	-
CNN+LSTM+RN‡ [29]	95.5	90.1	97.8	93.6	97.9	97.1	-
CNN+GRU+FiLM [23]	97.7	94.3	99.1	96.8	99.1	99.1	75.9
MAC [10]	98.9	97.1	99.5	99.1	99.5	99.5	81.5
TbD [20]	99.1	97.6	99.2	99.4	99.5	99.6	-
Stack-NMN (9 mod.)†[8]	91.41	81.78	95.78	85.23	95.45	95.68	68.06
LNMN (9 modules)	89.88	84.28	93.74	89.63	89.64	94.84	66.35
LNMN (11 modules)	90.52	84.91	95.21	91.06	90.03	94.97	65.68
LNMN (14 modules)	90.42	84.79	95.52	90.52	89.73	95.26	65.86

Table 2. Table 2 : Model Ablations for LNMN (CLEVR Validation set performance). The term ‘ map ​ _ ​ dim map _ dim \textrm{map}\_\textrm{dim} ’ refers to the dimension of feature representation obtained at the input or output of each node of cell.

Model	Overall	Count	Exist	Compare number	Query attribute	Compare Attribute
Original setting $\left(T=5,L=5,\text{map}\_\text{dim}=384\right)$	89.78	84.54	93.46	88.70	89.59	94.87
Use hard-max for operation weights (for inference only) $\left(T=5,L=5,\text{map}\_\text{dim}=384\right)$	87.99	81.53	94.11	87.70	88.27	91.55
$T=9,L=9,\text{map}\_\text{dim}=256$	89.96	84.03	93.45	89.98	90.75	93.10
Concatenate all inputs followed by conv. layer	47.03	42.5	61.15	68.64	38.06	49.43

Table 3. Table 5: Analysis of gradient attributions of α 𝛼 \alpha parameters corresponding to each module (LNMN (9 modules)), summed across all examples of CLEVR validation set.

Module ID	Module type	min	max	sum	product	choose_1	choose_2
0	Attn. (3 input)	6.3 $\mathrm{e4}$	2.7 $\mathrm{e4}$	3.6 $\mathrm{e4}$	1.1 $\mathrm{e5}$	5.1 $\mathrm{e4}$	1.6 $\mathrm{e4}$
1	Attn. (3 input)	4.4 $\mathrm{e4}$	1.8 $\mathrm{e4}$	6.2 $\mathrm{e4}$	1.4 $\mathrm{e4}$	2.8 $\mathrm{e4}$	1.7 $\mathrm{e5}$
2	Attn. (3 input)	7.0 $\mathrm{e4}$	3.3 $\mathrm{e4}$	3.8 $\mathrm{e4}$	1.1 $\mathrm{e5}$	5.2 $\mathrm{e4}$	1.5 $\mathrm{e4}$
3	Attn. (3 input)	8.6 $\mathrm{e3}$	6.2 $\mathrm{e4}$	1.7 $\mathrm{e4}$	1.8 $\mathrm{e4}$	4.7 $\mathrm{e4}$	3.0 $\mathrm{e4}$
4	Attn. (4 input)	4.5 $\mathrm{e4}$	3.2 $\mathrm{e4}$	7.6 $\mathrm{e4}$	1.7 $\mathrm{e4}$	3.6 $\mathrm{e4}$	2.1 $\mathrm{e5}$
5	Attn. (4 input)	1.1 $\mathrm{e5}$	5.6 $\mathrm{e5}$	2.3 $\mathrm{e5}$	8.5 $\mathrm{e3}$	2.8 $\mathrm{e4}$	1.8 $\mathrm{e5}$
6	Ans. (3 input)	2.1 $\mathrm{e6}$	4.3 $\mathrm{e6}$	4.4 $\mathrm{e6}$	8.3 $\mathrm{e6}$	2.3 $\mathrm{e6}$	4.9 $\mathrm{e5}$
7	Ans. (4 input)	1.2 $\mathrm{e5}$	5.8 $\mathrm{e4}$	1.7 $\mathrm{e5}$	5.2 $\mathrm{e3}$	1.0 $\mathrm{e5}$	4.5 $\mathrm{e5}$

Table 4. Table 6: Analytical expression of modules learned by LNMN (11 modules). In the above equations, ∑ \sum denotes sum over spatial dimensions of the feature tensor.

Module type	Module implementation
Attention (3 inputs)	$O(img,a,c_{txt})=con{v}_2\left(choos{e}_2(con{v}_1\left(ℐ\right),a)\odot W_1{c}_{txt}\right)=con{v}_2\left(a\odot W_1{c}_{txt}\right)$
	$O(img,a,c_{txt})=con{v}_2\left(choos{e}_2(choos{e}_1(con{v}_1\left(ℐ\right),a),W_1{c}_{txt})\right)=con{v}_2\left(W_1{c}_{txt}\right)$
	$O(img,a,c_{txt})=con{v}_2\left(choos{e}_2(min(con{v}_1\left(ℐ\right),a),W_1{c}_{txt})\right)=con{v}_2\left(W_1{c}_{txt}\right)$
	$O(img,a,c_{txt})=con{v}_2(max(con{v}_1\left(ℐ\right),a)+W_1{c}_{txt}))$
Attention (4 inputs)	$O(img,a_1,a_2,c_{txt})=con{v}_2(choos{e}_1(max(a_1,a_2),con{v}_1\left(ℐ\right))\odot W_1{c}_{txt}))$ $=con{v}_2\left(max(a_1,a_2)\odot W_1{c}_{txt}\right)$
	$O(img,a_1,a_2,c_{txt})=con{v}_2(max(choos{e}_2(a_1,a_2),con{v}_1\left(ℐ\right))\odot W_1{c}_{txt}))$ $=con{v}_2(max(a_2,con{v}_1\left(ℐ\right))\odot W_1{c}_{txt}))$
Answer (3 inputs)	$O(img,a,c_{txt})=W_2[\sum min(con{v}_1\left(ℐ\right),a)\odot W_1{c}_{txt},W_1{c}_{txt},f_{mem}]$
	$O(img,a,c_{txt})=W_2[\sum min(\left(con{v}_1\left(ℐ\right)\odot a\right),W_1{c}_{txt}),W_1{c}_{txt},f_{mem}]$
Answer (4 inputs)	$O(img,a_1,a_2,c_{txt})=W_2[\sum min(\left(min(a_1,a_2)\odot con{v}_1\left(ℐ\right)\right),W_1{c}_{txt}),W_1{c}_{txt},f_{mem}]$
	$O(img,a_1,a_2,c_{txt})=W_2[\sum \left(\left(min(a_1,a_2)+con{v}_1\left(ℐ\right)\right)\odot W_1{c}_{txt}\right),W_1{c}_{txt},f_{mem}]$

Table 5. Table 7: Analysis of performance drop with removing operators from a trained model (LNMN 9 modules) on CLEVR validation set.

Operator Name	Overall	Count	Exist	Compare number	Query attribute	Compare Attribute
min	86.64	77.98	86.79	87.89	88.77	93.10
max	45.54	35.92	55.25	63.66	40.52	51.83
sum	82.67	69.89	80.25	85.22	87.69	90.05
product	34.65	14.55	51.49	48.79	30.31	49.92
choose_1	89.74	84.24	93.81	89.02	89.59	94.67
choose_2	79.45	64.77	76.07	82.96	86.78	84.94
Original Model	89.88	84.28	93.74	89.63	89.64	94.84

Table 6. Table 8 : Neural modules used in [ 8 ] . The modules take image attention maps as inputs, and output either a new image attention a o ​ u ​ t subscript 𝑎 𝑜 𝑢 𝑡 a_{out} or a score vector y 𝑦 y over all possible answers ( ⊙ direct-product \odot is elementwise multiplication; ∑ \sum is sum over spatial dimensions).

module	input	output	implementation details
name	attention	type	($x$: image feature map, $c$: textual parameter)
Find	(none)	attention	$a_{out}={\mathrm{conv}}_2\left({\mathrm{conv}}_1\left(x\right)\odot Wc\right)$
Transform	$a$	attention	$a_{out}={\mathrm{conv}}_2\left({\mathrm{conv}}_1\left(x\right)\odot W_1\sum \left(a\odot x\right)\odot W_{2}c\right)$
And	$a_1,a_2$	attention	$a_{out}=\mathrm{minimum}(a_1,a_2)$
Or	$a_1,a_2$	attention	$a_{out}=\mathrm{maximum}(a_1,a_2)$
Filter	$a$	attention	$a_{out}=\mathrm{𝙰𝚗𝚍}(a,\mathrm{𝙵𝚒𝚗𝚍}\left(\right))$, i.e. reusing Find and And
Scene	(none)	attention	$a_{out}={\mathrm{conv}}_1\left(x\right)$
Answer	$a$	answer	$y=W_1^T\left(W_2\sum \left(a\odot x\right)\odot W_{3}c\right)$
Compare	$a_1,a_2$	answer	$y=W_1^T\left(W_2\sum \left(a_1\odot x\right)\odot W_3\sum \left(a_2\odot x\right)\odot W_{4}c\right)$
NoOp	(none)	(none)	(does nothing)

Table 7. Table 9 : Test Accuracy on VQA v1 [ 3 ]

Model	Overall	Yes/No	Number	Other
Stack-NMN	59.84	80.75	37.49	46.83
LNMN (9 modules)	57.67	80.41	36.65	42.82

Table 8. Table 10 : Test Accuracy on VQA v2 [ 6 ]

Model	Overall	Yes/No	Number	Other
Stack-NMN	58.23	77.06	37.48	46.59
LNMN (9 modules)	54.85	73.78	35.05	42.92

Equations

$$\mathbf{u}={\mathbf{W}}_2[{\mathbf{W}}_1^{(\mathbf{t})}\mathbf{q}+{\mathbf{b}}_1;{\mathbf{c}}_{\mathbf{t}-1}]+{\mathbf{b}}_2$$

$$c{v}_{t,s}=softmax({\mathbf{W}}_3(\mathbf{u}\odot {\mathbf{h}}_{\mathbf{s}}))$$

$${\mathbf{c}}_{\mathbf{t}}=\sum _{s=1}^{S}c{v}_{t,s}\cdot {\mathbf{h}}_{\mathbf{s}}$$

$${\mathbf{w}}^{(\mathbf{t})}=softmax(MLP(\mathbf{u};{\theta }_{MLP}))$$

$$(A_m^{(t)},p_m^{(t)})$$

$$A^{(t+1)}$$

$$p^{(t+1)}$$

$$O({\mathbf{x}}_1,{\mathbf{x}}_2)$$

$$+{\alpha }_4^{{}^{\prime }}\ast ({\mathbf{x}}_1\odot {\mathbf{x}}_2)+{\alpha }_5^{{}^{\prime }}\ast choos{e}_1({\mathbf{x}}_1,{\mathbf{x}}_2)+{\alpha }_6^{{}^{\prime }}\ast choos{e}_2({\mathbf{x}}_1,{\mathbf{x}}_2)$$

$$\displaystyle\textrm{IG}(\alpha^{m}_{i})=\sum_{j=1}^{N}\sum_{k=1}^{p}\bigg{[}(\alpha^{m,k}_{i}-(\alpha^{m,k}_{i})^{{}^{\prime}})\times\int_{\xi=0}^{1}\frac{\partial F(\mathcal{I}_{j},\bm{q}_{j},(1-\xi)\times(\alpha^{m,k}_{i})^{{}^{\prime}}+\xi\times\alpha^{m,k}_{i})}{\partial\alpha^{m,k}_{i}}\bigg{]}$$

Full text

1 Introduction

Designing general purpose reasoning modules is one of the central challenges in artificial intelligence. Neural Module Networks [2] were introduced as a general purpose visual reasoning architecture and have been shown to work well for the task of visual question answering [3, 19, 27, 26]. They use dynamically composable modules which are then assembled into a layout based on syntactic parse of the question. The modules take as input the images or the attention maps111An attention map denotes a $H\times W\times 1$ tensor which assigns a saliency score to the convolutional features in the spatial dimension. and return attention maps or labels as output. In [9], the layout prediction is relaxed by learning a layout policy with a sequence-to-sequence RNN. This layout policy is jointly trained along with the parameters of the modules. The model proposed in [8] avoids the use of reinforcement learning to train the layout predictor, and uses soft program execution to learn both layout and module parameters jointly.

A fundamental limitation of these previous modular approaches to visual reasoning is that the modules need to be hand-specified. This might not be feasible when one has limited knowledge of the kinds of questions or associated visual reasoning required to solve the task. In this work, we present an approach to learn the module structure, along with the parameters of the modules in an end-to-end differentiable training setting. Our proposed model, Learnable Neural Module Network (LNMN), learns the structure of the module, the parameters of the module, and the way to compose the modules based on just the regular task loss. Our results show that we can learn the structure of the modules automatically and still perform comparably to hand-specified modules. We want to highlight the fact that our goal in this paper is not to beat the performance of the hand-specified modules since they are specifically engineered for the task. Instead, our goal is to explore the possibility of designing general-purpose reasoning modules in an entirely data-driven fashion.

2 Background

In this section, we describe the working of the Stack-NMN model [8] as our proposed LNMN model uses this as the base model. The Stack-NMN model is an end-to-end differentiable model for the task of Visual Question Answering and Referential Expression Grounding [28]. It addresses a major drawback of prior visual reasoning models in the literature that compositional reasoning is implemented without the need of supervisory signals for composing the layout at training time. It consists of several hand-specified modules (namely Find, Transform, And, Or, Filter, Scene, Answer, Compare and NoOp) which are parameterized, differentiable, and implement common routines needed in visual reasoning and learns to compose them without strong supervision. The implementation details of these modules are given in Appendix A.2 (see Table 8). The different sub-components of the Stack-NMN model are described below.

2.1 Module Layout Controller

The structure of the controller is similar to the one proposed in [10]. The controller first encodes the question using a bi-directional LSTM [7]. Let $[\bm{h_{1}},\bm{h_{2}},...,\bm{h_{S}}]$ denote the output of Bi-LSTM at each time-step of the input sequence of question words. Let $\bm{q}$ denote the concatenation of final hidden state of Bi-LSTM during the forward and backward passes. $\bm{q}$ can be considered as the encoding of the entire question. The controller executes the modules iteratively for $T$ times. At each time-step, the updated query representation $\bm{u}$ is obtained as:

[TABLE]

where $\bm{W_{1}^{(t)}}\in\mathbb{R}^{d\times d}$, $\bm{W_{2}}\in\mathbb{R}^{d\times 2d}$, $\bm{b_{1}}\in\mathbb{R}^{d}$, $\bm{b_{2}}\in\mathbb{R}^{d}$ are controller parameters. $\bm{c_{t-1}}$ is the textual parameter from the previous time step. The controller has two outputs viz. the textual parameter at step $t$ (denoted by $\bm{c_{t}}$) and the attention on each module (denoted by vector $\bm{w^{(t)}}$). The controller first predicts an attention $cv_{t,s}$ on each of the words of the question and then uses this attention to do a weighted average over the outputs of the Bi-LSTM.

[TABLE]

[TABLE]

where, $\bm{W_{3}}\in\mathbb{R}^{1\times d}$ is another controller parameter. The attention on each module $\bm{w^{(t)}}$ is obtained by feeding the query representation at each time-step to a Multi-layer Perceptron (MLP).

[TABLE]

2.2 Operation of Memory Stack for storing attention maps

In order to answer a visual reasoning question, the model needs to execute modules in a tree-structured layout. In order to facilitate this sort of compositional behavior, a differentiable memory pool to store and retrieve intermediate attention maps is used. A memory stack (with length denoted by $L$) stores $H\times W$ dimensional attention maps, where $H$ and $W$ are the height and width of image feature maps respectively. Depending on the number of attention maps required as input by the module, it pops them from the stack and later pushes the result back to the stack. The model performs soft module execution by executing all modules at each time step. The updated stack and stack pointer at each subsequent time-step are obtained by a weighted average of those corresponding to each module using the weights $\bm{w^{(t)}}$ predicted by the module controller. This is illustrated by the equations below:

[TABLE]

Here, $A_{m}^{(t)}$ and $p_{m}^{(t)}$ denote the stack and stack pointer respectively, after executing module $m$ at time-step $t$. $A^{(t)}$ and $p^{(t)}$ denote the stack and stack pointer obtained after the weighted average of those corresponding to all modules at previous time-step $(t-1)$. The working of module layout controller and its interfacing with memory stack is illustrated in Algorithm 1. The implementation details of operation of the stack are shown in Appendix (see Algorithm 3).

2.3 Final Classifier

At each time-step of module execution, the weighted average of output of the Answer modules is called memory features (denoted by $f_{mem}^{(t)}=\sum_{m\in\textrm{ans. module}}o_{m}^{(t)}w_{m}^{(t)}$). Here, $o_{m}^{(t)}$ denotes the output of module $m$ at time $t$. The memory features are given as one of the inputs to the Answer modules at the next time-step. The memory features at the final time-step are concatenated with the question representation, and then fed to an MLP to obtain the logits.

3 Learnable Neural Module Networks

In this section, we introduce Learnable Neural Module Networks (LNMNs) for visual reasoning, which extends Stack-NMN. However, the modules in LNMN are not hand-specified. Rather, they are generic modules as specified below.

3.1 Structure of the Generic Module

The cell (see Figure 1) denotes a generic module, which we suppose can span all the required modules for a visual reasoning task. Each cell contains a certain number of nodes. The function of a node (denoted by $O$) is to perform a weighted sum of outputs of different arithmetic operations applied on the input feature maps $\bm{x_{1}}$ and $\bm{x_{2}}$. Let ${\bm{\alpha}}^{{}^{\prime}}=\sigma(\bm{\alpha})$ denote the output of softmax function applied to the vector $\bm{\alpha}$ such that

[TABLE]

All of the above operations (min, max, $+$, $\odot$) are element-wise operations. The last two non-standard functions are defined as: $choose_{1}(\bm{x_{1}},\bm{x_{2}})=\bm{x_{1}}\textrm{ and }choose_{2}(\bm{x_{1}},\bm{x_{2}})=\bm{x_{2}}$.

We consider two broad kinds of modules: (i) Attention modules which output an attention map (ii) Answer modules which output memory features to be stored in the memory. Among each of these two categories, there is a finer categorization:

3.1.1 Generic Module with 3 inputs

This module type receives 3 inputs (i.e. image features, textual parameter, and a single attention map) and produces a single output. The first node receives input from the image feature ($\mathcal{I}$) and the attention map (popped from the memory stack). The second node receives input from the textual parameter followed by a linear layer ($W_{1}c_{txt}$), and the output of the first node.

3.1.2 Generic Module with 4 inputs

This module type receives 4 inputs (i.e. image features, textual parameter and two attention maps) and produces a single output. The first node receives the two attention maps, each of which are popped from the memory stack, as input. The second node receives input from the image features along with the output of the first node. The third node receives input from the textual parameter followed by a linear layer, and the output of the second node.

For the Attention modules, the output of the final node is converted into a single-channel attention map using a $1\times 1$ convolutional layer. For the Answer modules, the output of the final node is summed over spatial dimensions, and the resulting feature vector is concatenated with memory features of previous time-step and textual parameter features, fed to a linear layer to output memory features. The schematic diagrams of the Attention module with four inputs and Answer modules are given in the Appendix A.1 (see Figures 5,  6,  7).

3.2 Overall structure

The structure of our end-to-end model extends Stack-NMN in that we specify each module in terms of the generic module (defined in Section 3.1). We experiment with three model ablations in terms of number of modules for each type being used. See Table 3 for details2221 NoOp module is included by default in all ablations.. We train the module structure parameters (denoted by $\bm{\alpha}={\left\{\alpha_{i}^{m,k}\right\}}_{i=1}^{6}$ for $k^{th}$ node of module $m$) and the weight parameters ($\mathcal{W}$) by adopting alternating gradient descent steps in architecture and weight spaces respectively. For a particular epoch, the gradient step in weight space is performed on each training batch, and the gradient step in architecture space is performed on a batch randomly sampled from the validation set.

This is done to ensure that we find an architecture corresponding to the modules which has a low validation loss on the updated weight parameters. This is inspired by the technique used in [18] to learn monolithic architectures like CNNs and RNNs in terms of basic building blocks (or cells). Algorithm 2 illustrates the training algorithm. Here, $\mathcal{L}_{train}(\mathcal{W},\bm{\alpha})$ and $\mathcal{L}_{val}(\mathcal{W},\bm{\alpha})$ denote the training loss and validation loss on the combination of parameters $(\mathcal{W},\bm{\alpha})$ respectively. For the gradient step on the training batch, we add an additional loss term to initially maximize the entropy of $\bm{w^{(t)}}$ and gradually anneal the regularization coefficient ($\lambda_{w}$) to the opposite sign (which minimizes the entropy of $\bm{w^{(t)}}$ towards the end of training). The value of $\lambda_{w}$ varies linearly from $1.0$ to $0.0$ in the first 20 epochs and then steeply decreases to $-1.0$ in next 10 epochs. The trend of variation of $\lambda_{w}$ is shown in Appendix (see Figure 4). For the gradient steps in the architecture space, we add an additional loss term ($\frac{l^{2}}{l^{1}}=\frac{\left\lVert\bm{\sigma}(\bm{\alpha})\right\rVert_{2}}{\left\lVert\bm{\sigma}(\bm{\alpha})\right\rVert_{1}}$) [11] to encourage the sparsity of module structure parameters ($\bm{\alpha}$) after the softmax activation.

4 Experiments

We train our model on the CLEVR visual reasoning task. CLEVR [13] is a synthetic dataset for visual reasoning containing around 700K examples, and has become the standard benchmark to test visual reasoning models. It contains questions that test visual reasoning abilities such as counting, comparing, logical reasoning based on 3D shapes like cubes, spheres, and cylinders of varied shades. A typical example question and image pair from this dataset is given in Appendix (see Figure 3). The results on CLEVR test set are reported in Table 1. Some ablations of the model are shown in Table 2. We use the pre-trained CLEVR model to fine-tune the model on CLEVR-Humans dataset. The latter is a dataset of challenging human-posed questions based on a much larger vocabulary on the same CLEVR images. The corresponding results are shown in Table 1 (see last column). In addition, we experiment on VQA v1 [3] and VQA v2 [6] which are VQA datasets containing natural images. The results for VQA v1 and VQA v2 are shown in Table 4.

[TABLE]

[TABLE]

The detailed accuracy for each question sub-type for the VQA datasets is given in Appendix A.4 (see Tables 9 and 10). We use Adam [15] as the optimizer for the weight parameters with a learning rate of $1\mathrm{e}{-4}$, $(\beta_{1},\beta_{2})=(0.9,0.999)$ and no weight decay. For the module network parameters, we use the same optimizer with a different learning rate $3\mathrm{e}{-4}$, $(\beta_{1},\beta_{2})=(0.5,0.999)$ and a weight decay of $1\mathrm{e}{-3}$. The value of $\lambda_{op}$ is set to $1.0$.

4.1 Results

The comparison of CLEVR overall accuracy shows that our model (LNMN (9 modules)) receives only a slight dip ($1.53\%$) compared to the Stack-NMN model. We also experiment with other variants of our model in which we increase the number of Answer modules (LNMN (11 modules)) and/or Attention modules (LNMN (14 modules)). The LNMN (11 modules) model performs better than the other two ablations ($0.89\%$ accuracy drop w.r.t. the Stack-NMN model). For the ‘Count’ and ‘Compare Numbers’ sub-category of questions, all of the 3 variants perform consistently better than the Stack-NMN model. In case of CLEVR-Humans dataset, the accuracy drop is a modest $1.71\%$. Even for the natural image VQA datasets, our approach has comparable results with the Stack-NMN model. The results clearly show that the modules learned by our model (in terms of elementary arithmetic operations) perform approximately as well as the ones specified in the Stack-NMN model (that contains hand-designed modules which were tailor-made for the CLEVR dataset). The results from the ablations in Table 2 show that a naive concatenation of all inputs to a module (or cell) results in a poor performance (around 47 $\%$). Thus, the structure we propose to fuse the inputs plays a key role in model performance. When we replace the $\bm{\alpha}$ vector for each node by a one-hot vector during inference, the drop in accuracy is only $1.79\%$ which shows that the learned distribution over operation weights peaks over a specific operation which is desirable.

4.2 Measuring the sensitivity of modules

We use an attribution technique called Integrated Gradients [31] to study the impact of module structure parameters (denoted by ${\left\{\alpha_{i}^{m,k}\right\}}_{i=1}^{6}$ for $k^{th}$ node of module $m$) on the probability distribution in the last layer of LNMN model. Let $\mathcal{I}_{j}$ and $\bm{q}_{j}$ denote the (image, question) pairs for the $j^{th}$ example. Let $F(\mathcal{I}_{j},\bm{q}_{j},\bm{\alpha})$ denote the function that assigns the probability corresponding to the correct answer index in the softmax distribution. Here, $\alpha^{m,k}_{i}$ denotes the module network parameter for the $i^{th}$ operator in $k^{th}$ node of module $m$. Then, the attribution of $[\alpha^{m}_{1},\alpha^{m}_{2},\alpha^{m}_{3},\alpha^{m}_{4},\alpha^{m}_{5},\alpha^{m}_{6}]$ (summed across all nodes $k=1,...,p$ for a particular module $m$ and over all examples) is defined as:

[TABLE]

Please note that attributions are defined relative to an uninformative input called the baseline. We use a vector of all zeros as the baseline (denoted by $(\alpha^{m,k}_{i})^{{}^{\prime}}$). Table 5 shows the results for this experiment.

The module structure parameters ($\bm{\alpha}$ parameters) of the Answer modules have their attributions to the final probability around 1-2 orders of magnitudes higher than rest of the modules. The higher influence of Answer modules can be explained by the fact that they receive the memory features from the previous time-step and the classifier receives the memory features of the final time-step. The job of Attention modules is to utilize intermediate attention maps to produce new feature maps which are used as input by the Answer modules.

4.3 Visualization of module network parameters

In order to better interpret the individual contributions from each of the arithmetic operators to the modules, we plot them as color-maps for each type of module. The resulting visualizations are shown in Figure 2 for LNMN (11 modules). It is clear from the figure that the operation weights (or $\bm{\alpha^{{}^{\prime}}}$ parameter) are approximately one-hot for each node. This is necessary in order to learn modules which act as composition of elementary operators on input feature maps rather than a mixture of operations at each node. The corresponding visualizations for LNMN (9 modules) and LNMN (14 modules) are given in Figure 8 and Figure 9 respectively (all of which are given in the Appendix A.3). The analytical expressions of modules learned by LNMN (11 modules) are shown in Table 6. The diversity of modules as given in their equations indicates that distinct modules emerge from training.

4.4 Measuring the role of individual arithmetic operators

Each module (aka cell) contains nodes which involves use of six elementary arithmetic operations (i.e. min, max, sum, product, choose_1 and choose_2). We zero out the contribution to the node output for one of the arithmetic operations for all nodes in all modules and observe the degradation in the CLEVR validation accuracy333The CLEVR test set ground truth answers are not public, so we use the validation set instead. However, Table 1 shows results for CLEVR test set (evaluated by the authors of CLEVR dataset).. The results of this study are shown in Table 7. The trend of overall accuracy shows that removing max and product operators results in maximum drop in overall accuracy ($\sim 50\%$). Other operators like min, sum and choose_1 result in minimal drop in overall accuracy.

5 Related Work

Neural Architecture Search: Neural Architecture Search (NAS) is a technique to automatically learn the structure and connectivity of neural networks rather than training human-designed architectures. In [33], a recurrent neural network (RNN) based controller is used to predict the hyper-parameters of a CNN such as number of filters, stride, kernel size etc. They used REINFORCE [32] to train the controller with validation set accuracy as the reward signal. As an alternative to reinforcement learning, evolutionary algorithms [30] have been used to perform architecture search in [25, 21, 17, 24]. Recently, [18] proposed a differentiable approach to perform architecture search and reported success in discovering high-performance architectures for both image classification and language modeling. [16] proposes an EM style algorithm to learn black-box modules and their layout for image recognition and language modeling tasks.

Visual Reasoning Models: Among the end-to-end models for the task of visual reasoning, FiLM [23] uses Conditional Batch Normalization (CBN) [4, 5] to modulate the channels of input convolutional features in a residual block. [10] obtains the features by iteratively applying a Memory-Attention-Control (MAC) cell that learns to retrieve information from the image and aggregate the results into a recurrent memory. [29] constructs the feature representation by taking into account the relational interactions between objects of the image. With regards to the modular approaches, [2] proposes to compose neural network modules (with shared parameters) for each input question based on layout predicted by syntactic parse of the question. [1] extends this approach to question-answering in a database domain. In [9], the layout prediction is relaxed by learning a layout policy with a sequence-to-sequence RNN. This layout policy is jointly trained along with the parameters of modules. In [14], the modules are residual blocks (convolutional), they learn the program generator separately and then fine-tune it along with the modules. TbD-net [20] builds upon the End-to-End Module Networks [9] but makes an important change in that the proposed modules explicitly utilize attention maps passed as inputs instead of learning whether or not to use them. This results in more interpretability of the modules since they perform specific functions.

Visual Question Answering: Visual question answering requires a learning model to answer sophisticated queries about visual inputs. Significant progress has been made in this direction to design neural networks that can answer queries about images. This can be attributed to the availability of relevant datasets which capture real-life images like DAQUAR  [19], COCO-QA [26] and most recently VQA (v1 [3] and v2 [6]). The most common approaches [27, 22] to this problem include construction of a joint embedding of question and image and treating it as a classification problem over the most frequent set of answers. Recent works [12, 13] have shown that the neural networks tend to exploit biases in the datasets without learning how to reason.

6 Conclusion

We have presented a differentiable approach to learn the modules needed in a visual reasoning task automatically. With this approach, we obtain results comparable to an analogous model in which modules are hand-specified for a particular visual reasoning task. In addition, we present an extensive analysis of the degree to which each module influences the prediction function of the model, the effect of each arithmetic operation on overall accuracy and the analytical expressions of the learned modules. In the future, we would like to benchmark this generic learnable neural module network with various other visual reasoning and visual question answering tasks.

Appendix A Appendix

A.1 Module schematic diagrams

A.2 Hand-crafted modules of Stack-NMN

A.3 Visualization of module structure parameters

A.4 Results on Natural Image VQA datasets