D EEP G RAPH M ATCHING C ONSENSUS
A BSTRACT
This work presents a two-stage neural architecture for learning and reﬁning structural correspondences between graphs.
First, we use localized node embeddings computed by a graph neural network to obtain an initial ranking of soft correspondences between nodes.
Secondly, we employ synchronous message passing networks to iteratively re-rank the soft correspondences to reach a matching consensus in local neighborhoods between graphs.
We show, theoretically and empirically, that our message passing scheme computes a well-founded measure of consensus for corresponding neighborhoods, which is then used to guide the iterative re-ranking process.
Our purely local and sparsity-aware architecture scales well to large, real-world inputs while still being able to recover global correspondences consistently.
We demonstrate the practical effectiveness of our method on real-world tasks from the ﬁelds of computer vision and entity alignment between knowledge graphs, on which we improve upon the current state-of-theart.
Our source code is available under https://github.com/rusty1s/ deep-graph-matching-consensus .
I NTRODUCTION
Graph matching refers to the problem of establishing meaningful structural correspondences of nodes between two or more graphs by taking both node similarities and pairwise edge similarities into account (Wang et al., 2019b).
Since graphs are natural representations for encoding relational data, the problem of graph matching lies at the heart of many real-world applications.
For example, comparing molecules in cheminformatics (Kriege et al., 2019b), matching protein networks in bioinformatics (Sharan & Ideker, 2006; Singh et al., 2008), linking user accounts in social network analysis (Zhang & Philip, 2015), and tracking objects, matching 2D/3D shapes or recognizing actions in computer vision (Vento & Foggia, 2012) can be formulated as a graph matching problem.
The problem of graph matching has been heavily investigated in theory (Grohe et al., 2018) and practice (Conte et al., 2004), usually by relating it to domain-agnostic distances such as the graph edit distance (Stauffer et al., 2017) and the maximum common subgraph problem (Bunke & Shearer, 1998), or by formulating it as a quadratic assignment problem (Yan et al., 2016).
Since all three approaches are NP -hard, solving them to optimality may not be tractable for large-scale, real-world instances.
Moreover, these purely combinatorial approaches do not adapt to the given data distribution and often do not consider continuous node embeddings which can provide crucial information about node semantics.
Recently, various neural architectures have been proposed to tackle the task of graph matching (Zanﬁr & Sminchisescu, 2018;
Wang et al., 2019b; Zhang & Lee, 2019; Xu et al., 2019d;b; Derr et al., 2019; Zhang et al., 2019a; Heimann et al., 2018) or graph similarity (Bai et al., 2018; 2019;
Li et al., 2019) in a data-dependent fashion.
However, these approaches are either only capable of computing similarity scores between whole graphs (Bai et al., 2018; 2019; Li et al., 2019), rely on an inefﬁcient global matching procedure (Zanﬁr & Sminchisescu, 2018; Wang et al., 2019b; Xu et al., 2019d; Li et al., 2019), or do not generalize to unseen graphs (Xu et al., 2019b; Derr et al., 2019; Zhang et al., 2019a).
Moreover, they might be prone to match neighborhoods between graphs inconsistently by only taking localized embeddings into account (Zanﬁr & Sminchisescu, 2018;
Wang et al., 2019b; Zhang & Lee, 2019; Xu et al., 2019d; Derr et al., 2019; Heimann et al., 2018).
Here, we propose a fully-differentiable graph matching procedure which aims to reach a data-driven neighborhood consensus between matched node pairs without the need to solve any optimization problem during inference.
In addition, our approach is purely local , i.e. , it operates on ﬁxed-size neighborhoods around nodes, and is sparsity-aware , i.e. , it takes the sparsity of the underlying structures into account.
Hence, our approach scales well to large input domains, and can be trained in an end-to-end fashion to adapt to a given data distribution.
Finally, our approach improves upon the state-of-the-art on several real-world applications from the ﬁelds of computer vision and entity alignment on knowledge graphs.
P ROBLEM D EFINITION
A graph G =
( V , A , X , E ) consists of a ﬁnite set of nodes V = { 1 , 2 , . . .
} , an adjacency matrix
A ∈ { 0 , 1 } |V|×|V| , a node feature matrix X ∈ R |V|×· , and an optional (sparse) edge feature matrix
E ∈ R |V|×|V|×· .
For a subset of nodes S ⊆ V , G [ S ] = ( S , A S , S , X S , : , E S , S , : ) denotes the subgraph of
G induced by S .
We refer to N T ( i ) =
{ j ∈ V : d ( i, j ) ≤ T } as the T -hop neighborhood around node i ∈ V , where d : V × V → N denotes the shortest-path distance in G .
A node coloring is a function
V → Σ with arbitrary codomain Σ .
The problem of graph matching refers to establishing node correspondences between two graphs.
Formally, we are given two graphs, a source graph G s =
( V s , A s , X s , E s ) and a target graph
G t =
( V t , A t , X t , E t ) , w.l.o.g.
|V s | ≤ |V t | , and are interested in ﬁnding a correspondence matrix
S ∈ { 0 , 1 } |V s |×|V t | which minimizes an objective subject to the one-to-one mapping constraints (cid:80) j ∈V t S
i,j = 1 ∀ i ∈
V s and (cid:80) i ∈V s S
i,j ≤ 1 ∀ j ∈ V t .
As a result, S infers an injective mapping π :
V s → V t which maps each node in G s to a node in G t .
Typically, graph matching is formulated as an edge-preserving, quadratic assignment problem (Anstreicher, 2003; Gold & Rangarajan, 1996; Caetano et al., 2009; Cho et al., 2013), i.e. ,
[Equation]
subject to the one-to-one mapping constraints mentioned above.
This formulation is based on the intuition of ﬁnding correspondences based on neighborhood consensus (Rocco et al., 2018), which shall prevent adjacent nodes in the source graph from being mapped to different regions in the target graph.
Formally, a neighborhood consensus is reached if for all node pairs ( i, j ) ∈ V s × V t with S i,j = 1 , it holds that for every node i (cid:48) ∈ N 1 ( i ) there exists a node j (cid:48) ∈ N 1 ( j ) such that S i (cid:48) ,j (cid:48)
= 1 .
In this work, we consider the problem of supervised and semi-supervised matching of graphs while employing the intuition of neighborhood consensus as an inductive bias into our model.
In the supervised setting, we are given pair-wise ground-truth correspondences for a set of graphs and want our model to generalize to unseen graph pairs.
In the semi-supervised setting, source and target graphs are ﬁxed, and ground-truth correspondences are only given for a small subset of nodes.
However, we are allowed to make use of the complete graph structures.
M ETHODOLOGY
In the following, we describe our proposed end-to-end, deep graph matching architecture in detail.
See Figure 1 for a high-level illustration.
The method consists of two stages: a local feature matching procedure followed by an iterative reﬁnement strategy using synchronous message passing networks.
The aim of the feature matching step, see Section 3.1, is to compute initial correspondence scores based on the similarity of local node embeddings.
The second step is an iterative reﬁnement strategy, see Sections 3.2 and 3.3, which aims to reach neighborhood consensus for correspondences using a differentiable validator for graph isomorphism.
Finally, in Section 3.4, we show how to scale our method to large, real-world inputs.
[Figure]
3. L OCAL F EATURE M ATCHING
We model our local feature matching procedure in close analogy to related approaches (Bai et al., 2018; 2019;
Wang et al., 2019b; Zhang & Lee, 2019; Wang & Solomon, 2019) by computing similarities between nodes in the source graph G s and the target graph G t based on node embeddings.
That is, given latent node embeddings H s =
Ψ θ 1 ( X s , A s , E
s ) ∈ R |V s |×· and
H t =
[Equation]
t , A t , E t ) ∈
R |V t |×· computed by a shared neural network Ψ θ 1 for source graph
G s and target graph G t , respectively, we obtain initial soft correspondences as
[Equation]
with
[Equation]
Here, sinkhorn normalization is applied to obtain rectangular doubly-stochastic correspondence matrices that fulﬁll the constraints (cid:80) j ∈V t S i,j = 1 ∀ i ∈
V s and (cid:80) i ∈V s S
i,j ≤ 1 ∀ j ∈ V t (Sinkhorn & Knopp, 1967; Adams & Zemel, 2011; Cour et al., 2006).
We interpret the i -th row vector S (0) i, : ∈ [0 , 1] |V t | as a discrete distribution over potential correspondences in G t for each node i ∈ V s .
We train Ψ θ 1 in a dicriminative, supervised fashion against ground truth correspondences π gt ( · ) by minimizing the negative log-likelihood of correct correspondence scores L (initial
[Equation]
We implement Ψ θ 1 as a Graph Neural Network (GNN) to obtain localized, permutation equivariant vectorial node representations (Bronstein et al., 2017; Hamilton et al., 2017; Battaglia et al., 2018;
Goyal & Ferrara, 2018).
Formally, a GNN follows a neural message passing scheme (Gilmer et al., 2017) and updates its node features (cid:126)h ( t − 1) i in layer t by aggregating localized information via (cid:126)a ( t ) i =
A GGREGATE ( t ) (cid:16)(cid:110)(cid:110)(cid:16) (cid:126)h
[Equation]
where (cid:126)h (0) i = (cid:126)x i ∈ X and {{ . . .
}} denotes a multiset.
The recent work in the ﬁelds of geometric deep learning and relational representation learning provides a large number of operators to choose from (Kipf & Welling, 2017; Gilmer et al., 2017; Veliˇckovi´c et al., 2018; Schlichtkrull et al., 2018;
Xu et al., 2019c), which allows for precise control of the properties of extracted features.
3. S YNCHRONOUS M ESSAGE P ASSING FOR N EIGHBORHOOD C ONSENSUS
Due to the purely local nature of the used node embeddings, our feature matching procedure is prone to ﬁnding false correspondences which are locally similar to the correct one.
Formally, those cases pose a violation of the neighborhood consensus criteria employed in Equation (1).
Since ﬁnding a global optimum is NP -hard, we aim to detect violations of the criteria in local neighborhoods and resolve them in an iterative fashion.
We utilize graph neural networks to detect these violations in a neighborhood consensus step and iteratively reﬁne correspondences S ( l ) , l ∈ { 0 , . . .
, L } , starting from S (0) .
Key to the proposed algorithm is the following observation: The soft correspondence matrix S ∈ [0 , 1] |V s |×|V t | is a map from the node function space L ( G s )
=
L ( R |V s | ) to the node function space L ( G t )
=
L ( R |V t | ) .
Therefore, we can use S to pass node functions (cid:126)x s ∈ L ( G s ) , (cid:126)x t ∈ L ( G t ) along the soft correspon- dences by (cid:126)x (cid:48) t = S (cid:62) (cid:126)x s and (cid:126)x (cid:48) s = S (cid:126)x t (3) to obtain functions (cid:126)x (cid:48) t ∈ L ( G t ) , (cid:126)x (cid:48) s ∈ L ( G s ) in the other domain, respectively.
Then, our consensus method works as follows:
Using S ( l ) , we ﬁrst map node indicator functions, given as an injective node coloring V s → { 0 , 1 } |V s | in the form of an identity matrix I |V s | , from G s to
G t .
Then, we distribute this coloring in corresponding neighborhoods by performing synchronous message passing on both graphs via a shared graph neural network Ψ θ 2 , i.e. ,
O
[Equation]
and
[Equation]
( S (cid:62)
[Equation] [Equation]
We can compare the results of both GNNs to recover a vector (cid:126)d i,j = (cid:126)o ( s ) i − (cid:126)o ( t ) j which measures the neighborhood consensus between node pairs ( i,
j ) ∈ V s × V t .
This measure can be used to perform trainable updates of the correspondence scores
[Equation]
with
[Equation]
based on an MLP Φ θ 3 .
The process can be applied L times to iteratively improve the consensus in neighborhoods.
The ﬁnal objective L = L (
[Equation]
reﬁned) with L (reﬁned
[Equation]
) combines both the feature matching error and neighborhood consensus error.
This objective is fullydifferentiable and can hence be optimized in an end-to-end fashion using stochastic gradient descent.
Overall, the consensus stage distributes global node colorings to resolve ambiguities and false matchings made in the ﬁrst stage of our architecture by only using purely local operators.
Since an initial matching is needed to test for neighborhood consensus, this task cannot be fulﬁlled by Ψ θ 1 alone, which stresses the importance of our two-stage approach.
The following two theorems show that (cid:126)d i,j is a good measure of how well local neighborhoods around i and j are matched by the soft correspondence between G s and G t .
The proofs can be found in Appendix B and C, respectively.
Theorem 1.
Let G s and G t be two isomorphic graphs and let Ψ θ 2 be a permutation equivariant
GNN, i.e. , P (cid:62) Ψ θ
( X , A ) =
Ψ θ
( P (cid:62) X , P (cid:62) AP ) for any permutation matrix P ∈ { 0 , 1 } |V|×|V| .
If S ∈ { 0 , 1 } |V s |×|V t | encodes an isomorphism between G s and G t , then (cid:126)d i,π ( i ) =
(cid:126)
for all i ∈ V s .
Theorem 2.
Let G s and G t be two graphs and let Ψ θ 2 be a permutation equivariant and T -layered
GNN for which both A GGREGATE ( t ) and U PDATE ( t ) are injective for all t ∈ { 1 , . .
, T } .
If (cid:126)
d i,j = (cid:126) 0 , then the resulting submatrix S N T ( i ) , N T ( j ) ∈ [0 , 1] |N T ( i ) |×|N T ( j ) | is a permutation matrix describing an isomorphism between the T -hop subgraph G s [ N T ( i )] around i ∈
V s and the T -hop subgraph
G t [ N T ( j )] around j ∈ V t .
Moreover, if (cid:126)d i, argmax S i, : = (cid:126) 0 for all i ∈ V s , then S denotes a full isomorphism between
G s and G t .
Hence, a GNN Ψ θ 2 that satisﬁes both criteria in Theorem 1 and 2 provides equal node embeddings (cid:126)o ( s ) i and (cid:126)o ( t )
j if and only if nodes in a local neighborhood are correctly matched to each other.
A value (cid:126)d i,j (cid:54) =
(cid:126) 0 indicates the existence of inconsistent matchings in the local neighborhoods around i and j , and can hence be used to reﬁne the correspondence score
ˆ S
i,j .
Note that both requirements, permutation equivariance and injectivity, are easily fulﬁlled: (1) All common graph neural network architectures following the message passing scheme of Equation (2) are equivariant due to the use of permutation invariant neighborhood aggregators.
(2) Injectivity of graph neural networks is a heavily discussed topic in recent literature.
It can be fulﬁlled by using a
GNN that is as powerful as the Weisfeiler & Lehman (1968) (WL) heuristic in distinguishing graph structures, e.g. , by using sum aggregation in combination with MLP s on
3. R ELATION TO THE G RADUATED A SSIGNMENT A LGORITHM
Theoretically, we can relate our proposed approach to classical graph matching techniques that consider a doubly-stochastic relaxation of the problem deﬁned in Equation (1), cf.
(Lyzinski et al., 2016) and Appendix F for more details.
A seminal work following this method is the graduated assignment algorithm (Gold & Rangarajan, 1996).
By starting from an initial feasible solution S (0) , a new solution S ( l +1) is iteratively computed from S ( l ) by approximately solving a linear assignment problem according to
[Equation]
Q i,j = 2 (cid:88)
[Equation]
where Q denotes the gradient of Equation (1) at S ( l ) .
The softassign operator is implemented by applying sinkhorn normalization on rescaled inputs, where the scaling factor grows in every iteration to increasingly encourage integer solutions.
Our approach also resembles the approximation of the linear assignment problem via sinkhorn normalization.
Moreover, the gradient Q is closely related to our neighborhood consensus scheme for the particular simple, non-trainable GNN instantiation Ψ ( X , A , E ) =
AX .
Given O s =
A s I |V s | =
A s and
O t =
A t S (cid:62) I |V s | =
A t S (cid:62) , we obtain Q = 2 O s O (cid:62) t by substitution.
Instead of updating S ( l ) based on the similarity between O s and O t obtained from a ﬁxed-function GNN Ψ , we choose to update correspondence scores via trainable neural networks Ψ
θ 2 and Φ θ 3 based on the difference between O s and O t .
This allows us to interpret our model as a deep parameterized generalization of the graduated assignment algorithm.
In addition, specifying node and edge attribute similarities in graph matching is often difﬁcult and complicates its computation (Zhou & De la Torre, 2016;
Zhang et al., 2019c), whereas our approach naturally supports continuous node and edge features via established GNN models.
We experimentally verify the beneﬁts of using trainable neural networks Ψ θ 2 instead of Ψ
( X , A , E ) =
AX in Appendix D.
3. S CALING TO L ARGE I NPUT
We apply a number of optimizations to our proposed algorithm to make it scale to large input domains.
See Algorithm 1 in Appendix A for the ﬁnal optimized algorithm.
Sparse correspondences.
We propose to sparsify initial correspondences S (0) by ﬁltering out low score correspondences before neighborhood consensus takes place.
That is, we sparsify S (0) by computing top k correspondences with the help of the K E O PS library (Charlier et al., 2019) without ever storing its dense version, reducing its required memory footprint from O ( |V s ||V t | ) to O ( k |V s | ) .
In addition, the time complexity of the reﬁnement phase is reduced from
O ( |V s ||V t | + |E s | + |E t | ) to
O ( k |V s | + |E s | + |E t | ) , where |E s | and |E t | denote the number of edges in G s and G t , respectively.
Note that sparsifying initial correspondences assumes that the feature matching procedure ranks the correct correspondence within the top k elements for each node
i ∈ V s .
Hence, also optimizing the initial feature matching loss L (initial) is crucial, and can be further accelerated by training only against sparsiﬁed correspondences with ground-truth entries top k ( S (0) i, : ) ∪ { S (0) i,π gt ( i ) } .
Replacing node indicators functions.
Although applying Ψ θ 2 on node indicator functions I |V s | is computationally efﬁcient, it requires a parameter complexity of O ( |V s | ) .
Hence, we propose to replace node indicator functions I |V s | with randomly drawn node functions R ( l ) s ∼ N (0 , 1) ,
where R ( l ) s ∈ R |V s |× r with r (cid:28)
|V s | , in iteration l .
By sampling from a continuous distribution, node indicator functions are still guaranteed to be injective (DeGroot & Schervish, 2012).
Note that Theorem 1 still holds because it does not impose any restrictions on the function space L ( G s ) .
Theorem 2 does not necessarily hold anymore, but we expect our reﬁnement strategy to resolve any ambiguities by re-sampling R ( l ) s in every iteration l .
We verify this empirically in Section 4.1.
Softmax normalization.
The sinkhorn normalization fulﬁlls the requirements of rectangular doubly-stochastic solutions.
However, it may eventually push correspondences to inconsistent integer solutions very early on from which the neighborhood consensus method cannot effectively recover.
Furthermore, it is inherently inefﬁcient to compute and runs the risk of vanishing gradients ∂ S ( l ) /∂
ˆ S ( l ) (Zhang et al., 2019b).
Here, we propose to relax this constraint by only applying row-wise softmax normalization on ˆ S ( l ) , and expect our supervised reﬁnement procedure to naturally resolve violations of (cid:80) i ∈V s S i,j ≤ 1 on its own by re-ranking false correspondences via neighborhood consensus.
Experimentally, we show that row-wise normalization is sufﬁcient for our algorithm to converge to the correct solution, cf.
Section 4.1.
Number of reﬁnement iterations.
Instead of holding L ﬁxed, we propose to differ the number of reﬁnement iterations L (train) and L (test) , L (train) (cid:28) L (test) , for training and testing, respectively.
This does not only speed up training runtime, but it also encourages the reﬁnement procedure to reach convergence with as few steps as necessary while we can run the reﬁnement procedure until convergence during testing.
We show empirically that decreasing L (train) does not affect the convergence abilities of our neighborhood consensus procedure during testing, cf.
Section 4.1.
E XPERIMENTS
We verify our method on three different tasks.
We ﬁrst show the beneﬁts of our approach in an ablation study on synthetic graphs (Section 4.1), and apply it to the real-world tasks of supervised keypoint matching in natural images (Sections 4.2 and 4.3) and semi-supervised cross-lingual knowledge graph alignment (Section 4.4) afterwards.
All dataset statistics can be found in Appendix H.
Our method is implemented in P Y T ORCH (Paszke et al., 2017) using the P Y T
ORCH G EOMETRIC
(Fey & Lenssen, 2019) and the K E O PS (Charlier et al., 2019) libraries.
Our implementation can process sparse mini-batches with parallel GPU acceleration and minimal memory footprint in all algorithm steps.
For all experiments, optimization is done via A DAM (Kingma & Ba, 2015) with a ﬁxed learning rate of 10 − 3 .
We use similar architectures for Ψ θ 1 and Ψ θ 2 except that we omit dropout (Srivastava et al., 2014) in Ψ θ 2 .
For all experiments, we report Hits@
k to evaluate and compare our model to previous lines of work, where Hits@
k measures the proportion of correctly matched entities ranked in the top k .
4. A BLATION S TUDY ON S YNTHETIC G RAPHS
In our ﬁrst experiment, we evaluate our method on synthetic graphs where we aim to learn a matching for pairs of graphs in a supervised fashion.
Each pair of graphs consists of an undirected Erd ˝ os & R ´ enyi (1959) graph G s with |V s | ∈ { 50 , 100 } nodes and edge probability p ∈ { 0 . 1 , 0 . 2 } , and a target graph
G t which is constructed from G s by removing edges with probability p s without dis- connecting any nodes (Heimann et al., 2018).
Training and evaluation is done on 1 000 graphs each for different conﬁgurations p s ∈ { 0 . 0 , 0 . 1 , 0 . 2 , 0 . 3 , 0 . 4 , 0 . 5 } .
In Appendix E, we perform additional experiments to also verify the robustness of our approach towards node addition or removal.
Architecture and parameters.
We implement the graph neural network operators Ψ θ 1 and Ψ θby stacking three layers ( T = 3 ) of the GIN operator (Xu et al., 2019c)
[Equation]
due to its expressiveness in distinguishing raw graph structures.
The number of layers and hidden dimensionality of all MLP s is set to 2 and 32 , respectively, and we apply ReLU activation (Glorot et al., 2011) and Batch normalization (Ioffe & Szegedy, 2015) after each of its layers.
Input features are initialized with one-hot encodings of node degrees.
We employ a Jumping Knowledge style concatenation (cid:126)h i =
W [ (cid:126) h (1) i , . . .
, (cid:126) h ( T ) i ] (Xu et al., 2018) to compute ﬁnal node representations (cid:126) h i .
We train and test our procedure with L (train) = 10 and L (test)
= 20 reﬁnement iterations, respectively.
Results.
Figures 2(a) and 2(b) show the matching accuracy Hits@1 for different choices of |V s | and p .
We observe that the purely local matching approach via softmax( ˆ S (0) ) starts decreasing in
[Figure]
performance with the structural noise p s increasing.
This also holds when applying global sinkhorn normalization on ˆ S (0) .
However, our proposed two-stage architecture can recover all correspondences, independent of the applied structural noise p s .
This applies to both variants discussed in the previous sections,
i
[Figure]
e. , our initial formulation sinkhorn( ˆ S ( L ) )
[Figure]
and our optimized architecture using random node indicator sampling and row-wise normalization softmax( ˆ S ( L ) ) .
This highlights the overall beneﬁts of applying matching consensus and justiﬁes the usage of the enhancements made towards scalability in Section 3.4.
In addition, Figure 2(c) visualizes the test error L (reﬁned) for varying number of iterations L (test) .
We observe that even when training to non-convergence, our procedure is still able to converge by increasing the number of iterations L (test) during testing.
Moreover, Figure 2(d) shows the performance of our reﬁnement strategy when operating on sparsiﬁed top k correspondences.
In contrast to its dense version, it cannot match all nodes correctly due to the poor initial feature matching quality.
However, it consistently converges to the perfect solution of Hits@1 ≈ Hits@
k in case the correct match is included in the initial top k ranking of correspondences.
Hence, with increasing k , we can recover most of the correct correspondences, making it an excellent option to scale our algorithm to large graphs, cf.
Section 4.4.
4. S UPERVISED K EYPOINT M ATCHING IN N ATURAL I MAGES
We perform experiments on the P ASCAL VOC (Everingham et al., 2010) with Berkeley annotations (Bourdev & Malik, 2009) and WILLOW-O BJECT C LASS (Cho et al., 2013) datasets which contain sets of image categories with labeled keypoint locations.
For P ASCAL VOC, we follow the experimental setups of Zanﬁr & Sminchisescu (2018) and Wang et al.
(2019b)
and use the training and test splits provided by Choy et al.
We pre-ﬁlter the dataset to exclude difﬁcult, occluded and truncated objects, and require examples to have at least one keypoint, resulting in 6 953 and 1 671 annotated images for training and testing, respectively.
The P ASCAL VOC dataset contains instances of varying scale, pose and illumination, and the number of keypoints ranges from 1 to 19 .
In contrast, the WILLOW-O BJECT C LASS dataset contains at least 40 images with consistent orientations for each of its ﬁve categories, and each image consists of exactly 10 keypoints.
Following the experimental setup of peer methods (Cho et al., 2013; Wang et al., 2019b), we pre-train our model on P ASCAL VOC and ﬁne-tune it over 20 random splits with 20 per-class images used for training.
We construct graphs via the Delaunay triangulation of keypoints.
For fair comparison with
Zanﬁr & Sminchisescu (2018) and Wang et al. (2019b), input features of keypoints are given by the concatenated output of relu4 2 and relu5 1 of a pre-trained VGG16 (Simonyan & Zisserman, 2014) on I MAGE N ET (Deng et al., 2009).
Architecture and parameters.
We adopt S PLINE CNN (Fey et al., 2018) as our graph neural network operator
[Equation]
whose trainable B-spline based kernel function Φ θ ( · ) is conditioned on edge features (cid:126)e j,i between node-pairs.
To align our results with the related work, we evaluate both isotropic and anisotropic
[Table] [Table]
edge features which are given as normalized relative distances and 2D Cartesian coordinates, respectively.
For S PLINE CNN, we use a kernel size of 5 in each dimension, a hidden dimensionality of 256 , and apply ReLU as our non-linearity function σ .
Our network architecture consists of two convolutional layers ( T = 2 ), followed by dropout with probability 0 .
5 , and a ﬁnal linear layer.
During training, we form pairs between any two training examples of the same category, and evaluate our model by sampling a ﬁxed number of test graph pairs belonging to the same category.
Results.
We follow the experimental setup of Wang et al.
(2019b)
and train our models using negative log-likelihood due to its superior performance in contrast to the displacement loss used in Zanﬁr & Sminchisescu (2018).
We evaluate our complete architecture using isotropic and anisotropic
GNNs for L ∈ { 0 , 10 , 20 } , and include ablation results obtained from using Ψ θ 1 = MLP for the local node matching procedure.
Results of Hits@1 are shown in Table 1 and 2 for P ASCAL VOC and WILLOW-O BJECT C LASS , respectively.
We visualize qualitative results of our method in Appendix I.
We observe that our reﬁnement strategy is able to signiﬁcantly outperform competing methods as well as our non-reﬁned baselines.
On the WILLOW-O BJECT C LASS dataset, our reﬁnement stage at least reduces the error of the initial model ( L = 0 ) by half across all categories.
The beneﬁts of the second stage are even more crucial when starting from a weaker initial feature matching baseline ( Ψ θ 1 = MLP ), with overall improvements of up to 14 percentage points on P ASCAL VOC.
However, good initial matchings do help our consensus stage to improve its performance further, as indicated by the usage of task-speciﬁc isotropic or anisotropic GNNs for Ψ θ 1 .
[Table] [Table]
S UPERVISED G EOMETRIC K EYPOINT M ATCHING
We also verify our approach by tackling the geometric feature matching problem , where we only make use of point coordinates and no additional visual features are available.
Here, we follow the experimental training setup of Zhang & Lee (2019)
[Table]
and test the generalization capabilities of our model on the P ASCAL PF dataset (Ham et al., 2016).
For training, we generate a synthetic set of graph pairs: We ﬁrst randomly sample 30–60 source points uniformly from [ − 1 , 1]
[Table]
and add
Gaussian noise from N (0 , 0 .
05 2 ) to these points
to obtain the target points.
Furthermore, we add 0–20 outliers from [ − 1 . 5 , 1 . 5] 2 to each point cloud.
Finally, we construct graphs by connecting each node with its k -nearest neighbors ( k = 8 ).
We train our unmodiﬁed anisotropic keypoint architecture from Section 4.2 with input (cid:126)x i = (cid:126) 1 ∈ R 1 ∀ i ∈ V s ∪ V t until it has seen 32 000 synthetic examples.
Results.
We evaluate our trained model on the P ASCAL PF dataset (Ham et al., 2016) which consists of 1 351 image pairs within 20 classes, with the number of keypoints ranging from 4 to 17.
Results of Hits@1 are shown in Table 3.
Overall, our consensus architecture improves upon the state-of-the-art results of Zhang & Lee (2019) on almost all categories while our L = 0 baseline is weaker than the results reported in Zhang & Lee (2019), showing the beneﬁts of applying our consensus stage.
In addition, it shows that our method works also well even when not taking any visual information into account.
4. S EMI - SUPERVISED C ROSS - LINGUAL K NOWLEDGE G RAPH A LIGNMENT
We evaluate our model on the DBP15K datasets (Sun et al., 2017) which link entities of the Chinese, Japanese and French knowledge graphs of DB PEDIA into the English version and vice versa.
Each dataset contains exactly 15 000 links between equivalent entities, and we split those links into training and testing following upon previous works.
For obtaining entity input features, we follow the experimental setup of Xu et al.
(2019d):
We retrieve monolingual FAST T EXT embeddings (Bojanowski et al., 2017) for each language separately, and align those into the same vector space afterwards (Lample et al., 2018).
We use the sum of word embeddings as the ﬁnal entity input representation (although more sophisticated approaches are just as conceivable).
Architecture and parameters.
Our graph neural network operator mostly matches the one proposed in Xu et al.
(2019d) where the direction of edges is retained, but not their speciﬁc relation type:
[Equation]
We use ReLU followed by dropout with probability 0 .
5 as our non-linearity σ , and obtain ﬁnal node representations via (cid:126)h i =
W 4 [ (cid:126)h (1) i , . . .
,(cid:126)h ( T ) i ] .
We use a three-layer GNN ( T = 3 ) both for obtaining initial similarities and for reﬁning alignments with dimensionality 256 and 32 , respectively.
Training is performed using negative log likelihood in a semi-supervised fashion: For each training node i in
V s , we train L (initial) sparsely by using the corresponding ground-truth node in V t , the top k =entries in S i, : and k randomly sampled entities in V t .
For the reﬁnement phase, we update the sparse top k correspondence matrix L = 10 times.
For efﬁciency reasons, we train L (initial) and L (reﬁned) sequentially for 100 epochs each.
Results.
We report Hits@1 and Hits@10 to evaluate and compare our model to previous lines of work, see Table 4.
In addition, we report results of a simple three-layer MLP which matches nodes purely based on initial word embeddings, and a variant of our model without the reﬁnement of initial correspondences ( L = 0 ).
Our approach improves upon the state-of-the-art on all categories with
[Table]
gains of up to 9 .
38 percentage points.
In addition, our reﬁnement strategy consistently improves upon the Hits@1 of initial correspondences by a signiﬁcant margin, while results of Hits@10 are shared due to the reﬁnement operating only on sparsiﬁed top 10 initial correspondences.
Due to the scalability of our approach, we can easily apply a multitude of reﬁnement iterations while still retaining large hidden feature dimensionalities.
L IMITATIONS
Our experimental results demonstrate that the proposed approach effectively solves challenging realworld problems.
However, the expressive power of GNNs is closely related to the WL heuristic for graph isomorphism testing (Xu et al., 2019c; Morris et al., 2019), whose power and limitations are well understood (Arvind et al., 2015).
Our method generally inherits these limitations.
Hence, one possible limitation is that whenever two nodes are assigned the same color by WL, our approach may fail to converge to one of the possible solutions.
For example, there may exist two nodes i, j ∈ V t with equal neighborhood sets N 1 ( i ) =
N 1 ( j ) .
One can easily see that the feature matching procedure generates equal initial correspondence distributions S (0): ,i = S (0): ,j , resulting in the same mapped node indicator functions
I (cid:62)|V s | S (0): ,i = I (cid:62)|V s | S (0): ,j from G s to nodes i and j , respectively.
Since both nodes share the same neighborhood, Ψ θ 2 also produces the same distributed functions (cid:126)o ( t ) i
= (cid:126)o ( t ) j .
As a result, both column vectors ˆ S ( l ) : ,i and ˆ S ( l ) : ,j receive the same update, leading to non-convergence.
In theory, one might resolve these ambiguities by adding a small amount of noise to ˆ S (0) .
However, the general amount of feature noise present in real-world datasets already ensures that this scenario is unlikely to occur.
R ELATED W ORK
Identifying correspondences between the nodes of two graphs has been studied in various domains and an extensive body of literature exists.
Closely related problems are summarized under the terms maximum common subgraph (Kriege et al., 2019b), network alignment (Zhang, 2016), graph edit distance (Chen et al., 2019) and graph matching (Yan et al., 2016).
We refer the reader to the Appendix F for a detailed discussion of the related work on these problems.
Recently, graph neural networks have become a focus of research leading to various proposed deep graph matching techniques (Wang et al., 2019b; Zhang & Lee, 2019; Xu et al., 2019d; Derr et al., 2019).
In Appendix G, we present a detailed overview of the related work in this ﬁeld while highlighting individual differences and similarities to our proposed graph matching consensus procedure.
C ONCLUSION
We presented a two-stage neural architecture for learning node correspondences between graphs in a supervised or semi-supervised fashion.
Our approach is aimed towards reaching a neighborhood consensus between matchings, and can resolve violations of this criteria in an iterative fashion.
In addition, we proposed enhancements to let our algorithm scale to large input domains.
We evaluated our architecture on real-world datasets on which it consistently improved upon the state-of-the-art.
A CKNOWLEDGEMENTS
This work has been supported by the German Research Association (DFG) within the Collaborative
Research Center SFB 876 Providing Information by Resource-Constrained Analysis , projects A and B2.
A O PTIMIZED G RAPH M ATCHING C ONSENSUS A LGORITHM
Our ﬁnal optimized algorithm is given in Algorithm 1:
Algorithm
Input : G s =
( V s , A s , X s , E s ) , G t =
( V t , A t , X t , E t ) , hidden node dimensionality d , sparsity parameter k , number of consensus iterations
L , number of random functions r
Output : Sparse soft correspondence matrix S ( L ) ∈ [0 , 1] |V s |×|V t | with k · |V s | non-zero entries ——————————————————————————————————————–
H s ← Ψ θ 1 ( X s , A s , E s ) (cid:46)
Compute node embeddings H s ∈ R |V s |×·
H t ← Ψ θ 1 ( X s , A t , E t )
(cid:46) Compute node embeddings H t ∈ R |V t |×· ˆ
S (0) ← H s H (cid:62) t (cid:46)
Local feature matching ˆ S (0) i, : ← top k ( ˆ S (0) i, : ) (cid:46) Sparsify to top k candidates ∀ i ∈ { 1 , . . .
, |V s |} for l in { 1 , . . .
, L } do (cid:46)
L ∈ { L (train) , L (test) }
S ( l − 1) i, : ← softmax( ˆ S ( l − 1) i, : ) (cid:46) Normalize scores ∀ i ∈ { 1 , . . . ,
|V s |}
R ( l ) s ∼ N (0 , 1) (cid:46)
Sample random node function R ( l ) s ∈ R |V s |× r
R ( l ) t ← S (cid:62) ( l − 1) R ( l ) s (
cid:46) Map random node functions R ( l ) s from G s to G t
O s ← Ψ θ 2 ( R ( l
[Equation]
s , A
[Equation]
, E s )
(cid:46) Distribute function R ( l ) s on G s
O t ← Ψ θ 2 ( R ( l ) t , A t , E t ) (cid:46) Distribute function R ( l ) t on G t (cid:126)d i,j ← (cid:126)o (
[Equation]
i − (cid:126)o ( t ) j (cid:46) Compute neighborhood consensus measure ˆ S ( l ) i,j ← ˆ S ( l − 1)
i,j + Φ θ 3 ( (cid:126)d i,j ) (cid:46) Perform trainable correspondence update end for
S ( L ) i, : ← softmax( ˆ S ( L ) i, : ) (cid:46) Normalize scores ∀ i ∈ { 1 , . . . ,
|V s |} return S ( L )
B P ROOF FOR T HEOREM
Proof.
Since Ψ θ 2 is permutation equivariant, it holds for any node feature matrix X s ∈ R |V s |×· that Ψ θ 2 ( S
[Equation]
X s , S (cid:62) A s S )
= S
[Equation]
Ψ θ 2 ( X s , A s ) .
With X t = S (cid:62) X s and A t = S (cid:62) A s S , it follows that
O
[Equation] [Equation]
S
[Equation]
O s .
Hence, it shows that (cid:126)o ( s ) i =
( S (cid:62) O s )
π ( i ) =
(cid:126)o ( t ) π ( i ) for any node i ∈ V s , resulting in (cid:126)d i,π ( i ) =
(cid:126) 0 .
C P ROOF FOR T HEOREM
Proof.
Let be (cid:126)d i,j = (cid:126)o ( s ) i − (cid:126)o
[Equation]
t )
[Equation]
= (cid:126) 0 .
Then, the T -layered GNN Ψ
θ 2 maps both T -hop neighborhoods around nodes i ∈
V s and j ∈ V t to the same vectorial representation:
[Equation]
Because Ψ θ 2 is as powerful as the WL heuristic in distinguishing graph structures (Xu et al., 2019c;
Morris et al., 2019) and is operating on injective node colorings I |V| s , it has the power to distinguish any graph structure from G s [ N T ( i )]
= ( N T ( i ) , I |V s | N T ( i ) , : , A ( s ) N T ( i ) , N T ( i ) ) , cf.
(Murphy et al., 2019).
Since (cid:126)o ( s ) i holds information about every node in G s [ N T ( i )] , it necessarily holds that G s [ N T ( i )]
(cid:39)
G t [ N T ( j )] in case (cid:126)o ( s ) i = (cid:126)o ( t ) j , where (cid:39) denotes the labeled graph isomorphism relation.
Hence, there exists an isomorphism P ∈ { 0 , 1 } |N T ( i ) |×|N T ( j ) | between G s [ N T ( j )] and G t [ N T ( j )] such that
[Equation]
and A ( s
[Equation]
With I |V s | being the identity matrix, it follows that
I |V s | N T ( i ) , : = P S (cid:62)N T ( j ) , : .
Furthermore, it holds that I |V s | N T ( i ) , N T ( i ) =
P S (cid:62)N T ( j ) , N T ( i ) when reducing I |V s | N T ( i ) , : to its column-wise non-zero entries.
It follows that S N T ( i ) , N T ( j )
=
P is a permutation matrix describing an isomorphism.
[Table] [Table]
Ψ θ 2 = GNN
L =80.
Moreover, if (cid:126)d i, argmax S i, : = (cid:126) 0 for all i ∈ V s , it directly follows that S is holding submatrices de- scribing isomorphisms between any T -hop subgraphs around i ∈
V s and argmax S
i, : ∈ V t .
Assume there exists nodes i, i (cid:48)
∈ V s that map to the same node j = argmax S
i, : = argmax S i (cid:48) , : ∈ V t .
It follows that (cid:126)o ( s ) i
=
(cid:126)o ( t )
j
= (cid:126)o ( s ) i (cid:48) which contradicts the injectivity requirements of A GGREGATE ( t ) and U PDATE ( t ) for all t ∈ { 1 , . .
, T } .
Hence, S must be itself a permutation matrix describing an isomorphism between G s and G t .
D C OMPARISON TO THE G RADUATED A SSIGNMENT A LGORITHM
As stated in Section 3.3, our algorithm can be viewed as a generalization of the graduated assignment algorithm
(Gold & Rangarajan, 1996) extending it by trainable parameters.
To evaluate the impact of a trainable reﬁnement procedure, we replicated the experiments of Sections 4.2 and 4. by implementing Ψ θ 2 via a non-trainable, one-layer GNN instantiation Ψ θ 2 ( X , A , E ) =
AX .
The results in Tables 5 and 6 show that using trainable neural networks Ψ θ 2 consistently improves upon the results of using the ﬁxed-function message passing scheme.
While it is difﬁcult to encode meaningful similarities between node and edge features in a ﬁxed-function pipeline, our approach is able to learn how to make use of those features to guide the reﬁnement procedure further.
In addition, it allows us to choose from a variety of task-dependent GNN operators, e.g. , for learning geometric/edge conditioned patterns or for fulﬁlling injectivity requirements.
The theoretical expressivity discussed in Section 5 could even be enhanced by making use of higher-order GNNs, which we leave for future work.
E R OBUSTNESS T OWARDS N ODE A DDITION OR R EMOVAL
To experimentally validate the robustness of our approach towards node addition (or removal), we conducted additional synthetic experiments in a similar fashion to Xu et al.
(2019b).
We form graph-pairs by treating an Erd˝os & R´enyi graph with |V s | ∈ { 50 , 100 } nodes and edge probability p ∈ { 0 . 1 , 0 . 2 } as our source graph G s .
The target graph G t is then constructed by ﬁrst adding q % noisy nodes to the source graph, i.e. ,
[Equation]
s | , and generating edges between these nodes and all other nodes based on the edge probability p afterwards.
We use the same network architecture and training procedure as described in Section 4.1.
Figure 3 visualizes the Hits@1 for different choices of |V s | , p and q ∈ { 0 . 0 , 0 . 1 , 0 . 2 , 0 . 3 , 0 . 4 , 0 . 5 } .
As one can see, our consensus stage is extremely robust to the addition or removal of nodes while the ﬁrst stage alone has major difﬁculties in ﬁnding the right matching.
This can be explained by the fact that unmatched nodes do not have any inﬂuence on the neighborhood consensus error since those nodes do not obtain a color from the functional map given by S .
Our neural architecture is able to detect and gradually decrease any false positive inﬂuence of these nodes in the reﬁnement stage.
[Figure]
F R ELATED W ORK I
Identifying correspondences between the nodes of two graphs is a problem arising in various domains and has been studied under different terms.
In graph theory, the combinatorial maximum common subgraph isomorphism problem is studied, which asks for the largest graph that is contained as subgraph in two given graphs.
The problem is NP -hard in general and remains so even in trees (Garey & Johnson, 1979) unless the common subgraph is required to be connected (Matula, 1978).
Moreover, most variants of the problem are difﬁcult to approximate with theoretical guarantees (Kann, 1992).
We refer the reader to the survey by Kriege et al.
(2019b)
for a overview of the complexity results noting that exact polynomial-time algorithms are available for speciﬁc problem variants only that are most relevant in cheminformatics.
Fundamentally different techniques have been developed in bioinformatics and computer vision, where the problem is commonly referred to as network alignment or graph matching .
In these areas large networks without any speciﬁc structural properties are common and the studied techniques are non-exact.
In graph matching, for two graphs of order n with adjacency matrix A s and A t , respectively, typically the function
[Equation]
j
[Equation]
∈V t
[Equation]
i
[Equation]
A
[Equation]
) j,j (cid:48)
[Equation]
i,j S i
[Equation]
,j
[Equation]
(12) is to be minimized,
where S ∈ P with P the set of n × n permutation matrices and (cid:107) A (cid:107) 2 F = (cid:80) i,i (cid:48)
∈V A 2 i,i (cid:48) denotes the squared Frobenius norm.
Since the ﬁrst two terms of the right-hand side do not depend on S , minimizing Equation (12) is equivalent in terms of optimal solutions to the problem of Equation (1).
We brieﬂy summarize important related work in graph matching and refer the reader to the recent survey by Yan et al.
for a more detailed discussion.
There is a long line of research trying to minimize Equation (12) for S ∈ [0 , 1] n × n by a Frank-Wolfe type algorithm
(Jaggi, 2013) and ﬁnally projecting the fractional solution to P (Gold & Rangarajan, 1996;
Zaslavskiy et al., 2009; Leordeanu et al., 2009; Egozi et al., 2013; Zhou & De la Torre, 2016).
However, the applicability of relaxation and projection is still poorly understood and only few theoretical results exist (Aﬂalo et al., 2015; Lyzinski et al., 2016).
A classical result by Tinhofer (1991) states that the WL heuristic distinguishes two graphs G s and G t if and only if there is no fractional S such that the objective function in Equation (12) takes 0 .
Kersting et al.
(2014) showed how the
Frank-Wolfe algorithm can be modiﬁed to obtain the WL partition.
Aﬂalo et al.
(2015) proved that the standard relaxation yields a correct solution for a particular class of asymmetric graphs, which can be characterized by the spectral properties of their adjacency matrix.
Finally, Bento & Ioannidis (2018) studied various relaxations, their complexity and properties.
Other approaches to graph matching exist, e.g. , based on spectral relaxations (Umeyama, 1988; Leordeanu & Hebert, 2005) or random walks (Gori et al., 2005).
The problem of graph matching is closely related to the notoriously hard quadratic assignment problem (QAP)
(Zhou & De la Torre, 2016), which has been studied in operations research for decades.
Equation (1) can be directly interpreted as KoopmansBeckmann’s QAP .
The more recent literature on graph matching typically considers a weighted version, where node and edge similarities are taken into account.
This leads to the formulation as
Lawler’s QAP , which involves an afﬁnity matrix of size n 2 × n 2 and is computational demanding.
Zhou & De la Torre (2016) proposed to factorize the afﬁnity matrix into smaller matrices and incorporated global geometric constraints.
Zhang et al.
(2019c) studied kernelized graph matching , where the node and edge similarities are kernels, which allows to express the graph matching problem again as Koopmans-Beckmann’s QAP in the associated Hilbert space.
Inspired by established methods for Maximum-A-Posteriori (MAP) inference in conditional random ﬁelds, Swoboda et al.
(2017) studied several Lagrangean decompositions of the graph matching problem, which are solved by dual ascent algorithms also known as message passing .
Speciﬁc message passing schedules and update mechanisms leading to state-of-the-art performance in graph matching tasks have been identiﬁed experimentally.
Recently, functional representation for graph matching has been proposed as a generalizing concept with the additional goal to avoid the construction of the afﬁnity matrix (Wang et al., 2019a).
Graph edit distance.
A related concept studied in computer vision is the graph edit distance , which measures the minimum cost required to transform a graph into another graph by adding, deleting and substituting vertices and edges.
The idea has been proposed for pattern recognition tasks more than 30 years ago (Sanfeliu & Fu, 1983).
However, its computation is NP -hard, since it generalizes the maximum common subgraph problem (Bunke, 1997).
Moreover, it is also closely related to the quadratic assignment problem (Bougleux et al., 2017).
Recently several elaborated exact algorithms for computing the graph edit distance have been proposed (Gouda & Hassaan, 2016; Lerouge et al., 2017; Chen et al., 2019), but are still limited to small graphs.
Therefore, heuristics based on the assignment problem have been proposed (Riesen & Bunke, 2009) and are widely used in practice (Stauffer et al., 2017).
The original approach requires cubic running time, which can be reduced to quadratic time using greedy strategies (Riesen et al., 2015a;b), and even linear time for restricted cost functions (Kriege et al., 2019a).
Network alignment.
The problem of network alignment typically is deﬁned analogously to Equation (1), where in addition a similarity function between pairs of nodes is given.
Most algorithms follow a two step approach: First, an n × n node-to-node similarity matrix M is computed from the given similarity function and the topology of the two graphs.
Then, in the second step, an alignment is computed by solving the assignment problem for M .
Singh et al.
(2008) proposed I SO R ANK , which is based on the adjacency matrix of the product graph K
=
A s ⊗ A t of G s and G t , where ⊗ denotes the Kronecker product.
The matrix M is obtained by applying P AGE R ANK (Page et al., 1999) using a normalized version of K as the G OOGLE matrix and the node similarities as the personalization vector.
Kollias et al.
(2012) proposed an efﬁcient approximation of I SO R ANK by decomposition techniques to avoid generating the product graph of quadratic size.
Zhang (2016) present an extension supporting vertex and edge similarities and propose its computation using nonexact techniques.
Klau (2009) proposed to solve network alignment by linearizing the quadratic optimization problem to obtain an integer linear program, which is then approached via Lagrangian relaxation.
Bayati et al.
(2013) developed a message passing algorithm for sparse network alignment, where only a small number of matches between the vertices of the two graphs are allowed.
The techniques brieﬂy summarized above aim to ﬁnd an optimal correspondence according to a clearly deﬁned objective function.
In practical applications, it is often difﬁcult to specify node and edge similarity functions.
Recently, it has been proposed to learn such functions for a speciﬁc task, e.g. , in form of a cost model for the graph edit distance (Cort´es et al., 2019).
A more principled approach has been proposed by Caetano et al.
(2009) where the goal is to learn correspondences.
G R ELATED W ORK II
The method presented in this work is related to different lines of research.
Deep graph matching procedures have been investigated from multiple perspectives, e.g. , by utilizing local node feature matchings and cross-graph embeddings (Li et al., 2019).
The idea of reﬁning local feature matchings by enforcing neighborhood consistency has been relevant for several years for matching in images (Sattler et al., 2009).
Furthermore, the functional maps framework aims to solve a similar problem for manifolds (Halimi et al., 2019).
Deep graph matching.
Recently, the problem of graph matching has been heavily investigated in a deep fashion.
For example, Zanﬁr & Sminchisescu (2018); Wang et al.
(2019b)
; Zhang & Lee
(2019) develop supervised deep graph matching networks based on displacement and combinatorial objectives, respectively.
Zanﬁr & Sminchisescu (2018) model the graph matching afﬁnity via a differentiable, but unlearnable spectral graph matching solver (Leordeanu & Hebert, 2005).
In contrast, our matching procedure is fully-learnable.
Wang et al.
(2019b) use node-wise features in combination with dense node-to-node cross-graph afﬁnities, distribute them in a local fashion, and adopt sinkhorn normalization for the ﬁnal task of linear assignment.
Zhang & Lee (2019) propose a compositional message passing algorithm that maps point coordinates into a high-dimensional space.
The ﬁnal matching procedure is done by computing the pairwise inner product between point embeddings.
However, neither of these approaches can naturally resolve violations of inconsistent neighborhood assignments as we do in our work.
Xu et al.
(2019b) tackles the problem of graph matching by relating it to the Gromov-Wasserstein discrepancy (Peyr´e et al., 2016).
In addition, the optimal transport objective is enhanched by simultaneously learning node embeddings which shall account for the noise in both graphs.
In a follow-up work, Xu et al. (2019a) extend this concept to the tasks of multi-graph partioning and matching by learning a Gromov-Wasserstein barycenter.
Our approach also resembles the optimal transport between nodes, but works in a supervised fashion for sets of graphs and is therefore able to generalize to unseen graph instances.
In addition, the task of network alignment has been recently investigated from multiple perspectives.
Derr et al.
(2019) leverage C YCLE GANs (Zhu et al., 2017) to align N ODE 2V EC embeddings (Grover & Leskovec, 2016) and ﬁnd matchings based on the nearest neighbor in the embedding space.
Zhang et al.
(2019a) design a deep graph model based on global and local network topology preservation as auxiliary tasks.
Heimann et al.
(2018) utilize a fast, but purely local and greedy matching procedure based on local node embedding similarity.
Furthermore, Bai et al.
(2019) use shared graph neural networks to approximate the graph edit distance between two graphs.
Here, a (non-differentiable) histogram of correspondence scores is used to ﬁne-tune the output of the network.
In a follow-up work, Bai et al.
(2018) proposed to order the correspondence matrix in a breadth-ﬁrst-search fashion and to process it further with the help of traditional CNNs.
Both approaches only operate on local node embeddings, and are hence prone to match correspondences inconsistently.
Intra- and inter-graph message passing.
The concept of enhanching intra-graph node embeddings by inter-graph node embeddings has been already heavily investigated in practice (Li et al., 2019;
Wang et al., 2019b; Xu et al., 2019d).
Li et al.
(2019) and Wang et al.
(2019b) enhance the GNN operator by not only aggregating information from local neighbors, but also from similar embeddings in the other graph by utilizing a cross-graph matching procedure.
Xu et al.
(2019d) leverage alternating GNNs to propagate local features of one graph throughout the second graph.
Wang & Solomon (2019) tackle the problem of ﬁnding an unknown rigid motion between point clouds by relating it to a point cloud matching problem followed by a differentiable SVD module.
Intra-graph node embeddings are passed via a Transformer module before feature matching based on inner product similarity scores takes place.
However, neither of these approaches is designed to achieve a consistent matching, due to only operating on localized node embeddings which are alone not sufﬁcient to resolve ambiguities in the matchings.
Nonetheless, we argue that these methods can be used to strengthen the initial feature matching procedure, making our approach orthogonal to improvements in this ﬁeld.
Neighborhood consensus for image matching.
Methods to obtain consistency of correspondences in local neighborhoods have a rich history in computer vision, dating back several years (Sattler et al., 2009; Sivic & Zisserman, 2003; Schmid & Mohr, 1997).
They are known for heavily improving results of local feature matching procedures while being computational efﬁcient.
Recently, a deep neural network for neighborhood consensus using 4D convolution was proposed (Rocco et al., 2018).
While it is related to our method, the 4D convolution can not be efﬁciently transferred to the graph domain directly, since it would lead to applying a GNN on the product graph with O ( n 2 ) nodes and O ( n 4 ) edges.
Our algorithm also infers errors for the (sparse) product graph but performs the necessary computations on the original graphs.
Functional maps.
The functional maps framework was proposed to provide a way to deﬁne continuous maps between function spaces on manifolds and is commonly applied to solve the task of
[Table]
[Table] [Table]
3D shape correspondence (Ovsjanikov et al., 2012; Litany et al., 2017; Rodol ` a et al., 2017; Halimi et al., 2019).
Recently, a similar approach was presented to ﬁnd functional correspondences between graph function spaces (Wang et al., 2019a).
The functional map is established by using a low-dimensional basis representation, e.g. , the eigenbasis of the graph Laplacian as generalized
Fourier transform.
Since the basis is usually truncated to the k vectors with the largest eigenvalues, these approaches focus on establishing global correspondences.
However, such global methods have the inherent disadvantage that they often fail to ﬁnd partial matchings due to the domain-dependent eigenbasis.
Furthermore, the basis computation has to be approximated in order to scale to large inputs.
H D ATASET S TATISTICS
We give detailed descriptions of all datasets used in our experiments, cf.
Tables 7, 8, 9 and 10.
I Q UALITATIVE K EYPOINT M ATCHING R ESULTS
Figure 4 visualizes qualitative examples from the task of keypoint matching on the
WILLOW-O BJECT C LASS dataset.
Examples were selected as follows:
Figure 4(a), (b) and (c) show examples where the initial feature matching procedure fails, but where our reﬁnement procedure is able to recover all correspondences succesfully.
Figure 4(d) visualizes a rare failure case.
However, while the initial feature matching procedure maps most of the keypoints to the same target keypoint, our reﬁnement strategy is still able to succesfully resolve this violation.
In addition, note that the target image contains wrong labels, e.g. , the eye of the duck, so that some keypoint mappings are mistakenly considered to be wrong.
[Table] [Figure]