Differentiable Scene Graphs

TL;DR

This paper introduces Differentiable Scene Graphs (DSGs), a novel dense, end-to-end trainable image representation that improves visual reasoning by enabling joint training for tasks like identifying referring relationships.

Contribution

The paper proposes DSGs, a differentiable scene graph representation that allows end-to-end training for visual reasoning tasks, overcoming the non-differentiability of traditional scene graphs.

Findings

Achieves state-of-the-art results on referring relationship identification.

Effective in three benchmark datasets: Visual Genome, VRD, and CLEVR.

Enables joint training with downstream tasks for improved performance.

Abstract

Reasoning about complex visual scenes involves perception of entities and their relations. Scene graphs provide a natural representation for reasoning tasks, by assigning labels to both entities (nodes) and relations (edges). Unfortunately, reasoning systems based on SGs are typically trained in a two-step procedure: First, training a model to predict SGs from images; Then, a separate model is created to reason based on predicted SGs. In many domains, it is preferable to train systems jointly in an end-to-end manner, but SGs are not commonly used as intermediate components in visual reasoning systems because being discrete and sparse, scene-graph representations are non-differentiable and difficult to optimize. Here we propose Differentiable Scene Graphs (DSGs), an image representation that is amenable to differentiable end-to-end optimization, and requires supervision only from the downstream tasks. DSGs provide a dense representation for all regions and pairs of regions, and do not spend modelling capacity on areas of the images that do not contain objects or relations of interest. We evaluate our model on the challenging task of identifying referring relationships (RR) in three benchmark datasets, Visual Genome, VRD and CLEVR. We describe a multi-task objective, and train in an end-to-end manner supervised by the downstream RR task. Using DSGs as an intermediate representation leads to new state-of-the-art performance.

Tables

Table 1. Table 1: Comparison with baselines. Test-set mean IOU in the referring relationship task for the baselines in Sec.  5.3 and the Differentiable Scene Graph (DSG) model. Results are also reported for a no-DSG model (see Sec.  6.2 ) which classifies the referring relationship directly from the RPN output.

	Average IOU
	Visual Genome		VRD		CLEVR
	subject	object	subject	object	subject	object
SS [29]	0.399	0.469	0.320	0.371	0.740	0.740
CO [10]	0.414	0.490	0.347	0.389	0.691	0.691
VRD [35]	0.417	0.480	0.345	0.387	0.734	0.732
SASS [27]	0.421	0.482	0.369	0.410	0.778	0.778
no-DSG	0.412	0.47	0.333	0.366	0.937	0.937
DSG	0.489	0.539	0.4	0.435	0.963	0.963

Table 2. Table 2: Model ablations : Results (including standard errors) for DSG variants on the validation set of the Visual Genome dataset. DSG values slightly differ from Table 1 which reports IOU on the test set. The various models are described in Sec.  6.2 .

	Average IOU
	subject	object
Two Step	$0.430\pm 0.0014$	$0.491\pm 0.0014$
no-DSG	$0.405\pm 0.0013$	$0.461\pm 0.0013$
DSG -SGL	$0.455\pm 0.0014$	$0.511\pm 0.0013$
DSG -BR	$0.469\pm 0.0014$	$0.519\pm 0.0014$
DSG	$\text{0.477}\pm 0.0014$	$\text{0.528}\pm 0.0014$

Table 3. Table 3: Analysis of running/training time and computational resources of DSGs.

	DSG Generator	Resnet101
Trainable parameters		$>40M$
Number of operations		$>15G$

Equations

$$\mathbf{g}=\sum _{i=1}^n\mathbf{\alpha }({\mathbf{z}}_i,\sum _{j\ne i}\mathbf{\varphi }({\mathbf{z}}_i,{\mathbf{z}}_{i,j},{\mathbf{z}}_j))$$

$${\mathbf{z}}_k^{\prime }={\mathbf{\rho }}^{entity}({\mathbf{z}}_k,\mathbf{g}),{\mathbf{z}}_{k,l}^{\prime }={\mathbf{\rho }}^{relation}({\mathbf{z}}_{k,l},\mathbf{g})$$

Full text

\star$$\starfootnotetext: Equal Contribution.

1 Introduction

Understanding the full semantics of rich visual scenes is a complex task that involves detecting individual entities, as well as reasoning about the combination of entities and the relations between them. To represent entities and their relations jointly, it is natural to view them as a graph, where nodes are entities and edges represent relations. Such representations are often called Scene Graphs (SGs) [23]. Because SGs allow to explicitly reason about images, substantial efforts have been made to infer them from raw images [22, 23, 50, 33, 57, 17, 58].

While scene graphs have been shown to be useful for various tasks [22, 23, 20], using them as a component in a visual reasoning system is challenging: (a) Because scene graphs are discrete representations, it is difficult to learn them in an end-to-end fashion from a downstream task. (b) The alternative is to pre-train SG predictors separately from supervised data, but this requires arduous and prohibitive manual annotation. Moreover, pre-trained SG predictors have low coverage, because the set of labels they are pre-trained on rarely fits the needs of a downstream task. For example, given an image of a parade and a question “point to the officer on the black horse”, that horse might not be a node in the graph, and the term “officer” might not be in the vocabulary. Given these limitations, it is an open question how to make scene graphs useful for visual reasoning applications.

In this work, we describe Differentiable Scene-Graphs (DSG), which address the above challenges (Figure 1). DSGs are an intermediate representation trained end-to-end from the supervision for a downstream reasoning task. The key idea is to relax the discrete properties of scene graphs such that each entity and relation is described with a dense differentiable descriptor.

We demonstrate the benefits of DSGs in the task of resolving referring relationships (RR) [27] (see Figure 1). Here, given an image and a triplet query $\langle$subject, relation, object$\rangle$, a model has to find the bounding boxes of the subject and object that participate in the relation.

We train an RR model with DSGs as an intermediate component. As such, DSGs are not trained with direct supervision about entities and relations, but using several supervision signals about the downstream RR task. We evaluate our approach on three standard RR datasets: Visual Genome [28], VRD [35] and CLEVR [21], and find that DSGs substantially improve performance compared to state-of-the-art approaches [35, 27].

To conclude, our novel contributions are: (1) A new Differentiable Scene-Graph representation for visual reasoning, which captures information about multiple entities in an image and their relations. We describe how DSGs can be trained end-to-end with a downstream visual reasoning task without direct supervision of manually annotated scene-graphs. (2) A new architecture for the task of referring relationships, using DSGs as its central component. (3) New state-of-the-art results on the task of referring relationships on the Visual Genome, VRD and CLEVR datasets.

2 Referring Relationship: The Learning Setup

In the referring relationship task [27] we are given an image $I$ and a subject-relation-object query $q=\langle s,r,o\rangle$. The goal is to output a bounding box $\mathcal{B}_{s}$ for the subject, and another bounding box $\mathcal{B}_{o}$ for the object. In practice there are sometimes several boxes for each. See Fig. 1 for a sample query and expected output.

Following [27], we focus on training a referring relationship predictor from labeled data. Namely, we use a training set consisting of images, queries and the correct boxes for these queries. We denote these by $\{(I_{j},q_{j},(\mathcal{B}^{s}_{j},\mathcal{B}^{o}_{j})\}_{j=1}^{N}$. As in [27], we assume that the vocabulary of query components (subject, object and relation) is fixed.

In our model, we break this task into two components that we optimize in parallel. We fine-tune the position of bounding boxes such that they cover entities tightly, and we also label each box as one of the following four possible labels. The labels “Subject” and “Object” correspond to the ’s’ and ’o’ entities in the query. The label “Other” corresponds to boxes that contain entities (e.g., person or any other category that can appear as a subject or object in queries) that are not the subject or the object of the query. Finally, the label “Background” corresponds to boxes that do not contain an entity. We refer to the above two modules as Box Refiner and Referring Relationships Classifier.

3 Differentiable Scene Graphs

We begin by discussing the motivation and potential advantages of using intermediate scene-graph-like representations, as compared to standard scene graphs. We then explain how DSGs fit into the full architecture of our model.

3.1 Why use intermediate DSG layers?

A “perfect” scene graph (representing all entities and relations) captures most of the information needed for visual reasoning, and thus should be useful as an intermediate representation. Such a SG can then be used by downstream reasoning algorithms, using the predicted SG as an input. Unfortunately, learning to predict “perfect” scene graphs for any downstream task is unlikely. First, there is rarely enough data to train good SG predictors, and second, learning to predict SGs in a way that is independent of the downstream task, tends to yield less relevant SGs.

Instead, we propose an intermediate representation, which we refer to as a “Differentiable Scene Graph” layer (DSG). A DSG captures the relational information as in a scene graph but can be trained end-to-end in a task-specific manner (Fig. 2). Like SGs, a DSG keeps descriptors for visual entities and their relations. Unlike SGs, whose nodes and edges are annotated by discrete values (labels), a DSG contains a dense distributed representation vector for each detected entity (referred to as a node descriptor) and each pair of entities (referred to as an edge descriptor). These representations are themselves learned functions of the input image (see supplementary for more details). Like SGs, a DSG only describes candidate boxes which cover entities of interest and their relations. Unlike SGs, each DSG descriptor captures not only the local information about a node, but also information about its context. Most importantly, because DSGs are differentiable, they are used as input to downstream visual-reasoning modules (in our case, a referring relationships module).

DGSs provide several computational and modelling advantages:

Differentiability. Because node and edge descriptors are differentiable functions of detected boxes, and are fed into a differentiable reasoning module, the entire pipeline can be trained with gradient descent.

Dense descriptors. By keeping dense descriptors for nodes and edges, the DSG keeps more information about possible semantics of nodes and edges, instead of committing too early to hard sparse representations. This allows it to better fit downstream tasks.

Supervision using downstream tasks. Collecting supervised labels for training scene graphs is hard and costly. DGSs can be trained using training data that is available for downstream tasks, saving costly labeling efforts. On the other hand, when labeled scene graphs are available for given images, that data can be used when training the DSG, using an additional loss component.

Holistic representation. DSG descriptors are computed by integrating global information from the entire image using graph neural networks (see supplemental materials). Combining information across the image increases the accuracy of object and relation descriptors.

3.2 The DSG Model for Referring relationships

We now describe how DSGs can be combined with other modules to solve a visual reasoning task. The architecture of the model is illustrated in Fig. 2. First, the model extracts bounding boxes for entities and relations in the image. Next, it creates a differentiable scene-graph over these bounding boxes. Then, DSG features are used by two output modules, aimed at answering a referring-relationship query: a Box Refiner module that refines the bounding box of the relevant entities, and a Referring Relationships Classifier module that classifies each box as Subject, Object, Other or Background. We now describe these components in more detail.

Object Detector. We detect candidate entities using a standard region proposal network (RPN) [43], and denote their bounding boxes by $\boldsymbol{b}{}_{1},\ldots,\boldsymbol{b}{}_{B}$ ($B$ may vary between images). We also extract a feature vector $\boldsymbol{f}{}_{i}$ for each box and concatenate it with the box coordinates, yielding $\boldsymbol{z}_{i}=[\boldsymbol{f}{}_{i};\boldsymbol{b}_{i}{}]$. See details in the supplemental material

Relation Feature Extractor. Given any two bounding boxes $\boldsymbol{b}{}_{i}$ and $\boldsymbol{b}{}_{j}$ we consider the smallest box that contains the two boxes (their “union” box). We denote this “relation box” by $\boldsymbol{b}{}_{i,j}$ and its features by $\boldsymbol{f}{}_{i,j}$. Finally, we denote the concatenation of the features $\boldsymbol{f}{}_{i,j}$ and box coordinates $\boldsymbol{b}_{i,j}{}$ by $\boldsymbol{z}_{i,j}=[\boldsymbol{f}{}_{i,j};\boldsymbol{b}_{i,j}]$.

Differentiable Scene-Graph Generator. As discussed above, the goal of the DSG Generator is to transform the above features $\boldsymbol{z}_{i}$ and $\boldsymbol{z}_{i,j}$ into differentiable representations of the underlying scene graph. Namely, map these features into a new set of dense vectors $\boldsymbol{z}`_{i}$ and $\boldsymbol{z}`_{i,j}$ representing entities and relations. This mapping is intended to incorporate the relevant context of each feature vector. Namely, the representation $z^{\prime}_{i}$ contains information about the $i^{th}$ entity, together with its image-wide context.

There are various possible approaches to achieve this mapping. Here we use the model proposed by [17], which uses a graph neural network for this transformation (see supplemental material).

Multi-task objective. In many domains, training with multi-task objectives can improve the accuracy of individual tasks, because auxiliary tasks operate as regularizers, pushing internal representations away from overfitting and towards capturing useful properties of the input. We follow this idea here and define a multi-task objective that has three components: (a) a Referring Relationships Classifier matches boxes to subject and object query terms. (b) A Box Refiner predicts accurate tight bounding boxes. (c) A Box Labeler recognizes visual entities in boxes if relevant ground truth is available.

Fig. 3 illustrates the effect of the first two components, and how they operate together to refine the bounding boxes and match them to the query terms. Specifically, Fig. 3c, shows how box-refinement produces boxes that are tight around objects and subjects, and Fig. 3d shows how RR classification matches boxes to query terms.

(A) Referring Relationships Classifier. Given a DSG representation, we use it for answering referring relationship queries. Recall that the output of an RR query $\langle$subject, relation, object$\rangle$ should be bounding boxes $\mathcal{B}_{s},\mathcal{B}_{o}$ containing subjects and objects that participate in the query relation. Our model has already computed $B$ bounding boxes $\boldsymbol{b}{}_{i}$, as well as representations $\boldsymbol{z}^{\prime}_{i}$ for each box. We next use a prediction model $F_{RRC}(\boldsymbol{z}^{\prime}_{i},q)$ that takes as input features describing the bounding box and the query, and outputs one of four labels $\{$Subject, Object, Other, Background$\}$ (see Sec. 2). Denote the logits generated by this classifier for the $i^{th}$ box by $\boldsymbol{r}_{i}\in\mathbb{R}^{4}$. The output set $\mathcal{B}_{s}$ (or $\mathcal{B}_{o}$) is simply the set of bounding boxes classified as Subject (or Object). See supplemental materials for further implementation details.

(B) Box Refiner. The DSG is also used for further refinement of the bounding-boxes generated by the RPN network. The idea is that additional knowledge about image context can be used to improve the coordinates of a given entity. This is done via a network $F_{BR}(\boldsymbol{b}_{i},\boldsymbol{z}^{\prime}_{i})$ that takes as input the RPN box coordinates and a differentiable representation $\boldsymbol{z}^{\prime}_{i}$ for box $i$, and outputs new bounding box coordinates. See Fig. 3 for an illustration of box refinement, and the supplemental material for further details.

(C) Optional auxiliary losses: Scene-Graph Labeling. In addition to the Box Refiner and Referring Relationships Classifier modules described above, one can also use supervision about labels of entities and relations if these are available at training time. Specifically, we train an object-recognition classifier operating on boxes, which predicts the label of every box for which a label is available. This classifier is trained as an auxiliary loss, in a multi-task fashion, and is described in detail below.

4 Training with Multiple Losses

We next explain how our model is trained for the RR task, and how we can also use the RR training data for supervising the DSG component. We train with a weighted sum of three losses: (1) Referring Relationships Classifier (2) Box Refiner (3) Optional Scene-Graph Labeling loss. We now describe each of these components. Additional details are provided in the supplemental material.

4.1 Referring Relationship Classification Loss

The Referring Relationships Classifier (Sec. 3.2) outputs logits $\boldsymbol{r}_{i}$ for each box, corresponding to its prediction (subject, object, etc.). To train these logits, we need to extract their ground-truth values from the training data. Recall that a given image in the training data may have multiple queries, and so may have multiple boxes that have been tagged as subject or object for the corresponding queries. To obtain the ground-truth for box $i$ and query $q=\langle s,r,o\rangle$ we take the following steps. First, we find the ground-truth box that has maximal overlap with box $i$. If this box is either a subject or object for the query $q$, we set $\boldsymbol{r}^{gt}_{i}$ to be Subject or Object respectively. Otherwise, if the overlap with a ground-truth box for a different image-query is greater than $0.5$, we set $\boldsymbol{r}^{gt}_{i}=\texttt{Other}$ (since it means there is some other entity in the box), and we set $\boldsymbol{r}^{gt}_{i}=\texttt{Background}$ if the overlap is less than $0.3$. If the overlap is in $[0.3,0.5]$ we do not use the box for training. For instance, given a query $\langle$woman, feeding, giraffe$\rangle$ with ground-truth boxes for “woman” and “giraffe”, consider the box in the RPN that is closest to the ground-truth box for “woman”. Assume the index of this box is $7$. Similarly, assume that the box closest to the ground-truth for “giraffe’ has index $5$. We would have $\boldsymbol{r}_{7}^{gt}={\texttt{Subject}}$, $\boldsymbol{r}_{5}^{gt}={\texttt{Object}}$ and the rest of the $\boldsymbol{r}_{i}^{gt}$ values would be either Other or Background. Given these ground-truth values, the Referring Relationship Classifier Loss is simply the sum of cross entropies between the logits $\boldsymbol{r}_{i}$ and the one-hot vectors corresponding to $\boldsymbol{r}_{i}^{gt}$.

4.2 Box Refiner Loss

To train the Box Refiner, we use a smooth $L_{1}$ loss between the coordinates of the refined (predicted) boxes and their ground truth ones.

4.3 Scene-Graph Labeling Loss

When ground-truth data about entity labels is available, we can use it as an additional source of supervision to train the DSG. Specifically, we train two classifiers. A classifier from features of entity boxes $\boldsymbol{z}^{\prime}_{i}$ to the set of entity labels, and a classifier from features of relation boxes $\boldsymbol{z}^{\prime}_{i,j}$ to relation labels. We then add a loss to maximize the accuracy of these classifiers with respect to the ground truth box labels.

4.4 Tuning the Object Detector

In addition to training the DSG and its downstream visual-reasoning predictors, the object detector RPN is also trained. The output of the RPN is a set of bounding boxes. The ground-truth contains boxes that are known to contain entities. The goal of this loss is to encourage the RPN to include these boxes as proposals. Concretely, we use a sum of two losses: First, an RPN classification loss, which is a cross entropy over RPN anchors where proposals of 0.8 overlap or higher with the ground truth boxes were considered as positive. Second, an RPN box regression loss which is a smooth L1 loss between the ground-truth boxes and proposal boxes.

5 Experiments

In the following sections we provide details about the datasets, training, baselines models, evaluation metrics, model ablations and results. Implementation details of the model are provided in the supplemental material.

5.1 Datasets

We evaluate the model in the task of referring relationships on three datasets, each exhibiting a unique set of characteristics and challenges.

CLEVR [21]. A synthetic dataset generated from scene-graphs with four spatial relations: “left”, “right”, “front” and “behind”, and 48 entity categories. It has over 5M relationships where 33% are ambiguous entities (multiple entities of the same type in an image).

VRD [35]. The Visual Relationship Detection dataset contains 5,000 images with 100 entity categories and 70 relation categories. In total, VRD contains 37,993 relationship annotations with 6,672 unique relationship types and 24.25 relations per entity category. 60.3% of these relationships refer to ambiguous entities.

Visual Genome [28]. VG is the largest public corpus for visual relationships in real images, with 108,077 images annotated with bounding boxes, entities and relations. On average, images have 12 entities and 7 relations per image. In total, there are over 2.3M relationships where 61% of those refer to ambiguous entities.

For a proper comparison with previous results [27], we used the data from [27] including the same entity and relation categories, query relationships and data splits.

5.2 Evaluation Metrics

We compare our model to previous work using the average IOU for subjects and for objects. To compute the average subject IOU, we first generate two $L\times L$ binary attention maps: one that includes all the ground truth boxes labeled as Subject (recall that few entities might be labeled as Subject) and the other includes all the box proposals predicted as Subject. If no box is predicted as Subject, the box with the highest score for the label Subject is included in the predicted attention map. We then compute the Intersection-Over-Union between the binary attention maps. For a proper comparison with previous work [27], we use $L=14$. The object boxes are evaluated similarly.

5.3 Baselines

The Referring Relationship task was introduced recently [27], and the SSAS model was proposed as a possible approach (see below). We report the results for the baseline models in [27]. When evaluating our Differentiable Scene-Graph model, we use exactly the evaluation setting as in [27] (i.e., same data splits, entity and relation categories). The baselines reported are:

Symmetric Stacked Attention Shifting (SSAS): [27] An iterative model that localizes the relationship entities using attention shift component learned for each relation. 2. 2.

Spatial Shifts [29]: Same as SSAS, but with no iterations and by replacing the shift attention mechanism with a simple statistical spatial shift for each relation label. 3. 3.

Co-Occurrence [10]: Uses an embedding of the subject and object pair for attending over the image features. 4. 4.

Visual Relationship Detection (VRD) [35]: Similar to Co-Occurrences model, but with an additional relationship embedding.

6 Results

Table 1 provides average IOU for Subject and Object over the three datasets described in Sec. 5.1. We compare our model to four baselines described in Sec. 5.3. Our Differentiable Scene-Graph approach outperforms all baselines in terms of the average IOU.

Our results for the CLEVR dataset are significantly better than those in [27]. Because CLEVR objects have a small set of distinct colors (Fig 5), object detection in CLEVR is much easier than in natural images, making it easier to achieve high IOU. The baseline model without the DSG layer (no-DSG) is an end-to-end model with a two-stage detector in contrast to [27] and already improves strongly over prior work with 93.7%, and our novel DSG approach further improves to 96.3% (reducing error by 50%).

6.1 Analysis of Success and Failure Cases.

Fig. 4 shows example of success cases and failure cases. We further analyzed the types of common mistakes and their distribution. Since DSGs depend on box proposals, they are sensitive to the quality of the object detectors. Manual inspection of images revealed four main error types: (1) 30%: Detector failed: the relevant box is missing from the box proposal list. (2) 23.3% Subject or Object detected but classified as Other or as Background. (3) 16.6%: Relation misclassified. The entities classified as Subject and Object match the query, but without the required relation. (4) 16.6%: Multiplicity. Either too few or too many of the GT boxes are classified as Subject or Object. (5) 13.3%: Other, including incorrect GT, and hard-to-decide cases.

6.2 Model Ablations

To gain further insight into the performance of the DSG model we performed the following ablations. First, since the model is trained with three loss components, we quantify the contribution of the Box Refinement loss and the Scene-Graph Labeling loss (it is not possible to omit the Referring Relationships Classifier loss). We further evaluate the contribution of the DSG compared with a two-step approach which first predicts an SG, and then reasons over it. We compare the following models:

DSG: The Differentiable Scene-Graph model described in Sec. 3.2 and trained as described in Sec. 4. 2. 2.

Two steps: Two-step model. We first predict a scene-graph, and then match the query with the SG. The SG predictor consists of the same components used in the DSG: A box detector, DSG dense descriptors, and an SG labeler. It is trained with the same set of SG labels used for training the DSG. Details in the supplemental material. 3. 3.

DSG -SGL: DSG without the Scene-Graph Labeling component described in Sec. 4.3). 4. 4.

DSG -BR: DSG where the Box Refiner component of Section 4.2 is replaced with fine tuning the coordinates of the box proposal using the visual features $\boldsymbol{f}_{i}$ extracted by the Object Detector. This variant allows us to quantify the benefit of refining the box proposals based on the differentiable representation of the scene. 5. 5.

no-DSG: A baseline model that does not use the DSG representations. Instead, the model includes only an Object Detector and a RR classifier. The RR classifier uses the $\boldsymbol{f}_{i}$ features extracted by the Object Detector instead of the $\boldsymbol{z}’_{i}$ features. This model allows us to quantify the benefit of the differentiable scene representation for RR classification.

Table 2 provides results of ablation experiments for the Visual Genome dataset [28] on the validation set. All model variants based on scene representation perform better than the model that does not use the DSG representation (i.e., DSG -SG), demonstrating the power of contextualized scene representation. The DSG model outperforms all model ablations, illustrating the improvements achieved by using partial supervision for training the differentiable scene-graph. Fig. 7 illustrates the effect of ablating various components of the model.

6.3 Inferring SGs from DSGs

The DSG is designed as a dense representation of objects and relations in the scene. It is thus natural to use it to predict these. This is easy to do in our context, since in Sec. 4.3 we in fact train such classifiers as an auxiliary task. Thus, for a given image we can construct a scene-graph out of the outputs of these objects and relation classifiers.

Fig. 6 illustrates the result of this process, showing a Scene-Graph inferred from the DSG. The predicted graph is indeed largely correct, even though it was not directly trained for this task (but rather from partial supervision). We further analyzed the accuracy of predicted SGs by comparing to ground-truth SG on visual genome (complete SGs were not used for training, only for analysis). SGs decoded from DSGs achieve accuracy of $76\%$ for object labels and $70\%$ for relations (calculated for proposals with IOU $\geq 0.8$).

7 Related Work

Graph Neural Networks. Recently, major progress has been made in constructing graph neural networks (GNN). These refer to a class of neural networks that operate directly on graph-structured data by passing local messages [11, 30]. Variants of GNNs have been shown to be highly effective at relational reasoning tasks [46], classification of graphs [3, 6, 39, 7] and classification of nodes in large graphs [25, 14]. The expressive power of GNNs has also been studied in [17, 56]. GNNs have also been applied to visual understanding in [17, 51, 49, 16] and control [45, 2]. Similar aggregation schemes have also been applied to object detection [18]. Our goal here is to generate DSG such that each object descriptor encompasses not only the local information about the object, but also information about its context within the scene. To achieve this we use the GNN proposed by [17].

Visual Relationships and Scene Graphs. Earlier work aimed to leverage visual relationships for improving detection [44], action recognition [16], few shot [5, 9], pose estimation [8], semantic image segmentation [13] or detection of human-object interactions [52, 40, 31]. Lu et al. [35] were the first to formulate detection of visual relationships as a separate task. They learn a likelihood function that uses a language prior based on word embeddings for scoring visual relationships and constructing SGs. SGs provide a compact representation of the semantics of an image. Previous SG prediction works used attention [41, 12] or neural message passing [50]. [38] suggested to predict graphs directly from pixels in an end-to-end manner. [57] considers global context using an RNN by reading sequentially the independent predictions for each entity and relation and then refines those predictions. SGs have been shown to be useful for semantic-level interpretation and reasoning about a visual scene [20, 1, 15, 47]. Extracting SGs from images provides a semantic representation that can later be used for reasoning, question answering [54, 19, 32], and image retrieval [22, 42]. Using SGs for reasoning tasks is challenging. Instead, we propose an intermediate representation which captures the relational information as in SGs but can be trained end-to-end in a task-specific manner.

Referring Relationships. The RR task is closely related to the task of referring expressions, where an entity in an image needs to be identified given a natural language expression. Several recent works considered using context for this task [24, 26, 4, 48, 53, 34]. [36] described a model that has two parts: one for generating expressions that point to an entity in a discriminative fashion and a second for understanding these expressions and detecting the referred entity. [55] explored the role of context and visual comparison with other entities in referring expressions. Modelling context was also the focus of [37], using a multi-instance-learning objective. RR [27] as opposed to referring expression, focuses on the vision side rather than the language side by forming a simple structured query that requires modeling interactions between the image entities. [27] also introduce an explicit iterative model that localizes the two entities in the RR task, conditioned on one another. We use the RR task to demonstrate the power of our semantic latent representation, resulting in a new state of the art results on three vision datasets that contains visual relationships.

8 Conclusion

This work is motivated by the assumption that accurate reasoning about images may require access to a detailed representation of the image. While scene graphs provide a natural structure for representing relational information, it is hard to train very dense SGs in a fully supervised manner, and for any given image, the resulting SGs may not be appropriate for downstream reasoning tasks. Here we advocate DSGs, an alternative representation that captures the information in SGs, which is continuous and can be trained jointly with downstream tasks. Our results, both qualitative (Fig 4 ) and quantitative (Table 1,2), suggest that DSGs effectively capture scene structure, and that this can be used for down-stream tasks such as referring relationships.

One natural next step is to study such representations in additional downstream tasks that require integrating information across the image. Some examples are caption generation and visual question answering. DSGs can be particularly useful for VQA, since many questions are easily answerable by scene graphs (e.g., counting questions and questions about relations). Another important extension to DSGs would be a model that captures high-order interactions, as in a hyper-graph. Finally, it will be interesting to explore other approaches to training the DSG, and in particular finding ways for using unlabeled data for this task.

Acknowledgments: This project was funded by the European Research Council (ERC) under the European Unions Horizon 2020 research and innovation programme (grant ERC HOLI 819080).

Supplementary Material

This supplementary material includes: (1) Model implementation details. (2) Details about the reasoning component in two steps ablation module.

1 Model Details

The model in Sec. 3.2 is implemented as follows.

Object Detector and Relation Feature Extractor. For object detection, we used Faster-RCNN with a 101-layers ResNet backbone. The RPN was trained with anchor scales of $\{4,8,16,32\}$ and aspect ratios $\{0.5,1,2\}$. RPN proposals were filtered by non-maximum suppression with IOU-threshold of 0.5 and score higher than 0.8. We use at most 32 proposals per image. Both the entity features $\boldsymbol{f}_{i}$ and the relation features $\boldsymbol{f}_{i,j}$ are first extracted from the convolutional network feature map by the ROI-Align layer as $7\times 7\times 2048$ features. They are then reduced to a $7\times 7\times 512$ by convolution layer of size $1\times 1$ and finally reduced to $1\times 512$ by an average pooling layer.

Referring Relationship Classifier. The referring relationship classifier $F_{RRC}$ is a fully-connected network with two layers of 512 hidden units each.

Bounding Box Refinement. The box refinement model applies a linear function to $\boldsymbol{z}_{i}$ to obtain four outputs $[dx,dy,dw,dh]$. Denote the RPN box by $[x,y,w,h]$. The refined box is then: $[dx\cdot w+x,dy\cdot h+y,e^{dw}\cdot w,e^{dh}\cdot h]$ (as in the correction used by Faster-RCNN).

Computational Estimation. Our model creates a graph with $n$ nodes for objects and $n^{2}$ edges for relations. In the datasets we analyzed, using $n=32$ objects within an image is sufficient. Adding the DSG component has a limited effect on complexity and run time. Specifically, as shown in Tab. 3, the DSG component adds 4M parameters and up to 1.5G operations (when $n=32$) which is only 10% of the parameters and number of operations of the backbone network ($\sim$40M parameters and $\sim$15G operations). Adding DSG increases training time by only 15%. This is largely thanks to the fact that all $n^{2}$ relations can parallelized.

Differentiable Scene Graph Generator. We next describe the module that takes as input features $\boldsymbol{z}_{i}$ and $\boldsymbol{z}_{i,j}$ extracted by the RPN and outputs a set of vectors $\boldsymbol{z}^{\prime}_{i},\boldsymbol{z}^{\prime}_{ij}$ corresponding to Differentiable Scene-Graph over entities and relationships in the image. For this model, we use the Graph Permutation Invariant (GPI) architecture introduced in [17]. A key property of this architecture is that it is invariant to permutations of the input that do not affect the labels.

The GPI transformation is defined as follows. First, the set of all input features is summarized via a permutation-invariant transformation into a single vector $\boldsymbol{g}$:

[TABLE]

Here $\boldsymbol{\alpha}$ and $\boldsymbol{\phi}$ are fully connected networks. Then the new representations for entities and relations are computed via:

[TABLE]

where ${\boldsymbol{\rho}}$ above are fully connected networks.

The three networks $\boldsymbol{\phi}$, $\boldsymbol{\alpha}$ and $\boldsymbol{\rho}$, described in GPI architecture are two fully-connected layers with 512 hidden units. The output size of $\phi$ and $\alpha$ is 512, and of $\boldsymbol{\rho}$ is 1024. We used the version with integrated attention mechanism replacing the sum operations in equation 1.

2 Model Ablations

Additional details about the Two Step model: Recall that in Two-step model a scene graph is first predicted, followed by a reasoning module. The reasoning module gets as an input a query $\langle$subject, relation, object$\rangle$ and a scene graph and outputs the nodes that represents the subject and the nodes that represents the object. In case the triplet $\langle$subject, relation, object$\rangle$ exists in the scene graph, the reasoning module simply returns the involved nodes. Otherwise, it selects the triplet in the scene graph that has the highest probability to be the required triplet according to the probabilities provided by the scene graph.