# Mapping Images to Scene Graphs with Permutation-Invariant Structured Prediction

Jump to: navigation, search

The paper Mapping Images to Scene Graphs with Permutation-Invariant Structured Prediction was written by Roei Herzig* from Tel Aviv University, Moshiko Raboh* from Tel Aviv University, Gal Chechik from Google Brain, Bar-Ilan University, Jonathan Berant from Tel Aviv University, and Amir Globerson from Tel Aviv University. This paper is part of the NIPS 2018 conference to be hosted in December 2018 at Montréal, Canada. This paper summary is based on version 3 of the pre-print (as of May 2018) obtained from arXiv

(*) Equal contribution

# Motivation

In the field of artificial intelligence, a major goal is to enable machines to understand complex images, such as the underlying relationships between objects that exist in each scene. Although there are models today that capture both complex labels and interactions between labels, there is a disconnect for what guidelines should be used when leveraging deep learning. This paper introduces a design principle for such models that stem from the concept of permutation invariance and proves state of the art performance on models that follow this principle.

The primary contributions that this paper makes include:

1. Deriving sufficient and necessary conditions for respecting graph-permutation invariance in deep structured prediction architectures
2. Empirically proving the benefit of graph-permutation invariance
3. Developing a state-of-the-art model for scene graph predictions over a large set of complex visual scenes

# Introduction

In order for a machine to interpret complex visual scenes, it must recognize and understand both objects and relationships between the objects in the scene. A scene graph is a representation of the set of objects and relations that exist in the scene, where objects are represented as nodes and relations are represented as edges connecting the different nodes. Hence, the prediction of the scene graph is analogous to inferring the joint set of objects and relations of a visual scene.

Given that objects in scenes are interdependent on each other, joint prediction of the objects and relations is necessary. The field of structured prediction, which involves the general problem of inferring multiple inter-dependent labels, is of interest for this problem.

In structured prediction models, a score function $s(x, y)$ is defined to evaluate the compatibility between label $y$ and input $x$. For instance, when interpreting the scene of an image, $x$ refers to the image itself, and $y$ refers to a complex label, which contains both the objects and the relations between objects. As with most other inference methods, the goal is to find the label $y*$ such that $s(x,y)$ is maximized. However, the major concern is that the space for possible label assignments grows exponentially with respect to input size. For example, although an image may seem very simple, the corpus containing possible labels for objects may be very large, rendering it difficult to optimize the scoring function.

The paper presents an alternative approach, for which input $x$ is mapped to structured output $y$ using a "black box" neural network, omitting the definition of a score function. The main concern for this approach is the determination of the network architecture.

# Structured prediction

This paper further considers structured predictions using score-based methods. For structured predictions that follow a score-based approach, a score function $s(x, y)$ is used to measure how compatible label $y$ is for input $x$. To optimize the score function, previous works have decomposed $s(x,y) = \sum_i f_i(x,y)$ in order to facilitate efficient optimization for each local score function, $\max_y f_i(x,y)$.

In the area of structured predictions, the most commonly-used score functions include the singleton score function $f_i(y_i, x)$ and pairwise score function $f_{ij} (y_i, y_j, x)$. Previous works explored a two-stage architectures (learn local scores independently of the structured prediction goal), and end-to-end architectures (to include the inference algorithm within the computation graph).

## Advantages of using score-based methods

1. Allow for intuitive specification of local dependencies between labels, and how they map to global dependencies
2. Linear score functions offer natural convex surrogates
3. Inference in large label space is sometimes possible via exact algorithms or empirically accurate approximations

The concern for modelling score functions using deep networks is that learning may no longer be convex. Hence, the paper presents properties for how deep networks can be used for structured predictions by considering architectures that do not require explicit maximization of a score function.

# Background, Notations, and Definitions

We denote $y$ as a structured label where $y = [y_1, \dots, y_n]$

Score functions: for score-based methods, the score is defined as either the sum of a set of singleton scores $f_i = f_i(y_i, x)$ or the sum of pairwise scores $f_{ij} = f_{ij}(y_i, y_j, x)$.

Let $s(x,y)$ be the score of a score-based method. Then:

$s(x,y) = \begin{cases} \sum_i f_i ~ \text{if we have a set of singleton scores}\\ \sum_{ij} f_{ij} ~ \text{if we have a set of pairwise scores } \\ \end{cases}$

Inference algorithm: an inference algorithm takes input set of local scores (either $f_i$ or $f_{ij}$) and outputs an assignment of labels $y_1, \dots, y_n$ that maximizes score function $s(x,y)$

Graph labeling function: a graph labeling function $\mathcal{F} : (V,E) \rightarrow Y$ is a function that takes input of: an ordered set of node features $V = [z_1, \dots, z_n]$ and an ordered set of edge features $E = [z_{1,2},\dots,z_{i,j},\dots,z_{n,n-1}]$ to output set of node labels $\mathbf{y} = [y_1, \dots, y_n]$. For instance, $z_i$ can be set equal to $f_i$ and $z_{ij}$ can be set equal to $f_{ij}$.

For convenience, the joint set of nodes and edges will be denoted as $\mathbf{z}$ to be a size $n^2$ vector ($n$ nodes and $n(n-1)$ edges).

Permutation: Let $z$ be a set of node and edge features. Given a permutation $\sigma$ of $\{1,\dots,n\}$, let $\sigma(z)$ be a new set of node and edge features given by [$\sigma(z)]_i = z_{\sigma(i)}$ and $[\sigma(z)]_{i,j} = z_{\sigma(i), \sigma(j)}$

One-hot representation: $\mathbf{1}[j]$ be a one-hot vector with 1 in the $j^{th}$ coordinate

# Permutation-Invariant Structured prediction

With permutation-invariant structured prediction, we would expect the algorithm to produce the same result given the same score function. For instance, consider the case where we have label space for 3 variables $y_1, y_2, y_3$ with input $\mathbf{z} = (f_1, f_2, f_3, f_{12}, f_{13}, f_{23})$ that outputs label $\mathbf{y} = (y_1^*, y_2^*, y_3^*)$. Then if the algorithm is run on a permuted version input $z' = (f_2, f_1, f_3, f_{21}, f_{23}, f_{13})$, we would expect $\mathbf{y} = (y_2^*, y_1^*, y_3^*)$ given the same score function.

Graph permutation invariance (GPI): a graph labeling function $\mathcal{F}$ is graph-permutation invariant, if for all permutations $\sigma$ of $\{1, \dots, n\}$ and for all nodes $z$, $\mathcal{F}(\sigma(\mathbf{z})) = \sigma(\mathcal{F}(\mathbf{z}))$

The paper presents a theorem on the necessary and sufficient conditions for a function $\mathcal{F}$ to be graph permutation invariant. Intuitively, because $\mathcal{F}$ is a function that takes an ordered set $z$ as input, the output on $\mathbf{z}$ could very well be different from $\sigma(\mathbf{z})$, which means $\mathcal{F}$ needs to have some sort of symmetry in order to sustain $[\mathcal{F}(\sigma(\mathbf{z}))]]_k = [\mathcal{F}(\mathbf{z})]_{\sigma(k)}$.

## Theorem 1

Let $\mathcal{F}$ be a graph labeling function. Then $\mathcal{F}$ is graph-permutation invariant if and only if there exist functions $\alpha, \rho, \phi$ such that for all $k=1, .., n$: \begin{align} [\mathcal{F}(\mathbf{z})]_k = \rho(\mathbf{z}_k, \sum_{i=1}^n \alpha(\mathbf{z}_i, \sum_{i\neq j} \phi(\mathbf{z}_i, \mathbf{z}_{i,j}, \mathbf{z}_j))) \end{align} where $\phi: \mathbb{R}^{2d+e} \rightarrow \mathbb{R}^L, \alpha: \mathbb{R}^{d + L} \rightarrow \mathbb{R}^{W}, p: \mathbb{R}^{W+d} \rightarrow \mathbb{R}$.

Notice that for the dimensions of inputs and outputs, $d$ refers to the number of singleton features in $z$ and $e$ refers to the number of edges.

A schematic representation of the GPI architecture. Singleton features $z_i$ are omitted for simplicity. First, the features $z_{i,j}$ are processed element-wise by $\phi$. Next, they are summed to create a vector $s_i$, which is concatenated with $z_i$. Third, a representation of the entire graph is created by applying $\alpha\ n$ times and summing the created vector. The graph representation is then finally processed by $\rho$ together with $z_k$.

## Proof Sketch for Theorem 1

The proof of this theorem can be found in the paper. A proof sketch below is provided:

For the forward direction (function that follows the form set out in equation (1) is GPI):

1. Using definition of permutation $\sigma$, and rewriting $[F(z)]_{\sigma(k)}$ in the form from equation (1)
2. Second argument of $\rho$ is invariant under $\sigma$, since it takes the sum of all indices $i$ and all other indices $j \neq i$.

For the backward direction (any black-box GPI function can be expressed in the form of equation 1):

1. Construct $\phi, \alpha$ such that second argument of $\rho$ contains all information about graph features of $z$, including edges that the features originate from
2. Assume each $z_k$ uniquely identifies the node and $\mathcal{F}$ is a function only of pairwise features $z_{i,j}$
3. Construct $H$ be a perfect hash function with $L$ buckets, and $\phi$ which maps pairwise features to a vector of size $L$
4. $*$Construct $\phi(z_i, z_{i,j}, z_j) = \mathbf{1}[H(z_j)] z_{i,j}$, which intuitively means that $\phi$ stores $z_{i,j}$ in the unique bucket for node $j$
5. Construct function $\alpha$ to output a matrix $\mathbb{R}^{L \times L}$ that maps each pairwise feature into unique positions ($\alpha(z_i, s_i) = \mathbf{1}[H(z_i)]s_i^T$)
6. Construct matrix $M = \sum_i \alpha(z_i,s_i)$ by discarding rows/columns in $M$ that do not correspond to original nodes (which reduces dimension to $n\times n$; set $\rho$ to have same outcome as $\mathcal{F}$, and set the output of $\mathcal{F}$ on $M$ to be the labels $\mathbf{y} = y_1, \dots, y_n$

$*$The paper presents the proof for the edge features $z_{ij}$ being scalar ($e = 1$) for simplicity, which can be extended easily to vectors with additional indexing.

Although the results discussed previously apply to complete graphs (edges apply to all feature pairs), it can be easily extended to incomplete graphs. However, in place of permutation-invariance, it is now an automorphism-invariance.

## Implications and Applications of Theorem 1

### Key Implications of Theorem 1

1. Architecture "collects" information from the different edges of the graph, and does so in an invariant fashion using $\alpha$ and $\phi$
2. Architecture is parallelizable, since all $\phi$ functions can be applied simultaneously

### Some applications of Theorem 1

1. Attention: the concept of attention can be implemented in the GPI characterization, with slight alterations to the functions $\alpha$ and $\phi$. The complete details can be found in the supplementary materials of the paper.
2. RNN: recurrent architectures can maintain GPI property, since all GPI function $\mathcal{F}$ are closed under composition. The output of one step after running $\mathcal{F}$ will act as input for the next step, but maintain the GPI property throughout.

# Related Work

1. Architectural invariance: suggested recently in a 2017 paper called Deep Sets by Zaheer et al., which considers the case of invariance that is more restrictive.
2. Deep structured prediction: previous work applied deep learning to structured prediction, for instance, semantic segmentation. Some algorithms include message passing algorithms, gradient descent for maximizing score functions, greedy decoding (inference of labels based on time of previous labels). Apart from those algorithms, deep learning has been applied to other graph-based problems such as the Travelling Salesman Problem (Bello et al., 2016; Gilmer et al., 2017; Khalil et al., 2017). However, none of the previous work specifically address the notion of invariance in the general architecture, but rather focus on message passing architectures that can be generalized by this paper.
3. Scene graph prediction: scene graph extraction allows for reasoning, question answering, and image retrieval (Johnson et al., 2015; Lu et al., 2016; Raposo et al., 2017). Some other works in this area include object detection, action recognition, and even detection of human-object interactions (Liao et al., 2016; Plummer et al., 2017). Additional work has been done with the use of message passing algorithms (Xu et al., 2017), word embeddings (Lu et al., 2016), and end-to-end prediction directly from pixels (Newell & Deng, 2017). A notable mention is NeuralMotif (Zellers et al., 2017), which the authors describe as the current state-of-the-art model for scene graph predictions on Visual Genome dataset.
4. Burst Image Deblurring Using Permutation Invariant Convolutional Neural Networks: similar ideas were applied, where Permutation Invariant CNN, are used to restore sharp and noise-free images from bursts of photographs affected by hand tremor and noise. This presented good quality images with lots of details for challenging datasets.

# Experimental Results

## Synthetic Graph Labeling

The authors created a synthetic problem to study GPI. This involved using an input graph $G = (V,E)$ where each node $i$ belongs to the set $\Gamma(i) \in \{1, \dots, K\}$ where $K$ is the number of samples. The task is to compute for each node, the number of neighbours that belong to the same set (i.e. finding the label of the node $i$ if $y_i = \sum_{j \in N(i)} \mathbf{1}[\Gamma(i) = \Gamma(j)]$) . Then, random graphs (each with 10 nodes) were generated by sampling edges, and the set $\Gamma(i) \in \{1, \dots, K\}$for each node independently and uniformly. The node features of the graph $z_i \in \{0,1\}^K$ are one-hot vectors of $\Gamma(i)$, and each pairwise edge feature $z_{ij} \in \{0, 1\}$ denote whether the edge $ij$ is in the edge set $E$. 3 architectures were studied in this paper:

1. GPI-architecture for graph prediction (without attention and RNN)
2. LSTM: replacing $\sum \phi(\cdot)$ and $\sum \alpha(\cdot)$ in the form of Theorem 1 using two LSTMs with state size 200, reading their input in random order
3. Fully connected feed-forward network: with 2 hidden layers, each layer containing 1,000 nodes; the input is a concatenation of all nodes and pairwise features, and the output is all node predictions

The results show that the GPI architecture requires far fewer samples to converge to the correct solution.

## Scene-Graph Classification

Applying the concept of GPI to Scene-Graph Prediction (SGP) is the main task of this paper. The input to this problem is an image, along with a set of annotated bounding boxes for the entities in the image. The goal is to correctly label each entity within the bounding boxes and the relationship between every pair of entities, resulting in a coherent scene graph.

The authors describe two different types of variables to predict. The first type is entity variables $[y_1, \dots, y_n]$ for all bounding boxes, where each $y_i$ can take one of L values and refers to objects such as "dog" or "man". The second type is relation variables $[y_{n+1}, \cdots, y_{n^2}]$, where each $y_i$ represents the relation (e.g. "on", "below") between a pair of bounding boxes (entities).

The scene graph and contain two types of edges:

1. Entity-entity edge: connecting two entities $y_i$ and $y_j$ for $1 \leq i \neq j \leq n$
2. Entity-relation edges: connecting every relation variable $y_k$ for $k \gt n$ to two entities

The feature set $\mathbf{z}$ is based on the baseline model from Zellers et al. (2017). For entity variables $y_i$, the vector $\mathbf{z}_i \in \mathbb{R}^L$ models the probability of the entity appearing in $y_i$. $\mathbf{z}_i$ is augmented by the coordinates of the bounding box. Similarly for relation variables $y_j$, the vector $\mathbf{z}_j \in \mathbb{R}^R$, models the probability of the relations between the two entities in $j$. For entity-entity pairwise features $\mathbf{z}_{i,j}$, there is a similar representation of the probabilities for the pair. The SGP outputs probability distributions over all entities and relations, which will then be used as input recurrently to maintain GPI. Finally, word embeddings are used and concatenated for the most probable entity-relation labels.

Components of the GPI architecture (ent for entity, rel for relation)

1. $\phi_{ent}$: network that integrates two entity variables $y_i$ and $y_j$, with input $z_i, z_j, z_{i,j}$ and output vector of $\mathbb{R}^{n_1}$
2. $\alpha_{ent}$: network with inputs from $\phi_{ent}$ for all neighbours of an entity, and uses attention mechanism to output vector $\mathbb{R}^{n_2}$
3. $\rho_{ent}$: network with inputs from the various $\mathbb{R}^{n_2}$ vectors, and outputs $L$ logits to predict entity value
4. $\rho_{rel}$: network with inputs $\alpha_{ent}$ of two entities and $z_{i,j}$, and output into $R$ logits

## Set-up and Results

Dataset: based on Visual Genome (VG) by (Krishna et al., 2017), which contains a total of 108,077 images annotated with bounding boxes, entities, and relations. An average of 12 entities and 7 relations exist per image. For a fair comparison with previous works, data from (Xu et al., 2017) for train and test splits were used. The authors used the same 150 entities and 50 relations as in (Xu et al., 2017; Newell & Deng, 2017; Zellers et al., 2017). Hyperparameters were tuned using a 70K/5K/32K split for training, validation, and testing respectively.

Training: all networks were trained using the Adam optimizer, with a batch size of 20. The loss function was the sum of cross-entropy losses over all of entities and relations. Penalties for misclassified entities were 4 times stronger than that of relations. Penalties for misclassified negative relations were 10 times weaker than that of positive relations.

Evaluation: there are three major tasks when inferring from the scene graph. The authors focus on the following:

1. SGCIs: given ground-truth entity bounding boxes, predict all entity and relations categories
2. PredCIs: given annotated bounding boxes with entity labels, predict all relations

The evaluation metric Recall@K (shortened to R@K) is drawn from (Lu et al., 2016). This metric is the fraction of correct ground-truth triplets that appear within the $K$ most confident triplets predicted by the model. Graph-constrained protocol requires the top-$K$ triplets to assign one consistent class per entity and relation. The unconstrained protocol does not enforce such constraint.

Models and baselines: The authors compared variants of the GPI approach against four baselines, state-of-the-art models on completing scene graph sub-tasks. To maintain consistency, all models used the same training/testing data split, in addition to the preprocessing as per (Xu et al., 2017).

Baselines from existing state-of-the-art models

1. (Lu et al., 2016): use of word embeddings to fine-tune the likelihood of predicted relations
2. (Xu et al., 2017): message passing algorithm between entities and relations to iteratively improve feature map for prediction
3. (Newell & Deng, 2017): Pixel2Graph, uses associative embeddings to produce a full graph from image
4. (Zellers et al., 2017): NeuralMotif method, encodes global context to capture higher-order motif in scene graphs; Baseline outputs entities and relations distributions without using global context

GPI models

1. GPI with no attention mechanism: simply following Theorem 1's functional form, with summation over features
2. GPI NeighborAttention: same GPI model, but considers attention over neighbours features
3. GPI Linguistic: similar to NeighborAttention model, but concatenates word embedding vectors

Key Results: The GPI Linguistic approach outperforms all baseline for SGCIs, and has similar performance to the state of the art NeuralMotifs method. The authors argue that PredCI is an easier task with less structure, yielding high performance for the existing state of the art models.

# Conclusion

A deep learning approach was presented in this paper to structured prediction, which constrains the architecture to be invariant to structurally identical inputs. This approach relies on pairwise features which are capable of describing inter-label correlations and inherits the intuitive aspect of score-based approaches. The output produced is invariant to equivalent representation of the pairwise terms.

As future work, the axiomatic approach can be extended. Additionally, exploring algorithms that discover symmetries for deep structured prediction when invariant structure is unknown and should be discovered from data is also an interesting extension of this work.

# Critique

The paper's contribution comes from the novelty of the permutation invariance as a design guideline for structured prediction. Although not explicitly considered in many of the previous works, the idea of invariance in architecture has already been considered in Deep Sets by (Zaheer et al., 2017). This paper characterizes relaxes the condition on the invariance as compared to that of previous works. In the evaluation of the benefit of GPI models, the paper used a synthetic problem to illustrate the fact that far fewer samples are required for the GPI model to converge to 100\% accuracy. However, when comparing the true task of scene graph prediction against the state-of-the-art baselines, the GPI variants had only marginal higher Recall@K scores. The true benefit of this paper's discovery is the avoidance of maximizing a score function (leading computationally difficult problem), and instead directly producing output invariant to how we represent the pairwise terms.

# References

Roei Herzig, Moshiko Raboh, Gal Chechik, Jonathan Berant, Amir Globerson, Mapping Images to Scene Graphs with Permutation-Invariant Structured Prediction, 2018.

Additional resources from Moshiko Raboh's GitHub