1 Introduction
A human dialogue by its nature exhibits highly complex structures. Specifically, when we have a dialogue, some utterances are semantically dependent on previous ones (i.e., context), while others are independent, due to an abrupt change in topic. Previous topics could be readdressed later on in the dialogue. Furthermore, we take advantage of multimodal inputs, including visual, linguistic, and auditory information, to capture the temporal topics of conversation. Notably, Visual Dialog (VisDial) [das2017visual], which is an extended version of visual question answering (VQA) [antol2015vqa, goyal2017making], reflects the complex and multimodal nature of the dialogue. Unlike VQA, it is designed to answer a sequence of questions given an image, utilizing a dialog history as context. For example, to answer an ambiguous question like “Do you think they are her parents?” (D4 in Fig. 1), a dialog agent should attend to the meaningful context from a dialog history as well as visual information. This task demands a rich set of abilities – understanding a sequence of multimodal contents (i.e., an input image, questions, and dialog history), and reasoning semantic structures among them.
Previous approaches in visual dialog have explored the problem of reasoning semantic structures in dialogs by employing the softattention mechanism [bahdanau2014neural, xu2015show]. Typically, most of the previous research has focused on extracting the rich questionrelevant representations from the given image and dialog history, while implicitly finding their relationships [das2017visual, lu2017best, wu2018you, guo2019image, gan2019multi, schwartz2019factor]. Another line of research has tackled the problem of visual coreference resolution [seo2017visual, niu2018recursive, kang2019dual], and the other approach [zheng2019reasoning] attempts to find the inherent structures of the dialog. However, all previous work relies on the softattention mechanism, and we argue that applying it to the previous utterances severely limits a dialog agent to learn various types of semantic relationships. Specifically, the soft attention, which is based on a softmax function, always assigns a nonzero weight to all previous utterances, which results in dense (i.e., fullyconnected) relationships. Herein lies the problem: even for questions that are partially dependent (Q5 in Fig. 1) or independent (Q6 in Fig. 1) from the dialog history, all previous utterances are still taken into consideration and integrated into the contextual representations. As a consequence, the dialog agent overly relies on all previous utterances, even when these previous utterances are irrelevant to the given question. It may potentially hurt performance and interpretability.
In this paper, we propose Sparse Graph Learning Networks (SGLNs) that explicitly discover the sparse structures of the visuallygrounded dialogs. We present a dialog in a graph structure where each node corresponds to the round of dialog, and edges represent the semantic dependencies between the nodes, as shown in Fig. 1. The proposed SGLNs infer the graph structure and predict the answer simultaneously. SGLNs involve two novel modules: a multimodal node embedding module and a sparse graph learning module. Inspired by a bottomup and topdown attention mechanism [Anderson2017updown]
, the node embedding module embeds the given image and each round of dialog in a joined fashion, yielding the multimodal joint embeddings. We represent each embedding vector as a node of the graph. The sparse graph learning module infers two edge weights: binary (
i.e., 0 or 1) and score edges. It then ultimately discovers the sparse and weighted structure by incorporating them. Note that the sparse graph learning module ensures an isolated node when all elements in the binary edge weights are zero. It updates each node by integrating the neighborhood nodes via a message passing framework and feeds the updated node features to the answer decoder. Furthermore, we introduce a new structural loss function to encourage our model to infer explicit and reliable dialog structures by leveraging supervision that is readily obtainable. Consequently, as shown in (c) for Fig. 1, our model learns various types of semantic relationships: (1) dense relationships as in D1D4, (2) sparse relationships as in D5, and (3) no relationships as in D6. The main contributions of our paper are as follows:
We propose Sparse Graph Learning Networks (SGLNs) that consider the sparse nature of a visuallygrounded dialog. By using a multimodal node embedding module and a sparse graph learning module, our proposed model circumvents the conceptual shortcoming of dense structures by pruning unnecessary relationships.

We propose a new structural loss function to encourage SGLNs to learn the aforementioned semantic relationships explicitly. SGLNs are the first approach that predicts the sparse structures of the visuallygrounded dialog with the structural loss function.

SGLNs achieve the new stateoftheart results on the visual dialog v1.0 dataset using only 10.95% of the dialog history. Also, we make a comparison between SGLNs and the baseline models to demonstrate the effectiveness of the proposed method. Finally, we perform a qualitative analysis of our proposed model, showing that SGLNs reasonably infer the underlying sparse structures and improve interpretability compared to a baseline model.
2 Related Work
Visual Dialog. Visual dialog task [das2017visual] was recently introduced as a temporal extension of VQA [antol2015vqa, goyal2017making]. In this task, a dialog agent should answer a sequence of questions by using an image and the dialog history as a clue. We carefully categorize the previous studies on visual dialog into three groups: (1) soft attentionbased methods that compute attended representations of the image, and the history [das2017visual, lu2017best, wu2018you, guo2019image, gan2019multi, schwartz2019factor, nguyen2019efficient], (2) a visual coreference resolution [seo2017visual, kottur2018visual, niu2018recursive, kang2019dual] that clarifies ambiguous expressions (e.g., it, them) in the question and links them to a specific entity in the image, and (3) a structural learning method [zheng2019reasoning] that attempts to infer dialog structures. Our approach belongs to the third group. Zheng et al. [zheng2019reasoning]
designed a structure inference model while predicting the answer in the context of an expectationmaximization (EM) algorithm. Specifically, they proposed the model based on graph neural networks (GNNs) that approximate a process of the EM algorithm. However, similar to the soft attentionbased methods, they inferred the dense semantic structures using a softmax function in GNNs. Moreover, they implicitly recovered the structures only using supervision for the given questions. To address these two aspects, we propose SGLNs that explicitly infer sparse structures with a definite objective (
i.e., a structural loss function).On the one hand, a few [niu2018recursive, kim2020modality] have noticed the sparse property of the visual dialog, but their reasoning capability is still quite limited. The CDF [kim2020modality] randomly extracted up to three elements of the dialog history to avoid excessive exploitation of the whole history. For the visual coreference resolution, RvA [niu2018recursive] backtracked the history and selectively retrieved the visual attention maps of the previous dialogs, which are determined to be useful.
Graph Neural Networks (GNNs) [gori2005new, scarselli2008graph] have sparked a tremendous interest at the intersection of deep neural networks and structural learning approaches. There are two existing methods involving GNNs: (1) a method that operates on graphstructured data [kipf2016semi, battaglia2018relational, hamilton2017inductive, niepert2016learning, xu2018powerful], and (2) a method that constructs a graph with neural networks to approximate the learning or inference process of graphical models [sukhbaatar2016learning, battaglia2016interaction, gilmer2017neural, kipf2018neural]. More recently, graph learning networks (GLNs), which are an extension of the second method, were proposed by [pilco2019graph, on2020cut], with the goal of reasoning underlying structures of input data. Note that GLNs consider unstructured data and dynamic domains (e.g., timevarying domain). Accordingly, CBGLNs [on2020cut] attempted to discover the compositional structure of long video data by using a normalized graphcut algorithm [shi2000normalized]. Our method belongs to GLNs. However, SGLNs are significantly different from previous studies in that the SGLNs learn to build sparse structures adaptively, not relying on a predefined algorithm, and the dataset we use is highly multimodal.
3 Sparse Graph Learning Networks
In this section, we formulate the visual dialog task using graph structures, then describe our proposed model, Sparse Graph Learning Networks (SGLNs). The visual dialog task [das2017visual] is defined as follows: given an image , a caption describing the image, a dialog history until round , and a question at round , the goal is to find an appropriate answer to the question among the answer candidates, = . Following the previous work [das2017visual], we use the groundtruth answers for the dialog history.
In our approach, we consider the task as a graph with nodes, where each node corresponds to the multimodal feature for the previous dialog history and the current question . The semantic dependencies among the nodes are represented as weighted edges .
Fig. 2
provides an overview of our proposed model, Sparse Graph Learning Networks (SGLNs). Specifically, the SGLNs consist of three components: a multimodal node embedding module, a sparse graph learning module, and an answer decoder. The multimodal node embedding module aims to learn the rich visuallinguistic representations for each round of dialog by employing the simple attention mechanism. We represent the multimodal joint feature vector for each round of dialog as a node of the graph. The sparse graph learning module estimates the binary and score edges among the nodes and combines these two edge weights into sparse weighted edges. Then, the sparse graph learning module aggregates the neighborhood node feature vector for the current question via the message passing algorithm
[gilmer2017neural]. The aggregated hidden feature is fed into the answer decoder, which yields the most likely answer. Furthermore, the binary edges (i.e., 0 or 1) that represent the semantic relevance among the nodes are fed into the structural loss function to predict reliable dialog structures in test time. Drawing comparisons to human cognition, this multimodal node embedding module acts similarly to human episodic memory [baddeley2000episodic], where each node corresponds to a unit of episodic memory that contains visual and linguistic information for each round of dialog. Also, the sparse graph learning module mimics the behavior of a human who adaptively recalls relevant multimodal information from their episodic memory.In the following subsections, we will introduce input features for SGLNs, then describe the detailed architectures of the multimodal node embedding module, the sparse graph learning module, and the answer decoder. Finally, we present the objective function for SGLNs.
3.1 Input Features
Visual Features. In the given image , we extract the dimensional visual features of objects by employing the pretrained Faster RCNN model [ren2015faster, Anderson2017updown], which are denoted as .
Language Features. We first encode the question which is a word sequence of length , , by using a bidirectional LSTM [hochreiter1997long] as follows:
(1)  
(2)  
(3) 
where and denote the forward and backward hidden states of the th word, respectively. Note that we use the concatenation of the last hidden states from each LSTM, followed by a projection matrix , which results in . Likewise, each round of the dialog history is encoded into , and the all answer candidates at the th round are also embedded to with additional LSTMs.
3.2 Multimodal Node Embedding Module
As shown in Fig. 2, the multimodal node embedding module embeds the visuallinguistic joint representations associated with each node , by performing visual grounding of each language features. To implement these processes, we take inspiration from a bottomup and topdown attention mechanism [Anderson2017updown, kim2016hadamard]. For the objectlevel visual features and the corresponding language feature , the node embedding module firstly finds the spatial objects that the language feature describes with the soft attention mechanism. Formally,
(4)  
(5)  
(6) 
where and are nonlinear functions that transforms inputs to
dimensional space, such as multilayer perceptrons (MLPs).
denotes the hadamard product (i.e., elementwise multiplication), and are a vector whose elements are all one. The attention function is parametrized by vector. Then, the multimodal feature is obtained from the attended visual feature and the language feature as follow:(7) 
where and are projection functions. As a consequence, we obtain visuallinguistic joint representations for all nodes which can be represented in the matrixform .
3.3 Sparse Graph Learning Module
The sparse graph learning module infers the underlying sparse and weighted graph structure between nodes, where the edge weights are estimated based on the node features. To make the graph structure to be sparse, we propose two types of edges on the graph : binary edges and score edges , which corresponding adjacency matrices are and respectively. To simplify the notations, we omit the subscription in the following equations.
Binary Edges. We first define the binary edge between two nodes and
as a binary random variable
, for all and. The sparse graph learning module estimates the likelihood of the binary variables given the node features, where the probability implies whether the two nodes are semantically related or not. We regard the binary variable as a twoclass categorical variable and define the probability distribution as follows:
(8)  
(9) 
where is a learnable parameter and is the softmax temperature. Since is discrete and nondifferentiable, we employ StraightThrough GumbelSoftmax estimator (i.e., STGumbel) [jang2016categorical] to ensure endtoend training. During the forward propagation, the STGumbel makes a discrete decision by using a GumbelMax trick [maddison2016concrete]:
(10) 
where random variable are drawn from [jang2016categorical]. In the backward pass, the STGumbel utilizes the derivative of the probabilities by approximating , thus enabling the backpropagation and endtoend training.
Score Edges. We also define the score edges that measure the extent to which the two nodes are relevant, and the weighted adjacency matrix is computed as:
(11) 
with a learnable parameter . Following the relational graph learning algorithm [yang2018glomo], we compute the score edges using the squared operation for the stabilized training.
Sparse Weighted Edges. The sparse graph learning module multiplies the binary edges and score edges, finally yielding the sparse and weighted adjacency matrix as:
(12) 
With the above edge weight estimations, the sparse graph learning module is able to model three types of relationship on : (1) dense relationships similar to the previous conventional softmaxbased approaches if (i.e., all entries in are one),
(2) sparse relationships if , and
(3) no relationships if (i.e., isolated).
Messagepassing and Update. Based on the sparse weighted adjacency matrix , the sparse graph learner updates the hidden states of all nodes through a messagepassing framework [gilmer2017neural]. Similar to the graph convolutional networks [kipf2016semi], we simply implemented the messagepassing layer as a linear projection of node features, followed by the normalized weighted sum according to the adjacent weights.
(13) 
Note that is the degree matrix of . The hidden features of nodes are calculated via the update layer that adds the input feature and aggregated messages then feeds them into a nonlinear function .
(14) 
Notice that the sparse graph structure inference followed by the hidden state update can be viewed as a dialog reasoning. Moreover, the model is able to do multistep reasoning by repeatedly conducting the inference and update based on the hidden states. In this paper, for the sake of simplicity, we assume that the only edges connected to the question node exist (i.e., ). For the question node , the message vector and hidden state vector is simply represented as below formula:
(15) 
The sparse graph learner outputs the hidden state vector for the question node to predict the answer.
3.4 Answer Decoder
3.4.1 Discriminative Decoder.
The discriminative decoder computes the likelihood of the answer candidates by dotproduct operations between the hidden vector and feature vectors for the answer candidates . Then, the SGLNs are optimized by minimizing negative loglikelihood of the groundtruth answer as:
(16)  
(17) 
where
is the onehot encoded label vector. For evaluation, the answer candidates are ranked according to the likelihood.
3.4.2 Generative Decoder.
Similarly to the sequencetosequence model, the generative decoder aims to generate the groundtruth answer’s word sequence autoregressively via a LSTMs:
(18) 
where is the output of the sparse graph learning module, and denotes the groundtruth answer consisting of words . We initialize the hidden states of the LSTMs with (i.e., ). Following the Visual Dialog task [das2017visual], we utilize the loglikelihood scores to determine the rank of candidate answers for the process of evaluation.
3.5 Objective Function
3.5.1 Structural Loss Function.
Along with the two loss functions, and , we introduce a structural loss function to encourage the SGLNs to infer explicit, reliable dialog structures. Inspired by the visual coreference resolution model [kottur2018visual], our method utilizes the structural supervision in addition to the groundtruth answer at each round. Specifically, we automatically obtain the semantic dependencies among each round of dialog as a form of a lower triangular binary matrix from an offtheshelf neural coreference resolution tool ^{1}^{1}1https://github.com/huggingface/neuralcoref based on the work [clark2016deep]. and use the information as the structural supervision. Consequently, the SGLNs minimize the distance between the structural supervision and the binary matrix that is predicted from our model:
(19) 
where denotes the elementwise mean squared error. Here, encourages the SGLNs to predict a reliable adjacency matrix (i.e., dialog structure). Note that the SGLNs use the structural supervision only while training, and infer the dialog structures at test time. We clarify that the efficiency of the coreference resolution was explored for the visual dialog tasks by the previous work [kottur2018visual]; however, their gain is limited as they use a different approach from ours.
3.5.2 Multitask Learning.
To predict the dialog structure and answer to the given questions, the SGLNs are trained to minimize the sum of the losses based on both the structural loss and the loss of answer decoder: or where are weights for each loss. Optionally, the SGLNs takes the dual decoder strategy by minimizing the three losses simultaneously: . Unless stated otherwise, the default loss is . The implementation details and results will be discussed in Section 4.
4 Experiments
In this section, we describe the details of our experiments on the Visual Dialog dataset. We first introduce the Visual Dialog dataset, evaluation metrics, and implementation details. Then, we compare the SGLNs with baseline models and stateoftheart methods. Note that the qualitative analysis of our proposed model is described in Sec.
5.4.1 Experimental Setup
Dataset. We benchmark our proposed model on the Visual Dialog (i.e., VisDial) v1.0 dataset. The VisDial dataset [das2017visual] was collected in a twoplayer chatting environment, where a questioner tries to figure out an unseen image by asking freeform questions, and an answerer responds to the questions based on the image. As a result, the VisDial v1.0 dataset contains 1.2M, 20k, and 44k questionanswer pairs as train, validation, and test splits, respectively. The 123,287 images from COCO [lin2014microsoft], 2,064, and 8k images from Flickr are used to collect the dialog data for each split, respectively. A list of 100 answer candidates accompanies each questionanswer pair.
Evaluation. We follow the standard protocol for evaluating the visual dialog model, as proposed in the earlier work [das2017visual]. Specifically, the visual dialog model ranks a list of 100 candidate answers and returns the ranked list for further evaluation. There are four kinds of evaluation metrics in the Visual Dialog task: (1) mean reciprocal rank (MRR) of the groundtruth answer in the ranked list, (2) recall@k (R@k), which is the existence of the groundtruth answer in the topk list, (3) mean rank (Mean) of the groundtruth answer, and (4) normalized discounted cumulative gain (NDCG). Contrary to the classical retrieval metrics (MRR, R@k or mean rank), which are only based on a single groundtruth answer, NDCG takes into account all relevant answers from the 100answer list by using the densely annotated relevance scores. It penalizes the lowerranked answers with high relevance scores, and swapping candidates with the same relevance does not affect NDCG. Due to these properties, NDCG is regarded as the primary metric and used to evaluate methods for the VisDial v1.0 dataset.
Implementation Details. The SGLNs embed all the language inputs to 300dimensional vector initialized by GloVe [pennington2014glove]. All three BiLSTMs used for encoding the word embedding vectors are singlelayer with 512 hidden units. We also use the bottomup attention features [Anderson2017updown] from Faster RCNN [ren2015faster] pretrained on the Visual Genome [krishna2017visual]. The number of object features per image is , and the dimension of each feature is . The dimension of
is 512. The hyperparameters for the multitask learning are
, , and . We employ Adam optimizer [kingma2014adam] with initial learning rate . The learning rate is warmed up tountil epoch 4 and is halved every two epochs from 5 to 10 epochs. We use the VisDial v1.0 training split for evaluating our proposed model on the validation and test splits.
Method  NDCG  MRR  R@1  R@5  R@10  Mean  Sparsity 
Dense  59.53  63.21  49.56  80.02  89.25  4.42  0% 
Sparsehard  61.89  61.28  47.41  78.13  88.27  4.70  81.82% 
SGLNs  62.83  60.54  46.64  77.59  87.33  4.89  89.15% 
4.2 Quantitative Results
4.2.1 Comparison with Baselines.
We compare SGLNs to the baseline models to demonstrate the effectiveness of our method. We define two models as baselines: Dense, and Sparsehard. The Dense model utilizes a softmax attention mechanism, which results in the fullyconnected graph. Contrary to the Dense model, the Sparsehard model picks exactly one element among the dialog history by applying the GumbelSoftmax to the whole dialog history. Note that the structural supervision is provided in the Sparsehard model. The results are summarized in Table 1. The SGLNs achieve better performance than the baseline models on the NDCG metric, maintaining competitive performance on the groundtruth dependent metrics (i.e., MRR, R@k, and Mean rank). We also observe that the Dense model, which overly exploits the dialog history, shows the best performance on the groundtruth dependent metrics. We argue that the Dense model mainly focuses on finding the single groundtruth answer with a rich set of dialog history, with the cost of sacrificing the ability to provide ‘flexible’ answers (i.e., NDCG). Similarly, the NDCG performance for the Sparsehard model tends to increase as the sparsity increased.
4.2.2 Questiontype Analysis.
As the same setup as the above experiment, we conduct a questiontype analysis of the NDCG scores to verify our hypothesis discussed in Sec. 1. Based on the semantic dependency information introduced in Sec. 3, we categorize the entire questions in the VisDial v1.0 validation split into three groups: (1) independent questions that can be answered without dialog history, (2) partially dependent questions that demand a few elements of dialog history, and (3) densely dependent questions that require all previous dialogs. As illustrated in Fig. 3, we compare our proposed model with a softmaxbased Dense model, showing that the SGLNs significantly outperform the Dense model on all types of questions. The performance gap between the two models is 3.74%, 2.61%, and 0.83% for each type of question, respectively. We observe that the Dense model relatively suffers from finding relevant answers for independent questions. It validates that excessive exploitation of the dialog history could cause a distraction for such questions.
Method  NDCG  MRR  R@1  R@5  R@10  Mean  Sparsity 
LF [das2017visual]  45.31  55.42  40.95  72.45  82.83  5.95   
HRE [das2017visual]  45.46  54.16  39.93  70.45  81.50  6.41   
MN [das2017visual]  47.50  55.49  40.98  72.30  83.30  5.92   
GNN [zheng2019reasoning]  52.82  61.37  47.33  77.98  87.83  4.57   
CorefNMN [kottur2018visual]  54.70  61.50  47.55  78.10  88.80  4.40   
RvA [niu2018recursive]  55.59  63.03  49.03  80.40  89.83  4.18   
DualVD [jiang2019dualvd]  56.32  63.23  49.25  80.23  89.70  4.11   
FGA [schwartz2019factor]  56.93  66.22  52.75  82.92  91.08  3.81   
HACAN [Yang_2019_ICCV]  57.17  64.22  50.88  80.63  89.45  4.20   
DL61 [guo2019image]  57.32  62.20  47.90  80.43  89.95  4.17   
DAN [kang2019dual]  57.59  63.20  49.63  79.75  89.35  4.30   
NMN [kottur2018visual]  58.10  58.80  44.15  76.88  86.88  4.81   
Transformer [nguyen2019efficient]  60.92  60.65  47.00  77.03  87.75  4.90   
SGLNs  60.77  58.40  44.15  75.65  85.70  5.22  89.14% 
SGLNs  61.27  59.97  45.68  77.12  87.10  4.85  89.05% 
Method  NDCG  MRR  R@1  R@5  R@10  Mean  Sparsity 
MN [das2017visual]  56.99  47.83  38.01  57.49  64.08  18.76   
HCIAE [lu2017best]  59.70  49.07  39.72  58.23  64.73  18.32   
CoAtt [wu2018you]  59.24  49.64  40.09  59.37  65.92  17.86   
ReDAN [gan2019multi]  60.47  50.02  40.27  59.93  66.78  17.40   
SGLNs  60.82  48.82  39.64  57.58  64.37  18.03  87.03% 
4.2.3 Comparison with the Stateoftheart.
We compare our proposed model with the stateoftheart methods on VisDial v1.0 dataset. As shown in Table 2, SGLNs with the discriminative decoder outperform all other methods with respect to the NDCG metric, including the concurrent work, Transformer [nguyen2019efficient]. They demonstrated the effectiveness of training the discriminative and generative decoder simultaneously (i.e., ). Accordingly, we also apply the dual decoder strategy as described Sec. 3 for a fair comparison, lifting our model’s NDCG to 61.27%. The results of the dual decoder models are obtained from the output of the discriminative decoder. Note that the sparsity of the SGLNs is 89.05%, which means that our proposed model only utilizes 10.95% of the dialog history. The sparsity is calculated as the percentage of zerovalued edges in the graph. We consider these results encouraging as they indicate that the SGLNs adaptively attend to the dialog history while achieving the new stateoftheart performance on the primary metric. Furthermore, we report the performance of the generative decoderbased models on VisDial v1.0 validation split. As shown in Table 3, the SGLNs achieve a new stateoftheart performance on NDCG with sparsity of 87.03%. Note that all entries in Table 3 are reimplemented by [gan2019multi], utilizing the objectlevel visual features from the Faster RCNN [ren2015faster] and GloVe [pennington2014glove] vectors for a fair comparison.
5 Discussions
Visualization of the Inferred Graph Structures.
For qualitative analysis, in Fig. 4, we visualize the images, the corresponding dialogs in the validation split, and the inferred adjacency matrices as well as the ones from the Dense mode as a counter.
Compared to the dense structure in the baseline, the proposed SGLNs indeed learn the innate sparse structures, and the question nodes receive the information from the other nodes in a selective fashion.
For instance, In the first dialog example, the questions from Q3 to Q10 have nonzero binary edges to all previous contexts except the D1 and D2, which do not contain relevant information about ‘the woman’.
On the contrary, the Q1 and Q2 are not connected to the other, even the caption node, because they can be answered solely without additional context.
Knowledge Transfer of Semantic Structure. In Section 3.5, the structural loss function can be seen as a knowledge distillation loss [Hinton2014] to transfer the knowledge from the pretrained neural coreference resolution model to our sparse graph learning module. Even though we employ STGumbel to mitigate the unpredictability of training the binary edges, this structural loss was decisively helpful to boost the early stage of training.
6 Conclusions
In this paper, we formulate the visual dialog tasks as a graph structure learning tasks where the edges represent the semantic dependencies among the multimodal embedding nodes learned from the given image, caption and question, and dialog history.
The proposed Sparse Graph Learning Networks (SGLNs) learn the sparse dialog structures by incorporating binary and score edges, leveraging structural supervisions.
Our experiments demonstrate the efficacy of SGLN by achieving the stateoftheart NDCG performance on the VisDial v1.0 dataset with 61.27 for the teststd split, only using the 10.95 % of dialog.
Qualitatively, the visualized analysis with the inferred graph structures shows adaptive mechanisms depending on the type of the questions.
Acknowledgements. The authors would like to thank SK TBrain for sharing GPU resources. This work was partly supported by the Korea government (2015000310SW.StarLab, 2017001772VTT, 2019001367BabyMind).