# Dynamic Graph Message Passing Networks
for Visual Recognition

Li Zhang, Mohan Chen, Anurag Arnab, Xiangyang Xue, and Philip H.S. Torr  Li
Zhang is the corresponding author with the School of Data Science, Fudan
University.
E-mail<EMAIL_ADDRESS>Anurag Arnab is with Google Research. Mohan
Chen and Xiangyang Xue are with School of Computer Science, Fudan University.
Philip H.S. Torr is with the Department of Engineering Science, University of
Oxford.

###### Abstract

Modelling long-range dependencies is critical for scene understanding tasks in
computer vision. Although convolution neural networks (CNNs) have excelled in
many vision tasks, they are still limited in capturing long-range structured
relationships as they typically consist of layers of local kernels. A fully-
connected graph, such as the self-attention operation in Transformers, is
beneficial for such modelling, however, its computational overhead is
prohibitive. In this paper, we propose a dynamic graph message passing
network, that significantly reduces the computational complexity compared to
related works modelling a fully-connected graph. This is achieved by
adaptively sampling nodes in the graph, conditioned on the input, for message
passing. Based on the sampled nodes, we dynamically predict node-dependent
filter weights and the affinity matrix for propagating information between
them. This formulation allows us to design a self-attention module, and more
importantly a new Transformer-based backbone network, that we use for both
image classification pretraining, and for addressing various downstream tasks
(e.g. object detection, instance and semantic segmentation). Using this model,
we show significant improvements with respect to strong, state-of-the-art
baselines on four different tasks. Our approach also outperforms fully-
connected graphs while using substantially fewer floating-point operations and
parameters. Code and models will be made publicly available at
https://github.com/fudan-zvg/DGMN2.

###### Index Terms:

Dynamic Message Passing, Transformer

##  1 Introduction

Capturing long-range dependencies is crucial for complex scene understanding
tasks such as image classification, semantic segmentation, instance
segmentation and object detection. Although convolutional neural networks
(CNNs) have excelled in a wide range of scene understanding tasks [33, 64,
25], they are still limited by their ability to capture these long-range
interactions. To improve the capability of CNNs in this regard, a recent,
popular model Non-local networks [73] proposes a generalisation of the
attention model of [69] and achieves significant advance in several computer
vision tasks.

Non-local networks essentially model pairwise structured relationships among
all feature elements in a feature map to produce the attention weights which
are used for feature aggregation. Considering each feature element as a node
in a graph, Non-local networks effectively model a fully-connected feature
graph and thus have a quadratic inference complexity with respect to the
number of the feature elements. This is infeasible for dense prediction tasks
on high-resolution imagery, as commonly encountered in semantic segmentation
[12]. Moreover, in dense prediction tasks, capturing relations between all
pairs of pixels is usually unnecessary due to the redundant information
contained within the image (Fig. 1). Simply subsampling the feature map to
reduce the memory requirements is also suboptimal, as such naïve subsampling
would result in smaller objects in the image not being represented adequately.

Graph convolution networks (GCNs) [31, 21] – which propagate information along
graph-structured input data – can alleviate the computational issues of non-
local networks to a certain extent. However, this stands only if local
neighbourhoods are considered for each node. Employing such local-connected
graphs means that the long-range contextual information needed for complex
vision tasks such as segmentation and detection [57, 54, 3] will only be
partially captured. Along this direction, GraphSAGE [23] introduced an
efficient graph learning model based on graph sampling. However, the proposed
sampling method considered a uniform sampling strategy along the spatial
dimension of the input, and was independent of the actual input. Consequently,
the modelling capacity was restricted as it assumed a static input graph where
the neighbours for each node were fixed and filter weights were shared among
all nodes.

Figure 1: Contextual information is crucial for complex scene understanding
tasks. To recognise the “boathouse”, one needs to consider the “boat” and the
“water” next to it. Fully-connected message passing models (a) are able to
obtain this information, but are prohibitively expensive. Furthermore, they
capture a lot of redundant information (i.e.“trees” and “sky”). Locally-
connected models (b) are more efficient, but miss out on important context.
Our proposed approach (c), dynamically samples a small subset of relevant
feature nodes based on a learned dynamic sampling scheme, i.e. the learned
position-specific random walk (indicated by the white dashed arrow lines), and
also dynamically predicts filter weights and affinities (indicated by unique
edge and square colors.), which are both conditioned on the sampled feature
nodes.

To address the aforementioned shortcomings, we propose a novel dynamic graph
message passing network (DGMN) model, targeting effective and efficient deep
representational learning with joint modeling of two key dynamic properties as
illustrated in Fig. 1. Our contribution is twofold: (i) We dynamically sample
the neighbourhood of a node from the feature graph, conditioned on the node
features. Intuitively, this learned sampling allows the network to efficiently
gather long-range context by only selecting a subset of the most relevant
nodes in the graph; (ii) Based on the nodes that have been sampled, we further
dynamically predict node-dependant, and thus position specific, filter weights
and also the affinity matrix, which are used to propagate information among
the feature nodes via message passing. The dynamic weights and affinities are
especially beneficial to specifically model each sampled feature context,
leading to more effective message passing. Both of these dynamic properties
are jointly optimised in a single model, and we modularise the DGMN as a
network layer for simple deployment into existing networks.

We demonstrate the proposed model on the tasks of image classification,
semantic segmentation, object detection and instance segmentation on the
challenging ImageNet [60], Cityscapes [12] and COCO [44] datasets. We achieve
significant performance improvements over the fully-connected model [73, 69],
while using substantially fewer floating point operations (FLOPs).
Specifically, “plugging” our module into existing networks, we show
considerable improvements with respect to strong, state-of-the-art baselines
on three different vision downstream tasks and backbone architectures.
Furthermore, we design a new Transformer backbone network based on the
building block of our formulation. It achieves leading performance on Imagenet
classification task and the pretrained backbone network also supports various
vision downstream tasks.

A preliminary version of this work was published in [85]. We have extended our
conference version as follows: (i) We introduce a modified process of dynamic
message passing calculation and present a simplified version of our prior
formulation; We further recast our formulation to take a Transformer
perspective and implement the message updating process into an efficient and
effective Transformer layer. (ii) Based on the building block of our
formulation, we propose a new backbone network DGMN2 with multi-scale feature
representation which is very compatibility in supporting various downstream
vision tasks. The experiment on upstream ImageNet [60] classification task
show that all the variants of DGMN2 (i.e., DGMN2-Tiny, DGMN2-Small,
DGMN2-Medium and DGMN2-Large respectively) can surpass the conventional
convolution-based backbones such as ResNet/ResNeXt [25, 77], and Transformer-
based backbone such as DeiT [68] and PVT [72]. (iii) With the pretrained
backbone network DGMN2, we show considerable improvements with respect to
strong, state-of-the-art baselines on three different vision downstream tasks
such as object detection, instance segmentation and semantic segmentation.

##  2 Related work

An early technique for modelling context for computer vision tasks involved
conditional random fields. In particular, the DenseCRF model [34] was popular
as it modelled interactions between all pairs of pixels in an image. Although
such models have been integrated into neural networks [88, 1, 2, 78], they are
limited by the fact that the pairwise potentials are based on simple
handcrafted features. Moreover, they mostly model discrete label spaces, and
are thus not directly applicable in the feature learning task since feature
variables are typically continuous. Coupled with the fact that CRFs are
computationally expensive, CRFs are no longer used for most computer vision
tasks.

A complementary technique for increasing the receptive field of CNNs was to
use dilated convolutions [6, 81]. With dilated convolutions, the number of
parameters does not change, while the receptive field grows exponentially if
the dilation rate is linearly increased in successive layers. Other
modifications to the convolution operation include deformable convolution [15,
90], which learns the offset with respect to a predefined grid from which to
select input values. However, the weights of the deformable convolution
filters do not depend on the selected input, and are in fact shared across all
different positions. In contrast, our dynamic sampling aims to sample over the
whole feature graph to obtain a large receptive field, and the predicted
affinities and the weights for message passing are position specific and
conditioned on the dynamically sampled nodes. Our model is thus able to better
capture position-based semantic context to enable more effective message
passing among feature nodes.

Another line of related research targets the graph learning [61, 30, 74, 18,
53, 37] on the irregular structured and geometric input. A neural network
module EdgeConv is proposed in [74] to learn dynamic graphs with k-nearest
neighbor (kNN) on the irregular point clouds data. DeepGCN [37] proposes to
enlarge the receptive field on graph networks with dilated convolution. DGM
[30] introduces a differentiable graph module that learns dynamic adjacency
matrices.

The idea of sampling graph nodes has previously been explored in GraphSAGE
[23]. Crucially, GraphSAGE simply uniformly samples nodes. In contrast, our
sampling strategy is learned based on the node features. Specifically, we
first sample the nodes uniformly in the spatial dimension, and then
dynamically predict walks of each node conditioned on the node features.
Furthermore, GraphSAGE does not consider our second important property, i.e.,
the dynamic prediction of the affinities and the message passing kernels.

We also note that [29] developed an idea of “dynamic convolution”, that is
predicting a dynamic convolutional filter for each feature position. More
recently, [75] further reduced the complexity of this operation in the context
of natural language processing with lightweight grouped convolutions. Unlike
[29, 75], we present a graph-based formulation, and jointly learn dynamic
weights and dynamic affinities, which are conditioned on an _adaptively
sampled_ neighbourhood for each feature node in the graph using the proposed
dynamic sampling strategy for effective message passing.

Recently, there have been a number of variants of Transformer [69, 16] in
computer vision. ViT [16] adopts a pure-Transformer architecture with query,
key and value self-attention for image classification and demonstrates its
effectiveness for replacing convolution neural networks. However, there is a
bottleneck in such Transformer based models, namely its quadratic complexity
in both computation and memory usage. PVT [72] uses downsampling operation to
shrink the number of key and value tokens. Similarly, MViT [17] also performs
pooling to reduce the number of tokens on which self-attention is applied.
Swin Transformer [48], on the other hand, predefines a local window region for
each query point to linearlize the attention computation. We also instantiate
our formulation into an efficient and effective Transformer layer and present
a new Transformer backbone network DGMN2 in supporting various vision
downstream tasks. Different to above Transformer-based backbone networks, we
introduce a graph-based formulation to adaptively sample feature nodes for
effective message passing.

##  3 Dynamic graph message passing networks

###  3.1 Problem definition and notation

Given an input feature map interpreted as a set of feature vectors, i.e.,
$\mathbf{F}=\\{\mathbf{f}_{i}\\}_{i=1}^{N}$ with
$\mathbf{f}_{i}\in\mathbb{R}^{1\times C}$, where $N$ is the number of pixels
and $C$ is the feature dimension, our goal is to learn a set of refined latent
feature vectors $\mathbf{H}=\\{\mathbf{h}_{i}\\}_{i=1}^{N}$ by utilising
hidden structured information among the feature vectors at different pixel
locations. $\mathbf{H}$ has the same dimension as the observation
$\mathbf{F}$. To learn such structured representations, we convert the feature
map into a graph $\mathcal{G}=\\{\mathcal{V},\mathcal{E},A\\}$ with
$\mathcal{V}$ as its nodes, $\mathcal{E}$ as its edges and $A$ as its
adjacency matrix. Specifically, the nodes of the graph represent the latent
feature vectors, i.e., $\mathcal{V}=\\{\mathbf{h}_{i}\\}_{i=1}^{N}$, and
$A\in\mathbb{R}^{N\times N}$ is a binary or learnable matrix with self-loops
describing the connections between nodes. In this work, we propose a novel
dynamic graph message passing network [21] for deep representation learning,
which refines each graph feature node by passing messages on the graph
$\mathcal{G}$. Different from existing message passing neural networks
considering a fully- or locally-connected static graph [73, 21], we propose a
dynamic graph network model with two dynamic properties, i.e., dynamic
sampling of graph nodes to approximate the full graph distribution, and
dynamic prediction of node-conditioned filter weights and affinities, in order
to achieve more efficient and effective message passing.

###  3.2 Graph message passing neural networks for deep representation
learning

Message passing neural networks (MPNNs) [21] present a generalised form of
graph neural networks such as graph convolution networks [31], gated graph
sequential networks [40] and graph attention networks [70]. In order to model
structured graph data, in which latent variables are represented as nodes on
an undirected or directed graph, feed-forward inference is performed through a
message passing phase followed by a readout phase upon the graph nodes. The
message passing phase usually takes $T$ iteration steps to update feature
nodes, while the readout phase is for the final prediction, e.g. , graph
classification with updated nodes. In this work, we focus on the message
passing phase for learning efficient and effective feature refinement, since
well-represented features are critical in all downstream tasks. The message
passing phase consists of two steps, i.e., a message calculation step $M^{t}$
and a message updating step $U^{t}$. Given a latent feature node
$\mathbf{h}_{i}^{(t)}$ at an iteration $t$, for computational efficiency, we
consider a locally connected node field with $v_{i}\subset\mathcal{V}$ and
$v_{i}\in\mathbb{R}^{(K\times C)}$, where $K\ll N$ is the number of sampled
nodes in $v_{i}$. Thus we can define the message calculation step for node $i$
operated locally as

$\displaystyle\mathbf{m}^{(t+1)}_{i}$
$\displaystyle=M^{t}\left(A_{i,j},\\{\mathbf{h}_{1}^{(t)},\cdots,\mathbf{h}_{K}^{(t)}\\},\mathbf{w}_{j}\right)$
$\displaystyle=\sum_{j\in\mathcal{N}(i)}A_{i,j}\mathbf{h}_{j}^{(t)}\mathbf{w}_{j},\
\,$ (1)

where $A_{i,j}=A[i,j]$ describes the connection relationship i.e., the
affinity between latent nodes $\mathbf{h}_{i}^{(t)}$ and
$\mathbf{h}_{j}^{(t)}$, $\mathcal{N}(i)$ denotes a self-included neighborhood
of the node $\mathbf{h}_{i}^{(t)}$ which can be derived from $v_{i}$ and
$\mathbf{w}_{j}\in\mathbb{R}^{C\times C}$ is a transformation matrix for
message calculation on the hidden node $\mathbf{h}_{j}^{(t)}$. The message
updating function $U^{t}$ then updates the node $\mathbf{h}_{i}^{(t)}$ with a
linear combination of the calculated message and the observed feature
$\mathbf{f}_{i}$ at the node position $i$ as:

$\mathbf{h}_{i}^{(t+1)}=U^{t}\left(\mathbf{f}_{i},\mathbf{m}^{(t+1)}_{i}\right)=\sigma\left(\mathbf{f}_{i}+\alpha^{m}_{i}\mathbf{m}^{(t+1)}_{i}\right),$
(2)

where $\alpha^{m}_{i}$ of a learnable parameter for scaling the message, and
the operation $\sigma(\cdot)$ is a non-linearity function, e.g. , ReLU. By
iteratively performing message passing on each node with $T$ steps, we obtain
a refined feature map $\mathbf{H}^{(T)}$ as output.

Figure 2:  Overview of our proposed dynamic graph message passing network
(DGMN). The neighbourhood used to update the feature representation of each
node (we show a single node with a red square) is predicted dynamically
conditioned on each input. This is done by first uniformly sampling (denoted
by “US”) a set of $S$ neighbourhoods around each node. Each neighbourhood
contains $K$ (e.g. $3\times 3$) sampled nodes. Here, the blue nodes were
sampled with a low sampling rate, and the green ones with a high sampling
rate. Walks are predicted (conditioned on the input) from these uniformly
sampled nodes, denoted by the $ⓢ$ symbol representing the random walk sampling
operation described in Sec. 3.3. $\mathrm{DMC}_{1},\cdots,\mathrm{DMC}_{S}$
and $\beta_{1},\cdots,\beta_{S}$ denotes $S$ dynamic message calculation
operations and $S$ message scaling parameters, respectively. The DMC module is
detailed in Figure 3. The symbol $\oplus$ indicates an element-wise addition
operation.

###  3.3 From a fully-connected graph to a dynamic sampled graph

A fully-connected graph typically contains many connections and parameters,
which, in addition to computational overhead, results in redundancy in the
connections, and also makes the network optimisation more difficult especially
when dealing with limited training data. Therefore, as in Eq. 1, a local node
connection field is considered in the graph message passing network. However,
in various computer vision tasks, such as detection and segmentation, learning
deep representations capturing both local and global receptive fields is
important for the model performance [57, 54, 39, 26]. To maintain a large
receptive field while utilising much fewer parameters than the fully-connected
setting, we further explore dynamic sampling strategies in our proposed graph
message passing network. We develop a uniform sampling scheme, which we then
extend to a predicted random walk sampling scheme, aimed at reducing the
redundancy found in a fully-connected graph. This sampling is performed in a
dynamic fashion, meaning that for a given node $\mathbf{h}_{i}$, we aim to
sample an optimal subset of $v_{i}$ from $\mathcal{V}$ to update
$\mathbf{h}_{i}$ via message passing as shown in Fig. 2.

Multiple uniform sampling for dynamic receptive fields. Uniform sampling is a
commonly used strategy for graph node sampling [36] based on Monte-Carlo
estimation. To approximate the distribution of $\mathcal{V}$, we consider a
set of $S$ uniform sampling rates $\mathbf{\varphi}$ with
$\mathbf{\varphi}=\\{\rho_{q}\\}_{q=1}^{S}$, where $\rho_{q}$ is a sampling
rate. Let us assume that the latent feature nodes are located in a
$P$-dimensional space $\mathbb{R}^{P}$. For instance, $P=2$ for images
considering the $x$\- and $y$-axes. For each latent node $\mathbf{h}_{i}$, a
total of $K$ neighbouring nodes are sampled from $\mathbb{R}^{P}$. The
receptive field of $v_{i}$ is thus determined by $\rho_{q}$ and $K$. Note that
the sampling rate $\rho_{q}$ corresponds to the “dilation rate” often used in
convolution [81] and is thus able to capture a large receptive field whilst
maintaining a small number of connected nodes. Thus we can achieve much lower
computational overhead compared with fully-connected message passing in which
typically all $N$ nodes are used when one of the nodes is updated. Each node
receives $S$ complementary messages from distinct receptive fields for
updating as

$\displaystyle\mathbf{m}^{(t+1)}_{i}$
$\displaystyle=\sum_{q}\sum_{j\in\mathcal{N}_{q}(i)}\beta_{q}A_{i,j}^{q}\mathbf{h}_{j}^{(t)}\mathbf{w}_{j}^{q},$
(3)

where $\beta_{q}$ is a weighting parameter for the message from the $q$-th
sampling rate and $q=1,\cdots,S$. $A^{q}$ denotes an adjacency matrix formed
under a sampling rate $\rho_{q}$, with $A_{i,j}^{q}$, $\mathbf{w}_{j}^{q}$ and
$\mathcal{N}_{q}(i)$ defined analogously. The uniform sampling scheme acts as
a linear sampler based on the spatial distribution while not considering the
original feature distribution of the hidden nodes, i.e., sampling
independently of the node features. Eq. 2 can still be used to update the
nodes.

Learning position-specific random walks for node-dependant adaptive sampling.
To take into account the feature data distribution when sampling nodes, we
further present a random walk strategy upon the uniform sampling. Walks around
the uniformly sampled nodes could sample the graph in a non-linear and
adaptive manner, and we believe that it could facilitate learning better
approximation of the original feature distribution. The “random” here refers
to the fact that the walks are predicted in a data-driven fashion from
stochastic gradient descent. Given a matrix, $v_{i}^{q}\in\mathbb{R}^{K\times
C}$, constructed from $K$ uniformly sampled nodes under a sampling rate,
$\rho_{q}$, the random walk of each node is further estimated based on the
feature data of the sampled nodes. Given the $P$-dimensional space where the
nodes distribute ($P=2$ for images), let us denote
$\bigtriangleup\mathbf{d}_{j}^{q}\in\mathbb{R}^{P\times 1}$ as predicted walks
from a uniformly sampled node $\mathbf{h}_{j}$ with $j\in\mathcal{N}_{q}(i)$.
The node walk prediction can then be performed using a matrix transformation
as

$\bigtriangleup\mathbf{d}_{j}^{q}=\mathbf{W}_{i,j}^{q}v_{i}^{q}+\mathbf{b}_{i,j}^{q},$
(4)

where $\mathbf{W}_{i,j}^{q}\in\mathbb{R}^{P\times(K\times C)}$ and
$\mathbf{b}_{i,j}^{q}\in\mathbb{R}^{P\times 1}$ are the matrix transformation
parameters, which are learned separately for each node $v_{i}^{q}$. With the
predicted walks, we can obtain a new set of adaptively sampled nodes
${v^{\prime}}_{i}^{q}$, and generate the corresponding adjacency matrix
${A^{\prime}}^{q}$, which can be used to calculate the messages as

$\displaystyle\mathbf{m}^{(t+1)}_{i}$
$\displaystyle=\sum_{q}\sum_{j\in\mathcal{N}_{q}(i)}\beta_{q}{A^{\prime}}_{i,j}^{q}\varrho\left(\mathbf{h^{\prime}}_{j}^{(t)}~{}|~{}\mathcal{V},~{}j,~{}\bigtriangleup\mathbf{d}_{j}^{q}\right)\mathbf{w}_{j}^{q},$
(5)

where the function $\varrho(\cdot)$ is a bilinear sampler [28] which samples a
new feature node $\mathbf{h^{\prime}}_{j}^{(t)}$ around $\mathbf{h}_{j}^{(t)}$
given the predicted walk $\bigtriangleup\mathbf{d}_{j}^{q}$ and the whole set
of graph vertexes $\mathcal{V}$.

Figure 3: Schematic illustration of the proposed dynamic message passing
calculation (DMC) module. The small red square indicates the receiving node
whose message is calculated from its neighbourhood, i.e. the sampled $K$ (e.g.
$3\times 3$) features nodes. The module accepts a feature map as input and
produces its corresponding message map. The symbol $\ast$ denotes group
convolution operation using the dynamically predicted and position specific
group kernels and affinities.

###  3.4 Joint learning of node-conditioned dynamic filters and affinities

In the message calculation formulated in Eq. 5, the set of weights
$\\{\mathbf{w}_{j}^{q}\\}_{j=1}^{K}$ of the filter is shared for each
adaptively sampled node field ${v^{\prime}}_{i}^{q}$. However, since each
${v^{\prime}}_{i}^{q}$ essentially defines a node-specific local feature
context, it is more meaningful to use a node-conditioned filter to learn the
message for each hidden node $\mathbf{h^{\prime}}_{i}^{(t)}$. In additional to
the filters for the message calculation in Eq. 5, the affinity
${A^{\prime}}_{i,j}$ of any pair of nodes $\mathbf{h^{\prime}}_{i}^{(t)}$ and
$\mathbf{h^{\prime}}_{j}^{(t)}$ could be also be predicted and should also be
conditioned on the node field ${v^{\prime}}_{i}^{q}$, since the affinity
reweights the message passing only in ${v^{\prime}}_{i}^{q}$. As shown in Fig.
3, we thus use matrix transformations to simultaneously estimate the dynamic
filter and affinity which are both conditioned on ${v^{\prime}}_{i}^{q}$,

$\\{\mathbf{w}_{j}^{q},~{}{A^{\prime}}_{i,j}^{q}\\}=\mathbf{W}_{i,j}^{k,A}{v^{\prime}}_{i}^{q}+\mathbf{b}_{i,j}^{k,A},$
(6)
${A^{\prime}}_{i,j}^{q}=\mathrm{softmax}_{c}({A^{\prime}}_{i,j}^{q})=\dfrac{\exp({{A^{\prime}}_{i,j}^{q}})}{\sum_{l\in\mathcal{N}_{q}(i)}\exp({{A^{\prime}}_{i,l}^{q}})},$
(7)

where the function $\mathrm{softmax}_{c}(\cdot)$ denotes a softmax operation
along the channel axis, which is used to perform a normalisation on the
estimated affinity ${A^{\prime}}_{i,j}^{q}\in\mathbb{R}^{1}$.
$\mathbf{W}_{i,j}^{k,A}\in\mathbb{R}^{(G\times C+1)\times(K\times C)}$ and
$\mathbf{b}_{i,j}^{k,A}\in\mathbb{R}^{(G\times C+1)}$ are matrix
transformation parameters. To reduce the number of the filter parameters, we
consider grouped convolutions [10] with a set of $G$ groups split from the
total $C$ feature channels, and $G\ll C$, i.e., each group of $C/G$ feature
channels shares the same set of filter parameters. The predicted dynamic
filter weights and the affinities are then used in Eq. 5 for dynamic message
calculation.

###  3.5 Modular instantiation

Fig. 2 and 3 shows how our proposed dynamic graph message passing network
(DGMN) can be implemented in a neural network. The proposed module accepts a
single feature map $\mathbf{F}$ as input, which can be derived from any neural
network layer. $\mathbf{H}^{(0)}$ denotes an initial state of the latent
feature map, $\mathbf{H}$, and is initialised with $\mathbf{F}$. $\mathbf{H}$
and $\mathbf{F}$ have the same dimension, i.e.,
$\mathbf{F},\mathbf{H}\in\mathbb{R}^{H\times W\times C}$, where $H$, $W$ and
$C$ are the height, width and the number of feature channels of the feature
map respectively. We first define a set of $S$ uniform sampling rates (we show
two uniform sampling rates in Fig. 2 for clarity). The uniform and the random
walk sampler sample the nodes from the full graph and return the node indices
for subsequent dynamic message calculation (DMC) in Fig. 3. The matrix
transformation $\mathbf{W}_{i,j}^{q}$ to estimate the node random walk in Eq.
4 is implemented by a $3\times 3$ convolution layer [15]. Note that other
sampling strategies could also be flexibly employed in our framework.

The sampled feature nodes are processed along two data paths: one for
predicting the node-dependant dynamic affinities
${A^{\prime}}^{q}\in\mathbb{R}^{H\times W\times K}$ and another path for
dynamic filters $\mathbf{w}^{q}\in\mathbb{R}^{H\times W\times K\times G}$
where $K$ (e.g. , $3\times 3$) is the kernel size for the receiving node. The
matrix transformation $\mathbf{W}_{i,j}^{k,A}$ used to jointly predict the
dynamic filters and affinities in Eq 6 is implemented by a $3\times 3$
convolution layer. Message $\mathbf{M}_{q}\in\mathbb{R}^{H\times W\times C}$
corresponding to the $q$-th sampling rate is then scaled to perform a linear
combination with the observed feature map $\mathbf{F}$, to produce a refined
feature map $\mathbf{H}^{(1)}$ as output. To balance performance and
efficiency, as in existing graph-based feature learning models [73, 9, 41,
84], we also perform $T=1$ iteration of message updating.

###  3.6 Discussion

Our approach is related to deformable convolution [15, 90] and Non-local [71],
but has several key differences:

A fundamental difference to deformable convolution is that it only learns the
offset dependent on the input feature while the filter weights are fixed for
all inputs. In contrast, our model learns the random walk, weight and affinity
as all being dependent on the input. This property makes our weights and
affinities position-specific whereas deformable convolution shares the same
weight across all convolution positions in the feature map. Moreover, [15, 90]
only consider $3\times 3$ local neighbours at each convolution position. In
contrast, our model, for each position, learns to sample a set of $K$ nodes
(where $K\gg 9$) for message passing globally from the whole feature map. This
allows our model to capture a larger receptive field than deformable
convolution.

Whilst Non-local also learns to refine deep features, it uses a self-attention
matrix to guide the message passing between each pair of feature nodes. In
contrast, our model learns to sample graph feature nodes to capture global
feature information efficiently. This dynamic sampling reduces computational
overhead, whilst still being able to improve upon the accuracy of Non-local
across multiple tasks as shown in our experiments (Section 5. We now detail
the extension of our model to transformer architectures next.

(a) Schematic illustration of the DGMN2 layer. The red arrowline denotes
dynamic weights and the blue arrowline denotes dynamic affinities.

(b) The RelPos operation in DGMN2 block.

(c) Schematic illustration of DGMN2 backbone network.

Figure 4:  The architecture of DGMN2 (DGMN2-Tiny). “$\rm d^{\prime}$” denotes
the embedding dimension of tokens in each attention head. “RelPos” denotes the
relative position encoding. $\bigoplus$ and $\bigotimes$ denotes element-wise
sum and matrix multiplication respectively.

##  4 Extending DGMN to Transformers

###  4.1 Interpretation as a Transformer layer

We further instantiate our formulation into an efficient and effective
Transformer layer and present a new Transformer backbone network DGMN2 to
support various vision downstream tasks.

Specifically, we modify the process of dynamic message passing calculation and
implement it as follows: With the predicted walk
$\bigtriangleup\mathbf{d}_{j}^{q}$, we can obtain a new set of adaptively
sampled nodes with graph vertexes $\mathcal{V}$. Given the latent node
$\mathbf{h}_{j}^{(t)}$, we can estimate the dynamic weight
$\mathbf{w}_{j}^{q}$ and dynamic affinity $\mathbf{A^{\prime}}_{i,j}^{q}$.
This process can be defined as:

$\displaystyle\\{\mathbf{w}_{j}^{q},~{}\mathbf{A^{\prime}}_{i,j}^{q}\\}=\varrho\left(\mathbf{W}_{i,j}^{k,A}\mathbf{h}_{j}^{(t)}+\mathbf{b}_{i,j}^{k,A}~{}|~{}\mathcal{V},~{}j,~{}\bigtriangleup\mathbf{d}_{j}^{q}\right),$
(8)

where $\mathbf{W}_{i,j}^{k,A}$ are two sets of matrix transformations to
transform the latent node $\mathbf{h}_{j}^{(t)}$. Both of them are implemented
by $1\times 1$ convolution layers. The function $\varrho(\cdot)$ is a bilinear
sampler [28].

With the estimated dynamic weight $\mathbf{w}_{j}^{q}$ and dynamic affinity
$\mathbf{A^{\prime}}_{i,j}^{q}$ on the sampled graph nodes, we can calculate
the messages as:

$\displaystyle\mathbf{m}^{(t+1)}_{i}=$
$\displaystyle\sum_{q}\sum_{j\in\mathcal{N}_{q}(i)}$ (9)
$\displaystyle\mathrm{softmax}\left(\mathbf{w}_{j}^{q}\left(\mathbf{W}_{i,j}^{h}\mathbf{h}_{j}^{(t)}+\mathbf{b}_{i,j}^{h}\right)+\mathbf{r}_{j}\right){A^{\prime}}_{i,j}^{q},$

where the $\mathrm{softmax}(\cdot)$ denotes a softmax operation along the axis
of number of sampled nodes. $\mathbf{r}_{j}$ is a relative position encoding
(Fig. 4b) and is added to each sampled node. $\mathbf{W}_{i,j}^{h}$ and
$\mathbf{b}_{i,j}^{h}$ are matrix transformation to transform the latent
feature $\mathbf{h}_{j}^{(t)}$. It is implemented by a $1\times 1$ convolution
layer. We set $q=1$ by default in our modified message passing process. We
then scale the message and add it with the observed feature map $\mathbf{F}$.
We can perform dynamic message passing for $T$ steps and produce a refined
feature map $\mathbf{H}^{(T)}$ as output.

Fig. 4a shows how our modified dynamic message passing networks (DGMN2 block)
can be implemented in a neural network. We replace the self-attention block
with our DGMN2 block in the traditional Transformer, that is, we stack a DGMN2
block with a feed forward residual block [16] to form a dynamic message
passing networks Transformer layer (DGMN2 layer). Base on above formulation,
we rephrase the dynamic message passing process from a Transformer perspective
[69, 16]. The node sampling process corresponds to the “Sampler” in Fig. 4a.
“$K$” denotes the number of sampled nodes and we set $K=9$ by default.
Specifically, we treat
$(\mathbf{W}_{i,j}^{h}\mathbf{h}_{j}^{(t)}+b_{i,j}^{h})$, $\mathbf{w}_{j}^{q}$
and ${A^{\prime}}_{i,j}^{q}$ as the query, key and value in the Transformer
respectively.

Relative position encoding. In order to make our DGMN2 position aware, we add
position encoding in each DGMN2 block. Specifically, we consider the relative
position [65, 62, 4] between the K sampled nodes. We add relative height
position and relative width position to obtain 2D relative position
information. For each direction, we add position information relative to the
sampled nodes. The specific implementation is shown in Fig. 4b. Typically, our
DGMN2 is pretrained on ImageNet with resolution of 224 $\times$ 224\. For the
downstream tasks with different input resolution, such as object detection and
semantic segmentation, we perform bilinear interpolation for the position
encoding to adapt to the input of various resolutions.

Complexity. We summary the complexity of DGMN2 in space and time. For time
complexity, it involves: (1) The linear layer to predict the random walks:
$O(HWKd)$; (2) Sampling nodes from key and value: $O(HWK)$; (3) The
multiplication of query and key: $O(HWKd)$; (4) The multiplication of
attention matrix and value: $O(HWKd)$. The total time complexity is
$O(3HWKd+HWK)$. For space complexity, it involves: (1) The predicted random
walks: $O(HWK)$; (2) Sampling nodes of key and value: $O(HWKd)$; (3) The
attention matrix: $O(HWK)$; (4) The product of attention matrix and value:
$O(HWd)$. The total space complexity is $O(2HWK+HWKd+HWd)$. As we keep $K=9$
($K\ll HW$) a fixed constant in our model, both time and space complexity are
$O(HW)$, making DGMN2 a linear Transformer.

###  4.2 Transformer network architecture

TABLE I: Architecture specifications of DGMN2 variants. C33-BN-ReLU denotes
three $3\times 3$ Conv-BN-ReLU, with the stride of 2, 1, 2 respectively.
C31-BN-ReLU denotes one $3\times 3$ Conv-BN-ReLU, with a stride of 2. $d_{i}$
denotes the embedding dimension of tokens in stage $i$; $h_{i}$ denotes the
head number of the stage $i$. $e_{i}$ denotes the expansion ratio of the feed-
forward layer in the stage $i$.

Stage |  Layer Name |  DGMN2-Tiny |  DGMN2-Small |  DGMN2-Medium |  DGMN2-Large
---|---|---|---|---|---
Stage 1 |  Patch Embedding | $\text{C33-BN-ReLU},d_{i}=64$
|  DGMN2 Layer |  $\begin{bmatrix}\begin{array}[]{l}h_{1}=1\\\ e_{1}=8\\\ \end{array}\end{bmatrix}\times 2$ |  $\begin{bmatrix}\begin{array}[]{l}h_{1}=1\\\ e_{1}=8\\\ \end{array}\end{bmatrix}\times 3$ |  $\begin{bmatrix}\begin{array}[]{l}h_{1}=1\\\ e_{1}=8\\\ \end{array}\end{bmatrix}\times 3$ |  $\begin{bmatrix}\begin{array}[]{l}h_{1}=1\\\ e_{1}=8\\\ \end{array}\end{bmatrix}\times 3$
Stage 2 |  Patch Embedding | $\text{C31-BN-ReLU},d_{i}=128$
|  DGMN2 Layer |  $\begin{bmatrix}\begin{array}[]{l}h_{2}=2\\\ e_{2}=8\\\ \end{array}\end{bmatrix}\times 2$ |  $\begin{bmatrix}\begin{array}[]{l}h_{2}=2\\\ e_{2}=8\\\ \end{array}\end{bmatrix}\times 4$ |  $\begin{bmatrix}\begin{array}[]{l}h_{2}=2\\\ e_{2}=8\\\ \end{array}\end{bmatrix}\times 4$ |  $\begin{bmatrix}\begin{array}[]{l}h_{2}=2\\\ e_{2}=8\\\ \end{array}\end{bmatrix}\times 8$
Stage 3 |  Patch Embedding | $\text{C31-BN-ReLU},d_{i}=320$
|  DGMN2 Layer |  $\begin{bmatrix}\begin{array}[]{l}h_{3}=5\\\ e_{3}=4\\\ \end{array}\end{bmatrix}\times 2$ |  $\begin{bmatrix}\begin{array}[]{l}h_{3}=5\\\ e_{3}=4\\\ \end{array}\end{bmatrix}\times 6$ |  $\begin{bmatrix}\begin{array}[]{l}h_{3}=5\\\ e_{3}=4\\\ \end{array}\end{bmatrix}\times 18$ |  $\begin{bmatrix}\begin{array}[]{l}h_{3}=5\\\ e_{3}=4\\\ \end{array}\end{bmatrix}\times 27$
Stage 4 |  Patch Embedding | $\text{C31-BN-ReLU},d_{i}=512$
|  DGMN2 Layer |  $\begin{bmatrix}\begin{array}[]{l}h_{4}=8\\\ e_{4}=4\\\ \end{array}\end{bmatrix}\times 2$ |  $\begin{bmatrix}\begin{array}[]{l}h_{4}=8\\\ e_{4}=4\\\ \end{array}\end{bmatrix}\times 3$ |  $\begin{bmatrix}\begin{array}[]{l}h_{4}=8\\\ e_{4}=4\\\ \end{array}\end{bmatrix}\times 3$ |  $\begin{bmatrix}\begin{array}[]{l}h_{4}=8\\\ e_{4}=4\\\ \end{array}\end{bmatrix}\times 3$

By performing dynamic message passing for $T$ steps, we can further propose an
efficient Transformer backbone network with $T$ DGMN2 layers. Focusing on the
general image recognition task and being able to support downstream vision
tasks, we integrate our DGMN2 layer into the recent pyramidal Transformer
architecture [72, 51] to form our final model DGMN2.

We take DGMN2-Tiny as an example, Fig. 4c illustrates the architecture of the
DGMN2 backbone network. DGMN2 has four stages to extract features at different
scales. For example, we use two DGMN2 layers after a patch embedding (e.g. ,
tokenization) layer in stage 1 of DGMN2-Tiny. The patch embedding layers are
used to downsample the token length to output stride of $\frac{1}{4}$,
$\frac{1}{8}$, $\frac{1}{16}$, $\frac{1}{32}$ respectively in each of the four
stages. Specifically, the STEM is implemented by three units of 3$\times$3
Conv-BN-ReLU, with the stride of 2, 1, 2 respectively; and one such unit is
applied to each of three following down-sampling operations with stride of 2
in the multi-stage architecture. Table I details the family of our DGMN2
configurations with varying capacities: -Tiny, -Small, -Medium and -Large. The
architecture hyper-parameters of DGMN2 are listed as follows:

  * •

$d_{i}$: the embedding dimension of tokens in stage $i$;

  * •

$h_{i}$: the head number in stage $i$;

  * •

$e_{i}$: the expansion ratio of the feed-forward layer in stage $i$;

###  4.3 Discussion

Our DGMN2 is related to DAT [76] and Deformable DETR [91], but has key
differences:

When calculating attention, DAT [76] learns a offset for each point on feature
map and use the deformed points as the key and value. In contrast, our DGMN2
samples $K$ nodes of key and value and calculate the attention using sampled
key and value. Thus our method need fewer FLOPs and is more efficient.

Deformable DETR [91] propose an object detector that uses deformable
attention. Deformable DETR samples a small number of points around a reference
point, while our DGMN2 sampling nodes on the whole feature map without the
assistance of reference points. Moreover, the attention weights of Deformable
DETR are obatained via linear projection over the query feature. In contrast,
our DGMN2 follows the form of dot-product attention and obtains attention
weights via the multiplication of queries and keys.

##  5 Experiments with convolutional architectures

Figure 5: Visualisation of the nodes sampled via learning the random walks
with our network (trained for instance segmentation on COCO). The red point
indicates a receiving node $i$. Different colour families (i.e. yellow and
blue) indicate the learned position specific weights and affinities of the
sampled nodes. Different colours in the same family show the sampled nodes
with different sampling rates for the same receiving node.

###  5.1 Experimental setup

Tasks and datasets. We evaluate our proposed model on three challenging public
benchmarks, i.e., Cityscapes [12] for semantic segmentation, and COCO [44] for
object detection and instance segmentation.

Cityscapes: Cityscapes [12] has densely annotated semantic labels for 19
categories in urban road scenes, and contains a total of 5000 finely annotated
images, divided into 2975, 500, and 1525 images for training, validation and
testing respectively. In addition, it provides 19,998 coarse annotated images
for model training. The images of this dataset have a high resolution of
$1024\times 2048$. Following the standard evaluation protocol [12], the metric
of mean Intersection over Union (mIoU) averaged over all classes is reported.

COCO: COCO 2017 [45] consists of 80 object classes with a training set of
118,000 images, a validation set of 5000 images, and a test set of 2000
images. We follow the standard COCO evaluation metrics [44] to evaluate the
performance of object detection and instance segmentation, employing the
metric of mean average-precision (mAP) at different box and mask IoUs
respectively.

We follow the standard protocol and evaluation metrics used by these public
benchmarks.

Baseline models. For semantic segmentation on Cityscapes, our baseline is
Dilated-FCN [81] with a ResNet-101 backbone pretrained on ImageNet. A randomly
initialised $3\times 3$ convolution layer, together with batch normalisation
and ReLU is used after the backbone to produce a dimension-reduced feature map
of 512 channels which is then fed into the final classifier. For the task of
object detection and instance segmentation on COCO, our baseline is Mask-RCNN
[24, 52] with FPN and ResNet/ResNeXt [25, 77] as a backbone architecture.
Unless otherwise specified, we use a single scale and test with a single model
for all experiments without using other complementary performance boosting
“tricks”. We train models on the COCO training set and test on the validation
and test-dev sets.

Across all tasks and datasets, we consider Non-local networks [73] as an
additional baseline. To have a direct comparison with the Deformable
Convolution method [15, 90], we consider two baselines: (i) “deformable
message passing”, which is a variant of our model using randomly initialised
deformable convolutions for message calculation, but without using the
proposed dynamic sampling and dynamic weights/affinities strategies, and (ii)
the original deformable method which replaces the convolutional operations as
in [15, 90].

Implementation details. For our experiments on Cityscapes, our DGMN module is
randomly initialised and inserted between the $3\times 3$ convolution layer
and the final classifier. For the experiments on COCO, we insert one or
multiple randomly initialised DGMN modules into the backbone for deploying our
approach for feature learning. Our models and baselines for all of our COCO
experiments are trained with the typical “$1\mathrm{x}$” training settings
from the public Mask R-CNN benchmark [52].

When predicting dynamic filter weights, we used the grouping parameter $G=4$.
For our experiments on Cityscapes, the sample rates are set to
$\varphi=\\{1,6,12,24,36\\}$. For experiments on COCO, we use smaller sampling
rates of $\varphi=\\{1,4,8,12\\}$. The effect of this hyperparameter and
additional implementation details are described in the supplementary material.

###  5.2 Model analysis

To demonstrate the effectiveness of the proposed components of our model, we
conduct ablation studies of: (i) DGMN w/ DA, which adds the dynamic affinity
(DA) strategy onto the DGMN base model; (ii) DGMN w/ DA+DW, which further adds
the proposed dynamic weights (DW) prediction; (iii) DGMN w/ DA+DW+DS, which is
our full model with the dynamic sampling (DS) scheme added upon DGMN w/ DA+DW.
Note that DGMN Base was described in Sec. 3.2, DS in Sec. 3.3, and DA and DW
in 3.4.

TABLE II: Ablation study on the Cityscapes validation set for semantic segmentation. All models have a ResNet-101 backbone and are evaluated at a single scale. |  mIoU (%) |  Params |  FLOPs
---|---|---|---
Dilated FCN [81] |  75.0 |  – |  –
\+ Deformable [90] |  78.2 |  +1.31M |  +12.34G
\+ ASPP [7] |  78.9 |  +4.42M |  +38.45G
\+ Non-local [73] |  79.0 |  +2.88M |  +73.33G
\+ DGMN w/ DA |  76.5 |  +0.57M |  +5.32G
\+ DGMN w/ DA+DW |  79.1 |  +0.73M |  +6.88G
\+ DGMN w/ DA+DW+DS |  80.4 |  +2.61M |  +24.55G

Effectiveness of the dynamic sampling strategy. Table II shows quantitative
results of semantic segmentation on the Cityscapes validation set. DGMN w/
DA+DW+DS clearly outperforms DGMN w/ DA+DW on the challenging segmentation
task, meaning that the feature-conditioned adaptive sampling based on learned
random walks is more effective compared to a spatial uniform sampling strategy
when selecting nodes. More importantly, all variants of our module for both
semantic segmentation and object detection that use dynamic sampling (Tab. II
and Tab. III) achieve higher performance than a fully-connected model (i.e.,
Non-local [73]) with substantially fewer FLOPs. This emphasises the
performance benefits of our dynamic graph sampling model. Visualisations of
the nodes dynamically sampled by our model are shown in Fig. 5.

TABLE III:  Quantitative results of different models on the COCO 2017 validation set for object detection ($\mathrm{AP^{b}}$) and instance segmentation ($\mathrm{AP^{m}}$). C5 denotes inserting DGMN after all $3\times 3$ convolutional layers in _res5_. All methods are based on the Mask R-CNN with ResNet-50 as backbone.  |  $\mathrm{AP^{b}}$ |  $\mathrm{AP^{b}_{50}}$ |  $\mathrm{AP^{b}_{75}}$ |  $\mathrm{AP^{m}}$ |  $\mathrm{AP^{m}_{50}}$ |  $\mathrm{AP^{m}_{75}}$
---|---|---|---|---|---|---
Mask R-CNN baseline |  37.8 |  59.1 |  41.4 |  34.4 |  55.8 |  36.6
\+ GCNet [5] |  38.1 |  60.0 |  41.2 |  34.9 |  56.5 |  37.2
\+ Deformable Message Passing |  38.7 |  60.4 |  42.4 |  35.0 |  56.9 |  37.4
\+ Non-local [73] |  39.0 |  61.1 |  41.9 |  35.5 |  58.0 |  37.4
\+ CCNet [27] |  39.3 |  - |  - |  36.1 |  - |  -
\+ DGMN |  39.5 |  61.0 |  43.3 |  35.7 |  58.0 |  37.9
\+ GCNet (C5) [5] |  38.7 |  61.1 |  41.7 |  35.2 |  57.4 |  37.4
\+ Deformable (C5) [90] |  39.9 |  - |  - |  34.9 |  - |  -
\+ DGMN (C5) |  40.2 |  62.0 |  43.4 |  36.0 |  58.3 |  38.2
Figure 6:  Validation curves of $\mathrm{AP^{box}}$ and $\mathrm{AP^{mask}}$
on COCO for Mask-RCNN baseline, Non-local and the proposed DGMN. The number of
training epochs is 90K.

Effectiveness of joint learning the dynamic filters and affinities. As shown
in Tab. II, DGMN w/ DA is 1.5 points better than Dilated FCN baseline with
only a slight increase in FLOPs and parameters, showing the benefit of using
predicted dynamic affinities for reweighting the messages in message passing.
By further employing the estimated dynamic filter weights for message
calculation, the performance increases substantially from a mIoU of 76.5% to
79.1%, which is almost the same as the 79.2% of the Non-local model [73].
Crucially, our approach only uses 9.4% of the FLOPs and 25.3% of the
parameters compared to Non-local. These results clearly demonstrate our
motivation of jointly learning the dynamic filters and dynamic affinities from
sampled graph nodes.

|  |  |
---|---|---|---
Input image |  Dilated FCN |  DGMN (ours) |  Ground truth
|  |  |
Mask R-CNN |  DGMN (ours) |  Mask R-CNN |  DGMN (ours)
Figure 7: Qualitative examples of our results for semantic segmentation on
Cityscapes (first row), and object detection and instance segmentation on COCO
(second row)

Comparison with other baselines. For semantic segmentation on Cityscapes, we
clearly outperform the ASPP module of Deeplab v3 [7] which also increases the
receptive field by using multiple dilation rates. Notably, we improve upon the
most related method, Non-local [73] which models a fully-connected graph,
whilst using only 33% of the FLOPs of [73]. This suggests that a fully-
connected graph models redundant information, and further confirms the
performance and efficiency of our model.

For fair comparison with Non-local [73] as well as other alternatives on COCO,
we insert one randomly initialised DGMN module right before the last residual
block of res4 [73] (Tab. III). We also compare to GCNet [5] and CCNet [27]
which both aim to reduce the complexity of the fully connected Non-local
model. Our proposed DGMN model substantially improves upon these strong
baselines and alternatives. Fig. 6 further shows the validation curves of our
method and different baselines using the standard $\text{AP}^{\text{Box}}$ and
$\text{AP}^{\text{Mask}}$ measures for semantic and instance segmentation
respectively. Our method is consistently better than the Non-local and Mask
R-CNN baselines throughout training.

Effectiveness of multiple DGMN modules. We further show the effectiveness of
our approach for representation learning by inserting multiple of our DGMN
modules into the ResNet-50 backbone. Specifically, we add our full DGMN module
after all $3\times 3$ conv layers in res5 which we denote as “C5”. The second
part of Tab. III shows that our model significantly improves upon the Mask
R-CNN baseline with the improvements of 2.4 points for the APbox on object
detection, and 1.6 points for the APmask on instance segmentation.
Furthermore, when we insert the GCNet module [5] in the same locations for
comparison, our model achieves better performance too. A straightforward
comparison to the deformable method of [90] is the deformable message passing
baseline in which we disable the proposed dynamic sampling and the dynamic
weights and affinities learning strategies. In Tab. III, our model
significantly improves upon the deformable message passing method, which is a
direct evidence of the effectiveness of jointly modeling the dynamic sampling
and dynamic filters and affinities for feature learning. Furthermore, we also
consider inserting the improved Deformable Conv method [90] in C5, which is
complementary to our model since it is plugged before $3\times 3$ layers to
replace the convolution operations. Our approach also achieves better
performance than it.

TABLE IV:  Comparison to state-of-the-art for semantic segmentation on Cityscapes. All methods are trained with the finely-annotated data from the training and validation sets.  |  Backbone |  mIoU (%)
---|---|---
PSPNet [86] |  ResNet 101 |  78.4
PSANet [87] |  ResNet 101 |  80.1
DenseASPP [79] |  DenseNet 161 |  80.6
GloRe [9] |  ResNet 101 |  80.9
Non-local [73] |  ResNet 101 |  81.2
CCNet [27] |  ResNet 101 |  81.4
DANet [20] |  ResNet 101 |  81.5
DGMN (Ours) |  ResNet 101 |  81.6
TABLE V: Quantitative results via plugging our DGMN module on different
backbones on the COCO 2017 test-dev set for object detection
($\mathrm{AP^{box}}$) and instance segmentation ($\mathrm{AP^{mask}}$).

|  Backbone |  $\mathrm{AP^{box}}$ |  $\mathrm{AP^{box}_{50}}$ |  $\mathrm{AP^{box}_{75}}$ |  $\mathrm{AP^{mask}}$ |  $\mathrm{AP^{mask}_{50}}$ |  $\mathrm{AP^{mask}_{75}}$
---|---|---|---|---|---|---|---
Mask R-CNN |  ResNet 50 |  38.0 |  59.7 |  41.5 |  34.6 |  56.5 |  36.6
\+ DGMN (C5) |  |  40.2 |  62.5 |  43.9 |  36.2 |  59.1 |  38.4
\+ DGMN (C4, C5) |  |  41.0 |  63.2 |  44.9 |  36.8 |  59.8 |  39.1
Mask R-CNN |  ResNet 101 |  40.2 |  61.9 |  44.0 |  36.2 |  58.6 |  38.4
\+ DGMN (C5) |  |  41.9 |  64.1 |  45.9 |  37.6 |  60.9 |  40.0
Mask R-CNN |  ResNeXt 101 |  42.6 |  64.9 |  46.6 |  38.3 |  61.6 |  40.8
\+ DGMN (C5) |  |  44.3 |  66.8 |  48.4 |  39.5 |  63.3 |  42.1

###  5.3 Comparison to state of the art

Performance on Cityscapes test set. Table IV compares our approach with state-
of-the-art methods on Cityscapes. Note that all the methods are trained using
only the fine annotations and evaluated on the public evaluation server as
test-set annotations are withheld from the public. As shown in the table, DGMN
(ours) achieves an mIoU of 81.6%, surpassing all previous works. Among
competing methods, GloRe [9], Non-local [73], CCNet [27] and DANet [20] are
the most related to us as they all based on graph neural network modules. Note
that we followed common practice and employed several complementary strategies
used in semantic segmentation to boost performance, including Online Hard
Example Mining (OHEM) [20], Multi-Grid [7] and Multi-Scale (MS) ensembling
[86]. The contribution of each strategy on the final performance is reported
in the supplementary.

Performance on COCO 2017 test set. Table V presents our results on the COCO
test-dev set, where we inserted our module on multiple backbones. By inserting
DGMN into all layers of C4 and C5, we substantially improve the performance of
Mask R-CNN, observing a gain of of 3.0 and 2.2 points on the APbox and the
APmask of object detection and instance segmentation respectively. We observe
similar improvements when using the ResNet-101 or ResNeXt-101 backbones as
well, showing that our proposed DGMN module generalises to multiple backbone
architectures.

Note that the Mask-RCNN baseline with ResNet-101 has 63.1M parameters and 354
GFLOPs. Our DGMN (C4, C5) model with ResNet-50 outperforms it whilst having
only 51.1M parameters and 297.1 GFLOPs. This further shows that the
improvements from our method are due to the model design, and not only the
increased parameters and computation. Further comparisons to the state of the
art are included in the supplementary.

###  5.4 Qualitative results

Figure 8: Qualitative results of the Dilated FCN baseline [81] and our
proposed DGMN model on the Cityscapes dataset.

Qualitative examples of our network’s results can be found in Fig 7. Fig. 8
shows more qualitative results for semantic segmentation (on Cityscapes) and
Fig. 9 and 10 show more qualitative results for object detection and instance
segmentation (on COCO).

##  6 Experiments with transformer architectures

In this section, we compare our DGMN2 model to representative backbones for
the image classification, object detection, instance segmentation and semantic
segmentation tasks.

TABLE VI: Evaluation results on ILSVRC-2012 ImageNet-1K [60] validation set.
We report the results using the input size of 224x224 and center cropped from
resized images with 256x256 pixels.

Method |  Params (M) |  FLOPs (G) |  Top1 Acc (%)
---|---|---|---
ResNet-18 [25] |  11.7 |  1.8 |  68.5
DeiT-Tiny/16 [68] |  5.7 |  1.3 |  72.2
PVT-Tiny [72] |  13.2 |  1.9 |  75.1
DGMN2-Tiny |  12.1 |  2.3 |  78.7
ResNet-50 [25] |  25.6 |  4.1 |  78.5
DeiT-Small/16 [68] |  22.1 |  4.6 |  79.9
PVT-Small [72] |  24.5 |  3.8 |  79.8
Swin-T [48] |  29.0 |  4.5 |  81.3
DGMN2-Small |  21.0 |  4.3 |  81.7
ResNet-101 [25] |  44.7 |  7.9 |  79.8
DeiT-Medium/16 [68] |  48.8 |  9.9 |  80.8
PVT-Medium [72] |  44.2 |  6.7 |  81.2
DGMN2-Medium |  35.8 |  7.1 |  82.5
ResNeXt-101-64x4d [77] |  83.5 |  15.6 |  81.5
ViT-Base/16 [16] |  86.6 |  17.6 |  81.8
DeiT-Large/16 [68] |  86.6 |  17.6 |  81.8
PVT-Large [72] |  61.4 |  9.8 |  81.7
Swin-S [48] |  50.0 |  8.7 |  83.0
SOFT-Large [51] |  64.0 |  11.0 |  83.1
DGMN2-Large |  48.3 |  10.4 |  83.3

###  6.1 Image classification

Datasets. ImageNet-1K [60] is the most popular classification dataset, which
contains 1.28M training images and 50K validation images with 1,000 classes.

Implementation details. We evaluate the proposed DGMN2 on ImageNet-1K [60] for
image classification task. Our models are trained with 1.28M training images
and evaluate on 50K validation images. We report the Top-1 accuracy on
validation set. During training, we follow the training hyperparameters of
recent work [68, 48] and use random-size cropping to 224 $\times$ 224, random
horizontal flipping [67], and mix up [83] for data augmentation. Optimization
is performed using AdamW [50] with momentum of 0.9 and a batch size of 1024.
The weight decay is set to $5\times 10^{-2}$ by default. The initial learning
rate is set to $1\times 10^{-3}$ and decreases following the cosine schedule
[49]. We conduct 300 epochs training from scratch using 8 NVIDIA Tesla V100
GPUs. FLOPs are calculated at batch size 1 with input of resolution 224
$\times$ 224.

Results on ImageNet. We compare with state-of-the-art methods and report the
Top-1 accuracy on the ImageNet-1K validation set. From Table VI we can make
following observations: (i) Transformer based models yield better
classification accuracy over convolution counterparts; (ii) Our proposed DGMN2
achieves best performance among recent pure Transformer based backbones such
as DeiT [68], the strong version of ViT [16]; (iii) We outperform the most
similar (in architecture configuration) Transformer counterparts PVT [72] at
all variants and with fewer parameters and FLOPs. (iv) We also beat the latest
alternatives Swin Transformer [48] and SOFT [51] which are designed to address
the efficiency limitation of Transformer based vision backbone. Particularly,
our DGMN2-Small is 0.4% higher and 8M parameters fewer than Swin-T. Moreover,
DGMN2-Large is 0.3% higher and 1.7M parameters fewer than Swin-S.

###  6.2 Object detection

TABLE VII: Object detection performance using our DGMN2 with RetinaNet [43] on
COCO validation set.

Backbone |  Params (M) |  FLOPs (G) |  $\rm AP$ |  $\rm AP_{50}$ |  $\rm AP_{75}$ |  $\rm AP_{S}$ |  $\rm AP_{M}$ |  $\rm AP_{L}$
---|---|---|---|---|---|---|---|---
ResNet-18 [25] |  21.3 |  198.2 |  31.8 |  49.6 |  33.6 |  16.3 |  34.3 |  43.2
PVT-Tiny [72] |  23.0 |  230.2 |  36.7 |  56.9 |  38.9 |  22.6 |  38.8 |  50.0
DGMN2-Tiny |  21.8 |  206.8 |  39.7 |  60.5 |  42.2 |  23.5 |  43.1 |  52.1
ResNet-50 [25] |  37.7 |  251.3 |  36.3 |  55.3 |  38.6 |  19.3 |  40.0 |  48.8
PVT-Small [72] |  34.2 |  298.0 |  40.4 |  61.3 |  43.0 |  25.0 |  42.9 |  55.7
DGMN2-Small |  30.7 |  248.2 |  42.5 |  63.3 |  45.3 |  25.3 |  46.1 |  56.5
ResNet-101 [25] |  56.7 |  331.2 |  38.5 |  57.8 |  41.2 |  21.4 |  42.6 |  51.1
PVT-Medium [72] |  53.9 |  389.3 |  41.9 |  63.1 |  44.3 |  25.0 |  44.9 |  57.6
DGMN2-Medium |  45.6 |  312.0 |  43.7 |  64.8 |  46.6 |  26.3 |  47.2 |  58.3
ResNeXt-101-64x4d [77] |  95.5 |  496.3 |  41.0 |  60.9 |  44.0 |  23.9 |  45.2 |  54.0
PVT-Large [72] |  71.1 |  496.1 |  42.6 |  63.7 |  45.4 |  25.8 |  46.0 |  58.4
DGMN2-Large |  57.9 |  382.1 |  44.7 |  65.4 |  48.0 |  26.6 |  48.7 |  60.6

TABLE VIII: Instance segmentation performance using our DGMN2 with Mask R-CNN
[24] on COCO validation set. $\rm AP^{b}$ denotes bounding box AP and $\rm
AP^{m}$ denotes mask AP.

Backbone |  Params (M) |  FLOPs (G) |  $\rm AP^{b}$ |  $\rm AP^{b}_{50}$ |  $\rm AP^{b}_{75}$ |  $\rm AP^{m}$ |  $\rm AP^{m}_{50}$ |  $\rm AP^{m}_{75}$
---|---|---|---|---|---|---|---|---
ResNet-18 [25] |  31.2 |  214.3 |  34.0 |  54.0 |  36.7 |  31.2 |  51.0 |  32.7
PVT-Tiny [72] |  32.9 |  247.3 |  36.7 |  59.2 |  39.3 |  35.1 |  56.7 |  37.3
DGMN2-Tiny |  31.8 |  223.0 |  40.1 |  62.4 |  43.8 |  37.2 |  59.7 |  39.6
ResNet-50 [25] |  44.2 |  269.8 |  38.0 |  58.6 |  41.4 |  34.4 |  55.1 |  36.7
PVT-Small [72] |  44.1 |  315.1 |  40.4 |  62.9 |  43.8 |  37.8 |  60.1 |  40.3
DGMN2-Small |  40.6 |  264.5 |  43.4 |  65.4 |  47.8 |  39.7 |  62.5 |  42.6
ResNet-101 [25] |  63.2 |  349.7 |  40.4 |  61.1 |  44.2 |  36.4 |  57.7 |  38.8
PVT-Medium [72] |  63.9 |  406.4 |  42.0 |  64.4 |  45.6 |  39.0 |  61.6 |  42.1
DGMN2-Medium |  55.5 |  328.2 |  44.4 |  66.3 |  48.6 |  40.2 |  63.3 |  43.1
ResNeXt-101-64x4d [77] |  101.9 |  514.7 |  42.8 |  63.8 |  47.3 |  38.4 |  60.6 |  41.3
PVT-Large [72] |  81.0 |  513.1 |  42.9 |  65.0 |  46.6 |  39.5 |  61.9 |  42.5
DGMN2-Large |  67.9 |  398.4 |  46.2 |  67.9 |  50.7 |  41.6 |  65.1 |  44.6

TABLE IX: Object detection performance using our DGMN2 with Deformable DETR
[91] on COCO validation set. “*” indicates that this result is from official
GitHub repository, which has improved performance with a fixed bug. “+”
indicates using iterative bounding box refinement and two-stage Deformable
DETR.

Backbone |  Params (M) |  FLOPs (G) |  $\rm AP$ |  $\rm AP_{50}$ |  $\rm AP_{75}$ |  $\rm AP_{S}$ |  $\rm AP_{M}$ |  $\rm AP_{L}$
---|---|---|---|---|---|---|---|---
ResNet-50 [25] |  39.9 |  206.7 |  43.8 |  62.6 |  47.7 |  26.4 |  47.1 |  58.0
ResNet-50* [25] |  39.9 |  206.7 |  44.5 |  63.6 |  48.7 |  27.1 |  47.6 |  59.6
DGMN2-Tiny |  24.0 |  163.6 |  44.4 |  63.5 |  48.3 |  26.4 |  48.0 |  57.7
DGMN2-Small |  32.9 |  205.1 |  47.3 |  66.9 |  51.4 |  28.9 |  51.2 |  62.1
DGMN2-Medium |  47.7 |  268.9 |  48.4 |  68.0 |  53.0 |  29.9 |  52.1 |  64.0
ResNet-50+ [25] |  41.0 |  215.9 |  46.2 |  65.2 |  50.0 |  28.8 |  49.2 |  61.7
ResNet-50*+ [25] |  41.0 |  215.9 |  46.9 |  65.6 |  51.0 |  29.6 |  50.1 |  61.6
DGMN2-Small+ |  34.0 |  214.3 |  48.5 |  68.0 |  52.5 |  30.6 |  52.1 |  63.9

TABLE X: Object detection performance using our DGMN2 with Sparse R-CNN [66]
on COCO validation set. All the models use 300 learnable proposal boxes.

Backbone |  Params (M) |  FLOPs (G) |  $\rm AP$ |  $\rm AP_{50}$ |  $\rm AP_{75}$ |  $\rm AP_{S}$ |  $\rm AP_{M}$ |  $\rm AP_{L}$
---|---|---|---|---|---|---|---|---
ResNet-50 [25] |  106.1 |  112.82 |  45.0 |  63.4 |  48.2 |  26.9 |  47.2 |  59.5
DGMN2-Small |  102.6 |  114.86 |  48.2 |  67.7 |  52.7 |  32.3 |  51.0 |  63.2

Implementation details. In this section, we use DGMN2 as the backbone to
perform object detection experiments. We evaluate our backbone on three
diverse object detection architectures: RetinaNet [43], Mask R-CNN [24] and
Deformable DETR [85] on the challenging COCO benchmark [46]. In all of our
experiments, use the ImageNet pretrained weights (from Table VI) to initialize
the backbone and train all models on COCO Train2017, and evaluate on COCO
Val2017. For fair comparisons, we follow the training and test hyperparameters
of our baselines. Specifically, we use AdamW [50] optimizer and a batch size
of 16 on 8 NVIDIA GPUs to train the model with the initial learning rate of
$1\times 10^{-4}$. We use the 1$\times$ schedule (12 epochs with the learning
rate decayed by 10$\times$ at epochs 9 and 11) to train the models. The
training image is resized to the shorter side of 800 and the longer side does
not exceed 1333. During testing, the shorter side of input image is set to
800. We also report the parameters and FLOPs of our models. The FLOPs is
calculated using the input resolution of 800 $\times$ 1333\. For the
experiments with Deformable DETR, we follow its implementation and use the
Adam optimizer with initial learning rate of $2\times 10^{-4}$ and the weight
decay of $10^{-4}$. Note that we use the official implementation of Deformable
DETR on GitHub which has improved performance with a fixed bug.

Results with RetinaNet [43]. Table VII lists the parameters and the bounding
box AP of different backbones when using RetinaNet [43], showing that our
DGMN2 models can consistently outperforms ResNet [25] and PVT [72] when using
similar parameters. Specifically, our DGMN2-Tiny significantly surpasses
ResNet-18 by 4.9% AP and PVT-Tiny by 3.0% AP using a similar parameters. Our
DGMN2-Small outperforms ResNet-50 by 6.2% AP and PVT-Small by 2.1% AP with
fewer parameters. Moreover, our DGMN2-Medium surpasses ResNet-101 by 5.2% AP
and PVT-Medium by 1.8% AP with fewer parameters. Finally, DGMN2-Large
surpasses ResNeXt-101-64x4d by 3.7% AP and surpass PVT-Large by 2.1% AP with
fewer parameters and FLOPs.

Results with Mask R-CNN [24]. Table VIII lists the parameters, the bounding
box AP and the mask AP of different backbones when using Mask R-CNN [24],
which also demonstrates the similar results. Our DGMN2-Tiny surpasses
ResNet-18 [25] by 6.2% on bounding box AP ($\rm AP^{b}$) and 6.0% on mask AP
($\rm AP^{m}$) and even surpasses ResNet-50 by about 2.2% on $\rm AP^{b}$ and
2.8% on $\rm AP^{m}$. When compared to PVT, our DGMN-Tiny outperforms PVT-Tiny
by 3.5% on $\rm AP^{b}$ and 2.1% on $\rm AP^{m}$. Our DGMN2-Small achieves
43.4% $\rm AP^{b}$ and 39.7% $\rm AP^{m}$, which is 5.4% and 5.3% higher than
ResNet-50. Our DGMN2-Small also outperforms PVT-Small by 3.0% on $\rm AP^{b}$
and 1.9% on $\rm AP^{b}$. DGMN2-Medium achieves 44.4% $\rm AP^{b}$ and 40.2%
$\rm AP^{m}$, which is 4.0% and 3.8% higher than ResNet-101 and also 2.4% and
1.2% higher than PVT-Medium. Finally, DGMN2-Large achieves 46.2% $\rm AP^{b}$
and 41.6% $\rm AP^{m}$, which is 3.4% and 3.2% higher than ResNeXt-101-64x4d
and also 3.3% and 2.1% higher than PVT-Large.

Results with Deformable DETR [91]. When using a Transformer-based detector
(such as Deformable DETR [91]), our DGMN2 still have performance improvement
under comparable parameters. Table IX lists the parameters and the bounding
box AP of different backbones when using Deformable DETR, showing that our
DGMN2-Tiny achieves comparable performance with ResNet-50 [25] with much fewer
parameters and FLOPs. For our DGMN2-Small, we surpass ResNet-50 for about 2.8%
AP and also have fewer parameters.

Results with Sparse R-CNN [66]. When using Sparse R-CNN [66] as the detector,
our DGMN2 models can achieve high performance under comparable parameters.
Table X lists the parameters and the bounding box AP of different backbones
when using Sparse R-CNN. For example, our DGMN2-Small surpass ResNet-50 [25]
for about 3.2% AP.

###  6.3 Semantic segmentation

TABLE XI: Semantic segmentation performance using our DGMN2 on Cityscapes
validation set. “SS” denotes single-scale testing and “MS” denotes multi-scale
testing. “21K” means the backbone is pretrained on ImageNet-21K, otherwise on
ImageNet-1K.

Backbone |  Decoder Head |  Params (M) |  FLOPs (G) |  mIoU (SS / MS)
---|---|---|---|---
DGMN2-Tiny |  Semantic FPN [32] |  15.84 |  76.35 |  78.09 / 79.4
DGMN2-Small |  Semantic FPN [32] |  24.71 |  99.57 |  80.65 / 81.58
DGMN2-Medium |  Semantic FPN [32] |  39.55 |  136.01 |  80.60 / 81.79
DGMN2-Large |  Semantic FPN [32] |  52.02 |  175.94 |  81.75 / 82.64
SETR (T-Base, 21K) [89] |  Naive [89] |  88.27 |  295.44 |  75.54 / -
SETR (T-Large, 21K) [89] |  Naive [89] |  306.58 |  953.44 |  77.37 / -
SETR (T-Base, DeiT) [89] |  Naive [89] |  88.27 |  295.44 |  77.85 / -
DGMN2-Tiny |  Naive [89] |  11.60 |  117.52 |  77.23 / 78.23
DGMN2-Small |  Naive [89] |  20.47 |  204.97 |  80.31 / 81.04
DGMN2-Medium |  Naive [89] |  35.31 |  347.76 |  80.83 / 81.39
DGMN2-Large |  Naive [89] |  47.78 |  467.46 |  81.80 / 82.61
SETR (T-Base, 21K) [89] |  PUP [89] |  98.12 |  414.15 |  76.71 / -
SETR (T-Large, 21K) [89] |  PUP [89] |  319.11 |  1079.18 |  78.39 / -
SETR (T-Base, DeiT) [89] |  PUP [89] |  98.12 |  414.15 |  78.79 / -
DGMN2-Tiny |  PUP [89] |  13.95 |  242.51 |  78.25 / 79.26
DGMN2-Small |  PUP [89] |  22.82 |  329.96 |  79.78 / 80.73
DGMN2-Medium |  PUP [89] |  37.67 |  472.75 |  80.97 / 81.80
DGMN2-Large |  PUP [89] |  50.14 |  592.45 |  81.58 / 82.27
SETR (T-Base, 21K) [89] |  MLA [89] |  92.50 |  309.45 |  75.60 / -
SETR (T-Large, 21K) [89] |  MLA [89] |  310.81 |  973.68 |  76.65 / -
SETR (T-Base, DeiT) [89] |  MLA [89] |  92.50 |  309.45 |  78.04 / -
DGMN2-Tiny |  MLA [89] |  13.37 |  141.72 |  78.25 / 79.32
DGMN2-Small |  MLA [89] |  22.24 |  229.17 |  80.79 / 81.62
DGMN2-Medium |  MLA [89] |  37.08 |  371.96 |  81.09 / 82.00
DGMN2-Large |  MLA [89] |  49.56 |  491.66 |  81.55 / 81.98

Implementation details. We use our DGMN2 as the backbone to perform the
semantic segmentation experiments on the Cityscapes dataset [12]. In all of
our experiments on semantic segmentation, we use ImageNet pretrained weights
(from Table VI) to initialize the backbone and train all models on the
training set and evaluated on the validation set and test set. For the decoder
head, it is randomly initialized. Following the default setting (e.g. , data
augmentation and training schedule) of public codebase mmsegmentation [11], we
set the number of training iterations to 40,000 and the input size to 769
$\times$ 769 for all our experiments. We use AdamW [50] optimizer and a batch
size of 8 to train the model with the initial learning rate of $1\times
10^{-4}$. For fair comparison with the Transformer-based semantic segmentation
model SETR [89], we also use the decoder heads of SETR-Naive, SETR-PUP and
SETR-MLA. As the DGMN2 is a pyramidal architecture and in order to adapt our
model to the semantic segmentation task with higher resolution outputs, we set
the stride of convolution in the patch embedding of the third and fourth
stages to 1. Note that we can still can use the ImageNet pretrained weights to
initialize the backbone, as we are simply changing the strides, but not any of
the parameters. For all experiments on semantic segmentation, we do not use
the auxiliary loss or complementary tricks like OHEM [63] in model training.

For the evaluation on test set, we submit the result to Cityscapes test
server. We use the same training schedule as SETR [89] to train the model: (1)
We first train the model on Cityscapes training and validation set for 100,000
iterations with the initial learning rate of $1\times 10^{-4}$; (2) We then
fine tune the model on Cityscapes coarse set for 50,000 iterations with the
initial learning rate of $1\times 10^{-5}$; (3) We finally fine tune the model
on Cityscapes training and validation set for 20,000 iterations with the
initial learning rate of $1\times 10^{-5}$.

Results on Cityscapes. Table XI and XII show the comparative results on the
validation and test set of Cityscapes respectively. We can make following
observations: (i) SETR with backbone of DeiT [68] with ImageNet-1K pretraining
even outperforms that of ViT [16] with ImageNet-21K pretraining and T-large
configuration; (ii) Our model consistently outperforms SETR [89] across all of
the decoder heads (e.g. , Naive, PUP, MLA), scales (e.g. , T-Base, T-Large)
and its strong version DeiT [68], with fewer parameters and FLOPs. Note that
our DGMN2 is pretrained on ImageNet-1K, much less data training than the SETR
ImageNet-21K configuration. This is again showing the effectiveness of our
dynamic graph message passing module is superior to the fully connected graph
in dense prediction task. (iii) Particularly, with the advantage of multi-
scale pyramidal architecture design, DGMN2 achieves superior results with
decoder head of Semantic FPN [32]. (iv) Our DGMN2-Large achieves mIoU 82.46%
on test set with the MLA [89] decoder head. which is on par with the best
results reported so far.

TABLE XII: Semantic segmentation performance using our DGMN2 on Cityscapes
test set.

Backbone |  Decoder Head |  Params (M) |  FLOPs (G) |  mIoU
---|---|---|---|---
SETR (T-Large) [89] |  PUP [89] |  319.11 |  1079.18 |  81.64
DGMN2-Large |  Semantic FPN [32] |  52.02 |  175.94 |  81.84
DGMN2-Large |  Naive [89] |  47.78 |  467.46 |  81.33
DGMN2-Large |  PUP [89] |  50.14 |  592.45 |  81.86
DGMN2-Large |  MLA [89] |  49.56 |  491.66 |  82.46

###  6.4 Visualization

——Mask R-CNN

——DGMN (ours)

——Mask R-CNN

——DGMN (ours)

——Mask R-CNN

——DGMN (ours)

Figure 9: Qualitative examples of the instance segmentation task on the COCO
validation dataset. The odd rows are the results from the Mask R-CNN baseline
[52, 24]. The even rows are the results from our DGMN approach. Note how our
approach often produces better segmentations and fewer false-positive and
false-negative detections.

——Mask R-CNN

——DGMN (ours)

——Mask R-CNN

——DGMN (ours)

——Mask R-CNN

——DGMN (ours)

Figure 10: More qualitative examples of the instance segmentation task on the
COCO validation dataset. The odd rows are the results from the Mask R-CNN
baseline [52, 24]. The even rows are the detection results from our DGMN
approach. Note how our approach often produces better segmentations and fewer
false-positive and false-negative detections.

(a)

(b)

(c)

(d)

(e)

(f)

(g)

(h)

(i)  (j)

(k)

(l)

(m)

(n)

(o)

(p)

Figure 11:  Visualization of dynamic sampled graph nodes with our DGMN2
(trained for object detection on COCO dataset). The blue circle denotes a
selected position on observed feature and the orange circles denote the
corresponding sampled graph nodes. The color shades of the orange circles
indicate the intensity of the dynamic filters of the sampling graph nodes. The
color bar is shown at the right.

We visualize the dynamic sampled graph nodes using the DGMN2 model trained for
object detection on COCO dataset. We select a point on image and find the
corresponding position on the observed feature and visualize their
corresponding sampled graph nodes. For better understanding, we draw all
sampled graph nodes from the last layer of each of the four stages in our
DGMN2. As shown in Fig. 11, the blue circles denotes a selected position on
observed feature and the orange circles denote the corresponding sampled graph
nodes. The color shades of the orange circles indicates the intensity of the
dynamic filters on the sampling graph nodes. This visualization demonstrates
that our proposed DGMN2 is able to adaptively sample nodes and use dynamic
filters with appropriate intensity at different positions according to context
feature of different objects.

##  7 Conclusion

We proposed Dynamic Graph Message passing Networks (DGMN), a novel graph
neural network module that dynamically determines the graph structure for each
input. It learns dynamic sampling of a small set of relevant neighbours for
each node, and also predicts the weights and affinities dependant on the
feature nodes to propagate information through this sampled neighbourhood.
This formulation significantly reduces the computational cost of static,
fully-connected graphs which contain many redundancies. We further recast our
formulation to take a Transformer perspective and instantiate an efficient and
effective Transformer layer and present a new Transformer backbone network
DGMN2 in supporting various vision downstream tasks. This is demonstrated by
the fact that we are able to clearly improve upon the accuracy of several
state-of-art baselines, on four complex scene understanding tasks.

## Acknowledgments

We thank Professor Dan Xu and Professor Andrew Zisserman for valuable
discussions. This work was supported in part by National Natural Science
Foundation of China (Grant No. 6210020439), Lingang Laboratory (Grant No. LG-
QS-202202-07) and Natural Science Foundation of Shanghai (Grant No.
22ZR1407500).

## References

  * [1] Anurag Arnab, Sadeep Jayasumana, Shuai Zheng, and Philip HS Torr.  Higher order conditional random fields in deep neural networks.  In European Conference on Computer Vision, 2016.
  * [2] Anurag Arnab, Shuai Zheng, Sadeep Jayasumana, Bernardino Romera-Paredes, Måns Larsson, Alexander Kirillov, Bogdan Savchynskyy, Carsten Rother, Fredrik Kahl, and Philip HS Torr.  Conditional random fields meet deep neural networks for semantic segmentation: Combining probabilistic graphical models with deep learning for structured prediction.  IEEE Signal Processing Magazine, 2018.
  * [3] Xue Bai and Guillermo Sapiro.  Geodesic matting: A framework for fast interactive image and video segmentation and matting.  International Journal of Computer Vision, 2009.
  * [4] Irwan Bello, Barret Zoph, Ashish Vaswani, Jonathon Shlens, and Quoc V Le.  Attention augmented convolutional networks.  In IEEE International Conference on Computer Vision, 2019.
  * [5] Yue Cao, Jiarui Xu, Stephen Lin, Fangyun Wei, and Han Hu.  Gcnet: Non-local networks meet squeeze-excitation networks and beyond.  In IEEE International Conference on Computer Vision workshops, 2019\.
  * [6] Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L. Yuille.  Semantic image segmentation with deep convolutional nets and fully connected CRFs.  In International Conference on Learning Representations, 2015.
  * [7] Liang-Chieh Chen, George Papandreou, Florian Schroff, and Hartwig Adam.  Rethinking atrous convolution for semantic image segmentation.  arXiv preprint arXiv:1706.05587, 2017.
  * [8] Liang-Chieh Chen, Yukun Zhu, George Papandreou, Florian Schroff, and Hartwig Adam.  Encoder-decoder with atrous separable convolution for semantic image segmentation.  In European Conference on Computer Vision, 2018.
  * [9] Yunpeng Chen, Marcus Rohrbach, Zhicheng Yan, Shuicheng Yan, Jiashi Feng, and Yannis Kalantidis.  Graph-based global reasoning networks.  In IEEE Conference on Computer Vision and Pattern Recognition, 2019\.
  * [10] François Chollet.  Xception: Deep learning with depthwise separable convolutions.  In IEEE Conference on Computer Vision and Pattern Recognition, 2017\.
  * [11] MMSegmentation Contributors.  MMSegmentation: Openmmlab semantic segmentation toolbox and benchmark.  https://github.com/open-mmlab/mmsegmentation, 2020.
  * [12] Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele.  The cityscapes dataset for semantic urban scene understanding.  In IEEE Conference on Computer Vision and Pattern Recognition, 2016\.
  * [13] Jifeng Dai, Kaiming He, and Jian Sun.  Boxsup: Exploiting bounding boxes to supervise convolutional networks for semantic segmentation.  In IEEE International Conference on Computer Vision, 2015.
  * [14] Jifeng Dai, Yi Li, Kaiming He, and Jian Sun.  R-fcn: Object detection via region-based fully convolutional networks.  In Advances in Neural Information Processing Systems, 2016.
  * [15] Jifeng Dai, Haozhi Qi, Yuwen Xiong, Yi Li, Guodong Zhang, Han Hu, and Yichen Wei.  Deformable convolutional networks.  In IEEE International Conference on Computer Vision, 2017.
  * [16] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al.  An image is worth 16x16 words: Transformers for image recognition at scale.  In International Conference on Learning Representations, 2021.
  * [17] Haoqi Fan, Bo Xiong, Karttikeya Mangalam, Yanghao Li, Zhicheng Yan, Jitendra Malik, and Christoph Feichtenhofer.  Multiscale vision transformers.  In IEEE International Conference on Computer Vision, 2021.
  * [18] Matthias Fey, Jan Eric Lenssen, Frank Weichert, and Heinrich Müller.  Splinecnn: Fast geometric deep learning with continuous b-spline kernels.  In IEEE Conference on Computer Vision and Pattern Recognition, 2018\.
  * [19] Cheng-Yang Fu, Wei Liu, Ananth Ranga, Ambrish Tyagi, and Alexander C Berg.  Dssd: Deconvolutional single shot detector.  arXiv preprint arXiv:1701.06659, 2017.
  * [20] Jun Fu, Jing Liu, Haijie Tian, Zhiwei Fang, and Hanqing Lu.  Dual attention network for scene segmentation.  In IEEE Conference on Computer Vision and Pattern Recognition, 2019\.
  * [21] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl.  Neural message passing for quantum chemistry.  In International Conference on Machine Learning, 2017.
  * [22] Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He.  Accurate, large minibatch sgd: Training imagenet in 1 hour.  arXiv preprint arXiv:1706.02677, 2017.
  * [23] Will Hamilton, Zhitao Ying, and Jure Leskovec.  Inductive representation learning on large graphs.  In Advances in Neural Information Processing Systems, 2017.
  * [24] Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross Girshick.  Mask r-cnn.  In IEEE International Conference on Computer Vision, 2017.
  * [25] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun.  Deep residual learning for image recognition.  In IEEE Conference on Computer Vision and Pattern Recognition, 2016\.
  * [26] Qinbin Hou, Li Zhang, Ming-Ming Cheng, and Jiashi Feng.  Strip pooling: Rethinking spatial pooling for scene parsing.  In IEEE Conference on Computer Vision and Pattern Recognition, 2020\.
  * [27] Zilong Huang, Xinggang Wang, Lichao Huang, Chang Huang, Yunchao Wei, and Wenyu Liu.  Ccnet: Criss-cross attention for semantic segmentation.  In IEEE International Conference on Computer Vision, 2019.
  * [28] Max Jaderberg, Karen Simonyan, Andrew Zisserman, and Koray Kavukcuoglu.  Spatial transformer networks.  In Advances in Neural Information Processing Systems, 2015.
  * [29] Xu Jia, Bert De Brabandere, Tinne Tuytelaars, and Luc V Gool.  Dynamic filter networks.  In Advances in Neural Information Processing Systems, 2016.
  * [30] Anees Kazi, Luca Cosmo, Seyed-Ahmad Ahmadi, Nassir Navab, and Michael Bronstein.  Differentiable graph module (dgm) for graph convolutional networks.  IEEE Transactions on Pattern Analysis and Machine Intelligence, 2022\.
  * [31] Thomas N Kipf and Max Welling.  Semi-supervised classification with graph convolutional networks.  In International Conference on Learning Representations, 2017.
  * [32] Alexander Kirillov, Ross Girshick, Kaiming He, and Piotr Dollár.  Panoptic feature pyramid networks.  In IEEE Conference on Computer Vision and Pattern Recognition, 2019\.
  * [33] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton.  ImageNet classification with deep convolutional neural networks.  In Advances in Neural Information Processing Systems, 2012.
  * [34] Philipp Krähenbühl and Vladlen Koltun.  Efficient inference in fully connected crfs with gaussian edge potentials.  Advances in Neural Information Processing Systems, 2011.
  * [35] Hei Law and Jia Deng.  Cornernet: Detecting objects as paired keypoints.  In European Conference on Computer Vision, 2018.
  * [36] Jure Leskovec and Christos Faloutsos.  Sampling from large graphs.  In SIGKDD, 2006.
  * [37] Guohao Li, Matthias Muller, Ali Thabet, and Bernard Ghanem.  Deepgcns: Can gcns go as deep as cnns?  In IEEE International Conference on Computer Vision, 2019.
  * [38] Qizhu Li, Anurag Arnab, and Philip HS Torr.  Holistic, instance-level human parsing.  In British Machine Vision Conference, 2017.
  * [39] Xiangtai Li, Li Zhang, Ansheng You, Maoke Yang, Kuiyuan Yang, and Yunhai Tong.  Global aggregation then local distribution in fully convolutional networks.  In British Machine Vision Conference, 2019.
  * [40] Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel.  Gated graph sequence neural networks.  In International Conference on Learning Representations, 2015.
  * [41] Guosheng Lin, Chunhua Shen, Ian Reid, and Anton van den Hengel.  Deeply learning the messages in message passing inference.  In Advances in Neural Information Processing Systems, 2015.
  * [42] Tsung-Yi Lin, Piotr Dollár, Ross B. Girshick, Kaiming He, Bharath Hariharan, and Serge J. Belongie.  Feature pyramid networks for object detection.  In IEEE Conference on Computer Vision and Pattern Recognition, 2017\.
  * [43] Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollár.  Focal loss for dense object detection.  In IEEE International Conference on Computer Vision, 2017.
  * [44] Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick.  Microsoft coco: Common objects in context.  In European Conference on Computer Vision, 2014.
  * [45] Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick.  Microsoft coco: Common objects in context.  In European Conference on Computer Vision, 2014.
  * [46] Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick.  Microsoft coco: Common objects in context.  In European Conference on Computer Vision, 2014.
  * [47] Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, and Alexander C Berg.  Ssd: Single shot multibox detector.  In European Conference on Computer Vision, 2016.
  * [48] Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, and Baining Guo.  Swin transformer: Hierarchical vision transformer using shifted windows.  In IEEE International Conference on Computer Vision, 2021.
  * [49] Ilya Loshchilov and Frank Hutter.  Sgdr: Stochastic gradient descent with warm restarts.  In International Conference on Learning Representations, 2017.
  * [50] Ilya Loshchilov and Frank Hutter.  Decoupled weight decay regularization.  In International Conference on Learning Representations, 2019.
  * [51] Jiachen Lu, Jinghan Yao, Junge Zhang, Xiatian Zhu, Hang Xu, Weiguo Gao, Chunjing Xu, Tao Xiang, and Li Zhang.  Soft: Softmax-free transformer with linear complexity.  In Advances in Neural Information Processing Systems, 2021.
  * [52] Francisco Massa and Ross Girshick.  maskrcnn-benchmark: Fast, modular reference implementation of Instance Segmentation and Object Detection algorithms in PyTorch.  https://github.com/facebookresearch/maskrcnn-benchmark, 2018.
  * [53] Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M Bronstein.  Geometric deep learning on graphs and manifolds using mixture model cnns.  In IEEE Conference on Computer Vision and Pattern Recognition, 2017\.
  * [54] Aude Oliva and Antonio Torralba.  The role of context in object recognition.  Trends in cognitive sciences, 2007.
  * [55] Jiangmiao Pang, Kai Chen, Jianping Shi, Huajun Feng, Wanli Ouyang, and Dahua Lin.  Libra r-cnn: Towards balanced learning for object detection.  In IEEE Conference on Computer Vision and Pattern Recognition, 2019\.
  * [56] Tobias Pohlen, Alexander Hermans, Markus Mathias, and Bastian Leibe.  Full-resolution residual networks for semantic segmentation in street scenes.  In IEEE Conference on Computer Vision and Pattern Recognition, 2017\.
  * [57] Andrew Rabinovich, Andrea Vedaldi, Carolina Galleguillos, Eric Wiewiora, and Serge Belongie.  Objects in context.  In IEEE International Conference on Computer Vision, 2007.
  * [58] Joseph Redmon and Ali Farhadi.  Yolov3: An incremental improvement.  arXiv preprint arXiv:1804.02767, 2018.
  * [59] Samuel Rota Bulò, Lorenzo Porzi, and Peter Kontschieder.  In-place activated batchnorm for memory-optimized training of dnns.  In IEEE Conference on Computer Vision and Pattern Recognition, 2018\.
  * [60] Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei.  Imagenet large scale visual recognition challenge.  International Journal of Computer Vision, 2015.
  * [61] Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini.  The graph neural network model.  IEEE transactions on neural networks, 2008.
  * [62] Peter Shaw, Jakob Uszkoreit, and Ashish Vaswani.  Self-attention with relative position representations.  arXiv preprint arXiv:1803.02155, 2018.
  * [63] Abhinav Shrivastava, Abhinav Gupta, and Ross Girshick.  Training region-based object detectors with online hard example mining.  In IEEE Conference on Computer Vision and Pattern Recognition, 2016\.
  * [64] Karen Simonyan and Andrew Zisserman.  Very deep convolutional networks for large-scale image recognition.  In International Conference on Learning Representations, 2015.
  * [65] Aravind Srinivas, Tsung-Yi Lin, Niki Parmar, Jonathon Shlens, Pieter Abbeel, and Ashish Vaswani.  Bottleneck transformers for visual recognition.  In IEEE Conference on Computer Vision and Pattern Recognition, 2021\.
  * [66] Peize Sun, Rufeng Zhang, Yi Jiang, Tao Kong, Chenfeng Xu, Wei Zhan, Masayoshi Tomizuka, Lei Li, Zehuan Yuan, Changhu Wang, et al.  Sparse r-cnn: End-to-end object detection with learnable proposals.  In IEEE Conference on Computer Vision and Pattern Recognition, 2021\.
  * [67] Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich.  Going deeper with convolutions.  In IEEE Conference on Computer Vision and Pattern Recognition, 2015\.
  * [68] Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Hervé Jégou.  Training data-efficient image transformers & distillation through attention.  In International Conference on Machine Learning, 2021.
  * [69] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin.  Attention is all you need.  In Advances in Neural Information Processing Systems, 2017.
  * [70] Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio.  Graph attention networks.  In International Conference on Learning Representations, 2018.
  * [71] Panqu Wang, Pengfei Chen, Ye Yuan, Ding Liu, Zehua Huang, Xiaodi Hou, and Garrison Cottrell.  Understanding convolution for semantic segmentation.  In IEEE Winter Conference on Applications of Computer Vision, 2018\.
  * [72] Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo, and Ling Shao.  Pyramid vision transformer: A versatile backbone for dense prediction without convolutions.  In IEEE International Conference on Computer Vision, 2021.
  * [73] Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He.  Non-local neural networks.  In IEEE Conference on Computer Vision and Pattern Recognition, 2018\.
  * [74] Yue Wang, Yongbin Sun, Ziwei Liu, Sanjay E Sarma, Michael M Bronstein, and Justin M Solomon.  Dynamic graph cnn for learning on point clouds.  Acm Transactions On Graphics, 2019.
  * [75] Felix Wu, Angela Fan, Alexei Baevski, Yann N Dauphin, and Michael Auli.  Pay less attention with lightweight and dynamic convolutions.  In International Conference on Learning Representations, 2019.
  * [76] Zhuofan Xia, Xuran Pan, Shiji Song, Li Erran Li, and Gao Huang.  Vision transformer with deformable attention.  In IEEE Conference on Computer Vision and Pattern Recognition, 2022\.
  * [77] Saining Xie, Ross Girshick, Piotr Dollár, Zhuowen Tu, and Kaiming He.  Aggregated residual transformations for deep neural networks.  In IEEE Conference on Computer Vision and Pattern Recognition, 2017\.
  * [78] Dan Xu, Wanli Ouyang, Xavier Alameda-Pineda, Elisa Ricci, Xiaogang Wang, and Nicu Sebe.  Learning deep structured multi-scale features using attention-gated crfs for contour prediction.  In Advances in Neural Information Processing Systems, 2017.
  * [79] Maoke Yang, Kun Yu, Chi Zhang, Zhiwei Li, and Kuiyuan Yang.  Denseaspp for semantic segmentation in street scenes.  In IEEE Conference on Computer Vision and Pattern Recognition, 2018\.
  * [80] Changqian Yu, Jingbo Wang, Chao Peng, Changxin Gao, Gang Yu, and Nong Sang.  Bisenet: Bilateral segmentation network for real-time semantic segmentation.  In European Conference on Computer Vision, 2018.
  * [81] Fisher Yu and Vladlen Koltun.  Multi-scale context aggregation by dilated convolutions.  In International Conference on Learning Representations, 2016.
  * [82] Yuhui Yuan, Lang Huang, Jianyuan Guo, Chao Zhang, Xilin Chen, and Jingdong Wang.  Ocnet: Object context network for scene parsing.  arXiv preprint arXiv:1809.00916, 2018.
  * [83] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz.  mixup: Beyond empirical risk minimization.  In International Conference on Learning Representations, 2018.
  * [84] Li Zhang, Xiangtai Li, Anurag Arnab, Kuiyuan Yang, Yunhai Tong, and Philip HS Torr.  Dual graph convolutional network for semantic segmentation.  In British Machine Vision Conference, 2019.
  * [85] Li Zhang, Dan Xu, Anurag Arnab, and Philip HS Torr.  Dynamic graph message passing networks.  In IEEE Conference on Computer Vision and Pattern Recognition, 2020\.
  * [86] Hengshuang Zhao, Jianping Shi, Xiaojuan Qi, Xiaogang Wang, and Jiaya Jia.  Pyramid scene parsing network.  In IEEE Conference on Computer Vision and Pattern Recognition, 2017\.
  * [87] Hengshuang Zhao, Yi Zhang, Shu Liu, Jianping Shi, Chen Change Loy, Dahua Lin, and Jiaya Jia.  Psanet: Point-wise spatial attention network for scene parsing.  In European Conference on Computer Vision, 2018.
  * [88] Shuai Zheng, Sadeep Jayasumana, Bernardino Romera-Paredes, Vibhav Vineet, Zhizhong Su, Dalong Du, Chang Huang, and Philip H. S. Torr.  Conditional random fields as recurrent neural networks.  In IEEE International Conference on Computer Vision, 2015.
  * [89] Sixiao Zheng, Jiachen Lu, Hengshuang Zhao, Xiatian Zhu, Zekun Luo, Yabiao Wang, Yanwei Fu, Jianfeng Feng, Tao Xiang, Philip HS Torr, and Li Zhang.  Rethinking semantic segmentation from a sequence-to-sequence perspective with transformers.  In IEEE Conference on Computer Vision and Pattern Recognition, 2021\.
  * [90] Xizhou Zhu, Han Hu, Stephen Lin, and Jifeng Dai.  Deformable convnets v2: More deformable, better results.  In IEEE Conference on Computer Vision and Pattern Recognition, 2019\.
  * [91] Xizhou Zhu, Weijie Su, Lewei Lu, Bin Li, Xiaogang Wang, and Jifeng Dai.  Deformable detr: Deformable transformers for end-to-end object detection.  In International Conference on Learning Representations, 2021.

##  8 Additional experiments

In this supplementary material, we report additional details about the
experiments in our paper (Sec. 8.1), and also conduct further ablation studies
(Sec. 8.2).

###  8.1 Additional experimental details

####  8.1.1 Semantic segmentation on Cityscapes

For the semantic segmentation task on Cityscapes, we follow [86] and use a
polynomial learning rate decay with an initial learning rate of 0.01. The
momentum and the weight decay are set to 0.9 and 0.0001 respectively. We use 4
Nvidia V100 GPUs, batch size 8 and train for $40000$ iterations from an
ImageNet-pretrained model. For data augmentation, random cropping with a crop
size of 769 and random mirror-flipping are applied on-the-fly during training.
Note that following common practice [86, 82, 87, 59] we used synchronised
batch normalisation for better estimation of the batch statistics for the
experiments on Cityscapes. When predicting dynamic filter weights, we use the
grouping parameter $G=4$. For the experiments on Cityscapes, we use a set of
the sampling rates of $\varphi=\\{1,6,12,24,36\\}$.

####  8.1.2 Object detection and instance segmentation on COCO

Our models and all baselines are trained with the typical “$1\mathrm{x}$”
training settings from the public Mask R-CNN benchmark [52] for all
experiments on COCO. More specificially, the backbone parameters of all the
models in the experiments are pretrained on ImageNet classification. The input
images are resized such that their shorter side is of 800 pixels and the
longer side is limited to 1333 pixels. The batch size is set to 16. The
initial learning rate is set to 0.02 with a decrease by a factor of 0.1 after
$60000$ and $80000$ iterations, and finally terminates at $90000$ iterations.
Following [52, 22], the training warm-up is employed by using a smaller
learning rate of 0.02 $\times$ 0.3 for the first 500 iterations of training.
All the batch normalisation layers in the backbone are “frozen” during fine-
tuning on COCO.

When predicting dynamic filter weights, we use the grouping parameter $G=4$.
For the experiments on COCO, a set of the sampling rates of
$\varphi=\\{1,4,8,12\\}$ is considered. We train models on only the COCO
training set and test on the validation set and test-dev set.

###  8.2 Additional ablation studies

Effectiveness of different training and inference strategies. When evaluating
models for the Cityscapes test set, we followed common practice and employed
several complementary strategies used to improve performance in semantic
segmentation, including Online Hard Example Mining (OHEM) [63, 56, 38, 82,
80], Multi-Grid [7, 20, 9] and Multi-Scale (MS) ensembling [6, 8, 86, 82, 13].
The contribution of each strategy is reported in Table XIII on the validation
set.

Inference time We tested the average run time on the Cityscapes validation set
with a Nvidia Tesla V100 GPU. The Dilated FCN baseline and the Non-local model
take 0.230s and 0.276s per image, respectively, while our proposed model uses
0.253s, Thus, our proposed method is more efficient than Non-local [73] in
execution time, FLOPs and also the number of parameters.

Effectiveness of different sampling rate $\varphi$ and group of predicted
weights $G$ (Section 3.3 and 3.4 in main paper). For our experiments on
Cityscapes, where are network has a stride of 8, the sampling rates are set to
$\varphi=\\{1,6,12,24,36\\}$. For experiments on COCO, where the network
stride is 32, we use smaller sampling rates of $\varphi=\\{1,4,8,12\\}$ in C5.
We keep the same sampling rate in C4 when DGMN modules are inserted into C4 as
well.

Unless otherwise stated, all the experiments in the main paper and
supplementary used $G=4$ groups as the default. Each group of $C/G$ feature
channels shares the same set of filter parameters [10].

The effect of different sampling rates and groups of predicted filter weights
are studied in Table XIV, for semantic segmentation on Cityscapes, and Table
XV, for object detection and instance segmentation on COCO.

TABLE XIII: Ablation studies of different training and inference strategies. Our method (DGMN w/ DA+DW+US) is evaluated under single scale mIoU with ResNet-101 backbone on Cityscapes validation set.  |  OHEM |  Multi-grid |  MS |  mIoU (%)
---|---|---|---|---
FCN w/ DGMN |  ✘ |  ✘ |  ✘ |  79.2
FCN w/ DGMN |  ✔ |  ✘ |  ✘ |  79.7
FCN w/ DGMN |  ✔ |  ✔ |  ✘ |  80.3
FCN w/ DGMN |  ✔ |  ✔ |  ✔ |  81.1
|  DA |  DW |  DS |  mIoU (%)
---|---|---|---|---
Dilated FCN |  ✘ |  ✘ |  ✘ |  75.0
\+ DGMN ($\varphi=\\{1\\}$) |  ✔ |  ✘ |  ✘ |  76.5
\+ DGMN ($\varphi=\\{1\\}$) |  ✔ |  ✔ |  ✘ |  79.1
\+ DGMN ($\varphi=\\{1,1,1,1\\}$) |  ✔ |  ✔ |  ✔ |  79.2
\+ DGMN ($\varphi=\\{1,6,12\\}$) |  ✔ |  ✔ |  ✔ |  79.7
\+ DGMN ($\varphi=\\{1,6,12,24,36\\}$) |  ✔ |  ✔ |  ✔ |  80.4
TABLE XIV: Quantitative analysis on different sampling rates of our dynamic sampling strategy in the proposed DGMN model on the Cityscapes validation set. We report the mean IoU and use a ResNet-101 as backbone. All methods are evaluated using a single scale. |  DA |  DW |  DS |  $\mathrm{AP^{box}}$ |  $\mathrm{AP^{mask}}$
---|---|---|---|---|---
Mask R-CNN baseline |  ✘ |  ✘ |  ✘ |  37.8 |  34.4
\+ DGMN ($\varphi=\\{1,4,8,12\\}$, $G=0$) |  ✔ |  ✘ |  ✘ |  39.4 |  35.6
\+ DGMN ($\varphi=\\{1,4,8,12\\}$, $G=0$) |  ✔ |  ✘ |  ✔ |  39.9 |  35.9
\+ DGMN ($\varphi=\\{1,4,8\\}$, $G=2$) |  ✔ |  ✔ |  ✔ |  39.5 |  35.6
\+ DGMN ($\varphi=\\{1,4,8\\}$, $G=4$) |  ✔ |  ✔ |  ✔ |  39.8 |  35.9
\+ DGMN ($\varphi=\\{1,4,8,12\\}$, $G=4$) |  ✔ |  ✔ |  ✔ |  40.2 |  36.0
TABLE XV: Quantitative analysis on different numbers of filter groups ($G$)
and sampling rates ($\varphi$) for the proposed DGMN model on the COCO 2017
validation set. All methods are based on the Mask R-CNN detection pipeline
with a ResNet-50 backbone, and evaluated on the COCO validation set. Modules
are inserted after all the $3\times 3$ convolution layers of C5 (_res5_) of
ResNet-50.

Effectiveness of feature learning with DGMN on stronger backbones. Table 4 of
the main paper showed that our proposed DGMN module still provided substantial
benefits on the more powerful backbones such as ResNet-101 and ResNeXt 101 on
the COCO test set. Table XVI shows this for the COCO validation set as well.
By inserting DGMN at the convolutional stage C5 of ResNet-101, DGMN (C5)
outperforms the Mask R-CNN baseline with 1.6 points on the APbox metricand by
1.2 points on the APmask metric. On ResNeXt-101, DGMN (C5) also improves by
1.5 and 0.9 points on the APbox and the APmask, respectively.

Model |  Backbone |  $\mathrm{AP^{box}}$ |  $\mathrm{AP^{box}_{50}}$ |  $\mathrm{AP^{box}_{75}}$ |  $\mathrm{AP^{mask}}$ |  $\mathrm{AP^{mask}_{50}}$ |  $\mathrm{AP^{mask}_{75}}$
---|---|---|---|---|---|---|---
Mask R-CNN baseline |  ResNet-101 |  40.1 |  61.7 |  44.0 |  36.2 |  58.1 |  38.3
\+ DGMN (C5) |  |  41.7 |  63.8 |  45.7 |  37.4 |  60.4 |  39.8
Mask R-CNN baseline |  ResNeXt-101 |  42.2 |  63.9 |  46.1 |  37.8 |  60.5 |  40.2
\+ DGMN (C5) |  |  43.7 |  65.9 |  47.8 |  38.7 |  62.1 |  41.3
TABLE XVI: Quantitative results via applying the proposed DGMN module into
different strong backbone networks for object detection and instance
segmentation on the COCO 2017 validation set.

###  8.3 State-of-the-art comparison on COCO

Table XVII shows comparisons to the state-of-the-art on the COCO test-dev set.
When testing, we process a single scale using a single model. We do not
perform any other complementary performance-boosting “tricks”. Our DGMN
approach outperforms one-stage detectors including the most recent CornerNet
[35] by 2.1 points on box Average Precision (AP). DGMN also shows superior
performance compared to two-stage detectors including Mask R-CNN [24] and
Libra R-CNN [55] using the same ResNeXt-101-FPN backbone.

| Backbone |  $\mathrm{AP^{box}}$ |  $\mathrm{AP^{box}_{50}}$ |  $\mathrm{AP^{box}_{75}}$ |  $\mathrm{AP^{mask}}$ |  $\mathrm{AP^{mask}_{50}}$ |  $\mathrm{AP^{mask}_{75}}$
---|---|---|---|---|---|---|---
_One-stage detectors_ |  |  |  |  |  |  |
YOLOv3 [58] | Darknet-53 |  33.0 |  57.9 |  34.4 |  - |  - |  -
SSD513 [47] | ResNet-101-SSD |  31.2 |  50.4 |  33.3 |  - |  - |  -
DSSD513 [19] | ResNet-101-DSSD |  33.2 |  53.3 |  35.2 |  - |  - |  -
RetinaNet [43] | ResNeXt-101-FPN |  40.8 |  61.1 |  44.1 |  |  |
CornerNet [35] | Hourglass-104 |  42.2 |  57.8 |  45.2 |  |  |
_Two-stage detectors_ |  |  |  |  |  |  |
Faster R-CNN+++ [25] | ResNet-101-C4 |  34.9 |  55.7 |  37.4 |  - |  - |  -
Faster R-CNN w FPN [42] | ResNet-101-FPN |  36.2 |  59.1 |  39.0 |  - |  - |  -
R-FCN [14] | ResNet-101 |  29.9 |  51.9 |  - |  - |  - |  -
Mask R-CNN [24] | ResNet-101-FPN |  40.2 |  61.9 |  44.0 |  36.2 |  58.6 |  38.4
Mask R-CNN [24] | ResNeXt-101-FPN |  42.6 |  64.9 |  46.6 |  38.3 |  61.6 |  40.8
Libra R-CNN [55] | ResNetX-101-FPN |  43.0 |  64.0 |  47.0 |  - |  - |  -
DGMN (ours) | ResNeXt-101-FPN |  44.3 |  66.8 |  48.4 |  39.5 |  63.3 |  42.1
TABLE XVII:  Object detection and instance segmentation performance using a
single-model on the COCO test-dev set. We use single scale testing.