Tips and Tricks for Visual Question Answering: Learnings from the 2017 Challenge

This paper presents a state-of-the-art model for visual question answering (VQA), which won the first place in the 2017 VQA Challenge. VQA is a task of significant importance for research in artificial intelligence, given its multimodal nature, clear evaluation protocol, and potential real-world applications. The performance of deep neural networks for VQA is very dependent on choices of architectures and hyperparameters. To help further research in the area, we describe in detail our high-performing, though relatively simple model. Through a massive exploration of architectures and hyperparameters representing more than 3,000 GPU-hours, we identified tips and tricks that lead to its success, namely: sigmoid outputs, soft training targets, image features from bottom-up attention, gated tanh activations, output embeddings initialized using GloVe and Google Images, large mini-batches, and smart shuffling of training data. We provide a detailed analysis of their impact on performance to assist others in making an appropriate selection.


page 1

page 7

page 10


Attention on Attention: Architectures for Visual Question Answering (VQA)

Visual Question Answering (VQA) is an increasingly popular topic in deep...

Show, Ask, Attend, and Answer: A Strong Baseline For Visual Question Answering

This paper presents a new baseline for visual question answering task. G...

VQA-MHUG: A Gaze Dataset to Study Multimodal Neural Attention in Visual Question Answering

We present VQA-MHUG - a novel 49-participant dataset of multimodal human...

CS-VQA: Visual Question Answering with Compressively Sensed Images

Visual Question Answering (VQA) is a complex semantic task requiring bot...

Effective Approaches to Batch Parallelization for Dynamic Neural Network Architectures

We present a simple dynamic batching approach applicable to a large clas...

Visual Question Answering: which investigated applications?

Visual Question Answering (VQA) is an extremely stimulating and challeng...

DualNet: Domain-Invariant Network for Visual Question Answering

Visual question answering (VQA) task not only bridges the gap between im...

Code Repositories


An efficient PyTorch implementation of the winning entry of the 2017 VQA Challenge.

view repo

1 Introduction

The task of Visual Question Answering (VQA) involves an image and a related text question, to which the machine must determine the correct answer (see Fig.  1

). The task lies at the intersection of the fields of computer vision, natural language processing, and artificial intelligence. This paper presents a relatively simple model for VQA that achieves state-of-the-art results. It is based on a deep neural network that implements the well-known joint embedding approach. The details of its architecture and hyperparameters were carefully selected for optimal performance on the VQA v2 benchmark 

[14]. Admittedly, a large part of such a search is necessarily guided by empirical exploration and validation. Given the limited understanding of neural networks trained on a task as complex as VQA, small variations of hyperparameters and of network architectures may have significant and sometimes unpredictable effects on final performance [22]. The aim of this paper is to share the details of a successful model for VQA. The findings reported herein may serve as a basis for future development of VQA systems and multimodal reasoning algorithms in general.

What is on the coffee table ?  What color is the hydrant ?
candles black and yellow
What is on the bed ? What is the long stick for ?
books whipping
Figure 1: The task of visual question answering (VQA) relates visual concepts with elements of language and, occasionally, common-sense or general knowledge. Examples of training questions and their correct answer from the VQA v2 dataset [14].

The proposed model is based on the principle of a joint embedding of the input question and image, followed by a multi-label classifier over a set of candidate answers. While this general approach forms the basis of many modern VQA methods 

[33], the details of the model are critical to achieving a high quality result. We also complement our model with a few key technical innovations that greatly enhance its performance. We have conducted an extensive empirical study to explore the space of architectures and hyperparameters to determine the importance of the various components.

1.1 Summary of findings

Our key findings are summarized with the following characteristics of the proposed model, which enable its high performance (see also Table 2).

  • [label=–]

  • Using a sigmoid output that allows multiple correct answers per question, instead of a common single-label softmax.

  • Using soft scores as ground truth targets that cast the task as a regression of scores for candidate answers, instead of a traditional classification.

  • Using gated tanh activations in all non-linear layers.

  • Using image features from bottom-up attention [3] that provide region-specific features, instead of traditional grid-like feature maps from a CNN.

  • Using pretrained representations of candidate answers to initialize the weights of the output layer.

  • Using large mini-batches and smart shuffling

    of training data during stochastic gradient descent.

Figure 2:

Overview of the proposed model. A deep neural network implements a joint embedding of the input question and image, followed by a multi-label classifier over a fixed set of candidate answers. Gray numbers indicate the dimensions of the vector representations between layers. Yellow elements use learned parameters. The elements

$⃝\hskip2.0pt\mathsf{w}\hskip1.0pt$ represent linear layers, and $⃝\hskip2.0pt\mathsf{w}\hskip1.0pt$ non-linear layers (gated tanh).

2 Background

The task of VQA has gathered increasing interest in the past few years since the seminal paper of Antol et al[6]. Even though the task straddles the fields of computer vision and natural language processing, it has primarily been a focus of the former. This is partly because VQA constitutes a practical setting to evaluate deep visual understanding, itself considered the over-arching goal of computer vision. The task of VQA is extremely challenging, since it requires the comprehension of a text question, the parsing of visual elements of an image, and reasoning over those modalities, sometimes on the basis of external or common-sense knowledge (see Fig. 1). The increasing interest in VQA parallels a similar trend for other tasks involving vision and language, such as image captioning [12, 32] and visual dialog [10].


A number of large-scale datasets for VQA have been created (e.g[6, 14, 24, 38]; see [33] for a survey). Each dataset contains various images, typically from Flickr and/or from the COCO dataset [25], together with human-proposed questions and ground truth answers. The VQA-real dataset of Antol et al.. [6] has served as the de facto benchmark since its introduction in 2015. As the performance of methods improved, however, it became apparent that language-based priors and rote-learning of example questions/answers were overly effective ways to obtain good performance [14, 18, 37]. That fact hinders the effective evaluation and comparison of competing methods. The observation led to the introduction of a new version of the dataset, referred to as VQA v2 [14]. It associates two images to every question. Crucially, the two images are chosen so as to each lead to different answers. This obviously discourages blind guesses, i.e. inferring the answer from the question alone. This new setting and dataset were the basis of the 2017 VQA challenge [1] and of the experiments presented in this paper.

Another dataset used in this paper is the Visual Genome [24]. This multipurpose dataset contains annotations of images in the form of scene graphs. Those constitute fine-grained descriptions of the image contents. They provide a set of visual elements appearing in the scene (e.g. objects, persons), together with their attributes (e.g. color, appearance) and the relations between them. We do not use these annotations directly, but they serve in [3] to train a Faster R-CNN model [28], which we use here to obtain object-centric image features. We directly use other annotations of the Visual Genome dataset which are simply questions relating to the images. In comparison to the questions of VQA v2, these have more diverse formulations and a more varied set of answers. Those answers are also often longer, i.e. short phrases, whereas most answers in VQA v2 are usually to -words long. As described in Sect.3.8, we only use the subset of questions whose answers overlap those in VQA v2.


The prevailing approach to VQA is based on three components. (1) Posing question answering as a classification problem, solved with (2) a deep neural network that implements a joint embedding model, (3)

 trained end-to-end with supervision of example questions/answers. First, question-answering is posed as a classification over a set of candidate answers. Questions in the current VQA datasets are mostly visual in nature, and the correct answers therefore only span a small set of words and phrases. Practically, correct answers are concentrated in a small set of words and phrases (typically a few hundreds to a few thousands). Second, most VQA models are based on a deep neural network that implements a joint embedding of the image and of the question. The two inputs are mapped into fixed-size vector representations with convolutional and recurrent neural networks, respectively. Further non-linear mappings of those representations are usually interpreted as projections into a joint “semantic” space. They can then be combined by means of concatenation of element-wise multiplication, before feeding the classifier mentioned above. Third, owing to the success of deep learning on supervised learning problems, this whole neural network is trained end-to-end from questions, images, and their ground truth answers. Note that this constitutes a relatively sparse training signal considering the huge dimensionality of the input space of possible images and questions. This in turn requires massive amounts of training examples. This has driven the efforts in collecting large-scale datasets such as

VQA v2. It contains in the order of 650,000 questions with ground-truth answers, relating to about 120,000 different images.

The majority of methods proposed for VQA in the past few years have built on the basic joint embedding approach with more complex mechanisms for attention (see [33] for a recent survey). Interestingly, recent studies have shown that very simple models can also achieve strong performance [18, 22] given careful implementation and/or selection of hyperparameters. Our work follows a similar line. Our extensive series of experiments show that a few keys choices in the implementation (e.g. gated activations, regression output, smart shuffling, etc.) dramatically improve the performance of a relatively simple model. We also show how the performance of a naive implementation gradually improves with each of those choices. We therefore hope that the proposed model can serve as a strong basis for other future incremental developments.

3 Proposed model

This section presents the proposed model, based on a deep neural network. For the sake of transparency, we pragmatically describe the model with the specific choices and values of hyperparameters that lead to its best performance. Section 4 will examine variations of architecture and hyperparameters and their influence on performance.

The complete model is summarized in Fig. 2. As a one-sentence summary, it implements the well-known joint RNN/CNN embedding of the question/image, with question-guided attention over the image [33, 35, 18, 22].

3.1 Question embedding

The input for each instance – whether during training or test time – is a text question and an image. The question is tokenized, i.e. first split into words using spaces and punctuation. Any number or number-based word (e.g. 10,000 or 2:15pm) is also considered as a word. Questions are trimmed to a maximum of 14 words for computational efficiency. The extra words are then simply discarded. but only about 0.25% of questions in the dataset are longer than 14 words. Each word is turned into a vector representation with a look-up table, whose entries are 300-dimensional vectors learned along other parameters during training. Those vectors are however initialized with pretrained GloVe word embeddings [27] (Global Vectors for Word Representation). We use the publicly available version of GloVe pretrained on the Wikipedia/Gigaword corpus111

. The words not present in the pretrained word embdding are initialized with vectors of zeros (subsequenty optimized during training). The questions shorter than 14 words are end-padded with vectors of zeros (frozen during training). The resulting sequence of word embeddings is of size

and it is passed through a Recurrent Gated Unit (GRU [9]). The recurrent unit has an internal state of dimension 512, and we use its final state, i.e. after processing the 14 word embeddings, as our question embedding . Note that we do not use sentinel start or end tokens, nor do we trim sequences, or process the strict number of tokens in the given sentence (also known as per-example dynamic unrolling in [22], or TrimZero in [23]). We rather found it more effective to always run the recurrent units for the same number of iterations, including entries containing zero-padding.

3.2 Image features

The input image is passed through a Convolutional Neural Network (CNN) to obtain a vector representation of size

, where is a number of image locations. Each location is thus represented by a 2048-dimensional vector that encodes the appearance of the image in that region. Our evaluation in Section 4 compares two main options with different trade-offs in commodity and performance: a standard pretrained CNN, or a better-performing option. The first, lower-performance option is a 200-layer ResNet (Residual Network [15]

) pretrained on ImageNet and publicly available 

[16]. This gives feature maps of size that we resize by average pooling (i.e

. bilinear interpolation) to

(i.e. =). The second, higher-performance option is to use the method proposed in [3] which provides image features using bottom-up attention. The method is based on a ResNet CNN within a Faster R-CNN framework [28]. It is trained to focus on specific elements in the given image, using annotations from the Visual Genome dataset [24]. The resulting features can be interpreted as ResNet features centered on the top- objects in the image. Our experiments evaluate both a fixed =36, and an adaptive that uses a fixed threshold for the detected elements in the image, allowing the number of regions to vary with the complexity of each image, up to a maximum of . The images used by the VQA v2 dataset yield in that case an average of about = per image.

In all cases, the CNN is pretrained and held fixed during the training of the VQA model. The features can therefore be extracted from the input images as a preprocessing step for efficiency.

3.3 Image attention

Our model implements a classical question-guided attention mechanism common to most modern VQA models (see e.g[38, 34, 8, 19, 5, 35]). We refer to this stage as the top-down attention, as opposed to the model of Anderson et al.. [3] that provides image features from bottom-up attention.

For each location in the image, the feature vector is concatenated with the question embedding (see Fig. 2). They are both passed through a non-linear layer (see Section 3.7) and a linear layer to obtain a scalar attention weight associated with that location. Formally,


where is a learned parameter vector. The attention weights are normalized over all locations with a softmax function (Eq. 2). The image features from all locations are then weighted by the normalized values and summed (Eq. 3) to obtain a single -sized vector representing the attended image.

Note that this attention mechanism is a simple one-glimpse, one-way attention, as opposed to more complex schemes of recent models (e.g. stacked, multi-headed, or bidirectional attention [35, 18, 22, 26]).

3.4 Multimodal fusion

The representations of the question () and of the image () are passed through non-linear layers and then combined with a simple Hadamard product (i.e. element-wise multiplication):


The resulting vector is referred to as the joint embedding of the question and of the image, and is then fed to the output classifier.

3.5 Output classifier

A set of candidate answers, that we refer to as the output vocabulary, is predetermined from all the correct answers in the training set that appear more than 8 times. This amounts to = candidate answers. We treat VQA as a multi-label classification task. Indeed, each training question in the VQA v2 dataset is associated with one or several answers, each labeled with soft accuracies in . Multiple answers and accuracies in arise in case of disagreement between human annotators, particularly with ambiguous questions and multiple or synonymous correct answers [14]. Moreover, in our case, some training questions (about ) have no correct answer within the selected output vocabulary. Those questions are not discarded however. We find them to provide a useful training signal, by driving towards zero the scores predicted for all candidates of the output vocabulary (see Section 4.1).

Our multi-label classifier passes the joint embedding through a non-linear layer then through a linear mapping to predict a score for each of the candidates:



is a sigmoid (logistic) activation function, and

is a learned weight matrix initialized as described below.

The sigmoid normalizes the final scores to , which are followed by a loss similar to a binary cross-entropy, although we use soft

target scores. This final stage can be seen as a logistic regression that predicts the correctness of each candidate answer. Our objective function is


where the indices and run respectively over the training questions and candidate answers. The ground-truth scores are the aforementioned soft accuracies of ground truth answers. The above formulation proved to be much more effective than a softmax classifier as commonly used in other VQA models. The advantage of the above formulation is two-fold. First, the sigmoid outputs allow optimization for multiple correct answers per question [18, 31] as is occasionally the case in the VQA v2 dataset. Second, the use of soft scores as targets provides a slightly richer training signal than binary targets, as they capture the occasional uncertainty in ground truth annotations.

3.6 Pretraining the classifier

In the output stage described above (Eq. 5), the score of a candidate answer is effectively determined by a dot product between our joint image-question representation and the th row of . During training, an appropriate representation for each candidate answer is thus learned as a row of . We propose to use prior information about the candidate answers from two sources to initialize the rows of . On the one hand, we use linguistic information in the form of the GloVe word embeddings of the answer word (as described above for Question embedding). When the answer cannot be matched exactly with a pretrained embedding, we use the closest match after spell checking, removing hyphenation, or keeping a single term from multi-word expressions. The corresponding vectors are placed in the matrix .

We also exploit visual information gathered from images representing the candidate answers. We use Google Images to automatically retrieve 10 photographs associated with each candidate answer. Those photographs are passed through a ResNet-101 CNN pretrained on ImageNet [15]. The final mean-pooled features are extracted and averaged over the 10 photographs. The resulting 2048-sized vector of each candidate answer is placed in the corresponding row of a matrix . Those visual representations are complementary to the linguistic ones obtained through word embeddings. They can also be obtained for any candidate answer, including multi-word expressions and rare words for which no word embeddings are available. On the downside, abstract words and expressions may not lead to informative visual representations (see Section 4.6 and Fig. 3).

We combine the prior representations and as follows, decomposing Eq. 5 into


where the non-linear transformations

and bring to the appropriate dimensions, i.e. 300 and 2048 respectively (see Fig. 2). The matrices and are fine-tuned with the remainder of the network using smaller relative learning rates, respectively 0.5 and 0.01 (determined through cross-validation).

3.7 Non-linear layers

The network described above uses multiple learned non-linear layers (see Fig. 2

). A common implementation for such a layer would be an affine transformation followed by a Rectified Linear Unit (ReLU). In our implementation, each non-linear layer uses a gated hyperbolic tangent activation. That is, each of those layers implements a function

with parameters defined as follows:


where is the sigmoid activation function, are learned weights, are learned biases, and  is the Hadamard (element-wise) product. The vector acts multiplicatively as a gate on the intermediate activation . That formulation is inspired by similar gating operations within recurrent units such as LSTMs and GRUs [9]. This can also be seen as a special case of highway networks [29] and has been mentioned in other work in natural language processing [11, 30].

3.8 Training

We train the network using stochastic gradient descent. We use the AdaDelta algorithm [36], which does not require fixing learning rates and is very insensitive to the initialization of the parameters. The model is prone to overfitting, which we prevent by early stopping as follows. We first train leaving out the official validation set of the VQA v2

dataset for monitoring, and identify the epoch yielding the best performance (highest overall VQA score). The training is then repeated for the same number of epochs, now also using the validation set as training data (as in 


We use questions/answers from the Visual Genome [24] as additional training data. We only use questions whose correct answers overlap the output vocabulary determined on the VQA v2 dataset. This amounts to only about or 485,000 questions from the Visual Genome.

During training with stochastic gradient descent, we enforce the shuffling of training instance to keep balanced pairs of VQA v2 in the same mini-batches. Those pairs correspond to identical questions with different images and answers. Our intuitive motivation is that such pairs likely lead to gradients pulling the network parameters in different directions. Keeping an example and its balanced counter-part in a same mini-batch is expected to make the learning more stable, and encourage the network to discern the subtle differences between the paired instances [30].

3.9 Implementation

Our model is implemented entirely in Matlab using custom deep learning libraries, with the exception of some Java code for multithreaded loading of input data. Training one network usually converges in 12–18 epochs, which takes in the order of 12–18 hours with  on a single Nvidia K40 GPU, or about twice as long on a CPU.

4 Ablative experiments


VQA v2 validation
VQA Score Accuracy over
All Yes/no Numbers Other balanced pairs


Reference model 63.15 0.08 80.07 42.87 55.81 34.66
Training data (reference: with Visual Genome data; shuffling keeps balanced pairs in the same minibatches)
        Without extra training data from Visual Genome 62.48 0.15 80.37 42.06 54.44 34.12
        Random shuffling of training data 63.16 0.06 80.17 42.92 55.73 34.54
        Discard training questions without answers of score= 63.15 0.12 80.15 42.90 55.73 34.62
Question embedding (reference: 300-dimensional GloVe word embeddings, 1-layer forward GRU)
        Word embeddings learned from random initialization; 1-layer forward GRU 62.28 0.06 78.77 41.92 55.27 33.67
        100-dimensional GloVe; forward GRU 62.45 0.05 78.84 42.12 55.51 33.70
        200-dimensional GloVe; forward GRU 62.96 0.12 79.76 42.49 55.75 34.34
        300-dimensional GloVe; bag-of-words (sum) 62.14 0.04 79.54 41.88 54.41 33.73
        300-dimensional GloVe; bag-of-words (average) 62.53 0.09 80.17 42.15 54.67 34.22
        300-dimensional GloVe; 1-layer backward GRU 62.82 0.02 79.57 42.39 55.64 33.98
        300-dimensional GloVe; 2-layer forward GRU 62.29 0.10 78.66 42.42 55.23 33.56
        300-dimensional GloVe randomly shuffled; 1-layer forward GRU 62.16 0.08 78.74 41.73 55.11 33.45
Image features (reference: image features from bottom-up attention, adaptive )
        ResNet-200 global features (=, i.e. without image attention)) 56.16 0.14 75.89 36.39 46.57 25.93
        ResNet-200 features (=)) 57.93 0.25 76.17 36.25 49.95 27.64
        ResNet-200 features downsampled to (=) 59.35 0.10 77.34 37.74 51.55 29.49
        Image features from bottom-up attention, = 62.82 0.14 79.92 42.44 55.35 34.18
Image attention (reference: image features from bottom-up attention, 1 attention head, softmax normalization)
        ResNet-200 features, 1 head, sigmoid normalization 58.96 0.37 77.05 37.99 50.90 28.68
        ResNet-200 features, 1 head, softmax normalization 59.35 0.10 77.34 37.74 51.55 29.49
        ResNet-200 features, 2 heads, sigmoid normalization 58.70 0.30 76.42 37.95 50.87 28.40
        ResNet-200 features, 2 heads, softmax normalization 59.20 0.13 76.97 37.52 51.58 29.43
        Image features from bottom-up attention, 1 head, sigmoid normalization 62.15 1.41 78.83 43.44 54.57 32.98
        Image features from bottom-up attention, 2 heads, sigmoid normalization 62.91 0.26 79.74 43.99 55.27 34.30
        Image features from bottom-up attention, 2 heads, softmax normalization 63.10 0.05 79.80 43.17 55.82 34.52
Output vocabulary (reference: 8 occurrences as correct answers in the training data,  
        Keep answers with 6 training occurrences,   63.26 0.07 80.23 42.94 55.89 34.50
        Keep answers with 10 training occurrences,   63.30 0.06 80.33 43.02 55.86 34.69
        Keep answers with 12 training occurrences,   63.16 0.08 80.18 43.17 55.66 34.56
        Keep answers with 14 training occurrences,   63.27 0.08 80.45 43.07 55.69 34.83
        Keep answers with 16 training occurrences,   63.17 0.10 80.29 42.94 55.65 34.62
        Keep answers with 20 training occurrences,   63.14 0.05 80.21 42.90 55.66 34.67
        Keep answers with 200 training occurrences,   59.59 0.04 79.90 42.11 48.93 32.64
Output classifier (reference: sigmoid output, and pretrained
        Softmax output,   pretrained,                   pretrained 60.47 0.08 78.19 40.93 52.32 32.27
        Sigmoid output,   randomly initialized,    randomly initialized 62.28 0.99 78.50 42.50 55.32 33.14
        Sigmoid output,   randomly shuffled,       randomly shuffled 62.64 0.15 79.82 42.26 55.13 34.17
        Sigmoid output,   pretrained,                    randomly initialized 62.94 0.14 79.99 42.72 55.47 34.26
        Sigmoid output,   pretrained,                    randomly shuffled 63.04 0.02 80.20 42.83 55.50 34.66
        Sigmoid output,   randomly initialized,   pretrained 63.21 0.01 80.06 42.97 55.90 34.65
        Sigmoid output,   randomly shuffled,      pretrained 62.97 0.06 79.83 42.62 55.68 34.31
General architecture (reference: gated tanh non-linear activations, hidden states of dimension 512)
        Non-linear activations: ReLU 61.63 0.21 78.48 41.15 54.39 32.57
        Non-linear activations: tanh 61.74 0.44 79.20 40.92 54.13 33.10
        Non-linear activations: gated ReLU 62.44 0.07 79.33 42.12 55.13 33.52
        Hidden states of dimension 256 62.80 0.05 79.62 42.46 55.53 34.12
        Hidden states of dimension 384 63.12 0.11 80.06 42.89 55.74 34.54
        Hidden states of dimension 768 63.12 0.11 80.06 42.89 55.74 34.54
        Hidden states of dimension 1024 63.02 0.55 79.88 42.68 55.73 34.34
        Hidden states of dimension 1280 63.37 0.21 80.40 43.02 55.96 34.76
Mini-batch size (reference: 512 training questions)
        128 Training questions 62.38 0.08 79.70 42.29 54.67 34.01
        256 Training questions 63.17 0.09 80.22 42.94 55.72 34.71
        384 Training questions 63.20 0.04 80.21 43.08 55.75 34.61
        768 Training questions 62.99 0.12 79.84 42.61 55.73 34.40


Table 1:

Ablations of a single network, evaluated on the VQA v2 validation set. We evaluate variations of our best “reference” model (first row), and show that it corresponds to a local optimum in the space of architectures and hyperparameters. Every row corresponds to one variation of that reference model. We train each variation with three different random seeds and report averages and standard deviations (



VQA v2 validation
VQA Score Accuracy over
All Yes/no Numbers Other balanced pairs


Reference model 63.15 0.08 80.07 42.87 55.81 34.66
(1)   Removing initialization of (randomly shuffled) 63.01 0.12 80.11 42.80 55.51 34.40
(2)   Removing initialization of (randomly shuffled) 62.67 0.07 79.75 42.64 55.14 34.22
(3)   Removing image features from bottom-up attention [3]; ResNet-200 features instead 58.90 0.10 77.16 37.18 50.92 29.39
(4)   Removing extra training data from the Visual Genome, only uses the VQA v2 training set 57.84 0.05 77.46 36.73 48.68 28.66
(5)   Removing shuffling “by balanced pairs”, standard random shuffling instead 57.68 0.14 77.25 36.46 48.58 28.53
(6)   Removing GloVe embeddings to encode the question; learned from random init. instead 56.97 0.22 75.92 36.03 48.26 27.50
(7a)  Replace gated tanh layers with tanh activations 52.13 7.33 75.90 34.51 38.92 24.78
(7b)  Replace gated tanh layers with ReLU activations 55.38 0.05 74.65 34.83 46.33 25.24
(8a)  Binary ground truth targets ;   ReLU 54.34 0.19 73.81 34.50 44.95 23.75
(8b)  Binary ground truth targets ;   ReLU 53.41 0.20 73.23 34.38 43.54 24.32
(9)   Replace sigmoid output with softmax; single binary target ;   ReLU 52.52 0.31 72.79 34.33 42.09 23.81


Table 2: Cumulative ablations of a single network, evaluated on the VQA v2 validation set. The ablations of table rows are cumulative from top to bottom. The experimental setup is identical to the one used for Table 1.

We present an extensive set of experiments that compare our model as presented above (referred to as the reference model) with alternative architecture and hyperparameter values. The objective is to show that the proposed model corresponds to a local optimum in the space of architectures and parameters, and to evaluate the sensitivity of the final performance to each design choice. The following discussion follows the structure of Tables 1 and 2. Note the significant breadth and exhaustivity of the following experiments, which represent more than 3,000 GPU-hours of training time.

Experimental setup

Each experiment in this section uses a single network (i.e. no ensemble) that is a variation of our reference model (first row of Table 1). Each network is trained on the official training set of VQA v2 and on the additional questions from the Visual Genome unless specified. Results are reported on the validation test VQA v2 at the best epoch (highest overall VQA score). Each experiment (i.e. each row of Tables 1 and 2) is repeated 3 times, training the same network with different random seeds. We report the average and standard deviation over those three runs. The main performance metric is the standard VQA accuracy [6], i.e. the average ground truth score of the answers predicted for all questions222The ground truth score of a candidate answer to a question is a value provided with the dataset. It accounts for possible disagreement between annotators: if provided by annotators, and otherwise. Those scores are further averaged in a 10–choose–9 manner [6].. We additionally report the metric of Accuracy over pairs [37] (last column of Tables 1 and 2). It is the ratio of balanced questions (i.e. questions associated with two images leading to two different answers) that are answered perfectly, i.e. with both predicted answers having a ground truth score of . This metric is significantly harder than the standard per-question score since it requires a correct answer to both images of the pair, discouraging blind guesses and reliance on language priors [14, 37].

We now discuss the results of each ablative experiment from Tables 1 and 2 in turn.

4.1 Training data

The use of additional training questions/answers from the Visual Genome (VG) [24] increase the performance on VQA v2 [14] in all question types. As mentioned above, we only use VG instances with a correct answer appearing the output vocabulary determined on VQA v2, and which use an image also used in VQA v2. Note that the increase in performance is modest relative to the amount of additional training questions (an additional  485,000 over the  650,000 of VQA v2). Note that including VG questions relating to MS COCO images not used in VQA v2 resulted in slightly lower final performance (not reported in Table 1). We did not further investigate this issue.

We compare the proposed shuffling of training data which keeps balanced pairs in the same mini-batches, with a standard, arbitrary random shuffling. The results in Table 1 are inconclusive: the overall VQA score is virtually identical either way. The accuracy over pairs however improves with the proposed shuffling. This is to be expected, as the purpose of the proposed method is to improve the learning of differentiating between balanced pairs. The cumulative ablation (row in Table 2) confirms this advantage more clearly.

We evaluate discarding the training questions that do not have their ground truth answer within the selected candidates. Early experiments have shown that those instances do still carry a useful training signal by drawing the predicted scores of the selected candidate answers towards zero. In Table 1, the VQA score remains virtually identical, but a very slight benefit is observed on the accuracy over pairs by retaining those instances.

4.2 Question embedding

Our reference model uses pretrained GloVe word embeddings of dimension 300 followed by a one-layer GRU processing words in forward order. We compare this choice to a series of more simple and more advanced options.

Learning the word embeddings from scratch, i.e. from random initializations reduces performance by . The gap with pretrained embeddings is even greater as the model is trained on less training data (Fig. 4 and Section 4.9). This is consistent with findings previously reported in [31]. This experiment shows, on the one hand, a benefit of leveraging non-VQA training data. On the other hand, it suggests that a sufficiently large VQA training set may remove this benefit altogether. Using GloVe vectors of smaller dimension ( or ) also give lower performance than those in the reference model ().

We investigate whether the pretrained word embeddings (GloVe vectors) really capture word-specific information. The alternative, null hypothesis is that the simple spreading of vectors in the word embedding space is a benefit in itself. To test this, we randomly shuffle the same GloVe vectors,

i.e. we associate them with words from the input dictionary chosen at random. The shuffled GloVe vectors perform even worse than word embeddings learned from scratch. This shows that GloVe vectors indeed capture word-specific information.

In other experiments (not reported in Table 1), we experimented with a tanh activation following the word embeddings as in [13, 22]. This had no significant effect, either with random or pretrained initializations.

Replacing our GRU with advanced options (backward, bidirectional, or two-layer GRU) gives lower performance. Simpler options (bag-of-words, simply summing or averaging word embeddings) also give lower performance but are still a surprisingly strong baseline, as previously reported in [18, 31].

4.3 Image features

Our best model uses the images features from bottom-up attention of Anderson et al[3]. These are obtained through a Faster R-CNN framework and an underlying 101-layer ResNet that focuses on specific image regions. The method uses a fixed threshold on object detections, and the number of features is therefore adaptive to the contents of the image. It is capped at a maximum of 100, and yields an average in the order of =. We experiment with a fixed number of features =. The performance degrades only slightly. This option may be a reasonable alternative considering the lower implementation and computational costs.

We also experiment with mainstream image features from a 200-layer ResNet [15, 16]. As per the common practice, we use the last feature map of the network, of dimensions and 2,048 channels. The performance with ResNet features drops dramatically from to . A global average pooling of those features, i.e. collapsing to a map and discarding the attention mechanism, is expectedly even worse. A surprising finding however is that coarser ResNet feature maps give a reasonable performance of 59.24. Those are obtained by linear interpolation of the maps, equivalent to a

average pooling of stride 2. As an explanation, we hypothesize that the resolution of the coarser maps better correspond to the scale of objects in our images.

Note that the proposed model was initially developed with standard ResNet features, and is not specifically optimized for the features of [3]. On the contrary, we found that optimal choices were stable across types of image features (including for the attention mechanism, see Section 4.4). In all cases, we also observed that an normalization of the image features was crucial for good performance – at least with our choices of architecture and optimizer.

4.4 Image attention

Our reference model uses a single set of attention weights normalized with a softmax. Some previous studies have reported better performance with multiple sets of attention weights (also known as multiple “glimpses” or “attentions heads”) [13] and/or with a sigmoid normalization over the weights [30] (which allows multiple glimpses in one pass). In our case, none of these options proved beneficial, whether with ResNet features or with features from bottom-up attention. This confirms that the latter image features are suited to a simple drop-in replacement in lieu of traditional feature maps, as argued in [3].

4.5 Output vocabulary

We determine the output vocabulary, i.e. the set of candidate answers from those appearing in the training set more than times. We cross-validate this threshold and find a relatively broad optimum around occurrences. This corresponds to about = to candidate answers, which is of the same order as the values typically reported in the literature (without cross-validation) of or . Note however a higher (i.e. lower ) still gives reasonable performance with a lower number of parameters and computational complexity.

4.6 Output classifier

Our reference model uses sigmoid outputs and the soft scores

as ground truth targets. We first compare the soft scores with two binarized versions:


The proposed soft scores perform significantly better than either of the binarized versions (Table 2).

We then compare the sigmoid outputs of our reference model to the common choice of a softmax. Both use a cross-entropy loss. The softmax uses the single ground truth answer provided in the dataset, whereas the sigmoid uses the complete annotation data, occasionally with multiple correct answers marked for one question, due to disagreement between multiple annotators. The sigmoid performs significantly better than a softmax. This observation is confirmed in the cumulative ablations (Table 2)

We now evaluate the proposed pretraining of the parameters and/or of the classifiers. We consider two baselines for those two matrices: random initialization and random shuffling. The former simply initializes and learns the weights like any others in the network. The latter uses the proposed pretraining as initializations but assigns then to the candidate answers randomly by shuffling the rows. This should reveal whether the proposed initialization provides answer-specific information, or whether it simply helps the numerical optimization because of better conditioned initial values. The proposed initialization performs consistently better than those baselines. The random initialization of may seem surprisingly good as it even surpasses the reference model on the overall VQA score. It does not, however, on the metric of Accuracy over pairs. The experiments with reduced training data (Section 4.9 and Fig. 4) confirm even more clearly the benefits of the proposed initialization.

We take a closer look at the actual answers that improve with the proposed initialization (Fig. 3). We look at the recall of each candidate answer , defined as


where is the number of evaluated questions, is a ground truth score, and a predicted score. In Fig. 3, we plot the recall of a random selection of answers with and without pretraining the classifier. It is expected that pretraining improves a variety of answers while improves those with clearer visual representation. That intuition is hard to evaluate subjectively and is easy to confirm or disprove by cherry-picking examples. Note that, despite the overall benefit for the proposed approach, the recall of many answers is affected negatively. Other architectures may be necessary to obtain the full benefits of the approach. Another observation – not directly inferable from Fig. 3 – is that the recall the most influenced by pretraining – positively or negatively – is of answers with few training occurrences. This confirms the potential of the approach for better handling rare answers [31].

Figure 3: Effect of pretraining the output classifier on specific answers. We compare the per-candidate-answer recall of three models: a baseline using a classifier trained from scratch or pretrained (in black), and models using pretrained and/or . (Leftmost chart) Random selection of answers sorted by their recall in the baseline model.  (Right three charts) Top-60 answers with the largest improvement in recall by pretraining the classifier. See discussion in Section 4.6.

4.7 General architecture

All of our non-linear layers are implemented as gated tanh (Section 3.7). These show a clear benefit over the gated ReLU, and even more so over simple ReLU or tanh activations. Note that we also experimented, without success, with various other combinations of highway [29], residual [15] and gating connections (not reported in Table 1). One benefit of gated layers is to double the number of learned parameters without increasing the dimension of the hidden states.

We cross-validate the dimension of hidden states among the values . We settled on 512 as a reasonable sweet spot. Larger dimensions (e.g

. 1280) can be better but without guarantees. The variance across repeated experiments is larger, likely due to overfitting and unstable training.

Our architecture uses a simple element-wise product to combine the question and image representations. This proved far superior to a concatenation (not reported in Table 1), but we did not experiment with the various advanced forms of pooling proposed in the recent literature [13, 7]

4.8 Mini-batch size

The size of mini-batches during the optimization proves to have a strong influence on the final performance. Mid-range values in  proved superior to smaller mini-batches (including even smaller values), although they require significantly more memory and high-end GPUs. We observed the optimum mini-batch size to be stable across variations of the network architecture, through other experiments not reported in Table 1.

4.9 Training set size

Figure 4: Performance of our reference model (Table 1, first row) trained on a subset of the training data. The use of additional non-VQA data for pretraining the word embeddings and the output classifiers is significant, especially when training on a reduced training set. Also not the tendency performance to plateau, and the small gain in performance relative to a 10-fold increase of training data. See discussion in Section 4.9.

We investigate the relation between performance and the quantity of training data. We create random subsets of our training data and train four different models on it.

  1. [label=(0)]

  2. Our best reference model.

  3. The ablation that uses word embeddings learned from scratch, instead of GloVe vectors.

  4. The ablation with the output classifier learned from scratch, instead of pretrained and .

  5. The conjunction of (2) and (3).

We plot in Fig. 4 their performance against the amount of training data and make the following observations.

  • [label=–]

  • Unsurprisingly, the performance improves monotonically with the amount of training data. It roughly follows a logarithmic trend. Remarkably, we already obtain reasonable performance with only 10 of the data. Consequently, the gain when training on the whole dataset appears small relative to the ten-fold increase in data. That observation is common among natural language tasks in which the data typically follows a Zipf law [2] and in other domains with long-tail distributions. In those cases, few training examples are sufficient to learn the most common cases, but an exponentially larger dataset is required for covering more and more of the rare concepts.

  • The use of extra data to pretrain word embeddings and classifiers is always beneficial. The gap with the baselines models learned from scratch shrinks as more VQA-specific training data is used. It could suggest that a sufficiently large VQA training set would remove the benefit altogether. An alternative view however, is that those other sources of information are most useful for representing rare words and concepts [31] which would require an impractically large dataset to be learned from VQA-specific examples alone. That view then suggests that extra data is necessary in practice.

  • Pretrained word embeddings and pretrained classifiers each provide a benefit of the same order of magnitude. Importantly, the two techniques are clearly complementary and the best performance is obtained by combining them.

4.10 Ensembling

Figure 5: Performance of our best model (last row of Table 3) as a function of the ensemble size. The ensemble uses several instances of a same network trained with different random seeds. Their predicted scores are combined additively. Even small ensembles provide a significant increase in performance over a single network.

We use the common practice of ensembling several networks to obtain better performance. We use the most basic form of ensembling: multiple instances of the same model (same network architecture, same hyperparameters, same data) is trained with different initial random seeds. This affects the initialization of the learned parameters and the stochastic gradient descent optimization. At test time, the scores predicted for the candidates answers by all instances are summed, and the final answer is determined from the highest summed score.

As reported in Fig. 5, the performance increases monotonically with the size of the ensemble, i.e. the number of network instances. We obtained our final, best results, with an ensemble of 30 networks. The training of multiple instances is independent and obviously parallelizeable on multiples CPUs or GPUs. Interestingly, even small ensembles of instances provide a significant increase in performance over a single network.

Note that those experiments include the validation split of VQA v2 for training and use its test-dev split for evaluation, hence the higher overall performance compared to Tables 1 and 2.

5 Cumulative ablations

All ablative experiments presented above consider one or two modifications of the reference model at a time. It is important to note that the cumulative effect of several modifications is not necessarily additive. In practice, this complicates the search for optimal architectures and hyperparameters. Some choices that appear promising at first may not pan out when combined with other optimizations. Conversely, some options discarded early on the search may prove effective once other hyperparameters have been tuned.

We report in Table 2 a series of cumulative ablations of our reference model. We consider a series of characteristics of our model in the inverse of the order in which they could be incorporated into other VQA models. The results follow the trends observed with the individual ablations. Removing each proposed contribution steadily decreases the performance of the model. This set of experiments reveals that the most critical components of our model are the sigmoid outputs instead of a softmax, the soft scores used as ground truth targets, the image features from bottom-up attention [3], the gated tanh activations, the output layers initialized using GloVE and Google Images, and the smart shuffling of training data.

6 Comparison with existing methods

  VQA v2 test-dev VQA v2 test-std Method All Yes/no Numb. Other All Yes/no Numb. Other   Prior (most common answer in training set) [14] 25.98 61.20  0.36 1.17 LSTM Language only (blind model) [14] 44.26 67.01 31.55 27.37 Deeper LSTM Q norm. I [lu2015deeperLstm] as reported in [14] 54.22 73.46 35.18 41.83 MCB [13] as reported in [14] 62.27 78.82 38.28 53.36 UPMC-LIP6 [7] 65.71 82.07 41.06 57.12 Athena 67.59 82.50 44.19 59.97 LV-NUS 66.77 81.89 46.29 58.30 HDU-USYD-UNCC 68.09 84.50 45.39 59.01 Proposed model      ResNet features , single network 62.07 79.20 39.46 52.62 62.27 79.32 39.77 52.59      Image features from bottom-up attention, adaptive , single network 65.32 81.82 44.21 56.05 65.67 82.20 43.90 56.26      ResNet features , ensemble 66.34 83.38 43.17 57.10 66.73 83.71 43.77 57.20      Image features from bottom-up attention, adaptive , ensemble 69.87 86.08 48.99 60.80 70.34 86.60 48.64 61.15  

Table 3: Comparison of our best model with competing methods. Excerpt from the official VQA v2 Leaderboard [1].

We compare in Table 3 the performance of our best model with existing methods. Ours is an ensemble of 30 networks identical to the reference model (first row of Table 1) with the exception of the dimension of the hidden states, increased here to . The issue of overfitting (Section 4.7) is mitigated by the large ensemble size. Compared to Table 1, this model also includes here the validation split of VQA v2 for training. Our model obtained the first place at the 2017 VQA Challenge [1]. It still surpasses all competing methods by a significant margin at the time of writing.

7 Discussion and conclusions

This paper presented a model for VQA based on a deep neural network that significantly outperforms all other approaches proposed to date. Importantly, we reported an extensive suite of experiments that identify the contribution of each design choice and the performance of alternative designs. The general take-away from this study is that the performance is very dependent on design choices and on various details of the implementation. We attribute the success of our model to a number of points. Some are seemingly minor and easily implemented (e.g. large mini-batch size, sigmoid output) while others are clearly non-trivial (e.g. gated non-linear activations, image features from bottom-up attention, pretraining the output classifier).

This paper does not claim to make breakthrough advances in the field of VQA, which remains a largely unsolved problem. We hope that our model may however serve as a solid basis on which to make future progress. Our extensive analysis and exploration of designs is unprecedented in scale for VQA, and is intended as a significant contribution to the field. It provides indicators on the importance of various components of a VQA model. It also allows us to point at several promising directions for future developments.

We showed that significant gains were still achievable through better image features, in particular with the region-specific features of [3] that use bottom-up attention. We also measured that gains from additional VQA training data had not reached a clear plateau yet. However, the trend of collecting larger datasets is unlikely to bring significant breakthroughs. We believe that incorporating other sources of information and leveraging non-VQA datasets is a promising direction.

Our evaluation of simple baselines have shown surprisingly strong performances. For example, encoding questions as a simple bag-of-words performs almost as well as state-of-the-art recurrent encoders. It suggests that the word ordering in questions may not convey much information – which is plausible for the most basic ones – or, more realistically, that our current models are still unable to understand and make effective use of language structure. Recent works on compositional models for VQA are a promising direction to address this issue [4, 17, 20, 21].

Finally, we must be reminded to look at performance measures with a critical eye. The commonly reported metrics such as our per-question accuracy appear encouraging, but it is valuable to keep an eye on failure cases and alternative performance measures. We reported throughout this study the accuracy over balanced pairs of questions. This stricter measure requires accurate answers to two complimentary versions of a same question relating to different images. It better reflects the ability of the method for visual understanding and for making out subtle differences between images. In that case, the performance drops to the order . While far less impressive, that figure is more representative of our current state of progress on VQA. We hope that keeping such a critical outlook will encourage more radical innovation and breakthroughs in the near future.