Add Batch fcfcbb71-1a07-40eb-8a12-fcd375d851e4

ICLR/2025/GLoRa_ A Benchmark to Evaluate the Ability to Learn Long-Range Dependencies in Graphs/60d4a255-ee6c-453e-8c72-b165437608ff_content_list.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a2e41a158c0e89ae360760cbe72a4e375b06d7742ca8e2ebdc6d9c3904bd425f
+size 121122

ICLR/2025/GLoRa_ A Benchmark to Evaluate the Ability to Learn Long-Range Dependencies in Graphs/60d4a255-ee6c-453e-8c72-b165437608ff_model.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b13bd5284a2de8e3d0325b52f9656399670a4373e694c2362c6aa96468f1855
+size 152655

ICLR/2025/GLoRa_ A Benchmark to Evaluate the Ability to Learn Long-Range Dependencies in Graphs/60d4a255-ee6c-453e-8c72-b165437608ff_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3908e5355a1345983d915fa1dd34ee654dd81953ae03c4d822a55ff7a19a1c5e
+size 8354552

ICLR/2025/GLoRa_ A Benchmark to Evaluate the Ability to Learn Long-Range Dependencies in Graphs/full.md

@@ -0,0 +1,475 @@
+# GLORA: A BENCHMARK TO EVALUATE THE ABILITIES TO LEARN LONG-RANGE DEPENDENCIES IN GRAPHS
+
+Dongzhuoran Zhou & Evgeny Kharlamov
+
+Bosch Center for AI, Germany and University of Oslo, Norway
+
+{dongzhuoran.zhou,evgeny.kharlamov}@de.bosch.com
+
+Egor V. Kostylev
+
+University of Oslo, Norway
+
+egork@ifi.uio.no
+
+# ABSTRACT
+
+Learning on graphs is one of the most active research topics in machine learning (ML). Among the key challenges in this field, effectively learning long-range dependencies in graphs has been particularly difficult. It has been observed that, in practice, the performance of many ML approaches, including various types of graph neural networks (GNNs), degrades significantly when the learning task involves long-range dependencies—that is, when the answer is determined by the presence of a certain path of significant length in the graph. This issue has been attributed to several phenomena, including over-smoothing, over-squashing, and vanishing gradient. A number of solutions have been proposed to mitigate these causes. However, evaluation of these solutions is currently challenging because existing benchmarks do not effectively test systems for their ability to learn tasks based on long-range dependencies in a transparent manner. In this paper, we introduce GLoRa, a synthetic benchmark that allows testing of systems for this ability in a systematic way. We then evaluate state-of-the-art systems using GLoRa and conclude that none of them can confidently claim to learn long-range dependencies well. We also observe that this weak performance cannot be attributed to any of the three causes, highlighting the need for further investigation.
+
+# 1 INTRODUCTION
+
+Graph structures are very common in many domains, including molecules in chemistry, social networks on the Web, and road networks in traffic management. Thus, it is not surprising that learning on graphs is among the most active topics in the theory and practice of ML. However, standard ML approaches, such as classic deep neural networks, are difficult to apply to graphs due to their non-trivial structure, and dedicated approaches have been developed for learning on graphs. The most prominent are based on the idea of Graph Neural Networks (GNNs) (Scarselli et al., 2008), where each layer updates the vector embedding of each node by aggregating the embeddings of the neighbours from the previous layer and combining the result with the previous embedding of the node itself. There are many GNN variants proposed in the literature, from basic GCNs (Kipf & Welling, 2017) and GraphSAGE (Hamilton et al., 2017) to more advanced methods such as Drew-GCN (Gutteridge et al., 2023) with Laplacian encoding (Kreuzer et al., 2021).
+
+Many GNN-based systems have had great success in various tasks in learning on graphs. However, it is also observed that the performance of such systems degrades dramatically when the task involves learning long-range dependencies—that is, when the ground-truth answer for a node in the graph (or, for graph-level tasks, for the full graph) depends on interaction of nodes with large graph distance between them (Alon & Yahav, 2021). However, this property is crucial for tasks in many applications, and essential interactions along several dozen of graph edges are not uncommon. For example, in the Web context, tasks such as social influence prediction (Qiu et al., 2018), social representation learning (Liu et al., 2022), and item recommendation (Fan et al., 2019) rely on the wide spread of information in social network and user-item graphs. In urban data mining, long-range dependencies are evident in
+
+air quality (Iskandaryan et al., 2023) and traffic flow prediction (Li & Zhu, 2021). In internet safety and finance, the challenges of fake news detection (Han et al., 2020) and anti-money laundering (Weber et al., 2018) are critical to detecting such dependencies in the corresponding graphs. Finally, in biochemistry, long-range dependencies emerge in protein-protein interaction (Jha et al., 2022) and drug side effects prediction (Bongini et al., 2022), where the properties are influenced by long chains of atoms in molecule graphs.
+
+Numerous works address the long-range dependency learning issue by trying to identify its causes and suggesting methods to mitigate these causes. Most prominently, the long-range issue was attributed to three phenomena: over-smoothing (Li et al., 2018), which is an observation that in many GNN architectures the embeddings of all nodes converge to the same constant vector as the number of layers increases; over-squashing (Alon & Yahav, 2021), concerning that the information from many nodes that are potentially relevant for the outcome of the target node has to be compressed into a fixed-size vector; and more classical vanishing gradient (Glorot & Bengio, 2010), saying that, as the number of layers increases, the gradient magnitude of the loss usually decreases, thus slowing training down.
+
+Several methods have been proposed to mitigate each of these phenomena. However, as a starting point for this paper, we observe that there are no methods that can with certainty verify whether an ML system is able to learn dependencies of a given length. Indeed, such systems are often evaluated on benchmarks based on real-life datasets (Dwivedi et al., 2023; Morris et al., 2020), whose properties are not known and not controlled enough to give any guarantees. For example, even if an ML system performs relatively well on such a benchmark, we do not know whether the function to learn and the function the system really learned rely on long-range dependencies. There are also a number of dedicated synthetic benchmarks (Di Giovanni et al., 2023; Bodnar et al., 2021; Alon & Yahav, 2021) to evaluate the long-range performance of such systems. Unfortunately, as we will see in more detail later on, these benchmarks are also not suitable for such guarantees, because they either allow simple functions that do not rely on long-range dependencies but perfectly fit the data examples, or, on the contrary, do not have fitting functions expressible in the GNN architectures.
+
+The main contribution of this paper overcomes these shortcomings; in particular, we present a synthetic benchmark (more precisely, an algorithm that generates a benchmark for every dependency length) and a method how to use this benchmark to identify, with certain guarantees, how long dependencies a graph learning system can learn. As our second contribution, we evaluate the state-of-the-art systems using our method, concluding that their dependency length limit is always very modest. As a final contribution, we demonstrate, by means of dedicated experiments, that the degradation of performance with increasing length cannot be attributed to any of the three phenomena. Therefore, further investigation is required to identify the real cause of the long-range dependency learning issue and to develop new methods to mitigate this issue.
+
+The rest of the paper is organised as follows. In Section 2, we first specify the typical graph ML tasks and formally introduce the long-range dependency issue, concentrating on a variant of formalisation that we call path-aware. Then we discuss possible causes for this issue identified in the literature and proposed evaluation methods; thus, Sections 2.3 and 2.4 give an overview of the most essential related work for this paper. Finally, we argue that these methods are not satisfactory, thus justifying the need for our benchmarks. We present our benchmark, which we call GLoRa (Graph Long-Range dependency benchmark), in Section 3, where we include detailed intuition and formal justifications that GLoRa benchmarks possess the desired formal properties. Then, in Section 4 we report the results of our experiments. The main experiment demonstrates that none of the state-of-the-art systems can learn dependencies beyond the very modest length 11. Secondary experiments demonstrate that this degradation cannot be attributed to any of the three phenomena. We conclude in Section 5. Secondary supporting materials for the claims of the paper are given in the appendices.
+
+# 2 THE CHALLENGE OF LEARNING LONG-RANGE DEPENDENCIES
+
+In this section, we first introduce typical graph ML tasks and graph neural networks as the standard approach to solving these tasks. We then formalise the long-range dependency learning issue, discuss its possible causes, and overview the existing benchmarks for this issue. Finally, we argue that these benchmarks are not satisfactory, thus justifying the need for our benchmark (presented in Section 3).
+
+# 2.1 LEARNING ON GRAPHS
+
+As customary in the context of graph ML, we formalise a graph as a triple  $(\mathcal{V},\mathcal{E},\lambda)$ , where  $\mathcal{V}$  is a finite set of nodes,  $\mathcal{E} \subseteq \mathcal{V} \times \mathcal{V}$  is a set of edges, which are pairs of nodes, and  $\lambda: \mathcal{V} \to \mathbb{R}^n$  is the node embedding, which is an assignment of real-valued vectors of some dimension  $n \in \mathbb{N}$  to the nodes.
+
+Note here that we assume edges to be directed; undirected graphs, which are sometimes adopted in graph learning, can be represented in this formalisation by assuming that  $\mathcal{E}$  is symmetric—that is, such that  $(v_{1}, v_{2}) \in \mathcal{E}$  implies  $(v_{2}, v_{1}) \in \mathcal{E}$ . As we will see later, our benchmark has a version for both the directed and undirected settings, and our experiments show that each considered existing system performs similarly across these versions; however, the directed version has a conceptual advantage, which ensures stronger guarantees (see Section 4.2). Note also that only nodes in our graphs have embeddings; this is just for brevity, and all our ideas apply to graphs with edge embeddings.
+
+The most common ML task on graphs is (supervised) node classification, where a system needs to learn, using training examples, a function that assigns a class (called a label in this context) from a finite set to each graph node. Binary classification is a particular case when there are only two classes, True and False. Another common task is node regression, where the function assigns a numeric value instead of a class. Both classification and regression may be transductive, when all relevant nodes (for all training, validation, and testing) belong to the same graph, fully known for training. The more general is the inductive setting, where each example may have its own graph (with the same node embedding dimension). Tasks very close in essence to the inductive tasks are graph classification and regression, where a value is assigned to the entire graph. In our presentation, we concentrate on inductive binary node classification, but all our ideas transfer directly to the other settings.
+
+# 2.2 GRAPH NEURAL NETWORKS
+
+In principle, we can use many ML approaches to graph learning. However, usual methods, such as deep neural networks, have limited applicability in our setting, because graphs may be of arbitrary size (e.g., a model trained on small graphs should be applicable to arbitrarily bigger graphs); moreover, a graph learning model is expected to be agnostic to graph representation—that is, the answer should be invariant over reshuffling of nodes and edges in the model's input. Thus, a standard neural architecture for graph learning is (message-passing) graph neural networks (GNNs); in general form, a GNN  $\mathcal{N}$  with  $L$  layers for classifying nodes with embedding dimension  $n$  to classes  $C$  is a triple
+
+$$
+\left(\left\{\operatorname {A g g} _ {\ell} \right\} _ {\ell \in \{1, \dots , L \}}, \left\{\operatorname {C o m b} _ {\ell} \right\} _ {\ell \in \{1, \dots , L \}}, \text {C l a s s}\right),
+$$
+
+where each aggregation function  $\mathrm{Agg}_{\ell}$  maps a multiset of vectors of size  $n_{\ell -1}$  to such a vector, each combination function  $\mathrm{Comb}_{\ell}$  maps two vectors of size  $n_{\ell -1}$  to a vector of size  $n_{\ell}$ , and classification function Class maps a vector of size  $n_{L}$  to a class in  $C$ ; here,  $n_0 = n$  and each  $n_{\ell}$  is the dimension of layer  $\ell$ . The aggregation, combination, and classification functions of a GNN usually depend on learnable parameters of the model, while  $L$  and each  $n_{\ell}$ ,  $\ell \in \{1,\dots ,L\}$ , are fixed in advance or among the hyperparameters. Given an input graph  $G = (\mathcal{V},\mathcal{E},\lambda)$  with dimension  $n$ , GNN  $\mathcal{N}$  computes, for each  $\ell \in \{1,\ldots ,L\}$ , the  $\ell$ -th embedding  $\mathbf{v}_{\ell}$  of each  $v\in \mathcal{V}$  as
+
+$$
+\mathbf {v} _ {\ell} = \operatorname {C o m b} _ {\ell} \left(\mathbf {v} _ {\ell - 1}, \operatorname {A g g} _ {\ell} \left(\left\{\left\{\mathbf {u} _ {\ell - 1} \mid u \in N (v) \right\} \right\}\right)\right), \tag {1}
+$$
+
+where  $\{\{\cdot \mid \cdot \}\}$  is the multiset constructor, each  $\mathbf{v}_0$  is  $\lambda (v)$ , and each  $N(v)$  is the neighbourhood  $\{u\in \mathcal{V}\mid (u,v)\in \mathcal{E}\}$  of a node  $v$  in  $G$ ; then, the final classification of each  $v$  is  $\mathrm{Class}(\mathbf{v}_L)$ .
+
+A GNN example is graph convolutional networks (GCNs) (Kipf & Welling, 2017) instantiating (1) as
+
+$$
+\mathbf {v} _ {\ell} = \sigma \left(\sum_ {u \in N (v) \cup \{v \}} \frac {\mathbf {W} _ {\ell} \mathbf {u} _ {\ell - 1}}{\sqrt {| N (v) | \cdot | N (u) |}}\right),
+$$
+
+where  $\sigma$  is a non-linearity activation function, such as ReLU or sigmoid, and each  $\mathbf{W}_{\ell}$  is a learnable matrix of parameters (of dimension  $n_{\ell} \times n_{\ell-1}$ ); it may also be assumed that, for binary classification, the final dimension  $n_{L}$  is 1, and  $\mathrm{Class}(v)$  just thresholds  $\mathbf{v}_L$ .
+
+Many other variants of GNN are suggested in the literature (GINs (Xu et al., 2019), GraphSAGE (Hamilton et al., 2017), GATs (Velickovic et al., 2018), etc.). Moreover, there are a number of proposals to use a known GNN architecture, but apply it to a modification of the input graph  $G$  rather
+
+than to  $G$  itself; the most prominent such idea is to rewire  $G$  by adding and removing nodes and edges according to some (often quite sophisticated) rule (Gutteridge et al., 2023; Abboud et al., 2022; Alon & Yahav, 2021; Gasteiger et al., 2019b; Topping et al., 2022; Karhadkar et al., 2023). An extreme of this idea is graph transformers (Dwivedi & Bresson, 2020; Kreuzer et al., 2021; Rampasek et al., 2022), where an edge is added between each two nodes, and an attention mechanism is employed to learn nontrivial dependencies. As we will see in the next section, several rewiring-based methods have been proposed to mitigate difficulties with learning long-range dependencies. Another idea to deal with long-range dependencies is realised by implicit GNNs (Gu et al., 2020; Liu et al., 2021; Chen et al., 2022), where the number of layers is not predefined but the same transformation is applied many times until (approximate) convergence. We omit the details of these systems here, because in this benchmark paper we largely treat graph learning systems as a black-box.
+
+Intuitively, node classification functions may be characterised by how long the dependencies they rely on are—that is, how far the target node (i.e., the node to classify) may be from the nodes that this node needs to interact with to decide its classification. It has been observed many times in practice that the quality of learning node classification functions using standard graph learning methods (e.g., GCNs) degrades dramatically when the function to learn relies on long dependencies (Gutteridge et al., 2023; Di Giovanni et al., 2023). As we will discuss in Section 2.3, this issue has been attributed to several causes, and a number of methods are proposed to mitigate this issue. However, we first note that, to the best of our knowledge, the long-range dependencies are not yet formalised in the context of graph learning, and only informal explanations have been suggested (Alon & Yahav, 2021; Dwivedi et al., 2022). Since this issue is central to our paper, we next give such a formalisation.
+
+In the following, let, as usual, a simple path  $p$  from a node  $v' \in \mathcal{V}$  to a node  $v \in \mathcal{V}$  of length  $d$  in a graph  $(\mathcal{V}, \mathcal{E}, \lambda)$  be a sequence  $v_0, \ldots, v_d$  of distinct nodes in  $\mathcal{V}$  such that  $v_0 = v'$ ,  $v_d = v$ , and  $(v_{i-1}, v_i) \in \mathcal{E}$  for every  $i$  with  $1 \leq i \leq d$ . Let then  $G^{p[k,m]}$ , for every  $k, m$  with  $0 < k \leq m < d$ , be the graph obtained from  $G$  by duplicating the part of  $p$  between  $v_k$  and  $v_m$ —that is, the graph with nodes  $\mathcal{V} \cup \{v_k', \ldots, v_m'\}$ ; edges  $\mathcal{E} \cup \mathcal{E}'$ , where  $\mathcal{E}'$  contains an edge  $(u^1, u^2)$  for each  $(v^1, v^2) \in \mathcal{E}$ , such that each  $u^h$  with  $h \in \{1, 2\}$  is  $v_j'$ , if  $v^h$  is  $v_j$  for some  $j$  with  $k \leq j \leq m$ , and  $v^h$  otherwise; and embedding  $\lambda'$  extending  $\lambda$  with  $\lambda'(v_j') = \lambda(v_j)$  for each  $j$  with  $k \leq j \leq m$ .
+
+Definition 1 A node classification function  $f$  for the node embedding dimension  $n$  relies on a (path-aware) dependency of length  $d$  if there is a graph  $G = (\mathcal{V},\mathcal{E},\lambda)$  with dimension  $n$ , a node  $v\in \mathcal{V}$ , a simple path  $p = v_{0},\ldots ,v_{d - 1},v$ , and vectors  $\mathbf{a}_i\neq \lambda (v_i)$  in  $\mathbb{R}^n$ , for each  $i$  with  $0 < i < d$ , such that
+
+- for each  $i$  with  $0 < i < d$ ,  $f(G, v) \neq f(G_i, v)$  where the graph  $G_i = (\mathcal{V}, \mathcal{E}, \lambda^*)$  is the same as  $G$  except that  $\lambda^*(v_i) = \mathbf{a}_i$  (i.e., in particular,  $\lambda^*(v') = \lambda(v')$  for every  $v' \neq v_i$ );  
+- for each  $k, j, m$  with  $0 < k \leq j \leq m < d$ ,  $f(G, v) = f(G_j^{p[k, m]}$ ,  $v)$  for  $G_j^{p[k, m]} = (\mathcal{V}^*, \mathcal{E}^*, \lambda^*)$  the same as  $G^{p[k, m]}$  except that  $\lambda^*(v_j') = \mathbf{a}_j$ ;  
+- for each  $i, k, j, m$  with  $0 < i < d$  and  $0 < k \leq j \leq m < d$ ,  $f(G, v) \neq f(G_{i,j}^{p[k,m]}, v)$  for  $G_{i,j}^{p[k,m]} = (\mathcal{V}^*, \mathcal{E}^*, \lambda^*)$  the same as  $G^{p[k,m]}$  except that  $\lambda^*(v_i) = \mathbf{a}_i$  and  $\lambda^*(v_j') = \mathbf{a}_j$ .
+
+This definition essentially says that there should be a node,  $v$ , in a graph with a long enough path,  $p$ , leading to  $v$  that is really important for the classification of  $v$ : it should be possible to distort the embedding of any node in  $p$  to change the classification of  $v$ ; moreover, a combination of  $p$  with a duplicate of its part where an embedding of a node is distorted should not lead to the change of classification, while distorting both the path and the duplicate should.
+
+We argue that such requirements for a witnessing path reflect the intuition of what a long-range dependency is. The examples of the real-life tasks in the introduction also essentially rely on these requirements. However, we agree that there may be other, inequivalent, formalisations of this intuition (e.g., one may waive the existence of a path to  $v$ , asking only for a node with some properties not too close to  $v$ ); we add 'path-aware' to the notion to emphasise our choice.
+
+# 2.3 POSSIBLE CAUSES FOR THE LONG-RANGE DEPENDENCY ISSUE
+
+Since learning long-range dependencies is crucial in graph learning, there is a line of research that has focused on identifying and mitigating the causes of performance degradation with increasing dependency length. In particular, this issue is currently linked to three phenomena: over-smoothing (Li
+
+et al., 2018), over-squashing (Alon & Yahav, 2021), and vanishing gradient (Glorot & Bengio, 2010; Bengio et al., 1994). The graph learning community has developed several methods to mitigate these causes, which we discuss next.
+
+Over-smoothing (Li et al., 2018) causes the node embeddings to converge to the same vector as the number of GNN layers increases. This may hamper the effectiveness of many GNNs, especially GCNs, when many layers are needed, for example, to capture long-range dependencies. Methods to mitigate over-smoothing include PairNorm (Zhao & Akoglu, 2020), ResGCN and DenseGCN (Li et al., 2019), JKNet (Xu et al., 2018), DropEdge (Rong et al., 2020), GPRGNN (Chien et al., 2021), DAGNN (Liu et al., 2020), GCNII (Chen et al., 2020), IGNN (Gu et al., 2020), EIGNN (Liu et al., 2021), GIND (Chen et al., 2022), and  $\mathrm{G}^2$  (Rusch et al., 2023).
+
+Over-squashing (Alon & Yahav, 2021) refers to the bottleneck of graph learning formalisms, including GNNs, where information from many nodes condense into a fixed-size vector of one node. In dense graphs, the number of paths to a target node may be exponential in the number of the GNN's layers. Therefore, over-squashing can limit learning long-range dependencies in such graphs. Methods to alleviate over-squashing include several variants of DRew (Gutteridge et al., 2023), SP-GCN (Abboud et al., 2022), FOSR (Karhadkar et al., 2023), SRDF (Topping et al., 2022), FA-GCN (Alon & Yahav, 2021), DIGL (Gasteiger et al., 2019b), Mixhop-GCN (Abu-El-Haija et al., 2019), and graph transformers, such as SAN (Kreuzer et al., 2021) and GraphGPS (Rampasek et al., 2022).
+
+Vanishing gradient (Glorot & Bengio, 2010) is a common phenomenon in deep neural networks, including GNNs. As the number of layers increases, the gradient of the loss often decreases, slowing or even stopping the training. Well-known techniques to mitigate this in usual neural networks, such as BatchNorm (Ioffe & Szegedy, 2015), ResNet (He et al., 2015), and LSTM (Graves, 2012), have been adapted for GNNs in systems  $\mathbf{G}^2$  (Rusch et al., 2023), Gradient-Guided Dynamic Rewiring (Jaiswal et al., 2022), and Residual GANs (Lukovnikov & Fischer, 2021).
+
+# 2.4 EXISTING BENCHMARKS AND THEIR LIMITATIONS
+
+Evaluation of the abilities of GNN-based methods to address the long-range dependency issue (e.g., by mitigating the three phenomena) usually employs benchmarks based on real-world and synthetic datasets. We next discuss these benchmarks and argue that they are ill-suited for this purpose.
+
+Many real-world benchmarks, such as Cora and Citeseer (Yang et al., 2016), Cornell and Texas (Pei et al., 2020), and TUDataset (Morris et al., 2020) were not initially designed for long-range dependency studies. Others, such as OGB (Hu et al., 2020) and LRGB (Dwivedi et al., 2022), were introduced specifically to assess the ability to mitigate the three phenomena. However, many of them have already been argued to lack significantly long-range dependencies (Dwivedi et al., 2022; Tonshoff et al., 2023). Moreover, we observe that real-life benchmarks do not suit well for the purpose in general, because we do not have enough control over their functions to learn. In particular, we have no means to ensure that a function that perfectly fits all the examples actually relies on a dependency of a particular length; in fact, we cannot even ensure that all the labels are justified by some properties of the inputs rather than being just noise. Thus, such benchmarks are only useful to conclude that one system is better than another on this particular benchmark, but not to claim with confidence that a specific approach can learn a dependency of a specific length. So, to give such guarantees, we have to employ synthetic benchmarks.
+
+Several synthetic benchmarks designed for long-range dependency evaluation have also been proposed. They include Tree-Neighbours (Alon & Yahav, 2021), h-Proximity (Abboud et al., 2022), Graph Transfer and Ring Transfer (Di Giovanni et al., 2023; Gutteridge et al., 2023), Synthetic Chains (Gu et al., 2020), Color-Connectivity (Rampášek & Wolf, 2021), Conditional Recall, and Tree Max (Lukovnikov & Fischer, 2021). The common principle in their design is that they label nodes in rather simple graphs using a known function that relies on dependency of a specific length. However, we argue that this is not enough: we also need to ensure that there is no other classification function that fits all the generated examples, but does not rely on long-enough dependency; moreover, we also need to guarantee that there exists such a long-range function that is in principle expressible in the tested graph learning architecture—that is, that there exists an instance of the architecture (e.g., GCN) that realises, in a uniform way, this function (see Barceló et al. (2020) and Grohe (2023) for the details of such expressibility and related notions (Xu et al., 2019; Morris et al., 2019; Grohe, 2023)). Unfortunately, none of the synthetic benchmarks mentioned above satisfy these two properties. For
+
+![](images/e2b7fd4024fad10ea58b213d823c5e660d14e785d7966ab2c8bfa9f4460eac17.jpg)  
+Figure 1: Positive (left) and negative (right) GLoRa examples for  $d = 6$ : green (i.e., source), blue (normal), and orange (hole) nodes have embeddings of form  $[1, -]$ ,  $[-1]$ , and  $[-0]$ , respectively; T marks the target node; the red-arrows chain is the long-range dependency path
+
+![](images/f33b106a3b36861d923d16379a20338e1663507c65605b46f24a163f33487a97.jpg)
+
+example, in the Synthetic Chains benchmark (Gu et al., 2020), the graph in each example is a directed chain, where the tail node is labelled True or False depending on whether the start node has 1 or 0 as the first element of its initial embedding vector. These examples are indeed generated by means of a function that relies on a long dependency (in particular, of the length of the longest chain). However, it is possible to perfectly solve this benchmark by a (learned) function that ignores the distance and path information, and only checks whether there somewhere in the graph there is a node without incoming edges with 1 or 0 as the first element. More detailed justification for this and other synthetic benchmarks are in Appendix D. The main contribution of this paper is benchmark generator GLoRa, which produces benchmarks satisfying the two crucial properties.
+
+# 3 BENCHMARK GENERATOR GLORA
+
+In this section, we present the main contribution of this paper: an algorithm GLoRa that generates benchmarks (i.e., sets of training, possibly validation, and test examples), which can be systematically used to check the ability of a system to learn functions relying on dependencies of a specified length. In particular, our benchmark generated for length  $d$  ensures the following properties.
+
+(P1) All node classification functions fitting the training examples rely on dependency of length  $d$  with arbitrarily high precision and probability.  
+(P2) There exists such a function that is expressible by all GNN-based graph learning approaches we are aware of (including GCNs).  
+(P3) The benchmark is fair—that is, all examples come from the same distribution.
+
+Before we start with intuition, we note that our benchmarks have two versions: one with directed and one with undirected graphs. However, in the following presentation we concentrate on the directed version, while the generalisation to undirected graphs is straightforward.
+
+# 3.1 INTUITION
+
+Our benchmark for the dependency of length  $d$  uses graphs with dimension 2 and relies on the following intended binary classification function, which clearly relies on the dependency of length  $d$ .
+
+(F) The target node is classified as True if and only if there is a path of length up to  $d$  from a node with embedding of the form  $[1, -]$  (which we call the source node) to the target node such that all nodes along the path, except the source, have embeddings  $[-1, 1]$ ; here,  $-$  represents any number different from 1.
+
+A naive benchmark for this function would use the following examples: a positive example will have a chain of length  $d$  or slightly less as the graph, starting from a source node with embedding  $[-1, -1]$ , ending at the target node, and such that all nodes along the chain except the source have embedding  $[-1, 1]$ ; in turn, each negative example is the same, except that one intermediate node has  $[-1, 0]$  instead of  $[-1, 1]$  (in what follows, we call a node with  $[-1, 0]$  embedding a hole).
+
+This approach, however, would not lead to a benchmark that satisfies property (P1). Indeed, it would be possible to perfectly fit all these examples by learning a much simpler function, which does not depend on any significantly long-range dependency; for instance, one such function classifies the target node as True if and only if there is no node anywhere in the graph, except the target node, with embedding  $[-,-]$  (i.e., where both elements are not 1). Thus, the model that learned this 'shallow' alternative can perfectly classify all the examples of this benchmark.
+
+Algorithm 1 GLoRa Benchmark Example Generation  
+Input: Length  $d\geq 3$  , label Ans  $\in$  {True, False}   
+Output: Graph-node pair  $(G,v)$  labelled Ans   
+1: Let  $\mathcal{D}\coloneqq [-12, - 2]\cup [3,13]$  /\* Part A: Create the main chain \*/   
+2: Let  $G\coloneqq (\mathcal{V},\mathcal{E},\lambda)$  with  $k_{0}\sim \mathsf{U}(\{\lfloor 2 / 3\cdot d\rfloor ,\ldots ,d\})$ $\mathcal{V}\coloneqq \{v_0^0,\dots ,v_0^{k_0}\}$ $\mathcal{E}\coloneqq \{(v_0^{i - 1},v_0^i)\mid i\in \{1,\dots ,k_0\} \}$ $\lambda (v_0^0)\coloneqq (1,y_0^0)$  with  $y_0^0\sim \mathsf{U}(\mathcal{D})$ $\lambda (v_0^i)\coloneqq (x_0^i,1)$  with  $x_0^i\sim \mathsf{U}(\mathcal{D})$  for each  $i\in \{1,\dots ,k_0\}$    
+3: if Ans  $=$  False then   
+4: Set  $\lambda (v_{0}^{h_{0}})\coloneqq (x_{0}^{h_{0}},0)$  with  $h_0\sim \mathsf{U}(\{1,\dots ,k_0 - 1\})$  /\* Part B: Add alternative chains \*/   
+5: Let  $P\sim \mathsf{U}(\{5,\dots ,10\})$    
+6: for  $p = 1$  to  $P$  do   
+7: Let  $k_{p}\sim \mathsf{U}(\{\lfloor 2 / 3\cdot d\rfloor ,\ldots ,d\})$  and  $m_p,n_p\sim \mathsf{U}(\{1,\dots ,k_p - 1\})$  assuming  $m_p\leq n_p$    
+8: Let  $v^{\prime}\sim \mathsf{U}(\{v_j^{m_j}\in \mathcal{V}\mid m_j = \lfloor k_j\cdot (m_p - 1) / k_p + 1 / 2\rfloor \})$    
+9: Let  $v''\sim \mathsf{U}(\{v_j^{n_j}\in \mathcal{V}\mid n_j = \lfloor k_j\cdot (n_p + 1) / k_p + 1 / 2\rfloor \})$    
+10: Add fresh  $v_{p}^{m_{p}},\ldots ,v_{p}^{n_{p}}$  to V and  $(v^{\prime},v_{p}^{m_{p}}),(v_{p}^{m_{p}},v_{p}^{m_{p} + 1}),\ldots ,(v_{p}^{n_{p} - 1},v_{p}^{n_{p}}),(v_{p}^{n_{p}},v^{\prime \prime})$  to E letting  $\lambda (v_{p}^{i})\coloneqq (x_{p}^{i},1)$  with  $x_{p}^{i}\sim \mathsf{U}(\mathcal{D})$  for each  $i\in \{m_p,\dots ,n_p\}$    
+11: Set  $\lambda (v_{p}^{h_{p}})\coloneqq (x_{p}^{h_{p}},0)$  with  $h_p\sim \mathsf{U}(\{m_p,\dots ,n_p\})$  /\* Part C: Add additional holes \*/   
+12: Let  $R\sim \mathsf{U}(\{2,3\})$  and  $\nu^{\prime}\coloneqq \nu \setminus \{v_0^0,v_0^{k_0}\}$    
+13: if Ans  $=$  True then   
+14: Set  $R\coloneqq R + 1$  and  $\nu^{\prime}\coloneqq \nu^{\prime}\setminus \{v_{0}^{i}\mid i\in \{1,\dots ,k_{0} - 1\}\}$    
+15: for  $r = 1$  to  $R$  do   
+16: Set  $\lambda (v_j^i)\coloneqq (x_j^i,0)$  with  $v_{j}^{i}\sim \mathsf{U}(\mathcal{V}')$    
+17: return  $(G,v_0^{k_0})$
+
+To ensure (P1), while preserving (P2), GLoRa adds to the chain-like graphs as in the naive approach alternative paths with holes (i.e.,  $[-, 0]$  embeddings) from the source to the target; this is illustrated in Figure 1. The embeddings on these extra chains also ensure that the number of holes cannot be used as a distinguishing property between positive and negative examples; same should hold for more complex properties, such as the number of holes on paths between a  $[1, -]$ -source node and the target node. As we will see formally in Theorem 1, such an approach ensures that any GNN-based function fitting (a sufficient number of) such examples rely on a dependency of length  $d$ . So, we can use GLoRa for length  $d$  to check if a system can learn functions with dependency of length  $d$  (e.g.,  $d = 6$  in Figure 1). Moreover, we can use a sequence of the benchmarks with increasing  $d$  to identify the limit of a system—that is, the maximal length for which it can learn the dependencies.
+
+# 3.2 GENERATOR ALGORITHM AND GUARANTEES
+
+The pseudocode that generates a GLoRa example is given in Algorithm 1. Since each benchmark is parameterised by length  $d$ , this number is one of the inputs of the algorithm. The second input,  $Ans$ , ranges over classes True and False—that is, specifies whether the example is positive or negative. It is assumed that GLoRa for a given depth  $d$  contains a sufficiently large balanced number of examples generated by this algorithm in its training, validation (possibly), and test sets. Note that the algorithm has a large degree of randomness, and the notation  $X \sim \mathsf{U}(S)$  means that  $X$  is sampled, uniformly at random and independently of other samplings, from a set  $S$ . The algorithm consists of three parts.
+
+In Part A (lines 2-4), the algorithm generates the main chain, which either has no holes, if the example is positive, or one hole (i.e., a  $[-0]$ -embedded node), otherwise. The chain length is not predetermined, but sampled randomly from (rounded)  $2/3$  of  $d$  to  $d$ , so that the exact length cannot be used by systems in learning. The main chain starts in source node  $v_0^0$  with embedding  $[1, -1]$ , while all other nodes have embeddings  $[-1, 1]$  or  $[-1, 0]$  (i.e., the hole); these nodes include the target node  $v_0^{k_0}$ .
+
+In Part B (lines 5-11), the algorithm adds several (5 to 10) alternative chains with the ends on the previously generated chains (main or additional). The construction ensures (lines 7-9) that there are no loops and the length of the path from the source to the target corresponding to each additional
+
+chain is within the same bounds as the main chain. Each additional chain has a hole, so that only the path along the main chain determines if the example is positive or negative. Note, however, that a model does not know which nodes belong to the main chain, so it has to explore all of them.
+
+Finally, in Part C (lines 12-17), the algorithm adds several holes so that each individual path from the source to the target does not have a predetermined number of holes. It also ensures that positive examples remain positive (i.e., that the main chain has no holes), and that the distribution of the number of holes in the positive and negative examples is the same.
+
+We next argue that GLoRa possesses properties (P1)-(P3). Property (P1) is the most sophisticated and is ensured by the following theorem (proved in Appendix C). We use several new notions. First, we introduce an approximate version of Definition 1: a node classification function  $f$  relying on a dependency of length  $d$  with precision  $\delta > 0$  is the same as in Definition 1 except that  $\lambda^*$  in each item is required to match  $\lambda$ ,  $\mathbf{a}_j$ , and  $\mathbf{a}_i$  (when relevant) only with precision  $\delta$  (under the maximum norm), while the difference between each  $\mathbf{a}_i$  and  $\lambda(v_i)$  should have the gap at least  $3\delta$  that is, we require, for example,  $||\lambda^*(v_i) - \mathbf{a}_i||_{\infty} \leq \delta$  instead of  $\lambda^*(v_i) = \mathbf{a}_i$  for each  $i$  and  $||\mathbf{a}_i - \lambda(v_i)||_{\infty} \geq 3\delta$  instead of  $\mathbf{a}_i \neq \lambda(v_i)$ . Then, a set of examples for node classification requires learning dependencies of length  $d$  with precision  $\delta > 0$  if each function that fits all these examples relies on such a dependency.
+
+Theorem 1 Let  $d \in \mathbb{N}$  be a length. Then, for every  $\delta > 0$  and  $\mathcal{P} \in (0,1)$  there exists a number  $K$  such that a set of  $K$  examples, half generated by  $GLoRa(d, \text{True})$  and half by  $GLoRa(d, \text{False})$ , requires learning dependencies of length  $d$  with precision  $\delta$  with probability at least  $\mathcal{P}$ .
+
+Moving on to property (P2) we note that the results of Barceló et al. (2020) imply that GCNs can express our intended function (F). We also observe that virtually all other known GNN-based classification approaches are more expressive than GCNs, which implies (P2). Finally, property (P3) is automatic since the same (probabilistic) algorithm is used for generating all examples.
+
+In the passing, we note that our algorithm can be easily adapted to undirected graphs.
+
+# 4 EMPIRICAL STUDIES
+
+In this section, we report our results on the evaluation of existing systems' ability to learn long-range dependencies. We begin with the setup of our main experiment, which is based on GLoRa benchmarks. We then present our results, demonstrating that, although some systems perform better than others, none can effectively learn dependencies of significantly long length. Finally, we show that this rather weak performance cannot be attributed to any of the three phenomena.
+
+# 4.1 MAIN EXPERIMENT SETUP AND RESULTS
+
+If a system for learning binary node classification claims that it can learn dependencies of length  $d$ , then it should show (nearly) perfect testing accuracy on a benchmark generated using GLoRa example generator for length  $d$ . So, we can find the length limit of a system by running it on such benchmarks with increasing values of  $d$  until the accuracy drops from nearly 1 to values close to 0.5.
+
+For our experiment, we generated 5000 positive and 5000 negative examples using Algorithm 1 for each  $d \in \{3, \ldots, 15\}$ , and split each half with the ratio 80:10:10 to training, validation, and test sets.
+
+Having these GLoRa benchmarks at hand, we evaluated state-of-the-art systems from four categories:
+
+1. vanilla GNN-based systems (i.e., not designed to deal with long-range dependencies): GCN (Kipf & Welling, 2017), GAT (Velickovic et al., 2018), GraphSAGE (Hamilton et al., 2017), GatedGCN (Bresson & Laurent, 2017), GGNN (Li et al., 2016), SGC (Wu et al., 2019), and GIN (Xu et al., 2019);  
+2. GNN-based systems targeting over-smoothing: GCNII (Chen et al., 2020), PairNorm (Zhao & Akoglu, 2020), DropEdge (Rong et al., 2020), GPRGNN (Chien et al., 2021), DAGNN (Liu et al., 2020), APPNP (Gasteiger et al., 2019a), ResGCN and DenseGCN (Li et al., 2019), as well as their variants ResGatedGCN, DenseGatedGCN, ResGAT, and DenseGAT with self-explanatory names, JKNet (Xu et al., 2018), IGNN (Gu et al., 2020), EIGNN (Liu et al., 2021), GIND (Chen et al., 2022), and  $\mathbf{G}^2$  (Rusch et al., 2023);
+
+3. GNN-based systems targeting over-squashing (and vanishing gradient):  $\nu$ Drew-GCN, for  $\nu \in \{1,\infty \}$ , and 1Drew-GCN+LapPE (Gutteridge et al., 2023), SP-GCN (Abboud et al., 2022), FA-GCN (Alon & Yahav, 2021), DIGL (Gasteiger et al., 2019b), MixHop-GCN (AbuEl-Haija et al., 2019), SDRF (Topping et al., 2022), and FOSR (Karhadkar et al., 2023);  
+4. transformer-based systems (Vaswani et al., 2017): GraphTransformer (Dwivedi & Bresson, 2020), SAN (Kreuzer et al., 2021), and GraphGPS (Rampasek et al., 2022), where the last uses either RWSE or LapPE positional encoding.
+
+We run each system on each benchmark five times, training for a maximum of 300 epochs or until convergence, validating hyperparameters, and computing the average testing accuracy over the five runs. For the GNN-based systems, we set the number of layers as  $d + 2$ , which is always enough to express (F). Further details on the experiment setting are given in Appendix A.
+
+In Figure 2, we present test accuracy results for the best five systems in each of the first three categories; detailed results for the other systems, including the transformer-based ones, which perform badly even for very short  $d$ , are given in Appendix B. Since our benchmark is noise-free, accuracy 1.0 is a reasonable target. Moreover, since this is a binary classification task, random guessing has accuracy 0.5. So, accuracy below 0.8 is an indication that the model has not effectively learned any function that fits the examples—that is, cannot learn dependencies of the given length.
+
+In the figure, we can observe that most systems experience a performance drop before  $d$  reaches 9, showing their inability to learn dependencies of significant length. We also see that some systems can learn longer dependencies a little better; however, even their performance is poor after  $d = 11$ . Notably, the best performance is achieved by systems that use gated edges—that is, GatedGCN, and its variants DenseGatedGCN and ResGatedGCN—suggesting that this feature may be a starting point for GNNs that can truly learn long-range dependencies.
+
+In summary, while some systems perform better than others, none can reliably claim to be able to learn dependencies much longer than of quite modest length 11. We also note that, as we report in Appendix E, the performance of all the systems in the undirected setting is very similar.
+
+![](images/dd59e858ba40b7cdf60ee88661d198a2663da888a4d4017817771f9ca375b3e2.jpg)
+
+![](images/22abb7127a730cbb729037b0d30ab322439592edd46a928456fb8eca85bae02c.jpg)  
+(a) Vanilla GNN-based systems
+
+![](images/d6ccfee5019f79024c3ed7f86c726dbcd946ca520c6516b493681a5f4282fac0.jpg)  
+(b) Systems targeting over-smoothing  
+(c) Systems targeting over-squashing  
+Figure 2: Test accuracy of based systems on GLoRa benchmarks for increasing  $d$  (lines represent mean accuracy over multiple runs, shaded areas indicate the standard deviation)
+
+# 4.2 OVER-SMOOTHING, OVER-SQUASHING, VANISHING GRADIENT ARE NOT THE REASON
+
+Finally, we argue that, rather surprisingly, none of the three phenomena—over-smoothing, oversquashing, or vanishing gradient—is the reason for the dropping performance in the main experiment. In this section, we focus on the best-performing systems in the three categories (GatedGCN, DenseGatedGCN, and 1Drew-GCN), but the same arguments apply to the other systems.
+
+We first argue that over-smoothing is not a reason for the performance drop in all three systems. To justify our claim, we considered the largest  $d$  for which the accuracy is 1 for all systems and
+
+![](images/8540228e5abf220e8d7842cced4aa1f5f3d2f1ac31aa9f9dd672fea8d2c467d2.jpg)  
+(a) GatedGCN
+
+![](images/ec096124837b6a75f551fd46523375c1d6bc208b9ef22d9a348a846587e41c1f.jpg)  
+(b) DenseGatedGCN
+
+![](images/98199532d18aa90526111aa443ff2d11db8df82401740b66760a1fb07e4342df.jpg)  
+(c) 1Drew-GCN
+
+![](images/512a2bbb4bf31e11016392aa163df8a6ed95f63cb0b0638ecb96ebb5768544e5.jpg)  
+(a) GatedGCN  
+Figure 4: First layer weight gradients across max 300 epochs for best-performing systems
+
+![](images/3fd88e3881cf70cff4614169b30918e553c222876ce24b1fdb6d36172d83bd29.jpg)  
+(b) DenseGatedGCN
+
+![](images/7eb90d2111ba3d717a1275a568173cd832678a8d0aadd7421bf3c94c08e0133f.jpg)  
+Figure 3: Histograms of the last-layer values for the best-performing systems  
+(c) 1Drew-GCN
+
+the smallest  $d$  for which the accuracy is close to 0.5: 6 and 13. For each case, we extracted the numeric value of the (1-dimensional) last (i.e., 8 and 15) layer embedding of the target node for each of the examples and plotted their histograms in Figure 3. As expected, when accuracy is good, the last-layer embeddings are clearly separated, while when accuracy is poor, they are more mixed together. However, even in the latter case they still do not converge—that is, have rather significant standard deviation. In other words, we do not observe over-smoothing in any of the three cases.
+
+We next argue that over-squashing is also not the reason for degradation for the systems. In fact, this is guaranteed by the construction of GLoRa examples. Indeed, since each example has  $P$  additional chains, which is at most 10 (line 5 in Algorithm 1), there is a small (and independent of  $d$ ) bound on the number of paths leading to the target node. Therefore, over-squashing, which concerns the compression of the information from many (exponential number of) paths to a single vector, is not relevant here. Note that directedness of the graphs is crucial for this argument: in undirected graphs, even a single chain to the target node would induce an exponential (in  $d$ ) number of paths leading to this node, and so making such a claim would not be possible.
+
+We finally argue that gradient vanishing is also not the reason for the performance degradation of the three systems. This phenomenon is primarily caused by the fact that the chain rule in backpropagation results in exponentially smaller gradients in previous layers, making training difficult when there are many of them. We plotted, in Figure 4, the distribution of the first layer gradients across multiple epochs for the three systems. As we can see, the gradients remain stable throughout training, with magnitudes well above zero, indicating no vanishing. As we report in Appendix F, the systems have similar behaviour on other layers. This suggests that gradient vanishing is not the reason for their inability to learn dependencies for the corresponding  $d$ . As a side comment, we note that the standard techniques against gradient vanishing, such as AdamW, weight initialisation, gradient clipping, ReLU activation, and batch normalisation are all employed during training for all the systems.
+
+# 5 CONCLUSION AND FUTURE WORK
+
+The main contribution of this paper is GLoRa, a generator of synthetic benchmarks that allows us to evaluate graph-learning systems in terms of their ability to learn long-range dependencies. Using GLoRa, we have demonstrated that none of the state-of-the-art systems can learn dependencies longer than a very modest length of 11. We have also shown that this degradation cannot be attributed to the over-smoothing, over-squashing, or vanishing gradient. This opens up two directions for future research: to identify the real causes of this degradation and to develop methods to overcome it.
+
+# ACKNOWLEDGEMENTS
+
+The work was partially supported by EU Projects Graph Massivizer (GA 101093202), Dome 4.0 (GA 953163), enRichMyData (GA 101070284), and SMARTY (GA 101140087), and the Research Council of Norway through its Centres of Excellence scheme, Integreat—Norwegian Centre for knowledge-driven machine learning, project 332645.
+
+# REFERENCES
+
+Ralph Abboud, Radoslav Dimitrov, and Ismail Ilkan Ceylan. Shortest path networks for graph property prediction. In Learning on Graphs Conference (LoG), 2022.  
+Sami Abu-El-Haija, Bryan Perozzi, Amol Kapoor, Nazanin Alipourfard, Kristina Lerman, Hrayr Harutyunyan, Greg Ver Steeg, and Aram Galstyan. Mixhop: Higher-order graph convolutional architectures via sparsified neighborhood mixing. In International Conference on Machine Learning (ICML), pp. 21-29, 2019.  
+Uri Alon and Eran Yahav. On the bottleneck of Graph Neural Networks and its practical implications. In International Conference on Learning Representations (ICLR), 2021.  
+Pablo Barceló, Egor V. Kostylev, Mikael Monet, Jorge Pérez, Juan Reutter, and Juan-Pablo Silva. The logical expressiveness of Graph Neural Networks. In International Conference on Learning Representations (ICLR), 2020.  
+Yoshua Bengio, Patrice Simard, and Paolo Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE Transactions on Neural Networks, 5(2):157-166, 1994.  
+Cristian Bodnar, Fabrizio Frasca, Nina Otter, Yuguang Wang, Pietro Lio, Guido F. Montúfar, and Michael M. Bronstein. Weisfeiler and Lehman go cellular: CW networks. In Annual Conference on Neural Information Processing Systems (NeurIPS), pp. 2625-2640, 2021.  
+Pietro Bongini, Franco Scarselli, Monica Bianchini, Giovanna Maria Dimitri, Niccolo Pancino, and Pietro Lio. Modular multi-source prediction of drug side-effects with DruGNN. IEEE/ACM Transactions on Computational Biology and Bioinformatics, 20(2):1211-1220, 2022.  
+Xavier Bresson and Thomas Laurent. Residual gated Graph ConvNets. CoRR, arXiv:1711.07553 [cs.LG], 2017.  
+Ming Chen, Zhewei Wei, Zengfeng Huang, Bolin Ding, and Yaliang Li. Simple and deep Graph Convolutional Networks. In International Conference on Machine Learning (ICML), pp. 1725-1735, 2020.  
+Qi Chen, Yifei Wang, Yisen Wang, Jiansheng Yang, and Zhouchen Lin. Optimization-induced graph implicit nonlinear diffusion. In International Conference on Machine Learning (ICML), pp. 3648-3661, 2022.  
+Eli Chien, Jianhao Peng, Pan Li, and Olgica Milenkovic. Adaptive universal generalized PageRank Graph Neural Network. In International Conference on Learning Representations (ICLR), 2021.  
+Francesco Di Giovanni, Lorenzo Giusti, Federico Barbero, Giulia Louise, Pietro Lio, and Michael M. Bronstein. On over-squashing in message passing neural networks: The impact of width, depth, and topology. In International Conference on Machine Learning (ICML), pp. 7865-7885, 2023.  
+Vijay Prakash Dwivedi and Xavier Bresson. A generalization of transformer networks to graphs. CoRR, arXiv:2012.09699 [cs.LG], 2020.  
+Vijay Prakash Dwivedi, Ladislav Rampasek, Michael Galkin, Ali Parviz, Guy Wolf, Anh Tuan Luu, and Dominique Beaini. Long range graph benchmark. In Annual Conference on Neural Information Processing Systems (NeurIPS), 2022.  
+Vijay Prakash Dwivedi, Chaitanya K. Joshi, Anh Tuan Luu, Thomas Laurent, Yoshua Bengio, and Xavier Bresson. Benchmarking Graph Neural Networks. Journal of Machine Learning Research, 24(43):1-48, 2023.
+
+Wenqi Fan, Yao Ma, Qing Li, Yuan He, Yihong Eric Zhao, Jiliang Tang, and Dawei Yin. Graph Neural Networks for social recommendation. In The World Wide Web Conference (WWW), pp. 417-426, 2019.  
+Johannes Gasteiger, Aleksandar Bojchevski, and Stephan Gunnemann. Predict then propagate: Graph Neural Networks meet personalized PageRank. In International Conference on Learning Representations (ICLR), 2019a.  
+Johannes Gasteiger, Stefan Weißenberger, and Stephan Gunnemann. Diffusion improves graph learning. In Annual Conference on Neural Information Processing Systems (NeurIPS), pp. 13333-13345, 2019b.  
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In International Conference on Artificial Intelligence and Statistics (AISTATS), pp. 249-256, 2010.  
+Alex Graves. Supervised Sequence Labelling with Recurrent Neural Networks, volume 385 of Studies in Computational Intelligence. Springer, 2012.  
+Martin Grohe. The descriptive complexity of Graph Neural Networks. In Symposium on Logic in Computer Science (LICS), pp. 1-14, 2023.  
+Fangda Gu, Heng Chang, Wenwu Zhu, Somayeh Sojoudi, and Laurent El Ghaoui. Implicit graph neural networks. In Annual Conference on Neural Information Processing Systems (NeurIPS), pp. 11984-11995, 2020.  
+Benjamin Gutteridge, Xiaowen Dong, Michael M. Bronstein, and Francesco Di Giovanni. Drew: Dynamically rewired message passing with delay. In International Conference on Machine Learning (ICML), pp. 12252-12267, 2023.  
+William L. Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Annual Conference on Neural Information Processing Systems (NIPS), pp. 1024-1034, 2017.  
+Yi Han, Shanika Karunasekera, and Christopher Leckie. Graph Neural Networks with continual learning for fake news detection from social media. CoRR, arXiv:2007.03316 [cs.SI], 2020.  
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, arXiv:1512.03385 [cs.LG], 2015.  
+Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. In Annual Conference on Neural Information Processing Systems (NeurIPS), 2020.  
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning (ICML), pp. 448-456, 2015.  
+Ditsuhi Iskandaryan, Francisco Ramos, and Sergio Trilles. Graph Neural Network for air quality prediction: A case study in Madrid. IEEE Access, 11:2729-2742, 2023.  
+Ajay Jaiswal, Peihao Wang, Tianlong Chen, Justin F. Rousseau, Ying Ding, and Zhangyang Wang. Old can be gold: Better gradient flow can make vanilla-GCNs great again. In Annual Conference on Neural Information Processing Systems (NeurIPS), 2022.  
+Kanchan Jha, Sriparna Saha, and Hiteshi Singh. Prediction of protein-protein interaction using Graph Neural Networks. Scientific Reports, 12(1):8360, 2022.  
+Kedar Karhadkar, Pradeep Kr. Banerjee, and Guido Montúfar. FoSR: First-order spectral rewiring for addressing oversquashing in GNNs. In International Conference on Learning Representations (ICLR), 2023.  
+Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR), 2017.
+
+Devin Kreuzer, Dominique Beaini, William L. Hamilton, Vincent Létourneau, and Prudencio Tossou. Rethinking graph transformers with spectral attention. In Annual Conference on Neural Information Processing Systems (NeurIPS), pp. 21618-21629, 2021.  
+Guohao Li, Matthias Muller, Ali Thabet, and Bernard Ghanem. DeepGCNs: Can GCNs go as deep as CNNs? In International Conference on Computer Vision (ICCV), pp. 9267-9276, 2019.  
+Mengzhang Li and Zhanxing Zhu. Spatial-temporal fusion Graph Neural Networks for traffic flow forecasting. In AAAI Conference on Artificial Intelligence (AAAI), volume 35, pp. 4189-4196, 2021.  
+Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into Graph Convolutional Networks for semi-supervised learning. In AAAI Conference on Artificial Intelligence (AAAI), pp. 3538-3545, 2018.  
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard S. Zemel. Gated Graph Sequence Neural Networks. In International Conference on Learning Representations (ICLR), 2016.  
+Hai Liu, Chao Zheng, Duantengchuan Li, Zhaoli Zhang, Ke Lin, Xiaoxuan Shen, Neal N. Xiong, and Jiazhang Wang. Multi-perspective social recommendation method with graph representation learning. Neurocomputing, 468:469-481, 2022.  
+Juncheng Liu, Kenji Kawaguchi, Bryan Hooi, Yiwei Wang, and Xiaokui Xiao. EIGNN: Efficient infinite-depth graph neural networks. In Annual Conference on Neural Information Processing Systems (NeurIPS), pp. 18762-18773, 2021.  
+Meng Liu, Hongyang Gao, and Shuiwang Ji. Towards deeper Graph Neural Networks. In International Conference on Knowledge Discovery & Data Mining (SIGKDD), 2020.  
+Denis Lukovnikov and Asja Fischer. Improving breadth-wise backpropagation in Graph Neural Networks helps learning long-range dependencies. In International Conference on Machine Learning (ICML), pp. 7180-7191, 2021.  
+Christopher Morris, Martin Ritzert, Matthias Fey, William L. Hamilton, Jan Eric Lenssen, Gaurav Rattan, and Martin Grohe. Weisfeiler and Leman go neural: Higher-order Graph Neural Networks. In AAAI Conference on Artificial Intelligence (AAAI), pp. 4602-4609, 2019.  
+Christopher Morris, Nils M. Kriege, Franka Bause, Kristian Kersting, Petra Mutzel, and Marion Neumann. Tudataset: A collection of benchmark datasets for learning with graphs. CoRR, arXiv:2007.08663 [cs.LG], 2020.  
+Hongbin Pei, Bingzhe Wei, Kevin Chen-Chuan Chang, Yu Lei, and Bo Yang. Geom-GCN: Geometric Graph Convolutional Networks. In International Conference on Learning Representations (ICLR), 2020.  
+Jiezhong Qiu, Jian Tang, Hao Ma, Yuxiao Dong, Kuansan Wang, and Jie Tang. DeepInf: Social influence prediction with deep learning. In International Conference on Knowledge Discovery & Data Mining (ICKDDM), pp. 2110-2119, 2018.  
+Ladislav Rampášek and Guy Wolf. Hierarchical Graph Neural Nets can capture long-range interactions. In International Workshop on Machine Learning for Signal Processing (MLSP), pp. 1-6, 2021.  
+Ladislav Rampásek, Michael Galkin, Vijay Prakash Dwivedi, Anh Tuan Luu, Guy Wolf, and Dominique Beaini. Recipe for a general, powerful, scalable graph transformer. In Annual Conference on Neural Information Processing Systems (NeurIPS), 2022.  
+Yu Rong, Wenbing Huang, Tingyang Xu, and Junzhou Huang. DropEdge: Towards deep Graph Convolutional Networks on node classification. In International Conference on Learning Representations (ICLR), 2020.  
+T. Konstantin Rusch, Benjamin Paul Chamberlain, Michael W. Mahoney, Michael M. Bronstein, and Siddhartha Mishra. Gradient gating for deep multi-rate learning on graphs. In International Conference on Learning Representations (ICLR), 2023.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The Graph Neural Network model. IEEE Transactions on Neural Networks, 20(1):61-80, 2008.  
+Jan Tönshoff, Martin Ritzert, Eran Rosenbluth, and Martin Grohe. Where did the gap go? Reassessing the long-range graph benchmark. Transactions on Machine Learning Research, 2023.  
+Jake Topping, Francesco Di Giovanni, Benjamin Paul Chamberlain, Xiaowen Dong, and Michael M. Bronstein. Understanding over-squashing and bottlenecks on graphs via curvature. In International Conference on Learning Representations (ICLR), 2022.  
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Annual Conference on Neural Information Processing Systems (NIPS), pp. 5998-6008, 2017.  
+Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph Attention Networks. In International Conference on Learning Representations (ICLR), 2018.  
+Mark Weber, Jie Chen, Toyotaro Suzumura, Aldo Pareja, Tengfei Ma, Hiroki Kanezashi, Tim Kaler, Charles E. Leiserson, and Tao B. Schardl. Scalable graph learning for anti-money laundering: A first look. CoRR, arXiv:1812.00076 [cs:SI], 2018.  
+Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. Simplifying Graph Convolutional Networks. In International Conference on Machine Learning (ICML), pp. 6861-6871, 2019.  
+Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. In International Conference on Machine Learning (ICML), pp. 5453-5462, 2018.  
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations (ICLR), 2019.  
+Zhilin Yang, William Cohen, and Ruslan Salakhudinov. Revisiting semi-supervised learning with graph embeddings. In International Conference on Machine Learning (ICML), pp. 40-48, 2016.  
+Lingxiao Zhao and Leman Akoglu. *PairNorm: Tackling oversmoothing in GNNs*. In International Conference on Learning Representations (ICLR), 2020.
+
+# A MAIN EXPERIMENT DETAILS
+
+In this appendix, we give additional details of the settings of the main experiment in Section 4.1.
+
+# A.1 STATISTICS OF THE BENCHMARK USED IN THE EXPERIMENT
+
+Table 1 presents an excerpt of the benchmark statistics. We created benchmarks for every  $d \in \{3, \ldots, 15\}$ , but, for readability, give the statistics only for those at intervals of 5—that is, for depths of 5, 10, and 15.
+
+<table><tr><td>Length d</td><td>Examples</td><td>Total Nodes</td><td>Average Nodes in a Graph</td><td>Mean In-Degree</td><td>Total Edges</td><td>Average Edges in a Graph</td><td>Average S → T</td></tr><tr><td>5</td><td>10000</td><td>19334</td><td>19</td><td>2</td><td>259154</td><td>26</td><td>5</td></tr><tr><td>10</td><td>10000</td><td>336606</td><td>33</td><td>2</td><td>401698</td><td>40</td><td>9</td></tr><tr><td>15</td><td>10000</td><td>497528</td><td>50</td><td>2</td><td>562624</td><td>56</td><td>14</td></tr></table>
+
+Table 1: Statistics of the synthetic benchmark generated by GLoRa with varying length  $d$ , where each column entry gives the number of the elements in the set of the column name; here 'Average  $S \rightarrow T$  stands for the average path length from the source node to the target node, while other column names are self-explanatory
+
+# A.2 BENCHMARK LICENSES
+
+Our benchmark generator source code is available at https://github.com/DongzhuoranZhou/GLoRa under the MIT License.
+
+# A.3 SOURCE CODES FOR EVALUATED SYSTEMS
+
+For the vanilla GNN-based systems (i.e., not designed to deal with long-range dependencies), GCN, GAT, GraphSAGE, GGNN, SGC, and GIN, we used the implementations included into library PyTorch Geometric (see https://github.com/pyg-team/pytorchbégeometric). The implementation of GatedGCN was taken from the repository of GraphGPS (Rampásek et al., 2022).
+
+For the GNN-based systems targeting over-smoothing, we used the PyTorch Geometric implementations for GCNII, PairNorm, DropEdge, APPNP, JKNet, ResGCN, and DenseGCN, as well as the variants ResGatedGCN, DenseGatedGCN, ResGAT, and DenseGAT of the last two. The implementations of GPRGNN, DAGNN, IGNN, EIGNN, GIND, and  $\mathbf{G}^2$  were obtained from the original repositories reported in the corresponding papers.
+
+For the GNN-based systems targeting over-squashing, the implementations of  $\nu$  Drew-GCN with  $\nu \in \{1,\infty \}$ , SP-GCN, DIGL, and MixHop-GCN were taken from the repository of Drew (Gutteridge et al., 2023), while SDRF and FOSR were taken from https://github.com/hieubkvn123/revisiting-gnn-curvature. Lastly, the FA-GCN architecture was re-implemented in-house.
+
+For all transformer-based systems—that is, GraphTransformer, SAN, and GraphGPS with RWSE and LapPE—we used the implementations available in the GraphGPS repository (Rampásek et al., 2022).
+
+The overview of these sources is given in Table 2.
+
+# A.4 COMPUTING ENVIRONMENT
+
+All experiments were conducted in a shared computing cluster environment utilizing various CPU and GPU architectures, including NVidia V100 (16GB/32GB) and NVidia A100 (40GB/80GB). Each system was allocated a resource budget of 1 GPU, 4 CPUs, and up to 32GB of system RAM.
+
+<table><tr><td>Category</td><td>Baseline</td><td>URLs</td></tr><tr><td rowspan="3">vanilla GNNs</td><td>GCN, GAT, GraphSAGE</td><td>https://github.com/pyg-team/pytorch.Geometry</td></tr><tr><td>GIN, GGNN, SGC</td><td>https://github.com/rampasek/GraphGPS</td></tr><tr><td>GatedGCN</td><td></td></tr><tr><td rowspan="10">targeting over-smoothing</td><td>GCNII, PairNorm, DropEdge</td><td>https://github.com/pyg-team/pytorch.Geometry</td></tr><tr><td>ResGCN, APPNP, ResGatedGCN</td><td></td></tr><tr><td>DenseGCN, JKNet, DenseGAT</td><td>https://github.com/pyg-team/pytorch.Geometry</td></tr><tr><td>ResGAT, DenseGatedGCN</td><td></td></tr><tr><td>GPRGNN</td><td>https://github.com/jianhao2016/GPRGNN</td></tr><tr><td>DAGNN</td><td>https://github.com/mengliu1998/DeeperGNN/tree/master</td></tr><tr><td>IGNNN</td><td>https://github.com/sczhou/IGNNN</td></tr><tr><td>EIGNN</td><td>https://github.com.liu-jc/EIGNN</td></tr><tr><td>GIND</td><td>https://github.com/7qchen/GIND</td></tr><tr><td>G2</td><td>https://github.com/tk-rusch/gradientsgating</td></tr><tr><td rowspan="7">targeting over-squashing</td><td>∞Drew-GCN, 1Drew-GCN</td><td>https://github.com/BenGutteridge/DRew/tree/main</td></tr><tr><td>SP-GCN</td><td>https://github.com/BenGutteridge/DRew/tree/main</td></tr><tr><td>DIGL</td><td>https://github.com/BenGutteridge/DRew/tree/main</td></tr><tr><td>MixHop-GCN</td><td>https://github.com/BenGutteridge/DRew/tree/main</td></tr><tr><td>SDRF</td><td>https://github.com/hieubkvn123/revisiting-gnn-curvature</td></tr><tr><td>FOSR</td><td>https://github.com/hieubkvn123/revisiting-gnn-curvature</td></tr><tr><td>FA-GCN</td><td>https://github.com/DongzhuoranZhou/GLoRa</td></tr><tr><td rowspan="3">transformer-based</td><td>GraphTransformer</td><td>https://github.com/rampasek/GraphGPS</td></tr><tr><td>SAN</td><td>https://github.com/rampasek/GraphGPS</td></tr><tr><td>GraphGPS with RWSE and LapPE</td><td>https://github.com/rampasek/GraphGPS</td></tr></table>
+
+Table 2: URLs for Baseline Model Source Codes
+
+# A.5 HYPERPARAMETER SETTINGS
+
+The essential parameters and hyperparameters are as follows.
+
+- All experiments are trained for 300 epochs or until convergence, with results averaged over 5 runs.  
+- All experiments use batch sizes of 32.  
+- All results use the AdamW optimiser with momentum  $\beta_{1} = 0.9$ , base learning rate search space [0.005, 0.01, 0.05], and weight decay space [0, 5e-6, 5e-5, 5e-4].  
+- All experiments use batch normalisation with  $\epsilon = 1\mathrm{e} - 5$ , momentum=0.9.  
+- For the GNN-based systems, the number of layers was set to  $d + 2$ , where  $d$  is the depth of the benchmark (which, not surprisingly, was shown to be a best number of layers in all cases in additional experiments).  
+- For MixHop-GCN, hyperparameter  $P$  is a set of integer adjacency powers. The search space for  $P$  is [3, 5, 7].  
+- DIGL and GraphGPS are configured to use GatedGCN as the base model, as it delivers the best performance among MPNNs.  
+- For DIGL, we employ PPR diffusion with  $\alpha$  with search space [0.1, 0.2, 0.5, 0.9] and apply threshold sparsification with average degree  $d_{\mathrm{avg}}$  with search space [1, 2, 3, 4, 5].  
+- GAT head search space is [1, 4, 8].  
+- JKNet has three options of connection, i.e., concatenation, max, and lstm, which is also taken as a hyperparameter.  
+- For GPRGNN, we set the random walk path length to  $K = 10$ , and search for the best PPR within space  $\alpha \in [0.1, 0.2, 0.5, 0.9]$ .  
+- For GPS and SAN, layer number search space is  $[5, \dots, 14]$ .
+
+# B ADDITIONAL RESULTS OF THE MAIN EXPERIMENT
+
+In this appendix, we report the results of the main experiment that are not included in the main body of the paper. In Figure 5, we show the testing accuracy on GLoRa benchmarks with increasing  $d$
+
+![](images/6a4307db3e6511a25acb35c34777d4a692b7b569d06b793d99981c05541234ac.jpg)
+
+![](images/6e648d9e734a57d3b75dbcc4b3c083f614594dfe5d7f7cd71df33b2d71c85a7b.jpg)
+
+![](images/5567e14b614c50a512d3225ba72c0ee0a17a06f09595417a8f8d1c280d0d283c.jpg)
+
+![](images/cc5fd29bef784780b74312cdd451807508bb74488ea976f0f1d09552fac473d5.jpg)
+
+![](images/95bd0c42f786737ec4be7efaf2f173dcd6b53a5b55a84cc999fece3cfb910135.jpg)  
+Figure 5: Test accuracy of non-top-5 based systems on GLoRa benchmarks for increasing  $d$  (lines represent mean accuracy over multiple runs, shaded areas indicate the standard deviation)
+
+![](images/1df9cde244c4ba27c42a380d2bf7a63d8cfee3a705cf33f4b680bdb278b7f912.jpg)
+
+for systems outside the top 5 in vanilla GNNs, GNNs targeting over-smoothing, GNNs targeting over-squashing, and all transformer-based methods. Specifically, for vanilla GNN-based systems they are GAT and GGNN; for the GNNs targeting over-smoothing they are ResGAT,  $\mathbf{G}^2$ , DenseGAT, DropEdge, DAGNN, PairNorm, APPNP, GPRGNN, GIND, EIGNN, JKNet, and IGNN; and for the GNNs targeting over-squashing systems they are DIGL, SDRF, FOSR, and FA-GCN. For transformer-based methods, we consider GraphTransformer, SAN, and GraphGPS.
+
+# C PROOF SKETCH OF THEOREM 1
+
+In this appendix, we give a proof sketch of our theorem.
+
+Theorem 1 Let  $d \in \mathbb{N}$  be a length. Then, for every  $\delta > 0$  and  $\mathcal{P} \in (0,1)$  there exists a number  $K$  such that a set of  $K$  examples, half generated by  $GLoRa(d, \text{True})$  and half by  $GLoRa(d, \text{False})$ , requires learning dependencies of length  $d$  with precision  $\delta$  with probability at least  $\mathcal{P}$ .
+
+Proof sketch. First, observe that, for the given  $d$ , there is only a finite number of pairs  $\mathcal{V}, \mathcal{E}$  of sets of nodes and edges that can be the first two components of a graph generated by GLoRa algorithm with parameter  $d$ . Moreover, each of these pairs has non-zero probability of being generated. Moreover,  $\mathcal{D}$  is bounded and the values are sampled from this set by the algorithm uniformly. So, for the given  $\delta$  and  $\mathcal{P}$ , there is a number  $K$  such that  $K$  generated examples include, with required probability, an appropriate number of examples that support the claim—that is, such that the approximated version of Definition 1 holds. Indeed, we only need to ensure that the graph structures of each
+
+positive-negative pair agree with the required structure and between the two examples in the pair, and that their embeddings are within  $\delta$  everywhere, except the designated differences.
+
+# D NON-SUITABILITY OF EXISTING SYNTHETIC BENCHMARKS
+
+In this appendix, we provide a summary of existing synthetic benchmarks, each with its unique graph structures and target functions. Then we explain why each of the existing synthetic benchmarks are not suitable for the purpose of checking whether a system is able to learn long-range dependencies.
+
+Summary of existing synthetic benchmarks is as follows:
+
+- Synthetic Chains (Gu et al., 2020). The graph structure in this benchmark is directed chain. The task is to classify nodes in a directed chain of length  $l$ . For simplicity, a binary classification is used, with two types of chains. The class of each node is determined by the 1/0 encoding in the first dimension of the starting node's 100-dimensional feature vector. The training set includes randomly sampled nodes from these chains. The target function is that the node is true if and only if the starting node, which has no incoming edges, has a value of 1 in its first dimension.  
+- Graph Transfer, Ring Transfer (Di Giovanni et al., 2023; Gutteridge et al., 2023). The graph structures in these benchmarks are ring, crossed-ring, and clique-path. Ring graphs are cycles of size  $n$ . In each ring, there exist pairs of nodes that are placed at a distance of  $\left\lfloor \frac{n}{2} \right\rfloor$  from each other. One of these node pairs is chosen. One node in the pair has its class information encoded as a one-hot vector (5 classes total) in its embedding, which is used to classify the other node. The target function is that there exists a node with a one-hot encoding node embedding in the graph. The class of the node at a distance of  $\left\lfloor \frac{n}{2} \right\rfloor$  from this node is the same as the one-hot encoded class. A similar setting applies in crossed-ring and clique-path.  
+- Tree-Neighbours (Alon & Yahav, 2021). The graph structure in this benchmark is a directed binary tree, where the root and leaves have some additional 1-hop neighbours pointing to them. The target function is that the class of the root node is the class of the leaf node, which has the same number of 1-hop neighbors pointing to it as the root node. Here, the 1-hop neighbours do not include the nodes on the original binary tree.  
+- h-Proximity (Abboud et al., 2022). The graph structure in the benchmark is defined as follows: (i) consecutive level nodes are pairwise fully connected, (ii) nodes within the same level are pairwise disconnected. Each node is either red, blue, or uncoloured. The target function states that the graph is positive if all red nodes in this graph have at most 2 blue nodes within their  $h$ -hop neighborhood.  
+- Colour-Connectivity (Rampášek & Wolf, 2021). The graph structure in the benchmark consists of 2D square grids. Each node is either red or blue. Red nodes are sampled by random walks starting from two random nodes until half the nodes are red; the remaining nodes are colored blue. The target function states that the graph is positive if there is a single connected island of red nodes, and negative if there are two disjoint islands of red nodes.  
+- Conditional Recall (Lukovnikov & Fischer, 2021): The graph structure in Conditional Recall is a directed chain. The nodes in the chain are encoded as letters (both uppercase and lowercase) and digits. The target function is as follows: (i) if there is a digit in the sequence, the first digit corresponds to the class label of the chain; (ii) otherwise, if there is an uppercase letter, the first uppercase letter is the class label; (iii) if neither digits nor uppercase letters are present, the class is given by the first character in the sequence.  
+- Tree-Max (Lukovnikov & Fischer, 2021). The graph structure in Tree-Max is a directed binary tree. The nodes in the tree are encoded as digits. The target function is that the label of the node is the largest value of all the descendants of a node and the node itself.
+
+The reason why each of the existing synthetic benchmarks are not suitable for the purpose of checking whether a system is able to learn long-range dependencies are as follows:
+
+- Synthetic Chains. Intuitively, to solve this benchmark, it is possible for the learned function to ignore the distance and path information, making global readouts like Virtual Nodes
+
+![](images/78af3aeb79f5bdefb1d083bdc163160d6bbd5d64d07f9be519b77708f533ad03.jpg)
+
+![](images/33c5c7d4d438ecdada344e5e86d1c5b0df254b117bb1a2852e7891aa74e573e1.jpg)
+
+![](images/3bff67d7a82d24719e43d84ade96ddae0b2948a933552217fb996ae9d73d1650.jpg)  
+Figure 6: Test accuracy of best five systems in each category of vanilla GNN-based systems, systems targeting over-smoothing and systems targeting over-squashing on undirected GLoRa benchmarks for increasing  $d$  (lines represent mean accuracy over multiple runs, shaded areas indicate the standard deviation)
+
+sufficient. In particular, such function does not rely on long-range dependency, because it does not satisfy the requirement that any intermediate node on a justifying path can be dropped.
+
+- Graph Transfer and Ring Transfer. This benchmark has similar properties as Synthetic Chains and hence also can be perfectly fitted with a similar function that does not rely on long-range dependency. Moreover, the design of these benchmarks allows only for five different examples (one for each class of the used multi-class classification), which makes the benchmarks of limited use, because these five examples may be memorised by the system during training.  
+- Tree-Neighbours. Same as the previous two cases, this benchmark can be perfectly fitted with a function that does not rely on long-range dependency, which is based on the same principle.  
+- h-Proximity. In this case, the possible function that does not rely on long-range dependency is the one that does not rely on the embeddings of the nodes on the paths between any red node and the target node (thus not satisfying Definition 1).  
+- **Colour-Connectivity.** On the contrary to the previous cases, this benchmark indeed requires learning function relying on long-range dependency. However, it has an opposite issue: all the GNN-based systems we are aware of cannot express any function that fits a sufficient amount of randomly generated training examples.  
+- Conditional Recall, Tree-Max. The graphs in these benchmarks have limited size, so it is also possible to solve each of them by using a function that does not depend on long-range dependency.
+
+# E UNDIRECTED GRAPH EXPERIMENT RESULTS
+
+In this section, we present the test results for all the based systems discussed in Section 4 on the undirected version of GLoRa. The results are reported in Figures 6 and 7.
+
+![](images/7d4ea6bfc592a98edb39c5a6cd7171f7672df40d5114630ab1d49b5c71377f58.jpg)
+
+![](images/0ef22f6b022e4df564ee9c4e337c19615b4822e4ef3c17e5f53911bd9ac3ec59.jpg)
+
+![](images/305ec4bfb6dc206ff3b9de9e5d71b0004cc8c24a042784a71ef52798d93d936e.jpg)
+
+![](images/30aa06e5929b0712ade81dacbe5cccb660a61e36d1b3eddbe7656b6e7334e451.jpg)
+
+![](images/a3b60c75e3e50637d368e81892d8ff1dc4efedabf95db9cf37b670bf84dc6c30.jpg)  
+Figure 7: Test accuracy of non-top-5 based systems on undirected GLoRa benchmarks for increasing  $d$  (lines represent mean accuracy over multiple runs, shaded areas indicate the standard deviation)
+
+![](images/0fa2cddcb99eeccd41e21c183cf9a90cbecb98e7c927c2ff54815acabe8bcb97.jpg)
+
+# F GRADIENT VISUALIZATION OF THE DEEP LAYERS
+
+In this section, we present the gradient distributions of the second and third layers for the best-performing systems. As shown in Figure 8, the gradients in both the second and third layers remain sufficiently large, indicating that the models do not suffer from vanishing gradient problems. This stability of gradients across deeper layers suggests that the degradation in performance is not due to gradient vanishing, but likely other factors.
+
+![](images/e3ca6228c0fe68ffabe41eeaa24c46998a1ec0e03100570b58311f24e5b5c6c4.jpg)  
+(a) GatedGCN
+
+![](images/0f65c867abecfeb22b8ee76c27a3a40c7ee62d2364bf79f632f7663734adeed5.jpg)  
+(b) DenseGatedGCN
+
+![](images/cc15d51626db4dfefdbd064e0c982a976e1bcd400274d87260c198e2ed10fa07.jpg)  
+(c) 1Drew-GCN
+
+![](images/37f009469855245c0eb07eaa0972d4c05a198af3907fd768b0b551f4d3a1996e.jpg)  
+(d) GatedGCN
+
+![](images/9a525b8d7c8351ee03d45eeb297232401541dfbd085109aa827a7152324903c7.jpg)  
+(e) DenseGatedGCN
+
+![](images/a98f09e9cdee3ea1c51572a67acd21a6029a80490a42cd004c4031687b3596a2.jpg)  
+(f) 1Drew-GCN  
+Figure 8: Gradient weights of the second (a, b, c) and third layer (d, e, f) across 300 epochs for the best-performing systems

ICLR/2025/GLoRa_ A Benchmark to Evaluate the Ability to Learn Long-Range Dependencies in Graphs/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb1e886fb7765de272c4ed186a822ba830491f2aff9553af25a233c9c4d71f99
+size 650725

ICLR/2025/GLoRa_ A Benchmark to Evaluate the Ability to Learn Long-Range Dependencies in Graphs/layout.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b32051b9d862b388bf1ce4319484785e111e3e8def3fa97481350f29751bf5d3
+size 783804

ICLR/2025/GMValuator_ Similarity-based Data Valuation for Generative Models/88272ed1-8509-48e0-8a26-3df7edf3f8fd_content_list.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:142a4ee778d05b7d4a0a56d399c5b22c148bfd79db81de924970d6b294bce4a0
+size 160246

ICLR/2025/GMValuator_ Similarity-based Data Valuation for Generative Models/88272ed1-8509-48e0-8a26-3df7edf3f8fd_model.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fcff17e33d12a7e8854fa59633f3a80c3a1def3e2a11698227e49adf42d2652
+size 194368

ICLR/2025/GMValuator_ Similarity-based Data Valuation for Generative Models/88272ed1-8509-48e0-8a26-3df7edf3f8fd_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93b2e76211343c816a4ff8c2d7af55ebd02b69239903be5261ec0ec16e384c63
+size 7492122

ICLR/2025/GMValuator_ Similarity-based Data Valuation for Generative Models/full.md

@@ -0,0 +1,652 @@
+# GMVALUATOR: SIMILARITY-BASED DATA VALUATION FOR GENERATIVE MODELS
+
+Jiaxi Yang $^{1*†}$ , Wenlong Deng $^{1,5*}$ , Benlin Liu $^{2}$ , Yangsibo Huang $^{3}$ , James Zou $^{4}$ , Xiaoxiao Li $^{1,5*}$
+
+<sup>1</sup>University of British Columbia <sup>2</sup>University of Washington <sup>3</sup>Princeton University
+
+4Stanford University 5Vector Institute
+
+# ABSTRACT
+
+Data valuation plays a crucial role in machine learning. Existing data valuation methods, mainly focused on discriminative models, overlook generative models that have gained attention recently. In generative models, data valuation measures the impact of training data on generated datasets. Very few existing attempts at data valuation methods designed for deep generative models either concentrate on specific models or lack robustness in their outcomes. Moreover, efficiency still reveals vulnerable shortcomings. We formulate the data valuation problem in generative models from a similarity matching perspective to bridge the gaps. Specifically, we introduce Generative Model Valuator (GMVALUATOR), the first training-free and model-agnostic approach to providing data valuation for image generation tasks. It empowers efficient data valuation through our innovative similarity matching module, calibrates biased contributions by incorporating image quality assessment, and attributes credits to all training samples based on their contributions to the generated samples. Additionally, we introduce four evaluation criteria for assessing data valuation methods in generative models. GMVALUATOR is extensively evaluated on benchmark and high-resolution datasets and various mainstream generative architectures to demonstrate its effectiveness. Our code is available at: https://github.com/ubc-tea/GMValuator.
+
+# 1 INTRODUCTION
+
+As the driving force behind modern AI, particularly deep learning Pei (2020), a substantial volume of data is indispensable for effective machine learning. On one hand, informative data samples relevant to the task at hand play a critical role in the training process. On the other hand, due to data privacy concerns, personal data is safeguarded by various regulations, including the General Data Protection Regulation (GDPR) Regulation (2018), and has become a valuable asset. Consequently, data valuation has garnered significant attention from academic and industrial sectors recently.
+
+The intricate relationship between data and model parameters presents a significant challenge in the contribution measurement of each training sample, thus making data valuation a difficult task. Most existing data valuation studies focus on supervised learning for discriminative models (e.g., classification and regression). These methods can be categorized as (1) Metric-based methods: Methods such as Shapley Value (SV) and Banzhaf Index (BI) Ghorbani & Zou (2019); Wang & Jia (2023) provide the assessment of data value by calculating marginal contribution on performance metrics (e.g., accuracy or loss) through retraining the model<sup>1</sup>. (2) Influence-based methods: This line of methods measures data value by evaluating influence on model parameters of data points Jia et al. (2019b); Nohyun et al. (2022). (3) Data-driven methods: These techniques avoid retraining by leveraging data characteristics (like data diversity, generalization bound estimation, class-wise distance), though generally necessitate data labels. Xu et al. (2021); Wu et al. (2022); Just et al. (2023).
+
+Urgent needs for generative models. Data valuation in the context of generative models has NOT been well-investigated in the current literature. Moreover, there exist significant challenges in
+
+directly adapting the aforementioned data valuation methods for discriminative models listed to generative models: Firstly, the challenge of applying metric-based methods arises from lacking robust performance metrics in generative models, in contrast to the existence of commonly used metrics (e.g., accuracy or loss) in discriminative models Betzalel et al. (2022). This could potentially result in inconsistent outcomes when employing various performance metrics Terashita et al. (2021). In addition, the expensive cost of retraining requirements is another obstacle to using metric-based methods. Secondly, influence-based methods may not perform well on non-convex objective function of generative models Bae et al. (2022). Besides, estimating the influence function in a deep generative model is expensive, as it requires computing (or approximation) inverse Hessian. Thirdly, for data-driven methods, they mainly focus on supervised learning, which requires knowing data labels to quantify data values.
+
+To the best of our knowledge, limited studies have explored model-dependent data evaluation using influence functions for specific generative models. IF4GAN Terashita et al. (2021) consider multiple evaluation metrics, such as log-likelihood, Inception Score (IS), and Frechet Inception Distance (FID) Heusel et al. (2017) to identify the most responsible training samples for the overall performance of Generative Adversarial Networks (GAN)-based models. However, selecting appropriate metrics is critical, as the results are inconsistent across metrics. VAE-TracIn Kong & Chaudhuri (2021) finds the most significant contributors for generating a particular generated sample for Variational Autoencoders (VAE) using the influence function. However, viable Hessian estimation in influence function calculations incur high computational costs and this method cannot be easily generalized to other generative models.
+
+Our motivation and goal. Considering the challenges posed by the selection of performance metrics and computational efficiency and the need for broader applicability across various generative models, we aim to propose a unified and efficient data valuation method. We expect the unified method to satisfy the following key properties: 1) Model-agnostic: the method should be versatile, capable of being employed across diverse generative model architectures and algorithms, regardless of specific design choices; 2) Computation Efficiency: the method does not require retraining the model and minimize computational overhead while maintaining a satisfactory level of accuracy and reliability in evaluating the value of data points; 3) Plausibility: the method should evaluate the value of data based on its alignment with human prior knowledge on the task, enhancing its credibility and reliability; 4) Truthfulness: the method should strive to provide an unbiased and accurate assessment of the value associated with individual data points. In this work, we evaluate the contribution of (good) training data given a fixed set of generated data from a certain well-trained generative model. We refer to the value of training data as the contribution to the given generated data, taking into account the quality of the generated data. To meet the design purposes, we propose a similarity-based data valuation approach  $^{2}$  for the generative model, called Generative Model Valuator (GMVALUATOR), which is model-agnostic and efficient.
+
+In summary, our work here provides the following specific novel contributions:
+
+- To the best of our knowledge, GMVALUATOR is the first modal-agnostic and retraining-free data valuation method for image generative models.  
+- We formulate data valuation for generative models as an efficient similarity-matching problem. We further eliminate the biased contribution measurement by introducing image quality assessment for calibration.  
+- We propose four evaluation methods to assess the truthfulness of data valuation and evaluate GMVALUATOR on different datasets (including benchmark datasets and high-resolution large-scale datasets) and various deep generative models to verify GMVALUATOR's validity.
+
+Related Work. Different from discriminative models for regression or classification tasks, generative models in various forms (i.e., Variational auto-encoders (VAEs) Rezende et al. (2014), Variational auto-encoders (VAEs) Rezende et al. (2014), Diffusion Model Ho et al. (2020); Rombach et al. (2022)) aim to learn data distribution for generation tasks. Consequently, the approach to data valuation in our work, which focuses on generative models, is distinct and orthogonal to that for discriminative models. The primary limitation of both metric-based methods and influence-based methods is the expensive computation cost, a drawback that is further magnified in generative models. Conversely, while
+
+data-driven methods are training-free, they predominantly concentrate on supervised learning and data itself Xu et al. (2021); Wu et al. (2022); Just et al. (2023). Apart from the expensive computational cost, the limited existing influence-based methods for generative models are model-specific, which can not adapt to the diverse and evolving trends in generative model development Terashita et al. (2021); Kong & Chaudhuri (2021). A more detailed related work is discussed in Sec. C of the appendix.
+
+# 2 MOTIVATION AND PROBLEM FORMULATION
+
+In this section, we present the background and motivation behind our proposed method GMVALUATOR, which formulates the data valuation for generative models as a similarity-matching problem.
+
+# 2.1 MOTIVATIONS
+
+Let us denote  $X = \{x_{1},\dots,x_{n} | x \sim \mathcal{X}\}$  as the training dataset without duplicated data for a generation task, and  $n$  is regarded as the size of the dataset. Denote the generated dataset as  $\hat{X} = \{\hat{x}_1,\dots,\hat{x}_m\}$  by a well trained generative model  $G^{*}$  (e.g., Generative Adversarial Network (GAN), Variational Auto-encoder (VAE), Diffusion Model) on  $X$ .
+
+The core of these generative models is an intractable probability distribution learning process to train a generator  $G$ , that maps each  $z$  sampled from the noise distribution  $\mathcal{Z}$  to a generated sample  $\hat{x}$  in estimated distribution by maximizing the likelihood  $p_{\mathcal{X}}(x) \approx \int p_G(x|z)p_{\mathcal{Z}}(z)dz$ . This can be achieved by minimizing the distance  $d(\cdot, \cdot)$  (i.e., Wasserstein Distance) between the estimated distribution and training data distribution:
+
+$$
+G ^ {*} = \underset {G} {\arg \min } d \left(G _ {z \sim \mathcal {Z}} (z)\right), \mathcal {X}). \tag {1}
+$$
+
+Therefore, the data generated by an optimal generator, which closely approximates the training distribution, can be considered as drawing from a subdistribution of  $\mathcal{X}$ .
+
+# 2.1.1 THEORETICAL JUSTIFICATION
+
+Let  $T \subset X$  denote the  $K$  contributors found by a data valuator (e.g., GMVALUATOR) for  $\hat{X}$ , and  $S$  is a subset of the training dataset  $X$ . We focus on the data type with describable attributes (e.g., image data with semantic attributes). We first provide definitions of data and contributors.
+
+Definition 2.1 (Data with Describable Attributes.) We assume an image can be characterized by  $V$  attributes, and there is a labeling function  $f$  mapping  $S, T$  and  $\hat{X}$  to the same attribute space  $\mathcal{A} = \{0,1\}^V$ .
+
+Definition 2.2 (Contributors in Generative Models.) Let  $S^*$  denotes the real  $K$  contributors, defined as follows:
+
+$$
+S ^ {*} = \underset {S \subset X} {\arg \min } d \left(\mathcal {X} _ {\left(\hat {X} | A\right)}, \mathcal {X} _ {\left(G (S) | A\right)}\right), \tag {2}
+$$
+
+where  $|S^{*}| = K$  and  $K$  is a reasonable number for generative model training.  $\mathcal{X}_{(\hat{X} |A)}$  is the data distribution of generated data  $\hat{X}$  on attributes  $A\in \mathcal{A}$ , and  $\mathcal{X}_{(G(S)|A)}$  is the distribution of data with attribute  $A$  that are generated by the optimal generator trained by contributors  $S$ . According to the objective of generative models and Eq. equation 2, we have  $\mathcal{X}_{(\hat{X} |A)}\sim \mathcal{X}_{(G(S^{*})|A)}$ . We follow Just et al. (2023) on assumptions and lemmas that will be used to obtain the theorem.
+
+Assumption 2.3 Assume that the function  $f$  is  $\epsilon$ -Lipschitz and the loss function  $\mathcal{L} : \{0,1\}^V \times [0,1]^V \to R^+$  is  $k$ -Lipschitz in both inputs and attributes. We have labeling functions that are all bounded by  $V$  as  $\| f \| \leq V$ .
+
+Then, we introduce the error bound between  $T$  and  $S^{*}$ .
+
+Theorem 2.4 (Bounded Attributes Classification Error on  $S^*$  to  $T$ .) Let  $f_{S^*}': \mu \to \mathcal{A} = \{0,1\}^V$  be the model trained on the optimal contributor dataset  $S^*$ . Following Assumption 2.3, if the contributors
+
+are corresponding to the given generated data  $\hat{X}$ , we have:
+
+$$
+\begin{array}{l} \mathbb {E} _ {x \sim \mu_ {T}} \left[ \mathcal {L} \left(f (x), f _ {S ^ {*}} ^ {\prime} (x)\right) \right] - \mathbb {E} _ {x \sim \mu_ {S ^ {*}}} \left[ \mathcal {L} \left(f (x), f _ {S ^ {*}} ^ {\prime} (x)\right) \right] \\ \leq k \epsilon \cdot \left[ d _ {W} \left(\mathcal {X} _ {(T | f)}, \mathcal {X} _ {(\hat {X} | f)}\right) + d _ {W} \left(\mathcal {X} _ {\left(S ^ {*} | f\right)}, \mathcal {X} _ {(\hat {X} | f)}\right) \right] \tag {3} \\ \end{array}
+$$
+
+As shown in the Theorem 2.4, given the optimal contributor  $S^{*}$ ,  $d_{W}\left(\mathcal{X}_{(S^{*}|f)},\mathcal{X}_{(\hat{X} |f)}\right)$  is a deterministic term that approaching zero. Then, approximate  $S^{*}$  can be achieved by reducing the distance term  $d_{W}\left(\mathcal{X}_{(T|f)},\mathcal{X}_{(\hat{X} |f)}\right)$ . Please see Sec. M in the appendix for the proof.
+
+# 2.1.2 EMPERICAL VALIDATION
+
+According to theoretical justification, the generated data should show more similarity to the data samples used for training. In this context, we examine the value of training data being more valuable compared to data that is not used for training, despite originating from a similar distribution. We support this by partitioning a class of CIFAR-10 (the class is plane here) into two non-overlapped subsets, denoted as  $X_{v1}$  and  $X_{v2}$ . Next, we keep  $X_{v1}$  as non-training data and use  $X_{v2}$  as training data to train a BigGAN Brock et al. (2018) and generate dataset  $\hat{X}$ . If our assumption holds, the generated data will be more similar to the training data  $X_{v2}$ . As presented in the T-SNE Van der Maaten & Hinton (2008) plot (Figure 1), the generated data demon
+
+![](images/e5239c4efbf91a2742a9722ba498f8d542bac068d29fef9bc379863d8b9fb839.jpg)  
+Figure 1: Data distribution for  $X_{v1}, X_{v2}$  and  $\hat{X}$  for CIFAR-10, and  $X_{v1}, X_{v2}$  are both airplane dataset.
+
+stratiate more substantial overlap in the shared feature space with the training dataset  $X_{v2}$  than the non-training ones  $X_{v1}$ . This observation motivates us to address the data valuation for the generative model from a similarity-matching perspective.
+
+# 2.2 PROBLEM FORMULATION AND CHALLENGES
+
+The primary objective of our research is to tackle the issue of data valuation in generative models using black-box access. In essence, given a fixed set of data samples  $\hat{X}$  with a size of  $m$  generated from the well-trained deep generative model  $G^{*}$ , our aim is to determine the value  $\phi_{i}(x_{i},\hat{X},G^{*})$  associated with each data point  $x_{i}\in X$  for  $i\in [n]$  in the deduplicated training dataset, which contributes to the generated dataset. We denote the value for training data  $x_{i}$  as  $\phi_{i}$  in the rest of the paper for simplicity.
+
+Following the motivation stated in Sec. 2.1,  $\phi_{i}$  should be a function of the distance between the data points. We denote the distance between training data  $x_{i}$  and generated data  $\hat{x}_j$  as  $d_{ij}$ , for  $i\in [n]$  and  $j\in [m]$ .
+
+Definition 2.5 (Primary Contribution Score.) The contribution score of  $x_{i}$  to  $\hat{x}_j$  is denoted as  $\mathcal{V}(x_i, \hat{x}_j) \propto d_{ij}^{-1}$ , which is inversely proportional to distance since maximizing the log-likelihood of a generative model is equivalent to minimizing the dissimilarity of real and generated data distribution. To link the dissimilarity  $-d_{ij}$  to likelihood, we choose  $exp(-d_{ij})$  to likelihood
+
+$$
+\mathcal {V} \left(x _ {i}, \hat {x} _ {j}\right) = \frac {\exp \left(- d _ {i j}\right)}{\sum_ {i} \exp \left(- d _ {i j}\right)}. \tag {4}
+$$
+
+Therefore, an intuitive definition for the value of data sample  $x_{i}$  can be written as below.
+
+![](images/f20c5227fd38e1a3fe2c690d8d65a0bc99bb0b092b81f695df5483b38d5cf961.jpg)  
+Figure 2: Overview of GMVALUATOR, a unified and training-free data valuation approach for any generative models. GMVALUATOR contains three important modules - (1) Efficient Similarity Matching (ESM), (2) Image Quality Assessment, and (3) Value Calculation. Each generated data  $\hat{x}_j$  is matched with training data through ESM approach, resulting in the distances with its top  $k$  contributors. The normalized contribution score from training sample  $x_i$  to  $\hat{x}_j$ , defined as  $\exp(-d_{ij}) / \sum_i^k \exp(-d_{ij})$ , is adjusted based on the quality of the associated generated samples  $q_j$ . We compute the data value  $\phi_i$  of each training sample  $x_i$  by summing its contributions to the generated samples, where it ranks among the top  $k$  contributors.
+
+Definition 2.6 (Data Value.) The contribution of each training data point  $x_{i} \in S^{*}$  for the generation of dataset  $\hat{X}$  equals to the sum of its contributions to each generated data point  $\hat{x}_i$  in  $\hat{X}$ .
+
+$$
+\phi_ {i} = \sum_ {j = 1} ^ {m} \mathcal {V} \left(x _ {i}, \hat {x} _ {j}\right), x _ {i} \in X, \hat {x} _ {j} \in S ^ {*}. \tag {5}
+$$
+
+The high-value data will achieve a smaller distance to the target distributions, thus, a better approximation. Therefore, data valuation in the above problem formulation contains two steps: Step 1, calculating all of the score value  $\mathcal{V}(x_i,\hat{x}_j)$ ; Step 2, mapping the contribution from training data to generative data based on the scores  $\mathcal{V}$ .
+
+However, there are several open questions and challenges in performing the above two steps for calculating Eq. equation 5:
+
+Challenge 1: Efficiency. In step 1, considering  $n$  training samples and  $m$  generated samples, where  $\mathcal{O}(C)$  represents the complexity of the selected pair-wise distance calculation, the total complexity of this step amounts to  $\mathcal{O}(mnC)$ . In practical scenarios with large training datasets (e.g.,  $n > 10K$ ), the computation cost becomes prohibitively expensive. Additionally, fitting such a large collection of high-dimensional data for distance calculation can pose significant challenges in system memory.
+
+Challenge 2: Contribution plausibility. To ensure that a training data point contributes more if it is similar to high-quality generated data and less if it is similar to low-quality generated data, the contribution scores should be adjusted based on the quality of the generated data.
+
+Challenge 3: Non-zero scores. In practical scenarios, the distance between training data and the least similar generated data is not infinite, which may result in false non-zero contribution scores. With a large dataset size, the accumulation of these noisy scores yields biased data valuation.
+
+In light of this, we present a novel and efficient data valuation approach suitable for agnostic generative models, termed as GMVALUATOR as elaborated in Section 3.
+
+# 3 THE PROPOSED DATA VALUATION METHODS
+
+The crucial idea behind GMVALUATOR is to transform the data valuation problem into a similarity-matching problem between generated and training data. The overview of GMVALUATOR is presented in Figure 2. To tackle challenge 1, we propose to employ efficient similarity matching (ESM), where
+
+each generated data point can be linked to multiple contributors from the training dataset (Section 3.1). Each generated data firstly is linked with top  $k$  contributors via recall phase and then re-ranked by a refined similarity for effectiveness. After that, the image quality of the generated sample is assessed to weigh the valuation (Sec. 3.2). Finally, the value computation function combines both the quality score and the image-space similarity score to measure the value of the training data (Sec. 3.3).
+
+# 3.1 EFFICIENT SIMILARITY MATCHING
+
+Considering the complexity of calculating  $\mathcal{V}(x_i, \hat{x}_j)$ , we formulate it as an ESM problem between generative data and training data. Each generated data sample is matched to several training data samples based on their similarity. We denote  $\mathcal{P}_j = \{x_1, x_2, \dots, x_k\} = f(X, \hat{x}_j)$  as the subset of training data that contains the  $k \ll n$  most similar data samples. Here,  $f$  represents the similarity-matching strategy, encompassing the recall and re-ranking phases, which will be introduced subsequently.
+
+Recall Phase: The main aim of the recall phase is to rapidly identify a subset of training samples that are similar to a generated sample. To achieve this, an initial step involves encoding all original training images and generated samples from the image space  $R^C$  to a lower-dimensional embedding space  $R^D$  using an pre-trained encoder  $f_e$  (such as CLIP Radford et al. (2021)) to reduce computational complexity. Subsequently, the technique of Product Quantization (PQ) Jegou et al. (2010) is employed to further decrease the computational burden. Specifically, PQ divides embedding vectors into subvectors and independently quantizes each subvector through  $Q$ -means clustering. This process generates compact PQ codes that serve as representations of the original vectors. This representation significantly reduces the vector sizes, allowing for efficient estimation of Euclidean Distance between two samples. By incorporating the recall method into the similarity matching process, the computational complexity is lowered from  $\mathcal{O}(mnC)$  to  $\mathcal{O}(mQD)$ , where  $D \ll C$  and  $Q \ll n$ . Consequently, generated images can quickly identify their top-  $k$  most similar training data samples.
+
+Re-Ranking Phase: Following the PQ-based efficient recall process in GMVALUATOR, we further improve the precision of the results by utilizing perceptual similarity Fu et al. (2023) for precision ranking. Once we have extracted perceptual features from the top  $k$  recalled training samples, we proceed to calculate the distance for each pair of items. To obtain precise distance measurements based on their perceptual content, we propose to use Learned Perceptual Image Patch Similarity (LPIPS) Zhang et al. (2018) or DreamSim Fu et al. (2023) as the distance measurement  $d$  to gain insights into the perceptual dissimilarity between the generated sample and different training samples. These metrics enable us to precisely measure the most significant contributors according to their perceived similarity, more importantly, the obtained distance  $d$  will be employed to compute data valuation in Eq. equation 6. We do not use Wasserstein distance as it is more proper to measure dissimilarity between two probability distributions rather than a pair of image instances with semantic characteristics.
+
+# 3.2 IMAGE QUALITY ASSESSMENT
+
+To tackle challenge 2, we have to establish a connection between the quality of the generated sample that the training samples contribute to and the contribution score. This is necessary before assigning contribution scores to the ranked training samples for the generated sample. For low-quality generated samples  $\hat{x}_{\mathrm{low}}$ , we expect their total contribution score from contributors to be lower compared to high-quality samples  $\hat{x}_{\mathrm{high}}$ , namely  $\sum_{i\in [k]}\mathcal{V}(x_i,\hat{x}_{\mathrm{low}}) < \sum_{i\in [k]}\mathcal{V}(x_i,\hat{x}_{\mathrm{high}})$ . This motivation arises from the observations in Figure 3, where the first and second rows show generated samples using  $z$  from a normal distribution and uniform distribution, respectively. The values denoted in Figure 3 directly employs Eq equation 4, so we have  $\sum_{x_i\in \mathcal{P}}\mathcal{V}(x_i,\hat{x}) = 1$  for  $\forall \hat{x}\in \hat{X}$ . The real samples are noticeably dissimilar to the generated data, yet they are still assigned a high value.
+
+Therefore, we propose to calibrate the contribution scores with the generated data quality. Specifically, we obtain a comprehensive quality score  $q_{j} \in [0,1]$  for each generated image integrated using MANIQA Yang et al. (2022) model into our evaluation process. A higher  $q_{j}$  indicates better data quality. This score of MANIQA considers various factors such as sharpness, color accuracy, composition, and overall visual appeal. We also provide the necessity of this calibration in the appendix I. Incorporating the image quality evaluation provided by MANIQA allows us to more
+
+![](images/ec2ed138031c9860d69788d68ea6c146ee9072e94d9fbf716a770d057ee17ebe.jpg)  
+Figure 3: The value without generated image quality calibration for q high-quality image (top row) and a low-quality image (bottom row). Column 1: generated images. Column 2-5:their top 4 contributors.
+
+accurately assess the generated images and take into account their perceptual fidelity and aesthetic qualities.
+
+# 3.3 VALUE CALCULATION
+
+Finally, we utilize the image quality  $q$  to calibrate the contribution scores. Notably, during the recall phase of similarity matching, we select the top  $k$  contributors  $\mathcal{P}_j$  for the generated data  $\hat{x}_j$ . Consequently, we only consider the contribution score between  $\mathcal{P}_j$  and  $\hat{x}_j$  by setting  $\mathcal{V}(x_i, \hat{x}_j) = 0$  for  $x_i \notin \mathcal{P}_j$ . This strategy addresses challenge 3 by assigning zero scores to irrelevant samples, effectively reducing bias and noise in value estimation when dealing with a large  $n$ . Hence, we define the contribution score of each training data point for a specific synthetic data point as follows:
+
+$$
+\mathcal {V} \left(x _ {i}, \hat {x} _ {j}, d _ {i j}, q _ {j}\right) = \left\{ \begin{array}{l l} q _ {j} \cdot \frac {\exp (- d _ {i j})}{\sum_ {i = 1} ^ {k} \exp (- d _ {i j})} & x _ {i} \in \mathcal {P} _ {j} \\ 0 & x _ {i} \notin \mathcal {P} _ {j} \end{array} \right. \tag {6}
+$$
+
+which is used to give different scores to training data points according to their ranking distance. The final data value is obtained by plugging Eq. 6 into Eq. 5.
+
+# 4 EXPERIMENTS
+
+# 4.1 EXPERIMENT SETUP
+
+Datasets. Our experiment settings are listed in Table 1. Particularly, we consider different types of generative models, including GAN based models,  $\beta$ -VAE Higgins et al. (2016), and diffusion models Ho & Salimans (2022); Wang et al. (2022). The generation tasks are conducted on benchmark datasets (i.e., MNIST LeCun et al. (1998) and CIFAR Krizhevsky et al. (2009)), face recognition dataset (i.e., CelebA Liu et al. (2018)), high-resolution image dataset with size  $512 \times 512$ , and  $1024 \times 1024$  (i.e., AFHQ Choi et al. (2020), FFHQ Karras et al. (2019)), the large-scale dataset with 1,000 classes and 14,197,122 images (i.e., ImageNet Deng et al. (2009)), and text-to-image dataset (i.e., Naruto Cervenka (2022)).
+
+Table 1: Evaluation Setup.  
+
+<table><tr><td></td><td>Dataset</td><td>Network</td></tr><tr><td rowspan="2">C1</td><td>MNIST, CIFAR-10</td><td>GAN, Diffusion Models, β-VAE</td></tr><tr><td>ImageNet</td><td>Masked Diffusion Transformer Gao et al. (2023)</td></tr><tr><td rowspan="3">C2</td><td>CelebA</td><td>Diffusion-StyleGAN</td></tr><tr><td>AFHQ, FFHQ</td><td>StyleGAN</td></tr><tr><td>Naruto</td><td>Stable Diffusion</td></tr><tr><td>C3</td><td>MNIST</td><td>DCGAN</td></tr><tr><td>C4</td><td colspan="2">Hardware Evironment</td></tr><tr><td>GPU</td><td colspan="2">One RTX 3080 (10GB) GPU</td></tr><tr><td>CPU</td><td colspan="2">12 vCPU Intel(R) Xeon(R), 
+Platinum 8255C CPU @ 2.50GHz</td></tr></table>
+
+Baselines. Note that GMVALUATOR is a model-agnostic method. To showcase its efficacy, we compare it with two baseline methods: VAE-TracIn Kong & Chaudhuri (2021) and IF4GAN Terashita et al. (2021). VAE-TracIn identifies the most significant contributors for a generated sample, which is the same as the similarity matching process of GMVALUATOR (Sec. 3.1). Thus, we compare GMVALUATOR with VAE-TracIn in Sec. 4.3 and Sec. 4.4. IF4GAN finds the high-valued training samples for generative model training, which we regard it as the baseline method in section 4.5. We also examine our approach using DreamSim, LPIPS and  $l_{2}$ -distance in the re-ranking phase, referred to as GMValuator (DreamSim), GMValuator (LPIPS) and GMValuator ( $l_{2}$ -distance) respectively, while the GMValuator without the re-ranking phase is referred to as GMValuator (No-Rerank).
+
+**Embedding Approach.** In this experiment, we utilize CLIP as an example choice for a pre-trained encoder  $f_{e}$  in the recall phase of efficient similarity matching. To demonstrate the generalizability of GMVALUATOR, we also do experiments using more embedding approaches in Sec. G of the appendix.
+
+# 4.2 METRICS
+
+Given the absence of a definitive benchmark to evaluate data valuation methods in the context of generative models, we propose to evaluate the truthfulness of data valuation outcomes through the examination of four criteria (C):
+
+- C1: Identical Class Test. Following the concept of an identical class Hanawa et al. (2020), we posit that the most significant contributors among the training samples should belong to the same class as the generated sample produced by a well-trained generative model, which is also used for evaluation in VAE-TrancIn Kong & Chaudhuri (2021).  
+- C2: Identical Attributes Test. Following C1, we extend the concept of identical class test and consider the attributes of samples as the ground truth to examine the most significant contributors by our approach on datasets without class labels. We examine the overlap level of attributes (i.e., the number of identical attributes) between the most significant training samples with the generated sample.  
+- C3: Out of Distribution Detection. Under the assumption, the out of distribution training data samples (e.g., noisy samples) can be identified as low-contribution training samples for the generated dataset. To evaluate the performance of data valuation approaches, we consider the contribution level of noisy data samples as the performance metric across various approaches.  
+- C4: Efficiency. As an efficient training-free approach, GMVALUATOR should measure the data value in a limited time and be much more efficient than the previous work while obtaining truthful results.
+
+# 4.3 IDENTICAL CLASS TEST (C1)
+
+Methodology. In this subsection, we follow setup of VAE-TracIn Kong & Chaudhuri (2021) by training separate  $\beta$ -VAE models on MNIST Krizhevsky et al. (2009), CIFAR LeCun et al. (1998). We then attribute the most significant contributors by VAE-TracIn and our approach over generated samples. By the concept of identical class test, we expect a perfect data valuation approach should indicate training data in the same subclass of the generated sample  $\hat{x}_j$  contribute more to  $\hat{x}_j$ . We examine GMVALUATOR (DreamSim), GMVALUATOR (LPIPS), GMValuator ( $l_2$ -distance) and GMVALUATOR (No-Rerank) separately. In addition to using VAE and comparing it with the baseline method, we also perform experiments using masked diffusion transformer on the large-scale dataset (ImageNet) and other various generative models (in the appendix) to demonstrate the model-agnostic property of GMVALUATOR.
+
+Results. For a given generated data, we examine the class(es) of is top  $k$  contributors in the training data. We count the number of training  $Q$  samples in the top  $k$  contributors, which have the identical class as the generated data. The identical class ratio  $\rho = Q / k$ . We report the averaged  $\rho$  over the generated datasets (the data size  $m = 100$ ) on different choices of  $k$  in Table 2. GMVALUATOR has the most contributors that belong to the same class with the generated sample among on MNIST and CIFAR-10, while GMVALUATOR (DreamSim) has the best performance. The results for CIFAR-10 using VAE-TracIn are extremely bad. This could be attributed to underfitting, as the authors mentioned in their study Kong & Chaudhuri (2021), training a good  $\beta$ -VAE model on CIFAR-10 is challenging. In addition, GMVALUATOR (DreamSim) shows a significant advantage on ImageNet since it considers semantic characteristics while  $l_{2}$ -distance or LPIPS destroy the performance, while the experiments conducted on ImageNet using baseline method (VAE-TracIn) is impractical due to
+
+its unacceptable computational overhead. In the appendix, further analysis and explanation for this phenomenon are discussed and the results from various generative models are presented as well.
+
+Table 2: Performance comparison of Identical Class Test (C1).  
+
+<table><tr><td rowspan="2">Top-k</td><td colspan="3">MNIST (%)</td><td colspan="3">CIFAR-10 (%)</td><td colspan="3">ImageNet (%)</td></tr><tr><td>k=30</td><td>k=50</td><td>k=100</td><td>k=30</td><td>k=50</td><td>k=100</td><td>k=30</td><td>k=50</td><td>k=100</td></tr><tr><td>VAE-TracIn</td><td>72.00</td><td>71.11</td><td>68.58</td><td>6.28</td><td>3.77</td><td>1.88</td><td>-</td><td>-</td><td>-</td></tr><tr><td>GMValuator (No-Rerank)</td><td>86.41</td><td>85.13</td><td>85.95</td><td>72.66</td><td>72.25</td><td>70.71</td><td>56.18</td><td>53.60</td><td>48.17</td></tr><tr><td>GMValuator (l2-distance)</td><td>87.76</td><td>86.95</td><td>85.92</td><td>72.66</td><td>72.25</td><td>70.71</td><td>42.44</td><td>40.51</td><td>39.00</td></tr><tr><td>GMValuator (LPIPS)</td><td>88.78</td><td>88.19</td><td>86.69</td><td>72.60</td><td>71.75</td><td>70.84</td><td>50.30</td><td>47.51</td><td>45.13</td></tr><tr><td>GMValuator (DreamSim)</td><td>88.78</td><td>88.05</td><td>86.84</td><td>77.94</td><td>76.41</td><td>73.47</td><td>77.27</td><td>70.90</td><td>58.89</td></tr></table>
+
+# 4.4 IDENTICAL ATTRIBUTES TEST (C2)
+
+Methodology. In extension to C1, we focus on certain image attributes instead of class labels as the ground truth. We posit that the most significant contributors to a generated sample should share similar attributes with it. We train Diffusion-StyleGAN Wang et al. (2022) on CelebA, and leverage our approach to identify the most significant contributors in training samples and use some attributes including hat, gender, and eyeglasses as the ground truth, to check the correctness of our approach for identifying the most significant contributors for a generated sample. We also examine this on AFHQ, FFHQ dataset by StyleGAN Choi et al. (2020), and text-to-image dataset Naruto Cervenka (2022) by stable diffusion model Rombach et al. (2022).
+
+Results. The results in Table 3 indicate that GMVALUATOR can find the most significant contributors with the same attributes to the generated sample. Besides, using DreamSim in the similarity re-ranking phase obtains the best performance over these three attributes. We also visualize some visible results in Figure 4 on CelebA, and AFHQ, FFHQ in the appendix. As we can see, the most significant contributors have similar attributes (e.g., skin color, hair) to the generated sample. Similarly, the visualized results on AFHQ and FFHQ shown in the appendix demonstrate that the top  $k$  contributors have similar attributes to the generated sample such as the fur color of cats or dogs in AFHQ or hair color in FFHQ. In addition, the results on the text-to-image dataset Naruto Cervenka (2022) corroborate the same conclusion, as shown in the appendix N.
+
+Table 3: Performance of Identical Attributes Test (C2) of some attributes including Hat, Gender, and Eyeglasses on CelebA.  
+
+<table><tr><td>Attribute (%)</td><td colspan="3">Hat</td><td colspan="3">Gender</td><td colspan="3">Eyeglasses</td></tr><tr><td>Top K contributors:</td><td>k=5</td><td>k=10</td><td>k=15</td><td>k=5</td><td>k=10</td><td>k=15</td><td>k=5</td><td>k=10</td><td>k=15</td></tr><tr><td>GMValuator (No-Rerank)</td><td>92.52</td><td>92.12</td><td>91.92</td><td>75.15</td><td>75.25</td><td>75.82</td><td>91.52</td><td>91.52</td><td>91.45</td></tr><tr><td>GMValuator (l2-distance)</td><td>90.91</td><td>89.90</td><td>89.83</td><td>63.64</td><td>61.01</td><td>60.00</td><td>94.95</td><td>94.65</td><td>93.80</td></tr><tr><td>GMValuator (LPIPS)</td><td>96.77</td><td>96.57</td><td>96.90</td><td>97.98</td><td>97.48</td><td>97.37</td><td>94.95</td><td>94.65</td><td>93.80</td></tr><tr><td>GMValuator (DreamSim)</td><td>97.78</td><td>97.07</td><td>96.90</td><td>99.19</td><td>98.99</td><td>98.79</td><td>96.77</td><td>96.26</td><td>95.96</td></tr></table>
+
+![](images/f5ac14551df087696a4d5eb19bd9cf6b5e621755f3456d4bfe449ffbba82d893.jpg)  
+Figure 4: Visualization of Identical Attributes Test on CelebA. Left: generated samples. Right: top  $k$  contributors.
+
+![](images/ab5c095e862f86a3ba5583fad4d0da90b23384f80847eef33dc8f850b4ac3ee9.jpg)  
+Figure 5: The  $y$ -axis represents the ranking of values from high to low, with the top being the highest value and the bottom being the lowest value. The  $x$ -axis represents the index of each noisy data.
+
+# 4.5 OUT OF DISTRIBUTION DETECTION (C3)
+
+Methodology In this experiment, we introduce 100 noisy images into the MNIST dataset to create a new corrupted training dataset and each noisy image is generated by adding Gaussian noise to the clean data. These contaminated samples can diminish the performance of generative models, and as a result, they are anticipated to possess lower values compared to the rest of the training dataset. Our objective is to assess the performance of both GMVALUATOR and its baseline method, IF4GAN Terashita et al. (2021), by analyzing the value rankings of noisy samples. An effective approach should place noisy data in lower positions within the value ranking. We conducted this evaluation using 10,000 generated images and referred to the study Terashita et al. (2021) for the baseline method (IF4GAN).
+
+Results. The results depicted in Figure 5 demonstrate that the values of all noisy training samples, as calculated by GMValuator, are lower compared to the values calculated by IF4GAN. This observation suggests that the performance of GMVALUATOR is significantly better than that of IF4GAN. Besides, the performance of GMVALUATOR with the re-ranking phase is better than GMVALUATOR (No-erank).
+
+# 4.6 EFFICIENCY (C4)
+
+Methodology. We thoroughly evaluate and compare the efficiency of our approach against existing data valuation methods for generative models discussed above: VAE-TracIn and IF4GAN. Specifically, we measure the attribute time for one generated sample on an average of 100 test samples using both VAE-TracIn and our proposed approach on MNIST and CIFAR-10. Furthermore, under the same setting in C3, we assess the data valuation time when utilizing IF4GAN and our approaches on noise MNIST which we mentioned in C3. In addition, we analyze our computational efficiency as the data scale grows in the appendix O.
+
+Results. The average time taken to attribute the most significant contributors for one generated sample is calculated and compared with the baseline method (VAE-TracIn), as demonstrated in Table 4. Our approaches are all greatly more efficient than the baseline methods on both datasets. When it comes to data valuation time for GAN on C3, GMVALUATOR (No-erank) and GMVALUATOR (LPIPS) are significantly better than IF4GAN. The aforementioned phenomenon is attributed to the costly nature of the Hessian estimation process, despite the utilization of certain acceleration methods. It is noticeable that GMVALUATOR (DreamSim) is lightly time-consuming when compared to IF4GAN. This lead to a trade-off problem due to the GMVALUATOR using DreamSim in the re-ranking phase obtained the better performance from C1 to C3.
+
+Overall, through the above experiments, GMVALUATOR outperforms than baseline methods, while GMVALUATOR (DreamSim) obtains the best performance. This is due to the fact that DreamSim captures mid-level similarities in image semantic content and layout compared to LPIPS. And the selection of different GMVALUATORS can be combined with the consideration of their efficiency. Furthermore, the results shown in the appendix O also demonstrate that our method maintains consistent computational efficiency even as the data scale increases and presents its scalability on large-scale datasets.
+
+Table 4: Efficiency Comparison  
+
+<table><tr><td rowspan="2">Attribute for VAE</td><td rowspan="2">VAE-TracIn</td><td colspan="4">GMValuator</td></tr><tr><td>No-Rerank</td><td>l2-distance</td><td>LPIPS</td><td>DreamSim</td></tr><tr><td>MNIST</td><td>47.945</td><td>0.250</td><td>0.339</td><td>0.477</td><td>1.709</td></tr><tr><td>CIFAR-10</td><td>66.178</td><td>0.755</td><td>1.226</td><td>2.412</td><td>15.491</td></tr><tr><td rowspan="2">Data Valuation for GAN</td><td rowspan="2">IF4GAN</td><td colspan="4">GMValuator</td></tr><tr><td>No-Rerank</td><td>l2-distance</td><td>LPIPS</td><td>DreamSim</td></tr><tr><td>Noise MNIST</td><td>14,543</td><td>2,137</td><td>3,388</td><td>4,771</td><td>17,086</td></tr></table>
+
+# 5 CONCLUSION
+
+To measure the contribution of each training data sample, we propose an efficient approach, GMVALUATOR, for generative model. As far as we are aware, there is no prior model-agnostic and training-free data valuation approach for generative models until GMVALUATOR. Our approach is based on efficient similarity matching, and it enables us to calculate the final value of each training data point, aligning with plausible assumptions. The proposed method is validated through a series of comprehensive experiments to showcase its truthfulness and efficacy on four criteria. In the future, we will validate the proposed methods on other data modalities.
+
+# 6 ACKNOWLEDGEMENT
+
+This work is supported in part by Natural Science and Engineering Research Council of Canada (NSERC), Canada CIFAR AI Chairs program, Canada Research Chair program, MITACS-CIFAR Catalyst Grant Program, the Digital Research Alliance of Canada, Institute of Information & communications Technology Planning & Evaluation (IITP) grant funded by the Korea government (MSIT).
+
+# REFERENCES
+
+Juhan Bae, Nathan Ng, Alston Lo, Marzyeh Ghassemi, and Roger B Grosse. If influence functions are the answer, then what is the question? Advances in Neural Information Processing Systems, 35:17953-17967, 2022.  
+Eyal Betzalel, Coby Penso, Aviv Navon, and Ethan Fetaya. A study on the evaluation of generative models. arXiv preprint arXiv:2206.10935, 2022.  
+Akhilan Boopathy, Kevin Liu, Jaedong Hwang, Shu Ge, Asaad Mohammedsaleh, and Ila R Fiete. Model-agnostic measure of generalization difficulty. In International Conference on Machine Learning, pp. 2857-2884. PMLR, 2023.  
+Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv preprint arXiv:1809.11096, 2018.  
+Eole Cervenka. Naruto blip captions. https://huggingface.co/datasets/lambdalabs/naruto-blip-captions/, 2022.  
+Yunjey Choi, Youngjung Uh, Jaejun Yoo, and Jung-Woo Ha. Stargan v2: Diverse image synthesis for multiple domains. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 8188-8197, 2020.  
+R Dennis Cook. Detection of influential observation in linear regression. Technometrics, 19(1):15-18, 1977.  
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248-255. IEEE, 2009.  
+Prafulla Dhariwal and Alexander Nichol. Diffusion models beat gans on image synthesis. Advances in neural information processing systems, 34:8780-8794, 2021.  
+Stephanie Fu, Netanel Tamir, Shobhita Sundaram, Lucy Chai, Richard Zhang, Tali Dekel, and Phillip Isola. Dreamsim: Learning new dimensions of human visual similarity using synthetic data. arXiv preprint arXiv:2306.09344, 2023.  
+Shanghua Gao, Pan Zhou, Ming-Ming Cheng, and Shuicheng Yan. Masked diffusion transformer is a strong image synthesizer. arXiv preprint arXiv:2303.14389, 2023.  
+Amirata Ghorbani and James Zou. Data shapley: Equitable valuation of data for machine learning. In International Conference on Machine Learning, pp. 2242-2251. PMLR, 2019.  
+Amirata Ghorbani, Michael Kim, and James Zou. A distributional framework for data valuation. In International Conference on Machine Learning, pp. 3535-3544. PMLR, 2020.  
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial networks. Communications of the ACM, 63(11):139-144, 2020.  
+Kazuaki Hanawa, Sho Yokoi, Satoshi Hara, and Kentaro Inui. Evaluation of similarity-based explanations. arXiv preprint arXiv:2006.04528, 2020.  
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. Advances in neural information processing systems, 30, 2017.
+
+Irina Higgins, Loic Matthew, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. In International conference on learning representations, 2016.  
+Jonathan Ho and Tim Salimans. Classifier-free diffusion guidance. arXiv preprint arXiv:2207.12598, 2022.  
+Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Advances in Neural Information Processing Systems, 33:6840-6851, 2020.  
+Herve Jegou, Matthijs Douze, and Cordelia Schmid. Product quantization for nearest neighbor search. IEEE transactions on pattern analysis and machine intelligence, 33(1):117-128, 2010.  
+Ruoxi Jia, David Dao, Boxin Wang, Frances Ann Hubis, Nezihe Merve Gurel, Bo Li, Ce Zhang, Costas J Spanos, and Dawn Song. Efficient task-specific data valuation for nearest neighbor algorithms. arXiv preprint arXiv:1908.08619, 2019a.  
+Ruoxi Jia, David Dao, Boxin Wang, Frances Ann Hubis, Nick Hynes, Nezihe Merve Gürel, Bo Li, Ce Zhang, Dawn Song, and Costas J Spanos. Towards efficient data valuation based on the shapley value. In The 22nd International Conference on Artificial Intelligence and Statistics, pp. 1167-1176. PMLR, 2019b.  
+Hoang Anh Just, Feiyang Kang, Jiachen T Wang, Yi Zeng, Myeongseob Ko, Ming Jin, and Ruoxi Jia. Lava: Data valuation without pre-specified learning algorithms. arXiv preprint arXiv:2305.00054, 2023.  
+Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 4401-4410, 2019.  
+Tero Karras, Samuli Laine, Miika Aittala, Janne Hellsten, Jaakko Lehtinen, and Timo Aila. Analyzing and improving the image quality of stylegan. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 8110-8119, 2020.  
+Zhifeng Kong and Kamalika Chaudhuri. Understanding instance-based interpretability of variational auto-encoders. Advances in Neural Information Processing Systems, 34:2400-2412, 2021.  
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.  
+Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278-2324, 1998.  
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaou Tang. Large-scale celebfaces attributes (celeba) dataset. Retrieved August, 15(2018):11, 2018.  
+Ki Nohyun, Hoyong Choi, and Hye Won Chung. Data valuation without training of a model. In The Eleventh International Conference on Learning Representations, 2022.  
+Jian Pei. A survey on data pricing: from economics to data science. IEEE Transactions on knowledge and Data Engineering, 34(10):4586-4608, 2020.  
+Gabriel Peyre, Marco Cuturi, et al. Computational optimal transport: With applications to data science. Foundations and Trends® in Machine Learning, 11(5-6):355-607, 2019.  
+Garima Pruthi, Frederick Liu, Satyen Kale, and Mukund Sundararajan. Estimating training data influence by tracing gradient descent. Advances in Neural Information Processing Systems, 33: 19920-19930, 2020.  
+Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International conference on machine learning, pp. 8748-8763. PMLR, 2021.  
+Protection Regulation. General data protection regulation. Intouch, 25, 2018.
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In International conference on machine learning, pp. 1278-1286. PMLR, 2014.  
+Adam Richardson, Aris Filos-Ratsikas, and Boi Faltings. Rewarding high-quality data via influence functions. arXiv preprint arXiv:1908.11598, 2019.  
+Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. High-resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10684-10695, 2022.  
+Nikunj Saunshi, Arushi Gupta, Mark Braverman, and Sanjeev Arora. Understanding influence functions and datamodels via harmonic analysis. arXiv preprint arXiv:2210.01072, 2022.  
+Naoyuki Terashita, Hiroki Ohashi, Yuichi Nonaka, and Takashi Kanemaru. Influence estimation for generative adversarial networks. arXiv preprint arXiv:2101.08367, 2021.  
+Laurens Van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 9(11), 2008.  
+Jiachen T Wang and Ruoxi Jia. Data banzhaf: A robust data valuation framework for machine learning. In International Conference on Artificial Intelligence and Statistics, pp. 6388-6421. PMLR, 2023.  
+Zhendong Wang, Huangjie Zheng, Pengcheng He, Weizhu Chen, and Mingyuan Zhou. Diffusion-gan: Training gans with diffusion. arXiv preprint arXiv:2206.02262, 2022.  
+Zhaoxuan Wu, Yao Shu, and Bryan Kian Hsiang Low. Davinz: Data valuation using deep neural networks at initialization. In International Conference on Machine Learning, pp. 24150-24176. PMLR, 2022.  
+Xinyi Xu, Zhaoxuan Wu, Chuan Sheng Foo, and Bryan Kian Hsiang Low. Validation free and replication robust volume-based data valuation. Advances in Neural Information Processing Systems, 34:10837-10848, 2021.  
+Sidi Yang, Tianhe Wu, Shuwei Shi, Shanshan Lao, Yuan Gong, Mingdeng Cao, Jiahao Wang, and Yujiu Yang. Maniaq: Multi-dimension attention network for no-reference image quality assessment. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1191-1200, 2022.  
+Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 586-595, 2018.
+
+# CONTENTS
+
+1 Introduction 1  
+2 Motivation and Problem Formulation 3
+
+2.1 Motivations 3
+
+2.1.1 Theoretical Justification 3  
+2.1.2 Empirical Validation 4
+
+2.2 Problem Formulation and Challenges 4
+
+3 The Proposed Data Valuation Methods 5
+
+3.1 Efficient Similarity Matching 6  
+3.2 Image Quality Assessment 6  
+3.3 Value Calculation 7
+
+4 Experiments 7
+
+4.1 Experiment Setup 7  
+4.2 Metrics 8  
+4.3 Identical Class Test (C1) 8  
+4.4 Identical Attributes Test (C2) 9  
+4.5 Out of Distribution Detection (C3) 10  
+4.6 Efficiency (C4) 10
+
+5 Conclusion 10  
+6 Acknowledgement 11
+
+Appendix 14
+
+A Notation 16  
+B Algorithm 16  
+C Related Work 16
+
+C.1 Data Valuation 16  
+C.2 Generative Model 17
+
+D Statistical Results for Figure 1 18  
+E Additional Results on C1 and C2 19
+
+E.1 (C1) Identical Class Test on Other Generative Models 19  
+E.2 (C2) Identical Attributes Test on CelebA 19  
+E.3 (C2) Identical Attributes Test on Other Datasets 20
+
+F Different Generated Data Sizes 21
+
+G Alternative Embedding Approaches 21
+
+H Alternative Distance Metric 21
+
+I Necessity for calibration 21
+
+J Additional Experimental Details 22
+
+J.1 Justification of Experiment Setup 22  
+J.2 Datasets 23  
+J.3 Architecture of Generative models 23
+
+K Discussion on the Possible Applications 24  
+L Current Limitation and Future Directions 24  
+M Omitted proofs 24  
+N Experiment on Text to Image generation Model (Stable Diffusion) 26  
+O Efficiency with Increased Data Size 26  
+P Impact of quantization recall 26
+
+Roadmap of Appendix. In this appendix, we provide a concise summary of key notations and Algorithm 1, detailing the pipeline of GMValuator in Sec. A and Sec. B. A more comprehensive review of related work is also provided in Sec. C. Additionally, Sec. D contains detailed statistical analysis for the results depicted in Figure 1. Our main text focuses on experiments conducted on benchmark datasets such as MNIST and CIFAR-10, along with a large-scale dataset, ImageNet, to evaluate the most significant contributors found by GMVALUATOR are in the same class as the generated sample (C1). In Sec. E, we extend the evaluation of GMVALUATOR to other generative models for C1. Additionally, we expand our evaluation using C2 by considering the ground truth of multiple combined attributes. We operate under the assumption that the most significant contributors to a generated sample should exhibit similar attributes in the images. For a more thorough validation of the effectiveness of GMVALUATOR, high-resolution datasets like AFHQ and FFHQ are also employed for C2. The appendix includes additional experimental insights such as ablation studies, alternative embedding approaches, alternative distance metrics, calibration and further experimental details in Sec. F, H, I and J, respectively. The potential applications, limitations and future directions are also provided in Sec. K and Sec. L. Lastly, we present the proof of our theorem and ensure the reproducibility of our experiments.
+
+Table 5: Some important notations in Sec. 2  
+
+<table><tr><td>Notations</td><td>Description</td></tr><tr><td>μ</td><td>the distribution of the subset of the training data</td></tr><tr><td>μT</td><td>a subset of the contributors</td></tr><tr><td>G</td><td>generative model</td></tr><tr><td>G*</td><td>well-trained generative model</td></tr><tr><td>Z</td><td>noise distribution</td></tr><tr><td>z</td><td>a latent sample in the latent space</td></tr><tr><td>d(·,·)</td><td>distance function</td></tr><tr><td>X, x</td><td>training dataset, training sample</td></tr><tr><td>X̂, x̂</td><td>generated dataset, generated sample</td></tr><tr><td>S</td><td>a subset of the training data</td></tr><tr><td>S*</td><td>the real K contributors</td></tr><tr><td>K</td><td>K = |S*|</td></tr><tr><td>T</td><td>K contributors found by a data valuator</td></tr><tr><td>A</td><td>attribute space</td></tr><tr><td>X</td><td>data distribution</td></tr><tr><td>L</td><td>loss function</td></tr><tr><td>f, f&#x27;S*</td><td>labeling function, model trained on S*</td></tr></table>
+
+# A NOTATION
+
+To make motivation and problem formulation clear, we list some significant notations from Sec. 2 in Table 5.
+
+# B ALGORITHM
+
+To better introduce GMVALUTOR, the pseudocode is shown in Algorithm 1.
+
+# C RELATED WORK
+
+# C.1 DATA VALUATION
+
+There are three lines of methods on data valuation: metric-based methods, influence-based methods and data-driven methods. In terms of metric-based methods, the commonly-used approach is to calculate its marginal contribution (MC) based on performance metrics (e.g., accuracy, loss). As the basic method depending on performance metrics for data valuation, LOO (Leave-One-Out) Cook (1977) is used to evaluate the value of the training sample by observational change
+
+Algorithm 1 GMVALUATOR  
+Input: Training dataset  $X = \{x_{i}\}_{i=1}^{n}$ , a well-trained model  $G^{*}$ , random distribution  $\mathcal{Z}$ .  
+Output: Generated dataset  $\hat{X}$ , the value of training data  
+points  $\Phi = \{\phi_{1},\phi_{2},\dots,\phi_{n}\}$   
+1:  $\hat{X} = \{\hat{x}_j\}_{j=1}^m \gets G^*(z_j)$ , for  $z_j \in \mathcal{Z}$  // Generate the synthetic dataset  
+2: for  $\hat{x}_j$  in  $\hat{X}$  do  
+3: // Matching process (see Sec. 3.1)  
+4:  $\mathcal{P}_j = f(X,\hat{x}_j)$  // Including two phases  
+5: for  $x_i$  in  $\mathcal{P}_j$  do  
+6:  $d_{ij} \gets \text{DreamSim}(x_i,\hat{x}_j)$  or others  
+7: end for  
+8:  $q_j = MANIQA(\hat{x}_j)$  // Image Quality Assessment (see Sec. 3.2)  
+9: Calculate score  $\mathcal{V}(x_i,\hat{x}_j,d_{ij},q_j)$  using Eq. equation 6 // Contribution Score Calculation (see Sec. 3.3)  
+10: end for  
+11: // Calculation of data value and return the result  $\Phi$   
+12: for  $x_i$  in  $X$  do  
+13: Calculate  $x_i$ 's value  $\phi_i$  using Eq.equation 5  
+14: end for  
+15: return  $\Phi = \{\phi_1,\phi_2,\dots,\phi_n\}$
+
+of model performance when leaving out that data point from the training dataset. To overcome inaccuracy and strict desirability of LOO, SV Ghorbani & Zou (2019) and BI Wang & Jia (2023) originated from Cooperative Game Theory are widely used to measure the contribution of data Jia et al. (2019b); Ghorbani et al. (2020). Considering the joining sequence of each training data point, SV needs to calculate the marginal performance of all possible subsets in which the time complexity is exponential. Despite the introduction of techniques such as Monte-Carlo and gradient-based methods, as well as others proposed in the literature, approximating data significance value (SV) is computationally expensive and it typically requires retraining Ghorbani & Zou (2019); Jia et al. (2019a). The computational cost and need for unconventional performance metrics present difficulties in adapting the methods to generative models. As for influence-based methods, they evaluate the influence of data points on model parameters by computing the inverse Hessian for data valuation Jia et al. (2019a); Richardson et al. (2019); Saunshi et al. (2022). Due to the high computational cost, some approximation methods have also been proposed Pruthi et al. (2020). In addition, the use of influence function for data valuation is not limited to discriminative models, but can also be applied to specific generative models such as GAN and VAE Terashita et al. (2021); Kong & Chaudhuri (2021). When it comes to data-driven methods, most of them are training-free methods that focus on the data itself Xu et al. (2021); Wu et al. (2022); Just et al. (2023). Additionally, the Information-Theoretic Measures method Boopathy et al. (2023) evaluates the inherent generalization difficulty of tasks and shows potential for adaptation to data valuation. However, it is not applicable to our specific setting due to its reliance on performance metrics, training requirements, and a focus on dataset-level trends.
+
+# C.2 GENERATIVE MODEL
+
+Generative models are a type of unsupervised learning that can learn data distributions. Recently, there has been significant interest in combining generative models with neural networks to create Deep Generative Models, which are particularly useful for complex, high-dimensional data distributions. They can approximate the likelihood of each observation and generate new synthetic data by incorporating variations. Variational auto-encoders (VAEs) Rezende et al. (2014) optimize the log-likelihood of data by maximizing the evidence lower bound (ELBO), while generative adversarial networks (GANs) Goodfellow et al. (2020); Karras et al. (2020) involves a generator and discriminator that compete with each other, resulting in strong image generation. Recently proposed diffusion models Ho et al. (2020); Rombach et al. (2022) add Gaussian noise to training data and learn to recover the original data. These models use variational inference and have a fixed procedure with a high-dimensional latent space.
+
+$$
+\begin{array}{r} H _ {0} \colon \phi (D _ {i}, S, \mu_ {i}) \geq \phi (D _ {j}, S, \mu_ {i}) \\ H _ {1} \colon \phi (X _ {i}, S, \mu_ {i}) <   \phi (X _ {j}, S, \mu_ {i}), i \in X _ {v 1}, j \in X _ {v 2} \end{array}
+$$
+
+Table 6: The statistic test of data values of  $X_{v1}$  versus  $X_{v2}$  using different generative models.  $X_{v1}$  is supposed to have higher value than  $X_{v2}$ , given the generated data.  
+
+<table><tr><td></td><td>BigGAN</td><td>Classifier-free Guidance Diffusion</td></tr><tr><td>Average value (v1)</td><td>0.319654</td><td>0.030434</td></tr><tr><td>Average value (v2)</td><td>1.632352</td><td>0.369565</td></tr><tr><td>P-value</td><td>6.937027 × 10-68</td><td>8.053195 × 10-55</td></tr><tr><td>T-statistic</td><td>17.924512</td><td>15.947860</td></tr><tr><td>Significance level</td><td>0.01</td><td>0.01</td></tr><tr><td>Result</td><td>p-value less than 0.01, reject H0, value of v2 less than v1 averagely</td><td>p-value less than 0.01, reject H0, value of v2 less than v1 averagely</td></tr></table>
+
+# D STATISTICAL RESULTS FOR FIGURE 1
+
+It is evident by visualization in Figure 1 that the data points in  $X_{v2}$  (used for training) are more overlapped with generated data than data points in  $X_{v1}$  (not used for training). We perform statistic testing on data values obtained by GMVALUATOR, to examine if data points  $X_{v2}$  (used for training) have significantly higher values than those of the data points in  $X_{v1}$  (not used for training).
+
+To this end, we use a t-test with the null hypothesis that data values in  $X_{v1}$  should not be smaller than those of  $X_{v12}$ . We compute  $p$ -value, which is the probability of getting a difference as large as we observed, or larger, under the null hypothesis. If the  $p$ -value is very low, we reject the null hypothesis and consider our approach, GMVALUATOR, to be verified with a high level of confidence (1-p). Typically, a  $p$ -value smaller than significance level 0.01 is used as a threshold for rejecting the null hypothesis. Table 6 showcases the outcomes of  $X_{v1}$  and  $X_{v2}$  in CIFAR-10 with  $p \ll 0.01$  for both BigGAN and diffusion model, indicating that the data points in  $X_{v2}$  have significantly more value than those in  $X_{v1}$ . Consequently, these findings align with the presumption that the trained dataset  $X_{v2}$  has a higher value than the untrained dataset  $X_{v1}$  and verify our approach.
+
+![](images/e17e514887bb5e01cbab18d4e6bd8fe1afde99a85ac33fd7e23a2b4e95ef7055.jpg)  
+Figure 6: Visualization of Identical Attributes Test on AFHQ and FFHQ. The results shown in the first and second subfigures on the left are conducted on AFHQ-Cat and AFHQ-Dog, respectively. The subfigure on the right presents the results of FFHQ. In each subfigure, the generated samples are on the left, and the top  $k$  contributors in the training dataset are on the right.
+
+![](images/d88ded9b7efe79d601be2f32e4fb768bc96b1b4f7eaf68734b29c42d5f03fe4e.jpg)
+
+![](images/37935229cb50f12f3d0933b24584c9df64ec956776ae48ab8b142f9b9515ca8a.jpg)
+
+Table 7: Performance comparison of Identical Class Test.  
+
+<table><tr><td colspan="4">MNIST</td></tr><tr><td>GAN (%)</td><td>k=30</td><td>k=50</td><td>k=100</td></tr><tr><td>GMValuator (No-Rerank)</td><td>96.27</td><td>96.26</td><td>95.86</td></tr><tr><td>GMValuator (l2-distance)</td><td>97.73</td><td>97.58</td><td>96.03</td></tr><tr><td>GMValuator (LPIPS)</td><td>97.77</td><td>97.72</td><td>97.38</td></tr><tr><td>GMValuator (DreamSim)</td><td>97.43</td><td>97.44</td><td>97.40</td></tr><tr><td>Diffusion (%)</td><td>k=30</td><td>k=50</td><td>k=100</td></tr><tr><td>GMValuator (No-Rerank)</td><td>92.40</td><td>91.82</td><td>91.26</td></tr><tr><td>GMValuator (l2-distance)</td><td>92.90</td><td>92.66</td><td>91.88</td></tr><tr><td>GMValuator (LPIPS)</td><td>93.73</td><td>97.72</td><td>92.42</td></tr><tr><td>GMValuator (DreamSim)</td><td>93.90</td><td>93.44</td><td>92.55</td></tr><tr><td colspan="4">CIFAR-10</td></tr><tr><td>BigGAN (%)</td><td>k=30</td><td>k=50</td><td>k=100</td></tr><tr><td>GMValuator (No-Rerank)</td><td>64.70</td><td>63.80</td><td>62.14</td></tr><tr><td>GMValuator (l2-distance)</td><td>64.70</td><td>63.80</td><td>62.14</td></tr><tr><td>GMValuator (LPIPS)</td><td>63.67</td><td>62.80</td><td>61.51</td></tr><tr><td>GMValuator (DreamSim)</td><td>70.33</td><td>68.74</td><td>65.18</td></tr><tr><td>Class-free Guidance Diffusion (%)</td><td>k=30</td><td>k=50</td><td>k=100</td></tr><tr><td>GMValuator (No-Rerank)</td><td>72.67</td><td>72.00</td><td>71.00</td></tr><tr><td>GMValuator (l2-distance)</td><td>72.67</td><td>72.00</td><td>71.00</td></tr><tr><td>GMValuator (LPIPS)</td><td>72.53</td><td>72.28</td><td>71.06</td></tr><tr><td>GMValuator (DreamSim)</td><td>79.37</td><td>78.08</td><td>74.61</td></tr></table>
+
+# E ADDITIONAL RESULTS ON C1 AND C2
+
+# E.1 (C1) IDENTICAL CLASS TEST ON OTHER GENERATIVE MODELS
+
+We have presented Identical Class Test (C1) on  $\beta$ -VAE and MNIST LeCun et al. (1998), CIFAR-10 Krizhevsky et al. (2009) in Sec. 4.3 in our main context. Since GMVALUATOR is model-agnostic, we further validate our method of C1 on other generative models.
+
+Here, we conduct the experiments using a GAN and a Diffusion Model on MNIST. The architectural details of the used generative models are described in Sec. J.3 in the appendix. We also conduct the experiment on BigGAN Brock et al. (2018) and Class-free Guidance Diffusion Ho & Salimans (2022) with CIFAR-10. We used the same number of generated samples  $m = 100$  as the experiments presented in Sec. 4.
+
+Following the similar settings in Sec. 4.3 (C1), we examine the class(es) of is top  $k$  contributors for a given generated data in the training data. We calculate the number of training samples, denoted as  $Q$ , from the top  $k$  contributors that have the same class as the generated data. The identical class ratio, denoted as  $\rho$ , is calculated as  $\rho = Q / k$ . We report the average value of  $\rho$  across the generated datasets for different choices of  $k$  in Table 7. GMVALUATOR (DreamSim) has the highest ratio of contributors that belong to the same class as the generated sample among most of the models evaluated on MNIST and CIFAR-10 datasets for different values of  $k$ . And the ratio improves as the value of  $k$  decreases, which is consistent with the top  $k$  assumption and validates our method.
+
+# E.2 (C2) IDENTICAL ATTRIBUTES TEST ON CELEBA
+
+We extend C1 to focus on the attributes present in the images, treating them as ground truth rather than class labels, as discussed in Sec. 4.4. Our experiments now incorporate multiple attributes simultaneously, rather than just a single attribute, to verify the performance of GMVALUATOR. For instance, when evaluating a generated image with both a hat and eyeglasses, the most significant contributors identified should also include both of these attributes. Table 8 showcases some outcomes of identical attributes test when regarding multiple combined attributes as ground truth, which validate the effectiveness of our methods.
+
+Table 8: Performance of Identical Attributes Test (C2) of multiple combined attributes.  
+
+<table><tr><td>Top K contributors:</td><td>k=5</td><td>k=10</td><td>k=15</td></tr><tr><td colspan="4">Attribute: Eyeglasses &amp; Gender (%)</td></tr><tr><td>GMValuator (No-Rerank)</td><td>50.10</td><td>48.48</td><td>48.42</td></tr><tr><td>GMValuator (l2-distance)</td><td>59.19</td><td>56.67</td><td>56.23</td></tr><tr><td>GMValuator (LPIPS)</td><td>78.18</td><td>74.24</td><td>73.87</td></tr><tr><td>GMValuator (DreamSim)</td><td>92.53</td><td>90.61</td><td>90.30</td></tr><tr><td colspan="4">Attribute: Eyeglasses &amp; Hat (%)</td></tr><tr><td>GMValuator (No-Rerank)</td><td>78.79</td><td>78.38</td><td>85.86</td></tr><tr><td>GMValuator (l2-distance)</td><td>84.44</td><td>82.93</td><td>83.23</td></tr><tr><td>GMValuator (LPIPS)</td><td>86.87</td><td>86.16</td><td>86.33</td></tr><tr><td>GMValuator (DreamSim)</td><td>89.49</td><td>87.58</td><td>87.41</td></tr><tr><td colspan="4">Attribute: Gender &amp; Hat (%)</td></tr><tr><td>GMValuator (No-Rerank)</td><td>58.59</td><td>57.47</td><td>57.71</td></tr><tr><td>GMValuator (l2-distance)</td><td>61.62</td><td>60.51</td><td>60.40</td></tr><tr><td>GMValuator (LPIPS)</td><td>63.84</td><td>63.23</td><td>62.96</td></tr><tr><td>GMValuator (DreamSim)</td><td>65.25</td><td>64.44</td><td>64.18</td></tr></table>
+
+# E.3 (C2) IDENTICAL ATTRIBUTES TEST ON OTHER DATASETS
+
+![](images/ca82a1cf7b95afbaadf2b43b5c4719604bebe3caf5ad583177613305eb4dee91.jpg)
+
+![](images/3e5a58739209c691d16fd2d8192301056568d8efd9edf66ab4ff8c51e328098b.jpg)
+
+![](images/22e7322dbfb455c7a4b1923a60fa6f9feb7d117720130ee9a4d6210ed8c210ff.jpg)
+
+![](images/1212ab45dfc54d19fce297a17c7b4b3dff218975ec57481162d6962ab2328739.jpg)
+
+![](images/8b4c6d058eb83255a5ae4ddc6294984a31479fac273ea2046a9337f8bc3ce51d.jpg)
+
+![](images/707b2ecfaeb566e486479417b0a49a4c3e7e0aaf73f94ceb5eb2a1a71506cc3a.jpg)
+
+![](images/6c1f1cb16739b2c9fb92bc86a4abfca4b84c733d04d1d7277621be3f366dbd25.jpg)
+
+![](images/330b85fa6927fde75e40f38088025eed1380c92cbcab0790f841c7bc082b0d3e.jpg)
+
+![](images/e7d3821919e796a49293d3e6137b02030dcb8d01f88d9f79f88dcbb198cbbc3d.jpg)
+
+![](images/ab0ff41a019ba5aa2b458c9b26aa80a32395c7758547f5f9f550ea219a6b668c.jpg)  
+Figure 7: The change of  $\rho$  with the different number of generated samples  $m$  on MNIST and CIFAR-10 by diverse generative models.
+
+![](images/fc18be422648509452df3280f5d8c64bb45ebc5e633c6673e1db25a52f61c04d.jpg)
+
+![](images/12bb4efef60aa30bbba9e5b61859c854e1738e0beb7b61bd4f7df84f3c54ecd3.jpg)
+
+To further validate GMVALUATOR, we also conducted experiments on high-resolution datasets: AFHQ Choi et al. (2020) and FFHQ Karras et al. (2019), following the same settings in Sec 4.4. The results are shown in Figure 6, which demonstrates the effectiveness of our methods in C2. The results show that the top  $k$  contributors have similar attributes with the generated sample such as fur color of cats or dogs in AFHQ. For the experiment conducted on FFHQ, human faces attributes of the most significant contributors are also similar to the attributes in generated images.
+
+# F DIFFERENT GENERATED DATA SIZES
+
+Since our value function  $\phi_{i}$  (Eq. equation 5) for training data  $x_{i}$  is computed by averaging over generated samples, it is expected that the sensitivity of  $\phi_{i}$  is connected to the size  $m$  of the investigated generated sample. To explore the influence of generated data size  $m$  on the utilization of GMVALUATOR, we perform sensitivity testing on MNIST, CIFAR10 using generative models GAN Goodfellow et al. (2020), and Diffusion models Dhariwal & Nichol (2021) as depicted below. The dataset, model and used  $k$  are denoted under each subfigure of Figure 7. First, we generate a varying number of samples from the same class. Specifically, we consider four different sample sizes, denoted by  $m$ , which are given by 1, 10, 30, and 50. Next, we evaluate the GMVALUATOR using parameter C1, and this evaluation is performed for each of the aforementioned values of  $m$ . Subsequently, we conduct the experiment 10 times using GMVALUATOR (No-Rerank), each time with different  $m$ -sized generated data samples from the same class. The results are presented as the mean and standard deviation  $(\rho)$  for accuracy, taken over these 10 runs. The results shown in Figure 7 imply that varying  $m$  does not yield notable differences in mean accuracy and increasing the number of generated samples  $m$  leads to more stable and consistent results.
+
+# G ALTERNATIVE EMBEDDING APPROACHES
+
+In the step of efficient similarity matching, the embedding  $f_{e}$  is exclusively used in the recall phase for retaining  $n$  samples with non-minimal contributions. Apart from using CLIP for embedding, we also investigate the influence for the results when using other embedding methods. We present results in Table 9 using more embedding methods, showing similar performance with CLIP with "Rerank". The reason for this results is that we implement re-ranking that relies on the image space rather than the embedding space, which allows us to derive accurate top  $k$  contributors from  $n$  samples  $n \gg k$ . Thus, the embedding could tolerate some noise in the recall phase.
+
+Table 9: Comparison of different embedding methods.  
+
+<table><tr><td>MNIST (%)</td><td>No-Rerank</td><td>l2-distance</td><td>LPIPS</td><td>DreamSim</td></tr><tr><td>CLIP</td><td>86.41</td><td>87.76</td><td>88.78</td><td>88.78</td></tr><tr><td>Alexnet</td><td>79.77</td><td>84.82</td><td>86.51</td><td>88.72</td></tr><tr><td>Densenet</td><td>80.47</td><td>86.77</td><td>87.97</td><td>89.35</td></tr></table>
+
+# H ALTERNATIVE DISTANCE METRIC
+
+We suggest utilizing Learned Perceptual Image Patch Similarity (LPIPS) Zhang et al. (2018) or DreamSim Fu et al. (2023) as the distance metric  $d$  during the re-ranking phase. This enables to understand the perceptual dissimilarity between generated and real data points. These metrics are applied in the image embedding space derived from pre-trained models. Alternatively, distance measurement can be based on pixel space, such as employing  $l2$ -distance. Notably, we find that distances calculated in the input pixel space yield comparable outcomes as shown in Table 7. This implies that our method GMVALUATOR could be flexible to the different choices of distance metrics and the selection can depend on data prior.
+
+# I NECESSITY FOR CALIBRATION
+
+For challenges 2 and 3, we utilize image quality assessment and establish a non-zero scores rule for calibration in GMVALUATOR. To better understand the impact and necessity of calibration,
+
+we compare the distribution of the top 1, 2, and 3 contributors' scores with (w) and without (w/o) calibration conducted on MNIST in Figure 8. It is evident that scores without calibration are generally higher than with calibration. We also extend C3 and perform an ablation study in Figure 9 on scenarios where the generated samples include low-quality outputs. The results show that the OOD (out-of-distribution) training samples' value rank by GMValuator without (w/o) calibration is smaller, indicating significant bias and poor performance.
+
+![](images/44e1c2b09e7ece54cd605e88073ecf2ef3b908ad3f2befd128b5dedf2818edc2.jpg)  
+Figure 8: Sore Distribution
+
+![](images/0bbf522b5dcdd992ec25a8e6bbe135a2508800a1eae720516cc5f558ab027776.jpg)  
+Figure 9: Value Rank
+
+# J ADDITIONAL EXPERIMENTAL DETAILS
+
+# J.1 JUSTIFICATION OF EXPERIMENT SETUP
+
+We provide a detailed justification in Table 10 for our experiment setup from C1 to C4.
+
+- C1. In Identical Class Test, the baseline method is VAE-TracIn Kong & Chaudhuri (2021), which can find the most influenced instances in the training dataset. Since VAE-TracIn is the model-specific method, we only need to compare it with GMVALUATOR when VAE model is used. Besides, all the datasets used in C1 should have the class labels. Considering the computational demands detailed in VAE-TracIn Kong & Chaudhuri (2021), the runtime complexity of VAE-TracIn correlates with the number of network parameters and the size of the dataset. Therefore, our analysis primarily utilizes simpler benchmark datasets such as MNIST and CIFAR-10 for comparative evaluations with VAE-TracIn.  
+- C2. In extending C1, we use image attributes to supplant the concept of class for datasets lacking class labels. For datasets with attribute labels, quantified experiments are feasible, as demonstrated in Table 3 and Table 8. For datasets without attribute labels, we employ visualized experiments.  
+- C3. IF4GAN, a model-specific method for GAN, serves as the baseline for measuring data value. Adhering to the settings outlined in Terashita et al. (2021) and considering the impractical computational costs, we conduct experiments on the same dataset (MNIST) in Terashita et al. (2021) using DCGAN.
+
+Table 10: Justification of Experiment Setup. The selection of datasets and models was based on three critical factors that guided the process. Firstly, attribute labels were required to evaluate C2 effectively. Secondly, benchmark datasets were meticulously chosen to ensure a fair comparison with baselines while also taking into account computational costs (C3 and C4). Finally, the selected generative models are powerful enough to generate good-quality data for the datasets.  
+
+<table><tr><td></td><td>Dataset</td><td>Model</td><td>Baseline</td><td>Label Requirements</td></tr><tr><td rowspan="3">C1</td><td rowspan="2">MNIST, CIFAR-10</td><td>VAE</td><td>VAE-TracIn Kong &amp; Chaudhuri (2021)</td><td>Class labels</td></tr><tr><td>Diffusion, GAN</td><td>-</td><td>Class labels</td></tr><tr><td>ImageNet</td><td>Masked Diffusion Transformer Gao et al. (2023)</td><td>-</td><td>Class labels</td></tr><tr><td rowspan="2">C2</td><td>CelebA</td><td>Diffusion-StyleGAN</td><td>-</td><td>Attribute labels</td></tr><tr><td>AFHQ, FFHQ</td><td>StyleGAN</td><td>-</td><td>-</td></tr><tr><td>C3</td><td>MNIST</td><td>DCGAN</td><td>IF4GAN Terashita et al. (2021)</td><td>Class labels</td></tr><tr><td rowspan="2">C4</td><td>MNIST, CIFAR-10</td><td>VAE</td><td>VAE-TracIn Kong &amp; Chaudhuri (2021)</td><td>Class labels</td></tr><tr><td>MNIST</td><td>DCGAN</td><td>IF4GAN Terashita et al. (2021)</td><td>Class labels</td></tr></table>
+
+- C4. We present a comparison of the efficiency of GMVALUATOR against baseline methods. In accordance with the settings used for VAE-TracIN and IF4GAN in Kong & Chaudhuri (2021), we report the efficiency results for C1 on the MNIST and CIFAR-10 datasets, and for C3 on MNIST.
+
+# J.2 DATASETS
+
+We conduct the generation tasks in the experiments on benchmark datasets (i.e., MNIST LeCun et al. (1998) and CIFAR Krizhevsky et al. (2009)), face recognition dataset (i.e., CelebA Liu et al. (2018)), high-resolution image dataset AFHQ Choi et al. (2020) and FFHQ Karras et al. (2019), large-scale image dataset ImageNet Deng et al. (2009).
+
+MNIST. The MNIST dataset consists of a collection of grayscale images of handwritten digits (0-9) with a resolution of 28x28 pixels. The dataset contains 60,000 training images and 10,000 testing images.
+
+CIFAR-10. CIFAR-10 dataset consists of 60,000 color images in 10 different classes, with 6,000 images per class. The classes include objects such as airplanes, cars, birds, cats, deer, dogs, frogs, horses, ships, and trucks. Each image in the CIFAR-10 dataset has a resolution of  $32 \times 32$  pixels.
+
+CelebA. The CelebA dataset is a widely used face recognition and attribute analysis dataset, which contains a large collection of celebrity images with various facial attributes and annotations. The dataset consists of more than 200,000 celebrity images, with each image labeled with 40 binary attribute annotations such as gender, age, facial hair, and presence of eyeglasses.
+
+AFHQ. The AFHQ dataset is a high-resolution image dataset that focuses on animal faces (e.g., dogs, cat), and it consists of high-resolution images with  $512 \times 512$  pixels.
+
+FFHQ. The FFHQ dataset is a high-resolution face dataset that contains high-quality images (1024x1024 pixels) of human faces.
+
+ImageNet. ImageNet is a large-scale image dataset, which contains over 14 million images and is categorized into more than 20,000 classes.
+
+# J.3 ARCHITECTURE OF GENERATIVE MODELS
+
+In our experiments, we leverage different generative models in the class of GAN, VAE and diffusion models. We utilize  $\beta$ -VAE for both MNIST and CIFAR-10 datasets while a simple GAN is conducted on MNIST. BigGAN and  $\beta$ -VAE are also conducted on CIFAR-10. We list the architecture details for these generative models from Table 11 to Table 13. StyleGAN is used for high-resolution datasets AFHQ and FFHQ. CelebA uses Diffusion-StyleGAN Wang et al. (2022), for which we use the exact architecture in their open-sourced code. In addition, Masked Diffusion Transformer, as introduced by Gao et al. Gao et al. (2023), is applied to the ImageNet.
+
+Table 11: The architecture of GAN for MNIST.  
+
+<table><tr><td>Generator</td><td>Discriminator</td></tr><tr><td>FC(100, 8192), BN(32), ReLUConv2D(128, 64, 4, 2, 1), BN(64), ReLU</td><td>Conv2D(1, 128, 4, 2, 1), BN(128), LeakyReLUFC(8192, 1024), BN(1024), LeakyReLU</td></tr></table>
+
+Table 12: The architecture of BigGAN.  
+
+<table><tr><td>Input</td><td>28×28×1 (MNIST) &amp; 32×32×3 (CIFAR-10).</td></tr><tr><td>Encoder</td><td>Conv 32×4×4 (stride 2), 32×4×4 (stride 2), 64×4×4 (stride 2), 64×4×4 (stride 2), FC 256. ReLU activation.</td></tr><tr><td>Latents</td><td>32</td></tr><tr><td>Decoder</td><td>Deconv reverse of encoder. ReLu acitvation. Gaussian.</td></tr></table>
+
+Table 13: The architecture of  $\beta$  -VAE.  
+
+<table><tr><td colspan="2">β-VAE</td></tr><tr><td>Generator</td><td>Discriminator</td></tr><tr><td>z∈R120~N(0,I)Embed(y)∈R32</td><td>RGB image x∈R32×32×3</td></tr><tr><td>Linear (20+128)→4×4×16ch</td><td>ResBlock down ch→2ch</td></tr><tr><td>ResBlock up 16ch→16ch</td><td>Non-Local Block (64×64)</td></tr><tr><td>ResBlock up 16ch→8ch</td><td>ResBlock down 2ch→4ch</td></tr><tr><td>ResBlock up 8ch→4ch</td><td>ResBlock down 4ch→8ch</td></tr><tr><td>ResBlock up 4ch→2ch</td><td>ResBlock down 8ch→16ch</td></tr><tr><td>Non-Local Block (16×16)</td><td>ResBlock down 16ch→16ch</td></tr><tr><td>ResBlock up 2ch→ch</td><td>ResBlock 16ch→16ch</td></tr><tr><td>BN,ReLU,3×3Conv ch→3</td><td>ReLU, Global sum pooling</td></tr><tr><td>Tanh</td><td>Embed (y)·h+(linear→1)</td></tr></table>
+
+# K DISCUSSION ON THE POSSIBLE APPLICATIONS
+
+The application of data valuation within generative models offers a wide range of opportunities. A potential use case is to quantify privacy risks associated with generative model training using specific datasets, since the matching mechanism GMVALUATOR can help re-identify the training samples given the generated data. By doing so, organizations and individuals will be able to audit the usage of their data more effectively and make informed decisions regarding its use.
+
+Another promising application is material pricing and finding in content creation. For example, when training generative models for various purposes, such as content recommendation or personalized advertising, data evaluation can be used to measure the value of reference content.
+
+In addition, GMVALUATOR can play an important role in the development of ensuring the responsibility of using synthetic data in safe-sensitive fields, such as healthcare or finance. By assessing the value of the data used in generative model training, researchers can ensure that the generated data are robust and reliable.
+
+Last but not least, the applications of GMVALUATOR can promote the recognition of intellectual property rights. Determining the value of the intellectual property being generated by generative models is critical. By evaluating the data employed in training generative models, we can develop a more comprehensive understanding of copyright that may emerge from the generative models. In essence, such insights can help advance licensing agreements for the utilization of the generative model and its outputs.
+
+# L CURRENT LIMITATION AND FUTURE DIRECTIONS
+
+The limitation of this work is that it only measures data value for vision-related generative models and conducts experiments exclusively within the field of computer vision. However, this does not mean that GMVALUATOR cannot be easily adapted to Natural Language Processing (NLP) fields, given its core idea of similarity matching. In the future, we should extend GMVALUATOR to NLP and assess the data value for language-related generative models, such as large language models (LLMs).
+
+# M OMITTED PROOFS
+
+We follow Just et al. (2023) to prove the theorem. Firstly, we give several assumptions that will be used in later proof.
+
+Assumption M.1 Following Assumption 2.3, given a distance function  $d(\cdot ,\cdot)$  between, we defined the coupling between  $\mathcal{X}_{(T|f)}$  and  $\mathcal{X}_{(S^{*}|f)}$  as  $\pi^*$ :
+
+$$
+\pi^ {*} := \underset {\pi \in \Pi \left(\mathcal {X} _ {(T \mid f)}, \mathcal {X} _ {(S ^ {*} \mid f)}\right)} {\arg \inf } \mathbb {E} _ {\left(x _ {T}, x _ {S ^ {*}}\right) \sim \pi} d \left(x _ {T}, x _ {S ^ {*}}\right) \tag {7}
+$$
+
+It is easy to see that all joint distributions defined above are couplings between the corresponding distribution pairs. Then, following Just et al. (2023) we prove the main Theorem.
+
+Theorem M.2 (Restated of Theorem 2.4.) Let  $f_{S^*}': \mu \to \mathcal{A} = \{0,1\}^V$  be the model trained on the optimal contributor dataset  $S^*$ . Following Assumption 2.3, if the contributors are corresponding to the given generated data  $\hat{X}$ , we have:
+
+$$
+\begin{array}{l} \mathbb {E} _ {x \sim \mu_ {T}} \left[ \mathcal {L} \left(f (x), f _ {S ^ {*}} ^ {\prime} (x)\right) \right] - \mathbb {E} _ {x \sim \mu_ {S ^ {*}}} \left[ \mathcal {L} \left(f (x), f _ {S ^ {*}} ^ {\prime} (x)\right) \right] \tag {8} \\ \leq k \epsilon \cdot \left[ d _ {W} \left(\mathcal {X} _ {(T | f)}, \mathcal {X} _ {(\hat {X} | f)}\right) + d _ {W} \left(\mathcal {X} _ {\left(S ^ {*} | f\right)}, \mathcal {X} _ {(\hat {X} | f)}\right) \right] \\ \end{array}
+$$
+
+# Proof M.3
+
+$$
+\begin{array}{l} \mathbb {E} _ {x \sim \mu_ {T}} \left[ \mathcal {L} \left(f (x), f _ {S ^ {*}} ^ {\prime} (x)\right) \right] = \mathbb {E} _ {x \sim \mu_ {T}} \left[ \mathcal {L} \left(f (x), f _ {S ^ {*}} ^ {\prime} (x)\right) \right] \\ - \mathbb {E} _ {x \sim \mu_ {S ^ {*}}} \left[ \mathcal {L} \left(f (x), f _ {S ^ {*}} ^ {\prime} (x)\right) \right] + \mathbb {E} _ {x \sim \mu_ {S ^ {*}}} \left[ \mathcal {L} \left(f (x), f _ {S ^ {*}} ^ {\prime} (x)\right) \right] \\ \leq \mathbb {E} _ {x \sim \mu_ {S ^ {*}}} \left[ \mathcal {L} \left(f (x), f _ {S ^ {*}} ^ {\prime} (x)\right) \right] \\ + \left| \mathbb {E} _ {x \sim \mu_ {S ^ {*}}} \left[ \mathcal {L} \left(f (x), f _ {S ^ {*}} ^ {\prime} (x)\right) \right] - \mathbb {E} _ {x \sim \mu_ {T}} \left[ \mathcal {L} \left(f (x), f _ {S ^ {*}} ^ {\prime} (x)\right) \right] \right| \tag {9} \\ \end{array}
+$$
+
+We bound  $\left|\mathbb{E}_{x\sim \mu_{S^*}}\left[\mathcal{L}\left(f(x),f_{S^*}^\prime (x)\right)\right] - \mathbb{E}_{x\sim \mu_T}\left[\mathcal{L}\left(f(x),f_{S^*}^\prime (x)\right)\right]\right|$  as follows:
+
+$$
+\begin{array}{l} \left| \mathbb {E} _ {x \sim \mu_ {S ^ {*}}} \left[ \mathcal {L} (f (x), f _ {S ^ {*}} ^ {\prime} (x)) \right] - \mathbb {E} _ {x \sim \mu_ {T}} \left[ \mathcal {L} (f (x), f _ {S ^ {*}} ^ {\prime} (x)) \right] \right| \\ = \left| \int_ {\mathcal {X} ^ {2}} \mathcal {L} \left(f \left(x _ {S ^ {*}}\right), f _ {S ^ {*}} ^ {\prime} \left(x _ {S}\right)\right) - \mathcal {L} \left(f \left(x _ {T}\right), f _ {S ^ {*}} ^ {\prime} \left(x _ {T}\right)\right) d \pi^ {*} \left(x _ {T}, x _ {S ^ {*}}\right) \right| \\ = \left| \int_ {\mathcal {X} ^ {2}} \mathcal {L} \left(f \left(x _ {S ^ {*}}\right), f _ {S ^ {*}} ^ {\prime} \left(x _ {S ^ {*}}\right)\right) \right. \\ - \mathcal {L} \left(f \left(x _ {S ^ {*}}\right), f _ {S ^ {*}} ^ {\prime} \left(x _ {T}\right)\right) + \mathcal {L} \left(f \left(x _ {S ^ {*}}\right), f _ {S ^ {*}} ^ {\prime} \left(x _ {T}\right)\right) - \mathcal {L} \left(f \left(x _ {T}\right), f _ {S ^ {*}} ^ {\prime} \left(x _ {T}\right)\right) d \pi^ {*} \left(x _ {T}, x _ {S ^ {*}}\right) \\ \leq \int_ {\mathcal {X} ^ {2}} \left| \mathcal {L} \left(f \left(x _ {S ^ {*}}\right), f _ {S ^ {*}} ^ {\prime} \left(x _ {S ^ {*}}\right)\right) - \int_ {\mathcal {X} ^ {2}} \mathcal {L} \left(f \left(x _ {S ^ {*}}\right), f _ {S ^ {*}} ^ {\prime} \left(x _ {T}\right)\right) \right| d \pi^ {*} \left(x _ {T}, x _ {S ^ {*}}\right) \\ + \int_ {\mathcal {X} ^ {2}} \left| \mathcal {L} \left(f \left(x _ {S ^ {*}}\right), f _ {S ^ {*}} ^ {\prime} \left(x _ {T}\right)\right) - \int_ {\mathcal {X} ^ {2}} \mathcal {L} \left(f \left(x _ {T}\right), f _ {S ^ {*}} ^ {\prime} \left(x _ {T}\right)\right) \right| d \pi^ {*} \left(x _ {T}, x _ {S ^ {*}}\right) \tag {10} \\ \end{array}
+$$
+
+Then due to  $k$ -Lipschitzness of  $\mathcal{L}$  and  $\epsilon$ -Lipschitzness of  $f$ , we can obtain:
+
+$$
+\begin{array}{l} R H S \text {o f} E q. e q u a t i o n 1 0 \leq k \int_ {\mathcal {X} ^ {2}} | | f _ {S ^ {*}} ^ {\prime} \left(x _ {S ^ {*}}\right) - f _ {S ^ {*}} ^ {\prime} \left(x _ {T}\right) | | d \pi^ {*} \left(x _ {T}, x _ {S ^ {*}}\right) \\ + k \int_ {\mathcal {X} ^ {2}} | | f (x _ {S ^ {*}}) - f (x _ {T}) | | d \pi^ {*} (x _ {T}, x _ {S ^ {*}}) \\ \leq k \epsilon \int_ {\mathcal {X} ^ {2}} 2 d \left(x _ {T}, x _ {S ^ {*}}\right) d \pi^ {*} \left(x _ {T}, x _ {S ^ {*}}\right) \\ = k \epsilon d _ {W} \left(\mathcal {X} _ {(T | f)}, \mathcal {X} _ {(S ^ {*} | f)}\right), \\ \end{array}
+$$
+
+where the last step is due to the definition of 1-Wasserstein distance. Then, according to the triangle inequality of Wasserstein distance Peyre et al. (2019), we can obtain:
+
+$$
+d _ {W} \left(\mathcal {X} _ {(T | f)}, \mathcal {X} _ {\left(S ^ {*} | f\right)}\right) \leq d _ {W} \left(\mathcal {X} _ {(T | f)}, \mathcal {X} _ {\left(\hat {X} | f\right)}\right) + d _ {W} \left(\mathcal {X} _ {\left(\hat {X} | f\right)}, \mathcal {X} _ {\left(S ^ {*} | f\right)}\right) \tag {11}
+$$
+
+Combining Eq. equation 9 and Eq. equation 11 we finished the proof and obtained the Theorem 2.4. By reducing the distance term  $d_W\left(\mathcal{X}_{(T|f)}, \mathcal{X}_{(\hat{X}|f)}\right)$ , we have  $\mathcal{X}_{(T|f)} \to \mathcal{X}_{(S^*|f)}$ . As a result, the expected distance
+
+$$
+\mathbb {E} _ {(S ^ {*} \sim \mathcal {X} _ {(S ^ {*} | f)}, T \sim \mathcal {X} _ {(T | f)})} \min _ {\pi \in \Pi (T, S ^ {*})} \mathbb {E} _ {(x _ {T}, x _ {S ^ {*}}) \sim \pi} d (x _ {T}, x _ {S ^ {*}}) \to 0,
+$$
+
+with randomly sampling  $S^{*}$  and  $T$  with  $K$  elements.
+
+# N EXPERIMENT ON TEXT TO IMAGE GENERATION MODEL (STABLE DIFFUSION)
+
+In this section, we conducted experiments using a stable diffusion model Rombach et al. (2022) fine-tuned with LoRA on a Naruto dataset Cervenka (2022).
+
+Identical Attributes Test (C2). To evaluate the effectiveness of GMVALUATOR on a text-to-image dataset, we use the attributes in the images as ground truth and employ the Identical Attributes Test (C2) to assess its performance. The results presented in Table 14 show that the top  $k$  contributors share similar attributes with the generated sample, such as gender, hair, and hat, demonstrating the effectiveness of our approach in evaluating data contributions.
+
+Table 14: Performance of Identical Attributes Test (C2) of some attributes including Gender, Hat, and Hair on Naruto.  
+
+<table><tr><td>Attribute (%)</td><td colspan="3">Gender</td><td colspan="3">Hat</td><td colspan="3">Hair</td></tr><tr><td>Top K contributors:</td><td>k=3</td><td>k=4</td><td>k=5</td><td>k=3</td><td>k=4</td><td>k=5</td><td>k=3</td><td>k=4</td><td>k=5</td></tr><tr><td>GMValuator (l2_distance)</td><td>94.33</td><td>93.50</td><td>92.80</td><td>86.30</td><td>85.50</td><td>84.40</td><td>88.00</td><td>87.75</td><td>88.40</td></tr><tr><td>GMValuator (LPIPS)</td><td>98.67</td><td>98.50</td><td>98.80</td><td>87.00</td><td>86.25</td><td>85.40</td><td>96.67</td><td>96.25</td><td>96.00</td></tr><tr><td>GMValuator (DreamSim)</td><td>99.00</td><td>98.50</td><td>98.80</td><td>86.33</td><td>86.75</td><td>85.80</td><td>98.30</td><td>97.75</td><td>96.00</td></tr></table>
+
+Efficiency. To evaluate computational efficiency, we report the time taken to identify significant contributors for a single generated sample in Table 15. The results emphasize the effectiveness and efficiency of our approach for text-image models such as Stable Diffusion. The experiments were conducted in an environment equipped with an RTX A6000 (48GB) GPU and a 12-vCPU Intel(R) Xeon(R) Platinum 8255C CPU @ 2.50GHz.
+
+Table 15: Efficiency using Stable Diffusion on Naruto.  
+
+<table><tr><td>Method</td><td>GMValuator (l2_distance)</td><td>GMValuator (LPIPS)</td><td>GMValuator (DreamSim)</td></tr><tr><td>Time (s)</td><td>1.27888</td><td>3.09580</td><td>6.28144</td></tr></table>
+
+# O EFFICIENCY WITH INCREASED DATA SIZE
+
+As a training-free and efficient data valuation approach for generative models, GMVALUATOR is also highly scalable to large-scale and complex datasets. To evaluate this, we assess the efficiency of GMVALUATOR on datasets of varying sizes, illustrating the trend in computational efficiency as the data size increases. In Fig.10, we present the running time versus the dataset size for GMVALUATOR variants (dashed lines, with colors representing different similarity metrics) using the same settings as in Sec.N. This result demonstrates that average running time for various variants of GMValuator on a single generated image, with the recalled number set to 200, is dominated by the re-ranking process. As a result, the running time is nearly independent of the dataset size. Noting that the number of recalled images during the re-rank phase is fixed, thus time cost reveals minimal variation in runtime with increasing dataset size, demonstrating that our method maintains consistent computational efficiency even as the data scale grows.
+
+In Fig.11, we present the time cost for one generated image during the recall phase (No-Rerank), with dataset sizes ranging from  $100\mathrm{K}$  to  $50000\mathrm{K}$ . The results show that the running time remains small across different dataset size. Benefiting from the efficiency of our recall phase, the time overhead increases only marginally. In contrast, as noted in Kong & Chaudhuri (2021), "the run-time complexity of VAE-TracIn is linear with respect to the number of samples, checkpoints, and network parameters". Similarly, IF4GAN Terashita et al. (2021) is time-intensive, with complexity increasing alongside model size and the number of training epochs, as outlined in Algorithm 2 of their work.
+
+# P IMPACT OF QUANTIZATION RECALL
+
+In this section, we evaluate the effect of quantization recall by empirically compare quantization recall with nearest neighbor (NN) search using varying recalled number  $K$  during the recall phase. To be specific, We conducted our experiments on the MNIST dataset using a GAN model with recalled number  $K$  increasing from 100 to 700. For consistency, we leverage  $l_{2}$ -distance in the reranking phase.
+
+![](images/f98607c737408bffbd7424ef9d4f6240f6d856a684d4cb74ed4a3dd96dc08614.jpg)  
+Figure 10: Running time vs. dataset size for variants of GMValuator.
+
+![](images/a25821d72ca470966ea38521abf9c2a7b06fe95f5725b095ad9c0d8644ccf6c3.jpg)  
+Figure 11: Running time vs. dataset size for recall phase (No-Rerank) of GMValuator.
+
+![](images/316da42001c21679d38a22800aa09d05d56e53c3fa51b7e1e1dc889ec2d15d01.jpg)  
+Figure 12: Running Time vs. Number of Recall Samples
+
+Efficiency. GMVALUATOR significantly outperforms nearest neighbor search in speed, taking an average of 0.25 seconds to attribute the most significant contributors for a generated sample, which is more than 50 times faster compared to 13.75 seconds for NN search. What's more, the time cost for NN search will increase linearly with dataset size, while using PQ recall shows only a slight increased time in larger dataset size as shown in Fig 11. The experiments in this section are run in an environment equipped with an RTX A6000 GPU (48GB) and a 12-vCPU Intel(R) Xeon(R) Platinum 8255C CPU @ 2.50GHz.
+
+**Effective.** As illustrated in Fig. 12, under different recalled numbers (from 100 to 700), the results of GMValuator are similar to the exhaustive KNN search, demonstrating that our method maintains high performance while ensuring computational efficiency.

ICLR/2025/GMValuator_ Similarity-based Data Valuation for Generative Models/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c679461784743072f27956b5e07e04c51aadbc14e8100b0613fd6361252cc66
+size 1363218

ICLR/2025/GMValuator_ Similarity-based Data Valuation for Generative Models/layout.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:069f12c486e9d291307b76e246a15716dc860665f19a892769d14bbb007d1ec3
+size 872890

ICLR/2025/GNNs Getting ComFy_ Community and Feature Similarity Guided Rewiring/936aff69-d4b9-4eea-84e0-6874673a5dde_content_list.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55911cde718c99ff358b5277c80e7854ebfa1a38ce078a7aa18abb63a3eb27a7
+size 207200

ICLR/2025/GNNs Getting ComFy_ Community and Feature Similarity Guided Rewiring/936aff69-d4b9-4eea-84e0-6874673a5dde_model.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8563d72c0dc37ae8f906b2d56e93f18665b555b1f427d2303568d68f423b3b60
+size 244659

ICLR/2025/GNNs Getting ComFy_ Community and Feature Similarity Guided Rewiring/936aff69-d4b9-4eea-84e0-6874673a5dde_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cfa0d869b894a989d8b051db8231638b2014ecf040c8505884e46a798f2d4fc
+size 1758368

ICLR/2025/GNNs Getting ComFy_ Community and Feature Similarity Guided Rewiring/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1ee17f00c5a4dba84e3eead74620a200a39e7e1b9dcf2158a25c5d6d2fe9ea0
+size 2466122

ICLR/2025/GNNs Getting ComFy_ Community and Feature Similarity Guided Rewiring/layout.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:001ce82b4fcda8b03119a334601f3ea26ab1c6efec16a9320cc470e037d2fea1
+size 1178566

ICLR/2025/GOAL_ A Generalist Combinatorial Optimization Agent Learner/d986b1c4-dafa-42c6-96d2-d1f874e9aff3_content_list.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7e212e432c5a1adf139a170d1c95fca6fde0baed9ecd5931df51d0e1363f0da
+size 150459

ICLR/2025/GOAL_ A Generalist Combinatorial Optimization Agent Learner/d986b1c4-dafa-42c6-96d2-d1f874e9aff3_model.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ace8fc607622e9f83670493d8cec858e93863218fd7d2b75da9eaf6a2d1662cd
+size 177312

ICLR/2025/GOAL_ A Generalist Combinatorial Optimization Agent Learner/d986b1c4-dafa-42c6-96d2-d1f874e9aff3_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a52051a9a465ef5539eac76a8805c9bb13d2581564ff541801bac346cf5499f
+size 986975

ICLR/2025/GOAL_ A Generalist Combinatorial Optimization Agent Learner/full.md

@@ -0,0 +1,607 @@
+# GOAL: A GENERALIST COMBINATORIAL OPTIMIZATION AGENT LEARNER
+
+Darko Drakulic, Sofia Michel & Jean-Marc Andreoli
+
+NAVER LABS Europe, France
+
+firstname.lastname@naverlabs.com
+
+# ABSTRACT
+
+Machine Learning-based heuristics have recently shown impressive performance in solving a variety of hard combinatorial optimization problems (COPs). However they generally rely on a separate neural model, specialized and trained for each single problem. Any variation of a problem requires adjustment of its model and re-training from scratch. In this paper, we propose GOAL (for Generalist combinatorial Optimization Agent Learner), a generalist model capable of efficiently solving multiple COPs and which can be fine-tuned to solve new COPs. GOAL consists of a single backbone plus light-weight problem-specific adapters for input and output processing. The backbone is based on a new form of mixed-attention blocks which allows to handle problems defined on graphs with arbitrary combinations of node, edge and instance-level features. Additionally, problems which involve heterogeneous types of nodes or edges are handled through a novel multitype transformer architecture, where the attention blocks are duplicated to attend the meaningful combinations of types while relying on the same shared parameters. We train GOAL on a set of routing, scheduling and classic graph problems and show that it is only slightly inferior to the specialized baselines while being the first multi-task model that solves a wide range of COPs. Finally we showcase the strong transfer learning capacity of GOAL by fine-tuning it on several new problems. Our code is available at this url.
+
+# 1 INTRODUCTION
+
+Combinatorial Optimization (CO) problems are extensively studied in the Operations Research community, because they are both challenging in terms of theoretical complexity and central in many applications such as transportation, logistics and finance. Traditional CO methods include exact solvers, typically based on integer programming (Korte & Vygen, 2018), and approximation algorithms (Vazirani, 2003) which provide optimality or approximation guarantees, respectively, but do not scale; and heuristic algorithms (Boussaïd et al., 2013) which produce good-quality solutions faster but without guarantees. Effective heuristics heavily rely on expert knowledge and are generally problem-specific. A more recent and promising family of methods for CO is based on Machine Learning, either to learn the hyper-parameters of classic CO solvers, or to directly learn heuristics in an end-to-end fashion (Bengio et al., 2021; Cappart et al., 2021). In particular constructive neural heuristics have been successful at solving a variety of CO problems, including routing (Bello et al., 2017; Nazari et al., 2018; Kool et al., 2018; Kwon et al., 2020), scheduling (Zhang et al., 2020; Kwon et al., 2021) and graph problems (Khalil et al., 2017; Qiu et al., 2022). However, in most cases, a separate model is specialized and trained for each problem, and sometimes even for each distribution of instances within a problem, especially for varying instance sizes. While much effort has been devoted to improving the generalization to different instance distributions (Manchanda et al., 2022; Zhou et al., 2023; Son et al., 2023; Drakulic et al., 2023), generalization to different problems is less studied. Indeed, although there are strong neural heuristics for many CO problems, any variation of these problems requires adjustment of their model and re-training from scratch. While it is true that some problem-specific model tailoring may be required, since the structure of problem instances and solutions are very diverse, many problems are related and it would be interesting to exploit their commonalities. In this paper, we seek to answer the following question: Can we design and train a single generalist model so that it can be efficiently adapted to solve a
+
+variety of CO problems? The idea of pretraining a unified model on some pretext task so that it can be efficiently fine-tuned to several downstream tasks has been extremely successful in the language and vision domains (Devlin et al., 2019; Brown et al., 2020; Radford et al., 2021). In these domains, a self-supervised pretraining task exploits the intrinsic structure and regularities of images and text to learn generic representations. In contrast, in CO, while most problem instances can be modeled as graphs, there is no generic regularity to leverage by a pretext task. Graphs, unlike images or text contain little redundancy or intrinsic semantics.
+
+In this paper, we propose a new model, named GOAL (for Generalist combinatorial Optimization Agent Learner), which consists of a single backbone and light-weight problem-specific adapters for input and output processing. To handle the large discrepancy between CO problems, we propose three complementary strategies. First, to ensure learning related representations for different CO problems, we propose to use a problem-specific projection of the input instance features to a small fixed-size representation, which is then projected into the main embedding space using a shared codebook. Second, to handle problems defined on graphs with arbitrary combinations of node, edge and instance-level features, we design a new form of mixed-attention blocks for the backbone, injecting edge information at the core of each attention block. Finally, we introduce a novel multitype transformer architecture to deal with problems which involve heterogeneous types of nodes or edges (typically represented as multipartite graphs). The idea is to duplicate the backbone's mixed-attention blocks in order to attend each meaningful combination of types while relying on the same fixed set of shared parameters. In principle, GOAL is able to handle any CO problem whose instances can be represented as a graph and where feasible solutions can be constructed iteratively, as a sequence of node selections. We find that this pattern is generic enough to cover a wide range of problems. We train GOAL in a multi-task setting, by imitation of expert trajectories of eight classic CO problems, spanning multiple domains: Routing problems: the Asymmetric Traveling Salesman Problem, the Capacitated Vehicle Routing Problem with or without Time Windows, the Orienteering Problem; Scheduling problems: the Job Shop Scheduling Problem and the Unrelated Machine Scheduling Problem; Packing problems: the Knapsack Problem; and Graph problems: the Minimum Vertex Covering Problem. The expert trajectories are based on good-quality solutions, easily generated by traditional problem-specific solvers for instances of medium size (generally 100 nodes).
+
+Experimentally we first show that GOAL performs very well on all the training tasks, making it the first model that solves such a variety of CO problems. Second, we consider eight new problems and demonstrate that GOAL can be fine-tuned to reach a good performance, either in a few minutes using few-shot imitation learning or in a couple of hours without supervision. In both cases, the fine-tuning takes a fraction of the time and data needed to train a model from scratch. We further provide an ablation study to evaluate the effectiveness of a shared codebook, multi-type transformer architecture and mixed-attention blocks. Notably the GOAL architecture gives state-of-the-art results on 7 out of our 8 training tasks when used as single-task model. In summary, our contributions are the following:
+
+- We introduce GOAL: a generic and flexible model for end-to-end combinatorial optimization. Two key ingredients of GOAL are the simple yet effective form of mixed-attention blocks which enables handling problems represented by graphs with any combination of node-, edge- and instance-level features and its multi-type transformer architecture which allows to seamlessly tackle problems with multipartite graph structures.  
+- We demonstrate that it is possible to learn a single backbone model to effectively solve a variety of CO tasks, spanning routing, scheduling, packing and graph problems.  
+- We showcase the potential of such a multi-task pretrained model to be efficiently adapted to handle varied new CO tasks, with or without supervision. We believe this is a key step toward a foundation model for CO.
+
+# 2 RELATED WORKS
+
+End-to-end heuristic learning for CO Our work falls into the category of end-to-end constructive heuristics for combinatorial optimization. Constructive neural heuristics have been successfully applied to a wide range of COPs, including many variants of routing problems (Kool et al., 2018; Xin et al., 2021; Kim et al., 2022; Kool et al., 2022; Fu et al., 2021; Sun & Yang, 2023), scheduling
+
+problems (Zhang et al., 2020; Kwon et al., 2021), as well as classic COPs such as the Knapsack Problem (Kwon et al., 2020) and the Maximum Independent Set (Khalil et al., 2017; Sun & Yang, 2023). Another successful category of neural CO methods are improvement heuristics, which focus on iteratively enhancing a given complete solution, typically by using a neural network to guide the selection of local search operators (Chen & Tian, 2019; Hottung & Tierney, 2020; Ma et al., 2021; Wu et al., 2022). The seminal work of Khalil et al. (2017) introduces graph embeddings which do work for a variety of CO problems but with limited performance. Current state-of-the-art models are tailored for certain problem structures (e.g. euclidian routing problems, where nodes are represented by their coordinates plus some extra node or graph features such as demand or vehicle capacity), and successfully handled by transformer-based architectures (Kool et al., 2018). For non-euclidian routing problems, Kwon et al. (2021) and Drakulic et al. (2023) propose adapted architectures to deal with the distance matrix, but they are specialized for such problems and do not apply to those with node-only features. In GOAL, we propose a novel mixed-attention modules which can flexibly deal with both node and edge features, incurring no overhead when one or the other is missing.
+
+Generalization of neural heuristics While the first seminal models for neural CO had a dramatic drop in performance when tested on out-of-training distribution instances (Joshi et al., 2022; Manchanda et al., 2022), several recent approaches show a greatly improved generalization performance, especially to larger instances (Fu et al., 2021; Li et al., 2021; Son et al., 2023; Pan et al., 2023), to distribution shifts of other instance parameters (Bi et al., 2022), or both (Manchanda et al., 2022; Bi et al., 2022; Zhou et al., 2023; Drakulic et al., 2023). Concurrently with our work, some papers have started to explore cross-problem generalization for the family of routing problems. Specifically, (Lin et al., 2024) propose to pretrain the AM model (Kool et al., 2018) on the TSP and to fine-tune either the entire model or some light-weight modules on the Price Collecting TSP and OP. Additionally, Zhou et al. (2024); Liu et al. (2024); Berto et al. (2024) explore generalization to different variants of the CVRP. They build on the idea of zero-shot compositionality (Ruis et al., 2021) by training a model on CVRPs with some combinations of constraints from a predefined set (e.g. time windows and duration limit constraints) and show that the model generalizes to some unseen combinations of the same constraints. Wang & Yu (2023) propose a bandit based approach to alternate between problems during training, so as to focus on those which have the best return. Although these approaches tackle multiple problems, it is important to note that the considered Euclidean routing problems remain very similar in structure and indeed many of those problems were solved by the seminal Attention Model of (Kool et al., 2018) with little adaptations of its base model. Our paper goes further and considers multi-task training and transfer learning of a new model on a variety of COPs with different structures.
+
+Multi-task training for sequential decision making Multi-task (pre-)training has recently shown promising results in related fields. For example, Ibarz et al. (2022) proposed a graph neural network processor capable of learning to execute a variety of algorithms, such as sorting and searching. The paper focuses only on polynomial problems and learns to imitate the execution of classical algorithms. In contrast, we address NP-hard problems and learn by imitation of the solution provided by (potentially exponential) specialized solvers. Recent approaches in control rely on sequence modeling of expert trajectories from multiple tasks (Stooke et al., 2021; Sun et al., 2023). Although they treat various tasks, with potentially diverse state and action spaces, these works still consider image observations and exploit this common structure. Reed et al. (2022) propose GATO, a general-purpose agent obtained by training a large transformer-based model on hundreds of tasks spanning vision, language and control. It demonstrates the potential of a single network (albeit with 1.2B parameters) to effectively tackle a wide variety of tasks.
+
+# 3 MULTI-TASK LEARNING FOR COMBINATORIAL OPTIMIZATION
+
+# 3.1 CONSTRUCTIVE CO PROBLEM SOLVING
+
+We assume that a CO problem instance is given by a pair of a finite, non-empty set  $X$  of feasible solutions, and a real-valued objective function  $f$  whose domain contains  $X$ . Solving the instance consists in finding an optimal solution, i.e. an element of  $\arg \min_{x \in X} f(x)$ . Constructive approaches assume that  $f$  is defined not only over  $X$  but over a set of partial solutions, which includes  $X$  and is amenable to a step-wise construction procedure where each partial solution can be
+
+![](images/eebad53b582adbe93cd165b5b7f268aefdcfc2dc6421199d5dfaab15a8347891.jpg)  
+Figure 1: Left: Architecture of GOAL for single-type problems; the green components are task-specific, while the others belong to the backbone. The codebook is a shared  $\ell \times D$  (resp.  $\bar{\ell} \times \bar{D}$ ) matrix (with  $\ell \ll D$ ,  $\bar{\ell} \ll \bar{D}$ ) applied to the node (resp. edge) representations produced by the input adapters. Right: Architecture of GOAL for multi-type problems (with here 2 node types T1,T2); it uses multiple mixed attention blocks ("MMA"), some in self- and some in cross-attention mode, but they all share the same parameters (per layer); so do the two Feed Forward blocks ("FF"). For the edges, all the type combinations are shown (here T11,T12,T21,T22) but those which have no meaning in a task are simply omitted. The same set of parameters is used for the two architectures.
+
+![](images/b031401d9b2dcbc12495d2cf686d1013f0c58a695d46cc7700afce5d086197e7.jpg)
+
+obtained by a sequence of construction steps. Thus, solving the problem instance can be formulated as a sequential decision procedure which iteratively selects the construction steps so as to reach not only a feasible but an optimal solution. That in turn can be modeled as a Markov Decision Problem (MDP) associated with the problem. In this paper, we use the BQ-MDPs introduced by Drakulic et al. (2023) which are defined for "tail-recursive" problems, i.e. the widespread class of problems that are solvable by dynamic programming (Bertsekas, 2019). In BQ-MDPs, the actions are the construction steps, typically the selection of a node, while the states are simply instances. This differs from many peer NCO models where each state is a pair of an instance and a partial solution. The tail recursion property precisely ensures that the two alternatives lead to "bisimilar" MDPs, which have the same optimal policies, as shown in Drakulic et al. (2023), but the BQ-MDPs' states more efficiently capture the relevant information to determine these policies.
+
+# 3.2 MULTI-TASK CO PROBLEMS
+
+Now, given a class  $\mathcal{T}$  of tail-recursive CO problems called tasks, let  $\Omega_t$  for each task  $t \in \mathcal{T}$  denote the parametric space used to represent its instances. Consider the new (multi-task) CO problem whose instances are represented in the disjoint union  $\biguplus_{t \in \mathcal{T}} \Omega_t$  consisting of pairs  $(t, \omega)$  of a task identifier  $t \in \mathcal{T}$  and a point  $\omega \in \Omega_t$  in its corresponding parameter space. It is easy to show that the multi-task problem is tail-recursive whenever each of its components is. And its BQ-MDP is then simply the disjoint union of the BQ-MDPs of its components.
+
+In this paper, we study alternatives for the multi-task policy space, beyond the (trivial) Cartesian product of the policy spaces of the individual tasks, where no parameter is shared between the different tasks. The underlying assumption is that if the tasks are sufficiently similar, learning one task may elicit implicit skills useful to other tasks, which are then leveraged by parameter sharing. In the extreme, some tasks may require little training data and/or just a few shot fine-tuning to obtain acceptable performance, leveraging their similarity to more thoroughly trained tasks. Since each task has its own parametric space used to represent its instances, some part of any multi-task policy has to be task specific, and trained by processing at least a few instances of each task: pure zero-shot generalization is not possible. The situation is close to multi-lingual Natural Language Processing,
+
+where the vocabulary of each language needs to be seen at least once at training or fine-tuning. And we borrow the solution used in that context, namely adapters (Bapna & First, 2019).
+
+# 3.3 TASK REPRESENTATION
+
+To leverage operational similarity between tasks, we need them to have at least representational similarity. Thus, we assume that each instance of size  $N$  of a task (CO problem) is represented by a set of  $N$  abstract "nodes", together with features which can be attached at node, edge (node pair) or instance level. Instance features can be replicated and appended to the features of each node, hence can be ignored without loss of generality. Since the construction steps (actions) are returned by the task-specific output adapters (Sec 3.4), there are no restrictions on their format. For simplicity and to cover the problems used in our experiments, we assume in the sequel that each construction step consists of the selection of a node, possibly with an option among a fixed number  $K$  of options (dependent on the task: in most cases,  $K = 1$  and the action simply selects a node).
+
+Hence, the GOAL model takes three inputs  $t, x, \bar{x}$ , where  $t$  is a task identifier, and  $(x, \bar{x}) \in \Omega_t$  is a parameter representing an instance of task  $t$ , where  $x \in \mathbb{R}^{N \times F_t}$  (resp.  $\bar{x} \in \mathbb{R}^{N \times N \times \bar{F}_t}$ ) represents the feature vectors of dimension  $F_t$  of the  $N$  nodes (resp.  $\bar{F}_t$  of the  $N \times N$  edges). While some tasks may have no edge feature  $(\bar{F}_t = 0)$ , we always assume that at least one node feature exists, which distinguishes the nodes by a randomly assigned value between 0 and 1, similar to the random features used in Graph Neural Networks (Sato et al., 2021), so we always have  $F_t \geq 1$ . Both  $F_t$  and  $\bar{F}_t$ , as well as the meaning of the corresponding features, depend on task  $t$ . The output of the model is a matrix  $y \in \mathbb{R}^{N \times K_t}$  representing the score of each candidate action, i.e. the pair of a node and an option for selection. As usual, it is passed to a softmax (over the whole matrix) to obtain a probability distribution. Wherever appropriate, task-dependent masking can be used to ensure that probabilities are null for the actions disallowed by a task.
+
+# 3.4 ARCHITECTURE OF THE MODEL
+
+The architecture of our model generalizes that of BQ-NCO (Drakulic et al., 2023), and is described in Fig. 1 left. It essentially consists of a sequence of layers whose parameters are shared by all the tasks (backbone) together with task-specific adapter modules at the input and output of the model<sup>1</sup>. The input-output adapter modules for task  $t$  are specific to the dimensions  $F_{t}, F_{t}, K_{t}$  and the meaning of the corresponding features. No positional encoding is used: all relational information is assumed to be captured by  $\bar{x}$ . The layers themselves, on the other hand, are only aware of the shared embedding dimensions  $D, \bar{D}$ . They are self-attention transformer layers (Vaswani et al., 2017) where vanilla attention is replaced by multi-head mixed attention, similar in intent to (Kwon et al., 2021; Henderson et al., 2023) but with a different design.
+
+Our mixed attention block, in the general case where  $M$  nodes attend on  $N$  nodes ( $M = N$  only in self-attention), is an instance of generalized attention (Andreoli, 2019). A generalized attention mechanism takes the following inputs: node representations as vectors for  $N$  queries,  $M$  keys, and  $M$  values, with an optional  $M \times N$  log-binary mask  $\mathcal{M}$ . In each head  $h$ , each query, key, value vector is first projected into a common space of dimension  $d$ , yielding for each  $n = 1:N$  and  $m = 1:M$ , vectors (of dimension  $d$ ):
+
+$$
+Q _ {n} ^ {(h)} = Q _ {n} \mathbf {W} _ {Q} ^ {(h)}, \qquad \qquad K _ {m} ^ {(h)} = K _ {m} \mathbf {W} _ {K} ^ {(h)}, \qquad \qquad V _ {m} ^ {(h)} = V _ {m} \mathbf {W} _ {V} ^ {(h)}.
+$$
+
+Then the key and query vectors are used to compute an  $M \times N$  score matrix  $S$ , which is transformed into an attention matrix (by adding the mask and applying softmax) multiplied by the reprojected value vectors to produce the output representation  $r$  of the  $N$  input query nodes as a matrix with  $N$  rows:
+
+$$
+r = \sum_{h}\underbrace{\operatorname{softmax}_{\mathrm{col}}(S^{(h)} + \mathcal{M})^{\top}}_{\text{attention matrix}}V^{(h)}\mathbf{W}_{O}^{(h)\top}.
+$$
+
+Attention mechanisms then differ in the way they compute the score matrix:
+
+$$
+(\text {v a n i l l a} S _ {m n} ^ {(h)} = \left\langle K _ {m} ^ {(h)} \mid Q _ {n} ^ {(h)} \right\rangle , \tag {1a}
+$$
+
+$$
+\text {(o u r m i x e d a t t e n t i o n)} \quad S _ {m n} ^ {(h)} = \left\langle K _ {m} ^ {(h)} + K _ {m n} ^ {\prime (h)} \mid Q _ {n} ^ {(h)} + Q _ {m n} ^ {\prime (h)} \right\rangle . \tag {1b}
+$$
+
+In vanilla attention, the scores are obtained by simple scalar product of the key and query vectors (equation 1a). Our mixed attention mechanism takes as additional input  $M \times N$  "edge" vectors, projected twice into the common space of dimension  $d$ , once as key and once as query, resulting in vectors (of dimension  $d$ ):
+
+$$
+Q _ {m n} ^ {\prime (h)} = E _ {m n} \mathbf {W} _ {Q} ^ {\prime (h)}, \quad K _ {m n} ^ {\prime (h)} = E _ {m n} \mathbf {W} _ {K} ^ {\prime (h)}. \tag {2}
+$$
+
+The score matrix is still obtained as a scalar product of a key and a query vector, but now, each of them is the sum of a node component and an edge component (equation 1b). Our mixed attention allows to incorporate arbitrary relational information (edge features) into the core of the attention mechanism. It differs from positional encoding, which attempts to instill a priori the edge information (limited to sequential ordering) into the node representations.
+
+In the GOAL backbone, all the node (resp. edge) inputs to the attention blocks are of dimension  $D$  (resp.  $\bar{D}$ ), and they are all projected into a common space of dimension  $d$  equal to  $D$  divided by the number of heads. No masking is used in the backbone. One well-known limitation of this model is its quadratic complexity, the attention matrices being of size  $N^2$ . In practice though, for many tasks, a simple, task-specific heuristic can deal with that problem by pre-filtering the set of nodes to present to the model (usually much fewer than  $N$ ). Whenever available, we use such heuristics.
+
+Input and output adapters are linear projections, from the task-specific instance features to the backbone's input embeddings and from the backbone's output embeddings to the task-specific action space. However, when the embedding dimension is large and the number of training tasks is small, there is a risk that the embeddings produced by each task end up occupying complementary subspaces of the embedding space throughout the layers, which would defeat the purpose of effectively sharing parameters across tasks. To prevent this, we simply force the input linear projection to be low rank. Thus, node (resp. edge) features are first mapped into a low dimension  $\ell \ll D$  (resp.  $\overline{\ell} \ll \bar{D}$ ), through a task-specific linear projection (the input adapter proper), forcing the representations to share dimensions across tasks. Then this "small" representation is plunged into a "large"  $D$ -resp.  $\bar{D}$ -dimensional embedding, through a common linear projection, called a codebook, shared by all the tasks (see Fig. 1 left).
+
+# 3.5 MULTI-TYPE TRANSFORMER ARCHITECTURE
+
+Many tasks (CO problems) involve different types of nodes. For example, scheduling problems often involve "operation" and "machine" nodes. For GOAL, one solution is to simply treat them all indiscriminately in the backbone. The adapters, being problem specific, are of course free to treat them differently according to their types. This is sometimes unsatisfactory though, since it forces the adapter to provide uniform embeddings for all the nodes and edges, though they are often heterogeneous by nature: in the scheduling example, edge features may carry precedence constraints when between operations, or processing times when between machines and operations, and no information at all when between machines. Instead of packing all these different types of relations into a single vector, with padding values wherever a feature is undefined for a given edge, we propose a multi-type architecture where the adapters output separate embeddings per type (for nodes) or compatible pairs of types (for edges). Each layer of the model, instead of being a monolithic self-attention block operating on all the nodes, becomes a task-specific combination of both cross- and self-attention blocks, as described by equation 1b, operating on different type-compatible subsets of nodes and edges. This is illustrated in Fig. 1 right in the case of two types. For  $n$  types, the architecture would be similar but involves  $n^2$  mixed-attention blocks, where each type attends to itself and every other type, or a selection of relevant types defined by the task. Therefore, in our scheduling example, the model will contain separate self-attention blocks, for operation nodes and machine nodes respectively, and cross-attention blocks, for operation-machine edges and vice-versa. Observe that while the architecture configuration is now task-specific, the model parameters remain the same for all the configurations: all the attention blocks of a layer, be them self- or cross-attention, and whatever the types they involve, share the same, layer-specific parameters. This is precisely what allows us to train a unique model to solve arbitrary single- and multi-type problems.
+
+# 3.6 TRAINING PROCEDURE
+
+We train GOAL on a set of eight various CO problems (described in Sec 4). For each training problem, we define the corresponding BQ-MDP, the linear input and output adapters to match the
+
+dimensions of the input features and the construction actions. We train the model by imitation of high-quality solutions, provided by specialized solvers. At each step, we sample a problem and create a batch of instances by sampling suffix subproblems from the training instances, similarly to (Drakulic et al., 2023). The forward and backward processes involve the input and output adapters, as well the backbone parameters, where the mixed-attention and feed-forward blocks are duplicated within each layer if the sampled task is multi-typed.
+
+# 4 EXPERIMENTS
+
+Our experiments aim to address the following questions: (i) does the GOAL approach enable learning a single backbone to effectively solve a variety of CO problems (Sec 4.1)? (ii) can it be used as a pretrained model and efficiently fine-tuned to solve new CO problems, unseen at training (Sec 4.2)? (iii) to what extent do our mixed-attention blocks and multi-type architecture contribute to the results (Sec 4.3)? We begin by describing the multi-task training of GOAL.
+
+Training tasks. We train GOAL on eight classic and varied CO problems. For each problem, we generate a training dataset of 1 million random instances and solve them using traditional solvers. Specifically, we consider the following problems and oracle solvers: the Asymmetric Traveling Salesman Problem (ATSP) with LKH (Helsgaun, 2017), the Capacitated Vehicle Routing Problem (CVRP) with LKH (Helsgaun, 2017), the Capacitated Vehicle Routing Problem with Time Windows (CVRPTW) with HGS (Vidal, 2022) the Orienteering Problem (OP) with A4OP (Kobeaga et al., 2018), the Knapsack Problem (KP) with ORTools (Perron & Furnon, 2022), the Minimum Vertex Covering Problem (MVC) with FastWVC (Cai, 2023), the Unrelated Machine Scheduling Problem (UMSP) with HiGHS (Huangfu & Hall, 2018) and the Job Shop Scheduling Problem (JSSP) with ORTools (Perron & Furnon, 2022). The training instances are of size 100 nodes, or  $10 \times 10$  for JSSP and  $100 \times 20$  for UMSP (resulting in both cases in 100 operation nodes). The description of the problems and the associated data generation processes is provided in Appendix F.
+
+Training details. GOAL is trained by alternating batches in random order from each of the training tasks, using a single-class cross-entropy loss for ATSP, CVRP, CVRPTW, OP, JSSP and UMSP and a multi-class cross-entropy loss for KP and MVC. We use AdamW optimizer (Loshchilov & Hutter, 2018), with an initial learning rate of 0.0005 and a decay rate of 0.97 every 10th epoch. We trained the model on 8 Nvidia V100 GPU servers, with batch size of 256 for 7 days, completing ca. 400 epochs. The best model was selected based on the average performance on a validation set of 128 instances per problem. The model hyperparameters are described in Appendix A.
+
+Baselines. We consider the following constructive neural models as baselines: AM (Kool et al., 2018), MDAM (Xin et al., 2021), POMO (Kwon et al., 2020), Sym-NCO (Kim et al., 2022), BQ-NCO (Drakulic et al., 2023), MVMoE (Zhou et al., 2024), MatNet (Kwon et al., 2021), S2VDQN (Khalil et al., 2017), RouteFinder (Berto et al., 2024), COMPASS (Chalumeau et al., 2023) and Gumbeldore (Pirnay & Grimm, 2024). All models except MVMoE and RouteFinder are specialized and trained in single-task mode. They are often combined at test time with various enhancers, such as beam search Drakulic et al. (2023), simulation-guided beam search (Choo et al., 2022), MCTS (Xing & Tu, 2020), instance augmentation (Kwon et al., 2020), or active search (Hottung et al., 2021), but for fair comparison, all the results we report are obtained by a pure greedy application of the trained policy at test time.
+
+# 4.1 PERFORMANCE ON THE TRAINING TASKS
+
+In Table 1 we compare the performance of GOAL to the relevant neural baselines for each problem as well as its single-task version (i.e. GOAL trained separately for each task). First, we observe that the best performance is achieved by the single-task GOAL in 7 out of the 8 tasks, with a computation time comparable to that of the baselines. This proves the versatility and effectiveness of our proposed architecture, even for a specialized model. Second, we see that multi-task GOAL is only slightly worse than the single-task version. These results validate the capability of the GOAL backbone, together with the task-specific adapters, to effectively solve the variety of training tasks. More broadly, they demonstrate that multi-task learning can be a successful paradigm for neural combinatorial optimization.
+
+<table><tr><td rowspan="2"></td><td colspan="2">ATSP100</td><td colspan="2">CVRP100</td><td colspan="2">CVRPTW100</td><td colspan="2">OP100</td></tr><tr><td>gap</td><td>time</td><td>gap</td><td>time</td><td>gap</td><td>time</td><td>gap</td><td>time</td></tr><tr><td>Oracle solver</td><td>0.00%</td><td>29s</td><td>0.00%</td><td>12m</td><td>0.00%</td><td>10m</td><td>0.00%</td><td>1.1m</td></tr><tr><td>AM greedy</td><td>-</td><td></td><td>7.11%</td><td>1s</td><td></td><td></td><td>5.35%</td><td>1s</td></tr><tr><td>MDAM greedy</td><td>-</td><td></td><td>4.84%</td><td>1s</td><td>-</td><td></td><td>2.88%</td><td>16s</td></tr><tr><td>POMO no aug</td><td>-</td><td></td><td>1.21%</td><td>1s</td><td>-</td><td></td><td>-</td><td></td></tr><tr><td>Sym-NCO greedy</td><td>-</td><td></td><td>3.33%</td><td>1s</td><td>-</td><td></td><td>2.03%</td><td>2s</td></tr><tr><td>BQ-NCO greedy</td><td>1.27%</td><td>2s</td><td>2.79%</td><td>2s</td><td>-</td><td></td><td>0.22%</td><td>2s</td></tr><tr><td>MVMoE/4E</td><td>-</td><td></td><td>1.65%</td><td>1s</td><td>4.90%</td><td>1s</td><td>-</td><td></td></tr><tr><td>RouteFinder-TE</td><td>-</td><td></td><td>1.50%</td><td>1s</td><td>3.19%</td><td>1s</td><td>-</td><td></td></tr><tr><td>MatNet greedy</td><td>0.93%</td><td>1s</td><td>-</td><td></td><td>-</td><td></td><td>-</td><td></td></tr><tr><td>GOAL SINGLE-TASK greedy</td><td>0.30%</td><td>10s</td><td>2.34%</td><td>10s</td><td>2.61%</td><td>10s</td><td>-0.04%</td><td>3s</td></tr><tr><td>GOAL MULTI-TASK greedy</td><td>0.91%</td><td>10s</td><td>3.16%</td><td>10s</td><td>3.82%</td><td>10s</td><td>0.43%</td><td>3s</td></tr><tr><td rowspan="2"></td><td colspan="2">KP100</td><td colspan="2">MVC100</td><td colspan="2">UMSP100x20</td><td colspan="2">JSSP10x10</td></tr><tr><td>gap</td><td>time</td><td>gap</td><td>time</td><td>gap</td><td>time</td><td>gap</td><td>time</td></tr><tr><td>Oracle solver</td><td>0.00%</td><td>1s</td><td>0.00%</td><td>2m</td><td>0.00%</td><td>2m</td><td>0.00%</td><td>47s</td></tr><tr><td>POMO no aug</td><td>0.19%</td><td></td><td>-</td><td></td><td>-</td><td></td><td>-</td><td></td></tr><tr><td>BQ-NCO greedy</td><td>0.10%</td><td></td><td>-</td><td></td><td>-</td><td></td><td>-</td><td></td></tr><tr><td>S2V-DQN</td><td>-</td><td></td><td>0.97%</td><td>2s</td><td>-</td><td></td><td>-</td><td></td></tr><tr><td>COMPASS</td><td>-</td><td></td><td>-</td><td></td><td>-</td><td></td><td>4.70%</td><td>3h</td></tr><tr><td>Gumbeldore greedy</td><td>-</td><td></td><td>-</td><td></td><td>-</td><td></td><td>3.17%</td><td>9s</td></tr><tr><td>GOAL SINGLE-TASK greedy</td><td>0.10%</td><td>3s</td><td>0.23%</td><td>3s</td><td>2.82%</td><td>7s</td><td>2.73%</td><td>15s</td></tr><tr><td>GOAL MULTI-TASK greedy</td><td>0.12%</td><td>3s</td><td>0.37%</td><td>3s</td><td>3.84%</td><td>7s</td><td>4.13%</td><td>15s</td></tr></table>
+
+Table 1: Performance on 128 test instances from the training tasks. Each gap is with respect to the oracle and often corresponds to the optimality gap. Lower is better.
+
+In addition, in Appendix E, we provide experimental results demonstrating GOAL's excellent zero-shot generalization on instances up to 10 times larger than the training instances. We can note in particular the strong generalization for ATSP which seems much more challenging for the state-of-the-art baselines. This confirms the effectiveness of our mixed-attention mechanism.
+
+# 4.2 FINE-TUNING TO NEW TASKS
+
+In this section, we want to evaluate the transfer capability of the trained GOAL backbone to unseen tasks. We consider eight diverse new COPs: the Traveling Repairman Problem (TRP), the Prize Collecting TSP (PCTSP), the Open CVRP (OCVRP), the Split Delivery CVRP (SDCVRP), the Sequential Ordering Problem (SOP), the Maximum Covering Location Problem (MCLP), the Maximum Independent Set (MIS) problem and the Open Shop Scheduling Problem (OSSP) (detailed descriptions in Appendix F). GOAL can be fine-tuned to specific problems in two modes. In both, the adapters are trained from scratch, and the backbone is also open to backpropagation (no parameter freeze). The supervised mode is identical to training, except it processes only a few (labeled) instances of the problem for a few steps. Details and results are given in Appendix B. The unsupervised mode is more challenging, but also more realistic, since we may not have access to good-quality solutions for the new problem. We propose to fine-tune the model by iterative imitation-improvement steps between an Apprentice and an Expert, as in ExIt (Anthony et al., 2017). While Exit relies on a possibly complex tree-search for improvement, we use instead a brute-force but fast method, where the Expert samples multiple solutions (in our case 128) per instance from the Apprentice and selects the best, if it is sufficiently better, and sends it back to the Apprentice (current model) for imitation. This is similar to the self-labeling strategy proposed by Corsini et al. (2024) for the JSSP. One could also use more sophisticated experts such as generic local search heuristics or smarter sampling (Pirnay & Grimm, 2024) to accelerate the finetuning. Performance results are given in Fig 2, which shows that unsupervised fine-tuning systematically outperforms unsupervised training of the whole model from scratch at a comparable processing time budget. We also compare finetuning GOAL to finetuning the single-task models and report the results in Fig 4. We observe that the multi-task model consistently performs as well or better than the "most-related" single-task
+
+model (e.g. CVRP model for OCVRP or JSSP model for OSSP), hinting to the synergistic effect of the multi-task training.
+
+![](images/bc271dbd60ca06606653507a3080588048267b2df11356f084b807bafe9da96e.jpg)
+
+![](images/eb1ad8b0bba3c489688d4aca7a5c99333f1643bc09489aef25784a69e37f3bc5.jpg)
+
+![](images/937295f8e71cd055b7c6c858ca0e920735f4f0c23ffcad06c7f3a1ef82da1558.jpg)
+
+![](images/9abbec311bdce6cca8233e513b7a3c226a013a6c3fb31c4a3972380274c6eab5.jpg)
+
+![](images/a71d9c5e3639179c0aa9eac4abb048cb065b03f278badcae845bc6008479fdea.jpg)  
+Figure 2: Unsupervised fine-tuning of GOAL to eight diverse new tasks. We report the best results over 10 runs both for training from scratch and fine-tuning.
+
+![](images/8f84f6a1d921c1033e55c2c09d3d8802ebdbddfaf9757b7be0e795f676381501.jpg)
+
+![](images/1970e78705807a470d2d1bcef00d944d4b8b1e77c420e6e0f6e7d93c4cbf3424.jpg)
+
+![](images/2a6f4fa0c0b654bfacc8152bee3052454ac1f63c2e5d55337d6c83cd84025b59.jpg)
+
+# 4.3 ABLATION STUDY
+
+Mixed-attention blocks. We compare our mixed-attention blocks with alternative modules which also aim at mixing the edge information with the attention scores, namely MatNet (Kwon et al., 2021) and G2G (Henderson et al., 2023). More precisely we focus on the ATSP and train three versions of GOAL with the three different variants of mixed-attention. For MatNet, we keep the original hyper-parameters used for solving the ATSP. Fig 3 (left) presents the models performance (optimality gap on a test set of 128 instances) at different points of the training. We see that using our mixed-attention blocks leads to a significant gain, on the performance at convergence (MatNet) or on the speed of convergence (G2G). Note that these ablations are performed on a smaller training dataset than in the previous experiments (100k instances), hence the larger optimality gap.
+
+Multi-type transformer. Our multi-type architecture is meant to deal with tasks that are naturally represented by multipartite graphs with heterogeneous nodes or edges, typically scheduling problems where job and machine nodes play different roles. To evaluate its effect on the performance, we compare it to that obtained with the more direct alternative which ignores node and edge heterogeneity: we simply gather in a single tensor the node (edge) representations of the different types, produced by the input adapter, and use the original single-type model. Note that because of the linearity of the input adapters, these representations can be obtained either by defining a specific linear transform per type, or equivalently by defining a single linear transform on the direct sum of the feature spaces of the different types. We implemented the former for the Job Shop Scheduling Problem and present in Fig 3 (middle) a comparison between the training performance of the single-type and multi-type architectures. Clearly, the multi-type architecture converges faster and to a better performance: after 200 epochs of training on 100K instances, it reaches a test optimality gap of  $4.6\%$  while the single-type model achieves only  $8.9\%$ . Finally, note that the multi-type model offers more flexibility for fine-tuning: while, in order to be task agnostic at training, parameter sharing between the type specific attention blocks of a layer must be enforced, that constraint can be relaxed at fine-tuning to better fit the task at hand.
+
+Sparsification using a codebook. Fig 3 (right) experimentally confirms the importance, in the fine-tuning phase (supervised mode), of sparsifying the input adapter with a shared codebook. The results are given for the PCTSP, but similar results are available in Fig 6 (Appendix) for the other problems. The shared codebook results in a more stable finetuning (over 10 runs) and to a better optimality gap. While we do not observe a significant effect on the performance on the training tasks, we believe that constraining the rank of the codebook tends to prevent its vectors from specializing for individual tasks seen at training, which would be of limited use when fine-tuning to new tasks.
+
+![](images/570de87a7313570ef0f71fd9456d746ad319322cdda74a866c6c3d1ce52bc86f.jpg)  
+Figure 3: (left) Performance with different variants of mixed-attention. (middle) Performance of single- vs multi-type GOAL. (right) Fine-tuning of GOAL with and without the codebook.
+
+![](images/49bc5bbc3fc4d1dcf91bda033b3d634481e6072fd8c5fc8007eda10f1a9ff9d8.jpg)
+
+![](images/17c1217673a876c84195c9fc46ec730311b29a1cfcc3e09cf9df7abb48d6536d.jpg)
+
+![](images/db42662a4c358ee5907bbb315cc3a222e5e2f57b59d64700b396b4d2d5c6ae01.jpg)
+
+![](images/054945efdd617da448a6659981828acf1ed01d31adb7616b3da3f81c4e8ba0f8.jpg)  
+Figure 4: Comparison of the (supervised) fine-tuning of the single- versus multi-task GOAL on four new problems.
+
+# 5 DISCUSSION AND CONCLUSION
+
+In this paper, we propose a generalist neural CO model (GOAL) and demonstrate the feasibility of learning a shared backbone model to solve a variety CO problems, spanning routing, scheduling, packing and classic graph problems. We have shown the benefits of GOAL as (i) a single-task specialized model, providing state-of-the-art results on seven CO problems; (ii) a multi-task model, able to solve different problems with the same backbone; and (iii) a pretrained model, which is efficiently fine-tuned to new problems. The proposed multi-task pre-training relies on imitation learning and therefore the availability of good-quality solutions. While this is not an intrinsic limitation of the GOAL model, we believe that imitation learning is an effective training paradigm for learning multitask models. This is indeed demonstrated by previous works which relied on sequence-modeling training tasks for control (Sun et al., 2023; Reed et al., 2022). It is particularly advantageous for CO as we can leverage high-quality solutions to classical NP-hard problems, provided by traditional solvers, which are based on decades of OR research. In contrast, for a new potentially more original problem, we show that GOAL can be effectively finetuned without any supervision. Our approach is limited to problems where solution feasibility is easy to ensure during the construction, which is a common requirement of constructive heuristics. Finally the quadratic complexity of the underlying transformer architecture makes the approach too costly for problem sizes beyond a thousand nodes. Exploring more efficient forms of attention as basis for our mixed-attention blocks would be a promising direction for better scaling.
+
+# ETHICS STATEMENT
+
+To the best of our knowledge, no aspect of our research raises ethics issues. It did not involve human subjects, and considers only generic Combinatorial Optimization problems with no dubious association.
+
+# REPRODUCIBILITY STATEMENT
+
+For full reproducibility, the implementation of the backbone, the adapters and all the experiments described in this paper are publicly available at https://github.com/naver/goal-co. The training data generation process, the training process, and its hyper-parameters are described in detail in the Appendix.
+
+# REFERENCES
+
+Jean-Marc Andreoli. Convolution, attention and structure embedding. In Proc. of NeurIPS Workshop on Graph Representation Learning, pp. 8, Vancouver, BC, Canada, December 2019.  
+Thomas Anthony, Zheng Tian, and David Barber. Thinking Fast and Slow with Deep Learning and Tree Search. In Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.  
+Thomas Bachlechner, Bodhisattwa Prasad Majumder, Henry Mao, Gary Cottrell, and Julian McAuley. ReZero is all you need: Fast convergence at large depth. In Proceedings of the Thirty-Seventh Conference on Uncertainty in Artificial Intelligence, pp. 1352-1361. PMLR, December 2021.  
+Ankur Bapna and Orhan First. Simple, Scalable Adaptation for Neural Machine Translation. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pp. 1538-1548, Hong Kong, China, November 2019. Association for Computational Linguistics.  
+Irwan Bello, Hieu Pham, Quoc V. Le, Mohammad Norouzi, and Samy Bengio. Neural Combinatorial Optimization with Reinforcement Learning. In 5th International Conference on Learning Representations, ICLR 2017, Toulouse, France, April 24-26, 2017, Workshop Track Proceedings. OpenReview.net, 2017.  
+Yoshua Bengio, Andrea Lodi, and Antoine Prouvost. Machine learning for combinatorial optimization: A methodological tour d'horizon. European Journal of Operational Research, 290(2): 405-421, 2021.  
+Federico Berto, Chuanbo Hua, Nayeli Gast Zepeda, Andre Hotung, Niels Wouda, Leon Lan, Kevin Tierney, and Jinkyoo Park. RouteFinder: Towards Foundation Models for Vehicle Routing Problems. In ICML 2024 Workshop on Foundation Models in the Wild, July 2024.  
+Dimitri Bertsekas. Reinforcement Learning and Optimal Control. Athena Scientific, July 2019. ISBN 978-1-886529-39-7.  
+Jieyi Bi, Yining Ma, Jiahai Wang, Zhiguang Cao, Jinbiao Chen, Yuan Sun, and Yeow Meng Chee. Learning Generalizable Models for Vehicle Routing Problems via Knowledge Distillation. In Sanmi Koyejo, S. Mohamed, A. Agarwal, Danielle Belgrave, K. Cho, and A. Oh (eds.), Advances in Neural Information Processing Systems 35: Annual Conference on Neural Information Processing Systems 2022, NeurIPS 2022, New Orleans, LA, USA, November 28 - December 9, 2022, 2022.  
+Ilhem Boussaïd, Julien Lepagnot, and Patrick Siarry. A survey on optimization metaheuristics. Information Sciences, 237:82-117, July 2013. ISSN 0020-0255.  
+Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M.
+
+Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language Models are Few-Shot Learners. In Hugo Larochelle, Marc' Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin (eds.), Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, Virtual, 2020.  
+Shaowei Cai. FastWVC Solver: Implementation of the algorithm proposed in Towards Faster Local Search for Minimum Weighted Vertex Cover on Massive Graphs, July 2023. Preprint.  
+Quentin Cappart, Didier Chételat, Elias B. Khalil, Andrea Lodi, Christopher Morris, and Petar Velicković. Combinatorial Optimization and Reasoning with Graph Neural Networks. In Twenty-Ninth International Joint Conference on Artificial Intelligence, volume 5, pp. 4348-4355, August 2021.  
+Felix Chalumeau, Shikha Surana, Clement Bonnet, Nathan Grinsztajn, Arnu Pretorius, Alexandre Laterre, and Thomas D. Barrett. Combinatorial Optimization with Policy Adaptation using Latent Space Search, November 2023. Preprint arXiv:2311.13569.  
+Xinyun Chen and Yuandong Tian. Learning to Perform Local Rewriting for Combinatorial Optimization. In Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.  
+Jinho Choo, Yeong-Dae Kwon, Jihoon Kim, Jeongwoo Jae, Andre Hottung, Kevin Tierney, and Youngjune Gwon. Simulation-guided Beam Search for Neural Combinatorial Optimization. In NeurIPS 2022, 2022.  
+Andrea Corsini, Angelo Porrello, Simone Calderara, and Mauro Dell'Amico. Self-Labeling the Job Shop Scheduling Problem, July 2024. Preprint arXiv:2401.11849.  
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pp. 4171–4186, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics.  
+Darko Drakulic, Sofia Michel, Florian Mai, Arnaud Sors, and Jean-Marc Andreoli. BQ-NCO: Bisimulation Quotienting for Efficient Neural Combinatorial Optimization. In Advances in Neural Information Processing Systems, volume 36, pp. 77416-77429, December 2023.  
+Jonas K. Falkner and Lars Schmidt-Thieme. Learning to Solve Vehicle Routing Problems with Time Windows through Joint Attention. arXiv:2006.09100 [cs, stat], June 2020.  
+Zhang-Hua Fu, Kai-Bin Qiu, and Hongyuan Zha. Generalize a Small Pre-trained Model to Arbitrarily Large TSP Instances. Proceedings of the AAAI Conference on Artificial Intelligence, 35(8): 7474-7482, May 2021. ISSN 2374-3468.  
+Keld Helsgaun. An Extension of the Lin-Kernighan-Helsgaun TSP Solver for Constrained Traveling Salesman and Vehicle Routing Problems. Technical report, Roskilde University, Roskilde, Denmark, 2017.  
+James Henderson, Alireza Mohammadshahi, Andrei Coman, and Lesly Miculicich. Transformers as Graph-to-Graph Models. In Yanai Elazar, Allyson Ettinger, Nora Kassner, Sebastian Ruder, and Noah A. Smith (eds.), Proceedings of the Big Picture Workshop, pp. 93-107, Singapore, December 2023. Association for Computational Linguistics.  
+Ellis Horowitz and Sartaj Sahni. Exact and Approximate Algorithms for Scheduling Nonidentical Processors. Journal of the ACM, 23(2):317-327, April 1976. ISSN 0004-5411.  
+Andre Hottung and Kevin Tierney. Neural Large Neighborhood Search for the Capacitated Vehicle Routing Problem. In ECAI 2020, pp. 443-450. IOS Press, 2020.  
+Andre Hottung, Yeong-Dae Kwon, and Kevin Tierney. Efficient Active Search for Combinatorial Optimization Problems. In International Conference on Learning Representations, October 2021.
+
+Q. Huangfu and J. A. J. Hall. Parallelizing the dual revised simplex method. Mathematical Programming Computation, 10(1):119-142, March 2018. ISSN 1867-2957.  
+Borja Ibarz, Vitaly Kurin, George Papamakarios, Kyriacos Nikiforou, Mehdi Bennani, Róbert Csordás, Andrew Joseph Dudzik, Matko Bosnjak, Alex Vitvitskyi, Yulia Rubanova, Andreea Deac, Beatrice Bevilacqua, Yaroslav Ganin, Charles Blundell, and Petar Velicković. A Generalist Neural Algorithmic Learner. In Proceedings of the First Learning on Graphs Conference, pp. 2:1-2:23. PMLR, December 2022.  
+Chaitanya K. Joshi, Quentin Cappart, Louis-Martin Rousseau, and Thomas Laurent. Learning the travelling salesperson problem requires rethinking generalization. Constraints, 27(1-2):70-98, April 2022. ISSN 1383-7133.  
+Elias Khalil, Hanjun Dai, Yuyu Zhang, Bistra Dilkina, and Le Song. Learning Combinatorial Optimization Algorithms over Graphs. In Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.  
+Minsu Kim, Junyoung Park, and Jinkyoo Park. Sym-NCO: Leveraging Symmetricity for Neural Combinatorial Optimization. In Advances in Neural Information Processing Systems, volume 35, pp. 1936-1949, December 2022.  
+Gorka Kobeaga, María Merino, and Jose A. Lozano. An efficient evolutionary algorithm for the orienteering problem. Computers & Operations Research, 90:42-59, February 2018. ISSN 0305-0548.  
+Wouter Kool, Herke van Hoof, and Max Welling. Attention, Learn to Solve Routing Problems! In International Conference on Learning Representations, September 2018.  
+Wouter Kool, Herke van Hoof, Joaquim Gromicho, and Max Welling. Deep Policy Dynamic Programming for Vehicle Routing Problems. In Pierre Schaus (ed.), Integration of Constraint Programming, Artificial Intelligence, and Operations Research, pp. 190-213, Cham, 2022. Springer International Publishing. ISBN 978-3-031-08011-1.  
+Bernhard Korte and Jens Vygen. Combinatorial Optimization: Theory and Algorithms, volume 21 of Algorithms and Combinatorics. Springer, Berlin, Heidelberg, 2018. ISBN 978-3-662-56038-9 978-3-662-56039-6.  
+Yeong-Dae Kwon, Jinho Choo, Byoungjip Kim, Iljoo Yoon, Youngjune Gwon, and Seungjai Min. POMO: Policy Optimization with Multiple Optima for Reinforcement Learning. In Advances in Neural Information Processing Systems, volume 33, pp. 21188-21198. Curran Associates, Inc., 2020.  
+Yeong-Dae Kwon, Jinho Choo, Iljoo Yoon, Minah Park, Duwon Park, and Youngjune Gwon. Matrix encoding networks for neural combinatorial optimization. In Advances in Neural Information Processing Systems, volume 34, pp. 5138-5149. Curran Associates, Inc., 2021.  
+Sirui Li, Zhongxia Yan, and Cathy Wu. Learning to delegate for large-scale vehicle routing. In Advances in Neural Information Processing Systems, volume 34, pp. 26198-26211. Curran Associates, Inc., 2021.  
+Zhuoyi Lin, Yaoxin Wu, Bangjian Zhou, Zhiguang Cao, Wen Song, Yingqian Zhang, and Senthilnath Jayavelu. Cross-Problem Learning for Solving Vehicle Routing Problems. In Thirty-Third International Joint Conference on Artificial Intelligence, volume 7, pp. 6958-6966, August 2024.  
+Fei Liu, Xi Lin, Zhenkun Wang, Qingfu Zhang, Tong Xialiang, and Mingxuan Yuan. Multi-Task Learning for Routing Problem with Cross-Problem Zero-Shot Generalization. In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, KDD '24, pp. 1898–1908, New York, NY, USA, August 2024. Association for Computing Machinery. ISBN 979-8-4007-0490-1.  
+Ilya Loshchilov and Frank Hutter. Decoupled Weight Decay Regularization. In International Conference on Learning Representations, September 2018.
+
+Fu Luo, Xi Lin, Zhenkun Wang, Xialiang Tong, Mingxuan Yuan, and Qingfu Zhang. Self-Improved Learning for Scalable Neural Combinatorial Optimization, May 2024. Preprint arXiv:2403.19561.  
+Yining Ma, Jingwen Li, Zhiguang Cao, Wen Song, Le Zhang, Zhenghua Chen, and Jing Tang. Learning to Iteratively Solve Routing Problems with Dual-Aspect Collaborative Transformer. In Advances in Neural Information Processing Systems, November 2021.  
+Sahil Manchanda, Sofia Michel, Darko Drakulic, and Jean-Marc Andreoli. On the Generalization of Neural Combinatorial Optimization Heuristics. In European Conference on Machine Learning and Principles and Practice of Knowledge Discovery in Databases (ECML-PKDD), Grenoble, France, September 2022.  
+MohammadReza Nazari, Afshin Oroojlooy, Lawrence Snyder, and Martin Takac. Reinforcement Learning for Solving the Vehicle Routing Problem. In Advances in Neural Information Processing Systems, volume 31. Curran Associates, Inc., 2018.  
+Xuanhao Pan, Yan Jin, Yuandong Ding, Mingxiao Feng, Li Zhao, Lei Song, and Jiang Bian. H-TSP: Hierarchically solving the large-scale traveling salesman problem. In Proceedings of the Thirty-Seventh AAAI Conference on Artificial Intelligence and Thirty-Fifth Conference on Innovative Applications of Artificial Intelligence and Thirteenth Symposium on Educational Advances in Artificial Intelligence, volume 37 of AAAI'23/IAAI'23/EAAI'23, pp. 9345-9353. AAAI Press, February 2023. ISBN 978-1-57735-880-0.  
+Laurent Perron and Vincent Furnon. OR-tools, 2022. Preprint.  
+Jonathan Pirnay and Dominik G. Grimm. Self-Improvement for Neural Combinatorial Optimization: Sample without Replacement, but Improvement, March 2024. Preprint arXiv:2403.15180.  
+Ruizhong Qiu, Zhiqing Sun, and Yiming Yang. DIMES: A Differentiable Meta Solver for Combinatorial Optimization Problems. In Advances in Neural Information Processing Systems, December 2022.  
+Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya Sutskever. Learning Transferable Visual Models From Natural Language Supervision. In Proceedings of the 38th International Conference on Machine Learning, pp. 8748-8763. PMLR, July 2021.  
+Scott Reed, Konrad Zolna, Emilio Parisotto, Sergio Gomez Colmenarejo, Alexander Novikov, Gabriel Barth-maron, Mai Giménez, Yury Sulsky, Jackie Kay, Jost Tobias Springenberg, Tom Eccles, Jake Bruce, Ali Razavi, Ashley Edwards, Nicolas Heess, Yutian Chen, Raia Hadsell, Oriol Vinyals, Mahyar Bordbar, and Nando de Freitas. A Generalist Agent. Transactions on Machine Learning Research, August 2022. ISSN 2835-8856.  
+Frank Ruis, Gertjan Burghouts, and Doina Bucur. Independent Prototype Propagation for Zero-Shot Compositionality. In Advances in Neural Information Processing Systems, volume 34, pp. 10641-10653. Curran Associates, Inc., 2021.  
+Ryoma Sato, Makoto Yamada, and Hisashi Kashima. Random Features Strengthen Graph Neural Networks. arXiv:2002.03155 [cs, stat], January 2021.  
+Jiwoo Son, Minsu Kim, Hyeonah Kim, and Jinkyoo Park. Meta-SAGE: Scale Meta-Learning Sched- uled Adaptation with Guided Exploration for Mitigating Scale Shift on Combinatorial Optimization. In Proceedings of the 40th International Conference on Machine Learning, volume 202 of ICML'23, pp. 32194-32210, Honolulu, Hawaii, USA, July 2023. JMLR.org.  
+Adam Stooke, Kimin Lee, Pieter Abbeel, and Michael Laskin. Decoupling representation learning from reinforcement learning. In International Conference on Machine Learning, pp. 9870-9879. PMLR, 2021.  
+Yanchao Sun, Shuang Ma, Ratnesh Madaan, Rogerio Bonatti, Furong Huang, and Ashish Kapoor. SMART: Self-supervised Multi-task pretrAining with contRol Transformers. In The Eleventh International Conference on Learning Representations, February 2023.
+
+Zhiqing Sun and Yiming Yang. DIFUSCO: Graph-based Diffusion Solvers for Combinatorial Optimization. Advances in Neural Information Processing Systems, 36:3706-3731, December 2023.  
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is All you Need. In Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.  
+Vijay V. Vazirani. Approximation Algorithms. Springer, Berlin, Heidelberg, 2003. ISBN 978-3-642-08469-0 978-3-662-04565-7.  
+Thibaut Vidal. Hybrid genetic search for the CVRP: Open-source implementation and SWAP* neighborhood. Computers & Operations Research, 140:105643, April 2022. ISSN 0305-0548.  
+Chenguang Wang and Tianshu Yu. Efficient Training of Multi-task Neural Solver with Multi-armed Bandits. CoRR, abs/2305.06361, 2023.  
+Yaoxin Wu, Wen Song, Zhiguang Cao, Jie Zhang, and Andrew Lim. Learning Improvement Heuristics for Solving Routing Problems. IEEE Transactions on Neural Networks and Learning Systems, 33(9):5057-5069, September 2022. ISSN 2162-2388.  
+Liang Xin, Wen Song, Zhiguang Cao, and Jie Zhang. Multi-Decoder Attention Model with Embedding Glimpse for Solving Vehicle Routing Problems. Proceedings of the AAAI Conference on Artificial Intelligence, 35(13):12042-12049, May 2021. ISSN 2374-3468.  
+Zhihao Xing and Shikui Tu. A Graph Neural Network Assisted Monte Carlo Tree Search Approach to Traveling Salesman Problem. IEEE Access, 8:108418-108428, 2020. ISSN 2169-3536.  
+Cong Zhang, Wen Song, Zhiguang Cao, Jie Zhang, Puay Siew Tan, and Chi Xu. Learning to dispatch for job shop scheduling via deep reinforcement learning. In Proceedings of the 34th International Conference on Neural Information Processing Systems, NIPS'20, pp. 1621-1632, Red Hook, NY, USA, December 2020. Curran Associates Inc. ISBN 978-1-7138-2954-6.  
+Jianan Zhou, Yaoxin Wu, Wen Song, Zhiguang Cao, and Jie Zhang. Towards omni-generalizable neural methods for vehicle routing problems. In International Conference on Machine Learning, pp. 42769-42789. PMLR, 2023.  
+Jianan Zhou, Zhiguang Cao, Yaoxin Wu, Wen Song, Yining Ma, Jie Zhang, and Chi Xu. MVMoE: Multi-task vehicle routing solver with mixture-of-experts. In Proceedings of the 41st International Conference on Machine Learning, volume 235 of ICML'24, pp. 61804-61824, Vienna, Austria, July 2024. JMLR.org.
+
+# A GOAL HYPERPARAMETERS AND SIZE
+
+The GOAL backbone consists of  $L = 9$  layers with an embedding size of  $D = \bar{D} = 128$  (the same for both nodes and edges), a feed-forward dimension of 512, and ReZero normalization Bachlechner et al. (2021). The mixed-attention blocks have 8 heads. The task specific input adapters produce representations of low dimension  $\ell = 8$  for nodes and  $\bar{\ell} = 4$  for edges, which are mapped to embeddings by a shared codebook of dimension  $\ell \times D$  for nodes and  $\bar{\ell} \times \bar{D}$  for edges, respectively. GOAL backbone has 2.1M parameters and adapters are very light, with only a few thousand parameters per task. For the illustration, RouteFinder (Berto et al., 2024) with POMO has 1.3M, MVMoE (Zhou et al., 2024) has 3.7M (the same model is used in RouteFinder with MVMoE), and RouteFinder with the Transformer Encoder 1.7M.
+
+# B SUPERVISED FINE-TUNING OF GOAL
+
+In section 4.2 we describe the process of fine-tuning our multitask model on eight unseen tasks in unsupervised mode. Although fine-tuning without labeled data is useful for transferring to new tasks, it comes at a cost - it is quite expensive. Our experiments show that fine-tuning to the new problems with unsupervised learning takes, on average, a few hours.
+
+On the other hand, we demonstrate that GOAL can be effectively fine-tuned using a very small amount of labeled data, in a short time. Figure 5 presents the performance of fine-tuning GOAL on the same eight problems used in unsupervised tuning. Here, we use only 128 solved (but not necessarily optimal) instances and tune the model with just one training step per instance (more precisely, one training step per tail-subproblem of each instance). In contrast to unsupervised tuning, this method is extremely fast; fine-tuning takes only a few minutes.
+
+![](images/b2b527ba004168110608cb0048fdc6c303b3867024dd5e31550baa5617c16d3c.jpg)  
+Figure 5: Supervised fine-tuning on eight new problems. We report the best results over 10 runs for both training from scratch and fine-tuning.
+
+# C IMPACT OF CODEBOOK ON FINE-TUNING
+
+In 4.3 We discussed the importance of sparsifying the input adapter with a shared codebook. Although this feature does not impact training performance, it is very important in the fine-tuning phase. By adding a codebook to the model, fine-tuning becomes more stable and achieves better performance. In the main text, we presented a figure comparing fine-tuning for the PCTSP with models that have and do not have a codebook. Figure 6 illustrates the impact of the codebook on fine-tuning the multitask model across all eight problems we used for transfer. In these experiments, we used light-trained models with and without a codebook. The models are trained on 100K instances, for 200 epochs. For each experiment, we perform 10 inference runs and report the mean with a confidence interval of 100.
+
+![](images/0aa9e1443acc45f7f11e2b26498799c33d5a5bf18b221ec0925c27c3266628a3.jpg)
+
+![](images/cb74ce8ad97b7e2620f0490eee170c0323dd5a79730b0b528811052b46c9c7eb.jpg)
+
+![](images/07f7c79cbe1eae880fec0ed85b81f127dbda200b9c9a0dd1e7a1b710a27541ee.jpg)
+
+![](images/ebab8c7bb28170e753d8393c3462b81bc5abfcf8c1c9a4b83feb699b78ca5db5.jpg)
+
+![](images/4cc131d9e1588c917ba4f1b6d81b3d6630d97a292c66309ac54442351d1bdfa1.jpg)  
+Figure 6: Ablation study of codebook
+
+![](images/e746368733676a968e3681ffefd9617ebda7069b8789219b35a5ce9c3f309e47.jpg)
+
+![](images/0e46adf953dfeca6b18e5e8f2cf4c10d4947b8b9843fe835bd60a4eb4f6dc6bb.jpg)
+
+![](images/f129f6514d520cca9767258838dbad85e053df82a1fcd0d43837686fb8b3c21a.jpg)
+
+![](images/57de529d3b1c34c6890b79b9d4722bda6f2d2469cc3302dacb6dd1b478f291db.jpg)  
+(a) the Unrelated Machine Scheduling Problem (UMSP)  
+Figure 7: Illustration of the multi-type model on scheduling tasks in GOAL. The "MA" blocks use vanilla multi-head attention while the "MMA" use our multi-head mixed-attention.
+
+![](images/b2d543fa9eaf4577e7eb342563261edbd19e95529b9a5883a532a8588c9c5159.jpg)  
+(b) the Job-shop Scheduling Problem (JSSP)
+
+# D MULTI-TYPE MIXED ATTENTION LAYERS FOR UMSP AND JSSP
+
+As an illustration of our proposed multi-type transformer architecture, we present in Figure 7 the inputs to the mixed-attention blocks for the Unrelated Machine Scheduling (UMSP) and the Job Shop Scheduling Problems (JSSP). Note that in the case of UMSP, since there is no edge information between jobs and between machines, the self-attention blocks (left-most and right-most attention blocks) degenerate to vanilla attention. The cross-attention blocks, on the other hand, are mixed, and they are fed the same edge information, holding the job execution times on each machine (transposed from each other). In JSSP, the situation is similar, but ops have two kinds of relations between themselves: precedence, and sharing the same job. Hence the self-attention block on ops is mixed.
+
+<table><tr><td rowspan="2" colspan="2"></td><td colspan="2">Train. distrib.</td><td colspan="6">Generalization</td></tr><tr><td colspan="2">100</td><td colspan="2">200</td><td colspan="2">500</td><td colspan="2">1000</td></tr><tr><td rowspan="4">ATSP</td><td>LKH</td><td>0.00%</td><td>29s</td><td>0.00%</td><td>48s</td><td>0.00%</td><td>2m</td><td>0.00%</td><td>4m</td></tr><tr><td>MatNet</td><td>1.57%</td><td>1s</td><td>97.21%</td><td>12s</td><td colspan="2">-</td><td colspan="2">-</td></tr><tr><td>BQ-NCO</td><td>1.63%</td><td>1s</td><td>1.90%</td><td>9s</td><td>4.29%</td><td>26s</td><td>8.09%</td><td>1m</td></tr><tr><td>GOAL</td><td>0.45%</td><td>5s</td><td>1.54%</td><td>30s</td><td>1.62%</td><td>3m</td><td>1.96%</td><td>5m</td></tr><tr><td rowspan="7">CVRP</td><td>LKH</td><td>0.00%</td><td>12m</td><td>0.00%</td><td>2h</td><td>0.00%</td><td>5h</td><td>0.00%</td><td>7h</td></tr><tr><td>AM</td><td>7.11%</td><td>1s</td><td>10.16%</td><td>1s</td><td>17.2%</td><td>1s</td><td>72.95%</td><td>2s</td></tr><tr><td>MDAM</td><td>4.84%</td><td>1s</td><td>7.54%</td><td>6s</td><td>12.94%</td><td>24s</td><td>32.25%</td><td>1m</td></tr><tr><td>POMO</td><td>1.21%</td><td>1s</td><td>5.94%</td><td>6s</td><td>31.36%</td><td>32s</td><td>284.58%</td><td>1m</td></tr><tr><td>Sym-NCO</td><td>3.33%</td><td>1s</td><td>8.42%</td><td>3s</td><td>37.58%</td><td>54s</td><td>481.53%</td><td>9m</td></tr><tr><td>BQ-NCO</td><td>2.79%</td><td>1s</td><td>2.81%</td><td>9s</td><td>3.64%</td><td>55s</td><td>5.88%</td><td>2m</td></tr><tr><td>GOAL</td><td>3.16%</td><td>5s</td><td>3.42%</td><td>30s</td><td>3.90%</td><td>2m</td><td>7.37%</td><td>5m</td></tr><tr><td rowspan="3">CVRPTW</td><td>HGS (1s) †</td><td>108/128</td><td>2m</td><td>14/128</td><td>2m</td><td>0/128</td><td>2m</td><td>0/128</td><td>2m</td></tr><tr><td>HGS (1m)</td><td>0.00%</td><td>10m</td><td>0.00%</td><td>26m</td><td>0.00%</td><td>2h</td><td>0.00%</td><td>2h</td></tr><tr><td>GOAL</td><td>3.82%</td><td>5s</td><td>7.71%</td><td>30s</td><td>9.49%</td><td>2m</td><td>6.75%</td><td>5m</td></tr><tr><td rowspan="5">OP</td><td>EA4OP</td><td>0.00%</td><td>1m</td><td>0.00%</td><td>3m</td><td>0.00%</td><td>11m</td><td>0.00%</td><td>45m</td></tr><tr><td>AM</td><td>5.35%</td><td>1s</td><td>11.05%</td><td>1s</td><td>22.29%</td><td>1s</td><td>30.73%</td><td>1s</td></tr><tr><td>MDAM</td><td>2.88%</td><td>16s</td><td>5.55%</td><td>1s</td><td>18.31%</td><td>4s</td><td>30.05%</td><td>15s</td></tr><tr><td>SymNCO</td><td>2.03%</td><td>2s</td><td>6.60%</td><td>3s</td><td>19.81%</td><td>24s</td><td>31.79%</td><td>1m</td></tr><tr><td>GOAL</td><td>0.43%</td><td>3s</td><td>1.60%</td><td>10s</td><td>7.45%</td><td>17s</td><td>15.62%</td><td>30s</td></tr><tr><td rowspan="4">KP</td><td>ORTools</td><td>0.00%</td><td>&lt; 1s</td><td>0.00%</td><td>&lt; 1s</td><td>0.00%</td><td>&lt; 1s</td><td>0.00%</td><td>&lt; 1s</td></tr><tr><td>POMO</td><td>0.19%</td><td>1s</td><td>0.50%</td><td>1s</td><td>6.41%</td><td>31s</td><td>5.34%</td><td>1m</td></tr><tr><td>BQ-NCO</td><td>0.10%</td><td>2s</td><td>0.14%</td><td>6s</td><td>0.74%</td><td>7s</td><td>0.92%</td><td>13s</td></tr><tr><td>GOAL</td><td>0.12%</td><td>3s</td><td>1.63%</td><td>6s</td><td>2.40%</td><td>10s</td><td>2.59%</td><td>16s</td></tr><tr><td colspan="2"></td><td colspan="2">10x10</td><td colspan="2">10x15</td><td colspan="2">15x15</td><td colspan="2">20x15</td></tr><tr><td rowspan="3">JSSP</td><td>ORTools</td><td>0.00%</td><td>47s</td><td>0.00%</td><td>2m</td><td>0.00%</td><td>3h</td><td>0.00%</td><td>80h</td></tr><tr><td>COMPASS◇</td><td>4.70%</td><td>3h</td><td colspan="2">-</td><td>8.00%</td><td>5h</td><td>10.40%</td><td>8h</td></tr><tr><td>GOAL</td><td>4.13%</td><td>15s</td><td>11.02%</td><td>43s</td><td>10.74%</td><td>45s</td><td>22.53%</td><td>4m</td></tr></table>
+
+Table 2: Generalization performance on larger instances. Lower is better. All NCO methods perform greedy decoding, except for methods marked with  $\diamond$ ; they do not provide results for greedy decoding. Solvers marked with  $\dagger$  are unable to solve all instances within the given time budget; we report the number of instances successfully solved.
+
+# E GENERALIZATION TO NEW INSSTANCE DISTRIBUTIONS
+
+Table 2 presents the generalization to instances up to 10 times bigger than the training ones, for a subset of the training tasks. Our approach takes a bit more time than some baselines, but note that scaling to much larger instances is not a focus of this paper. One possible way to avoid the quadratic complexity of attention is by using task-specific heuristics, such as the KNN heuristic for routing problems (proposed by Drakulic et al. (2023), to reduce the size of the input instance and the overall complexity. Another approach could be using methods that do not rely on quadratic attention blocks, such as those proposed by Luo et al. (2024), though this method tends to be highly specialized for specific problems.
+
+Our model demonstrates excellent generalization performance in terms of the optimality gap for problems with various edge features, such as ATSP (with an asymmetric distance matrix) and JSSP (with two binary matrices with precedence constraints and job-machine relations).
+
+# F DESCRIPTION OF THE CONSIDERED CO PROBLEMS
+
+In this Section, we describe the CO problems (in alphabetical order) that are solved by GOAL as well as the instance generation process. GOAL solves problems from various categories: Routing, Scheduling, Packing, Graph, and Location Problems. For each problem, we provide all the details of how it is represented in our model, including a list of instance, node and edge features, the action chosen by the model, and the objective. We also describe how we generate a solution trajectory for problems where we use single cross-entropy loss for behavioral cloning.
+
+# F.1 CAPACITATED VEHICLE ROUTING PROBLEM AND SPLIT-DELIVERY CAPACITATED VEHICLE ROUTING PROBLEM
+
+![](images/6839e1c292dce6be5244f69a2458b2f485d6d0cb5d9bd622d51d227e0c7dfe70.jpg)
+
+The Capacitated Vehicle Routing Problem (CVRP) is a standard routing problem. The goal of CVRP is to optimize the delivery routes of a fleet of vehicles to a set of customers while considering each vehicle's capacity. The objective is to minimize the overall distance traveled by the vehicles while respecting the capacity constraints and ensuring that all the customer demands are met. Split-Delivery CVRP (SDCVRP) is a variant of the CVRP that allows a single customer's demand to be fulfilled by multiple vehicles. In our experiments we use Euclidean CVRP for training GOAL and SDCVRP for fine-tuning.
+
+Data generation. Node locations are randomly sampled from the unit square, while node demands are randomly generated integers from the interval [1, 10]. Following Kool et al. (2018), the vehicle capacity depends on the problem size: capacity of 50 for a problem size of 100, 80 for 200, 100 for 500, and capacity of 250 for problems with 1000 nodes.
+
+Instance features: Remaining vehicle capacity
+
+Node features: Origin/destination tokens, demand
+
+Edge features: Distance between nodes
+
+Oracle: LKH
+
+Objective: Minimize traveled distance
+
+Action: Select a node, with direct edge or via-depot
+
+Trajectory: Nodes ordered by a solution subtour. Subtours are ordered by their final remaining capacity in descending order
+
+# F.2 CAPACITATED VEHICLE ROUTING PROBLEM WITH TIME WINDOWS
+
+The Capacitated Vehicle Routing Problem with Time Windows (CVRPTW) is an extension of the CVRP. In addition to demand constraints, each customer also has a specified time window during which they can be visited, along with the necessary service time required for serving that customer. The objective of the CVPTW is to find routes for the vehicles that satisfy the capacity limits, deliver goods within the specified time windows, and minimize the total travel and waiting time or the number of vehicles used. In our experiments, we consider the standard version of the Euclidean problem where total traveling and serving time should be minimized and we use it for training GOAL.
+
+Data generation. For the time windows and service times, we use a similar procedure to Falkner & Schmidt-Thieme (2020), where the locations are sampled sampled from the unit square. We ensure the feasibility of the resulting instances by sampling time windows using a more refined procedure. Windows start time values are sampled from the range (0.01, 0.25). It's important to note that start times do not directly impact problem feasibility, as vehicles can wait at the node until the service starts. On the other hand, the choice of the visiting end time has an impact on feasibility. An instance is unfeasible if the window end time of a customer is less than the travel time from the depot plus the service time. To avoid this, end times are sampled from the interval [maxwindow start time, travel time from depot)  $+2 \times$  service time, maxwindow start time, travel time from depot)  $+4 \times$  service time].
+
+Instance features: Remaining vehicle capacity, current time
+
+Node features: Origin/destination tokens, demand, start time window, end time window, service time
+
+Edge features: Distance between nodes
+
+Oracle: HGS
+
+Objective: Minimize traveled time
+
+Action: Select a node, with direct edge or via-depot
+
+Trajectory: Nodes ordered by a solution subtour. Subtours are ordered by their final remaining capacity in descending order
+
+# F.3 JOB SHOP SCHEDULING PROBLEM
+
+![](images/83744612a7f013a042385cdb343c6aeac4a458138656af5ff92ea6d80987b96a.jpg)
+
+The Job Shop Scheduling Problem (JSSP) is a classic scheduling problem. We are given  $N$  jobs and  $M$  machines. Each job consists of a sequence of operations that need to be processed in a specific order (implying precedence constraints). Each operation has a given processing time. Each machine can only process one operation at a time and when an operation is started it cannot be inter
+
+rupted (no preemption). A solution is a schedule, defined by the start time of each operation such that a specific criterion, such as makespan, total completion time, or total tardiness is minimized.
+
+Data generation. We follow the standard procedure for generating JSSP benchmark datasets: execution times are randomly sampled from  $U(1, 100)$ .
+
+# Instance features: None
+
+Node features: Operation execution time, job availability time, machine availability time
+
+Edge features: Precedence constraint, operation-machine dependency
+
+Oracle: ORTools
+
+Objective: Minimize makespan
+
+Action: Select an operation
+
+Trajectory: Tasks ordered by minimal finishing time
+
+# F.4 KNAPSACK PROBLEM
+
+The Knapsack Problem (KP) is a well-known combinatorial optimization problem that involves selecting a subset of items from a given set. Each item had a weight and a value, and the goal is to maximize the cumulated value of selected items, without exceeding a given cumulated weight threshold, known as the knapsack's (weight) capacity.
+
+Data generation. Following the same procedure as in Kwon et al. (2020), node weights and values are randomly sampled from the unit interval, and knapsack capacity is set to 25.
+
+Instance features: Remaining knapsack capacity
+
+Node features: Value, weight
+
+Edge features: None
+
+Oracle: ORTools
+
+Objective: Maximizing packed values
+
+Action: Select an item
+
+Trajectory: There is no order
+
+# F.5 MAXIMUM INDEPENDENT SET PROBLEM
+
+![](images/3f352823da412713534c541cd18b0a29e257b22331a8d0459b08be7031c55074.jpg)
+
+In the Maximum Independent Set (MIS), we are given an undirected graph  $G = (V, E)$  and the goal is to find a subset of nodes  $S \subset V$  of maximal size  $|S|$  such that each pair of nodes in  $S$  is not connected by an edge. In other words, the maximum independent set is the largest possible independent set in  $G$ , i.e., an independent set with the maximum number of vertices. In our experiments, we fine-tune GOAL to MIS problem.
+
+Data generation. For this problem, we follow a similar procedure as in Khalil et al. (2017). We generate random
+
+graphs by using Erdős–Rényi model with the critical edge probability  $p$  sampled from [0.05, 0.15].
+
+Instance features: None
+
+Node features: None
+
+Edge features: Adjacency value (0-1)
+
+Oracle: FastWVC
+
+Objective: Maximize number of selected nodes
+
+Action: Select an node
+
+Trajectory: There is no order
+
+# F.6 MAXIMUM COVERAGE LOCATION PROBLEM
+
+![](images/fbb36993951889cd5f536ab862452bca44494315373bd96d907bf4e23d6ae815.jpg)
+
+In the Maximum Coverage Location Problem (MCLP), we are given a set of locations with associated weights and several facilities with associated radius of coverage. The goal is to find the optimal placement of the facilities, on a subset of the locations, to maximize the number of covered locations. There is also a variant in which nodes have associated weights; in this case, the objective is to maximize the sum of the weights of the covered locations. In our experiments, we fine-tune our multitask model to MCLP.
+
+Data generation. Node locations are randomly sampled from the unit square, the number of facilities is fixed to 10 and their radius of coverage to 0.1.
+
+Instance features: Number of facilities, radius of coverage
+
+Node features: None
+
+Edge features: Distance between nodes
+
+Oracle: PuLP²
+
+Objective: Maximize the number of covered locations
+
+Action: Select an facility node
+
+Trajectory: There is no order
+
+# F.7 MINIMUM VERTEX COVER PROBLEM
+
+The goal of the Minimum Vertex Cover Problem (MVC) is to find the smallest set of vertices in a graph, such that each edge is incident to at least one of these vertices. In the weighted version of this problem (MWVC), each vertex has an associated weight, and the goal is to select vertices with the minimum cumulated sum of weights while satisfying the vertex cover condition. Data generation and problem features are the same as in MIS. We use MVC to train our model.
+
+# F.8 OPEN SHOP SCHEDULING PROBLEM
+
+![](images/1b29bdd8f7afaa97974771d3fb3a054b298fac28a4b170588c2519019ad118d6.jpg)
+
+The Open Shop Scheduling Problem (OSSP) is a scheduling problem in which a set of jobs (with a given set of operations) must be processed on a set of machines, but unlike job shop scheduling, there is no predefined order. Each operation must be processed, with no overlapping between operations and machines at the same time unit. The goal is typically to minimize the makespan, or the total time required to complete all jobs. Data generation
+
+and problem features are the same as in JSSP, except OSSP does not have precedence constraints.
+
+# F.9 OPEN VEHICLE ROUTING PROBLEM
+
+![](images/d2f012f4f28bdc1c9e1d6cc679ad0890dbbbab21c3984463e0acbb8c8379facb.jpg)
+
+Open Vehicle Routing Problem (OCVRP) is a variant of CVRP where an unbounded fleet of vehicles is available at the depot, each serving a set of customers. In contrast with other CVRP variants, vehicles do not need to return to the depot at the end of their service. This makes OCVRP similar to the classical CVRP, as both problems involve a set of locations with demand and vehicle capacity constraints. However, the key difference lies in the route structure: in OCVRP, vehicles do not need to return to the depot after completing deliveries, which affects the solution space and cost minimization strategy. OCVRP has common applications in logistics, where delivery trucks do not need to return to the depot after com
+
+pleting deliveries. Data generation and problem features are the same as for the CVRP. In our experiments, we handle the Euclidean version of the OCVRP and fine-tune GOAL to solve it.
+
+# F.10 ORIENTEERING PROBLEM
+
+![](images/60930a953962a0994a0c300bf29326d128a10c718d5331a47e62366034677ee3.jpg)
+
+The Orienteering Problem (OP) is a combinatorial optimization problem that combines aspects of the Traveling Salesman Problem (TSP) and the Knapsack Problem. It is commonly used in routing and scheduling applications where the goal is to maximize collected rewards while respecting a constraint on total travel distance or time. The OP is defined by a set of locations (nodes), each associated with a reward; a starting location and an ending location (usually the same node); a travel cost matrix between locations; and a maximum allowable travel budget. The objective is to visit a subset of locations that maximizes the total collected reward while ensuring the total travel cost does not exceed the budget.
+
+Data generation. We generated data following previous work Kool et al. (2018): node locations are uniformly sampled from the unit square and prizes are proportional to the distance to the depot (in Kool et al. (2018) this variant of the problem is called  $OP_{distance}$ ). The maximal distance constraint is set to 4. We use Euclidean OP for training GOAL.
+
+Instance features: Remaining distance
+
+Node features: Origin/destination tokens, prize
+
+Edge features: Distance between nodes
+
+Oracle: A4OP
+
+Objective: Maximize collected prizes
+
+Action: Select a node (including coming back to the depot)
+
+Trajectory: Ordered nodes by a solution tour
+
+# F.11 PRICE COLLECTION TRAVELING SALESMAN PROBLEM
+
+![](images/dbbf46bb14e6dd92225d564eb83aa4084c8b5dabb9e1929967bea5965fc7b1dd.jpg)
+
+The Prize-Collecting Traveling Salesman Problem (PCTSP) is a variant of the classic Traveling Salesman Problem. In the PCTSP, each node has an associated prize and penalty, and the goal is to minimize the traveled distance while satisfying a minimum total prize constraint. Unlike the traditional TSP, where all cities must be visited, the PCTSP allows for skipping some nodes; however, unvisited nodes incur a penalty, creating a trade-off between collecting prizes and minimizing travel distance. The final objective is to minimize the
+
+sum of the traveled distance and the sum of the penalties for unvisited nodes.
+
+Data generation. We generated data following previous work Xin et al. (2021): node locations are uniformly sampled from the unit square, while prizes are randomly sampled from  $U[0, num - nodes]$  and penalties are sampled from  $U[0, num - nodes]$ . Both features are normalized by multiplying by  $4 / num - nodes$  and  $12 / num - nodes$ , respectively.
+
+Instance features: Remaining prize constraint
+
+Node features: Origin/destination tokens, prize, penalty
+
+Edge features: Distance between nodes
+
+Oracle: ORTools
+
+Objective: Minimize the sum of traveled distances and penalties of univisited nodes
+
+Action: Select a node (including coming back to the depot)
+
+Trajectory: Ordered nodes by a solution tour
+
+# F.12 SEQUENTIAL ORDERING PROBLEM
+
+The Sequential Ordering Problem (SOP) is a combinatorial optimization problem where a set of tasks or nodes must be visited in a specific order while minimizing the total travel cost or distance. This problem can be modeled as the Traveling Salesman Problem, with precedence constraints. The objective is to find the shortest possible route that satisfies these precedence conditions. In our experiments, we fine-tune our multitask model to SOP.
+
+Data generation. The values of the cost matrix are integers randomly generated from a uniform distribution  $U[1, 1000]$  with zero costs between the same task. To fulfill feasibility constraints, we randomly order the tasks, and for the  $i$ -th task, we randomly add  $k$  precedent jobs, where  $k$  is sampled from  $U[0, \lfloor i / 2 \rfloor]$ .
+
+Instance features: None
+
+Node features: Origin token
+
+Edge features: Distance between nodes, precedence constraint
+
+Oracle: LKH
+
+Objective: Minimize cost
+
+Action: Select a node
+
+Trajectory: Ordered nodes by a solution tour
+
+# F.13 TRAVELING REPAIRMAN PROBLEM
+
+![](images/3214b7e1ce87f722f61b1fd811e1c87f840a70b964a216a7e8cda9ec97a8b584.jpg)
+
+The Traveling Repairman Problem (TRP) is a combinatorial optimization problem where a repairman must determine the most efficient route to visit a set of locations, performing repairs or services at each site. In the Traveling Repairman Problem, a set of locations is given with the time needed to travel between any pair of locations. Each location has a task to be performed by the repairman. The objective of the problem is to find the route that minimizes the sum of the delays for reaching each point. In our experiments, we fine-tune GOAL to Euclidean TRP.
+
+Data generation. Node locations are uniformly sampled from the unit square.
+
+Instance features: None
+
+Node features: Origin token
+
+Edge features: Distance between nodes
+
+Oracle: LKH
+
+Objective: Minimize waiting time of all nodes
+
+Action: Select a node
+
+Trajectory: Ordered nodes by a solution tour
+
+# F.14 TRAVELING SALESMAN PROBLEM
+
+![](images/9114fa9ac3d2d1cfa37ef227ef21871863aa5442cbadabe1e5ce46a2d56550f0.jpg)
+
+The Traveling Salesman Problem (TSP) is a classic combinatorial optimization problem. The objective of the TSP is to find the shortest possible route that a salesman can take to visit a given set of cities exactly once and return to its starting point. In the path-TSP variant, the origin and destination of the salesman are distinct nodes (but may have the same coordinates, so that the TSP is a special case of the path-TSP). A TSP instance can be represented either by node coordinates or by a distance matrix. The majority of NCO models address TSP in the coordinate setting, yet the matrix setting holds greater significance for practical applications, as it applies beyond the Euclidean context, where the matrix can represent time,
+
+energy, or cost, rather than distance, and need not satisfy the symmetry property of a distance matrix. In our work, we use the Asymmetric TSP (where the distances satisfy the triangular inequality property) to train our multi-task model."
+
+Data generation For the Euclidean case, we generate datasets as described in Kool et al. (2018): points are uniformly sampled from the unit square, and the corresponding distance matrix  $A$  is computed. For non-Euclidean problems (ATSP) we generate data as described in Kwon et al. (2021), where distance matrices are generated randomly, but post-processed to satisfy the triangular inequality.
+
+# Instance features: None
+
+Node features: Origin/destination tokens
+
+Edge features: Distance between nodes
+
+Oracle: Concorde (for Euclidean) and LKH (for non-Euclidean)
+
+Objective: Minimize tour length
+
+Action: Select a node
+
+Trajectory: Ordered nodes by a solution tour
+
+# F.15 UNRELATED MACHINE SCHEDULING PROBLEM
+
+![](images/3452d5aa87b92d87c6d9ac2135d86a3cfca6374d60d67fb6118c977ac9b865e1.jpg)
+
+The Unrelated Machine Scheduling Problem (UMSP) is an optimization problem in operations research where a set of jobs must be assigned to a set of machines, each with different processing times for each job, to minimize a specific criterion, such as makespan, total completion time, or total tardiness. Unlike related machine scheduling, where machines have similar characteristics and pro
+
+cessing times are proportional, in UMSP, the performance and efficiency of machines vary, making it a more complex and challenging problem to solve. Horowitz & Sahni (1976) shows that this problem is NP-hard. We use UMSP for multitask training of our GOAL model.
+
+Data generation. For UMSP, the processing times are randomly generated from  $U(1, 100)$ .
+
+# Instance features: None
+
+Node features: Machine availability times
+
+Edge features: Execution times
+
+Oracle: ORTools
+
+Objective: Minimize makespan
+
+Action: Select a machine to randomly selected task
+
+Trajectory: Ordered tasks by execution time

ICLR/2025/GOAL_ A Generalist Combinatorial Optimization Agent Learner/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9bf78ea68a3e65d2828f6078dda29cb4f6abda6b63cd51a7a00207509502b75
+size 979564

ICLR/2025/GOAL_ A Generalist Combinatorial Optimization Agent Learner/layout.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c04bc4885f25482bac935037ee878fc56bec439fd339be3640eeff0ebf685df
+size 675407

ICLR/2025/GOFA_ A Generative One-For-All Model for Joint Graph Language Modeling/215cea83-d1de-4d7f-b92b-df8c958f645c_content_list.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa49d934e89f8cf99e82d089410bc987952af2c3b3f45da42d8f112285e01a2f
+size 180754

ICLR/2025/GOFA_ A Generative One-For-All Model for Joint Graph Language Modeling/215cea83-d1de-4d7f-b92b-df8c958f645c_model.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fafc2a2c0bf80d1369dcc08b11c1f66e2913c96c4cd116fae5a8952091d5cfa9
+size 211938

ICLR/2025/GOFA_ A Generative One-For-All Model for Joint Graph Language Modeling/215cea83-d1de-4d7f-b92b-df8c958f645c_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:412d228f4015aa4ac3a5eb323e4d679403e69cd634948a8a7c16a2cc77a0b422
+size 974774

ICLR/2025/GOFA_ A Generative One-For-All Model for Joint Graph Language Modeling/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98b2497283420cbda470fd6d9450af946b2882b0f50bf9e4fe425640fbfc00e7
+size 2342845

ICLR/2025/GOFA_ A Generative One-For-All Model for Joint Graph Language Modeling/layout.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f767d5bbb5f65d07d2e163c1f0b4506d81047936c47a27b9668121c02160cbcc
+size 680477

ICLR/2025/GOttack_ Universal Adversarial Attacks on Graph Neural Networks via Graph Orbits Learning/a40bbf86-46e9-47e7-b609-e19a4fb0ae0f_content_list.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a77b0bdf5f77a2b285f651fc7c8461dc14f61313f0d142039583d641339eb4c0
+size 93479

ICLR/2025/GOttack_ Universal Adversarial Attacks on Graph Neural Networks via Graph Orbits Learning/a40bbf86-46e9-47e7-b609-e19a4fb0ae0f_model.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:594c1e137d7becde6a7796a756e8b130edde70b8e4f9e3d39f4048288dd1e951
+size 115337

ICLR/2025/GOttack_ Universal Adversarial Attacks on Graph Neural Networks via Graph Orbits Learning/a40bbf86-46e9-47e7-b609-e19a4fb0ae0f_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:404a19a05a875c8d2049ed8b7ad55ef9d4b75c5be4fc513feba1490f8d7c03ba
+size 491939

ICLR/2025/GOttack_ Universal Adversarial Attacks on Graph Neural Networks via Graph Orbits Learning/full.md

@@ -0,0 +1,324 @@
+# GOTTACK: UNIVERSAL ADVERSARIAL ATTACKS ON GRAPH NEURAL NETWORKS VIA GRAPH ORBITS LEARNING
+
+Zulfikar Alom<sup>1</sup>, Tran Gia Bao Ngo<sup>1</sup>, Murat Kantarcioglu<sup>2</sup>, Cuneyt Gurcan Akcora<sup>3</sup>
+
+$^{1}$ Department of Computer Science, University of Manitoba, Canada  
+$^{2}$ Department of Computer Science, Virginia Tech, USA  
+$^{3}$ AI Initiative - University of Central Florida, USA
+
+md.alom@umanitoba.ca, ngot1@myumanitoba.ca, muratk@vt.edu  
+cuneyt.accora@ucf.edu
+
+# ABSTRACT
+
+Graph Neural Networks (GNNs) have demonstrated superior performance in node classification tasks across diverse applications. However, their vulnerability to adversarial attacks, where minor perturbations can mislead model predictions, poses significant challenges. This study introduces GOattack, a novel adversarial attack framework that exploits the topological structure of graphs to undermine the integrity of GNN predictions systematically.
+
+By defining a topology-aware method to manipulate graph orbits, our approach generates adversarial modifications that are both subtle and effective, posing a severe test to the robustness of GNNs. We evaluate the efficacy of GOttack across multiple prominent GNN architectures using standard benchmark datasets. Our results show that GOttack outperforms existing state-of-the-art adversarial techniques and completes training in approximately  $55\%$  of the time required by the fastest competing model, achieving the highest average misclassification rate in 155 tasks. This work not only sheds light on the susceptibility of GNNs to structured adversarial attacks but also shows that certain topological patterns may play a significant role in the underlying robustness of the GNNs. Our Python implementation is shared at https://github.com/cakcora/GOttack.
+
+# 1 INTRODUCTION
+
+Recent advances in Graph Neural Networks (GNNs) have brought significant progress in node classification tasks, utilizing the power of graph topology and node features to generate insightful inferences across various application domains such as social networks (Fan et al., 2020), bioinformatics (Zhang et al., 2021) and communication systems (He et al., 2021). Despite their effectiveness, GNNs exhibit inherent vulnerabilities to adversarial attacks; a minor yet strategically designed perturbation in the graph structure or nodal features can deceive the model into erroneous predictions. This susceptibility not only undermines the reliability of GNNs but also poses a grave security risk in critical applications.
+
+Existing approaches predominantly rely on direct node feature manipulation or edge modifications without considering their topological impact. We address this limitation by designing a novel adversarial attack framework that systematically alters the graph topology to induce misclassification errors. Distinct from existing methods, we leverage node connectivity patterns (i.e., orbits) in local graph structures to maximize adversarial efficacy.
+
+Our studies of graph topology yield a surprising result; we have uncovered a universal attack strategy commonly employed by several well-known gradient-based adversarial models. This strategy uses two graph orbits to delineate the resilience of GNNs to adversarial manipulations. Following this discovery, we introduce the GOttack algorithm, an advanced method that identifies and exploits these vulnerable graph orbits. GOttack not only enhances attack misclassification rates but also operates
+
+with greater efficiency, reducing the complexity of the attack search associated with such adversarial interventions.
+
+Through rigorous experiments across three GNN node classification backbones, four state-of-the-art adversarial models, five benchmark datasets, and four defense models, we demonstrate that GOattack achieves higher misclassification rates, maintains a lower computational overhead, and proves effective against defense models.
+
+Our contributions can be summarized as follows:
+
+- We determine a key topological equivalence group among graph nodes, revealing its frequent use in the selection process of gradient-based adversarial models.  
+- Our findings present a new vulnerability in GNNs related to graph topology. Our experiments demonstrate that such attacks are highly effective against state-of-the-art defense models.  
+- Our proposed attack strategy, GOattack, achieves the highest misclassification rate and represents a scalable attack model suitable for large graphs.
+
+# 2 NOTATION AND PRELIMINARIES
+
+We consider the task of node classification in a graph, denoted as  $\mathcal{G} = (\mathcal{V},\mathcal{E},\mathbf{X})$ , where  $\mathcal{V}$  represents the set of nodes,  $\mathcal{E} \subseteq \{(v,w) \mid v,w \in \mathcal{V}\}$  is the set of edges, and  $\mathbf{X} = \{x_0,x_1,\ldots,x_{n-1}\}$  comprises feature vectors such that  $x_i \in \mathbb{R}^M$  is the  $M$ -dimensional feature vector of node  $i$ . The adjacency matrix  $\mathbf{A} \in \{0,1\}^{N \times N}$  for the graph  $\mathcal{G}$  has elements  $\mathbf{A}_{vw} = 1$  if there is an edge  $e_{vw}$  connecting nodes  $v$  and  $w$ , and 0 otherwise.
+
+A subset of nodes  $\mathcal{V}_L \subseteq \mathcal{V}$  is labeled, each associated with class labels from the set  $\mathcal{C} = \{1, \dots, c\}$ , where  $y_v$  denotes the true label of node  $v$  in  $\mathcal{V}_L$ . This setup facilitates examining how shared labels influence edge formation between nodes, an essential aspect of understanding neighbor influence on node classification. Homophily (Zhu et al., 2020) in graphs is traditionally characterized by the similarity between connected node pairs, where nodes are considered similar if they share identical labels. The homophily ratio is constructed based on this premise as follows:
+
+Definition 1 (Homophily Ratio). Let  $\mathcal{G}$  denote the aforementioned graph and  $\mathbf{y}$  represent the vector of node labels. The homophily ratio is defined as the proportion of edges connecting nodes with the same labels, formally given by:  $h(\mathcal{G},\{y_v;v\in \mathcal{V}\}) = \frac{1}{|\mathcal{E}|}\sum_{(v,w)\in \mathcal{E}}\mathbb{1}(y_v = y_w)$ , where  $\mathbb{1}(\cdot)$  denotes the indicator function.
+
+A graph is considered highly homophilous if the homophily ratio  $h(\cdot)$  is large, typically within the range  $0.5 \leq h(\cdot) \leq 1$ . Conversely, a low homophily ratio indicates a heterophilous graph.
+
+Node Classification. The goal of node classification is to infer a function  $g: \mathcal{V} \to \mathbb{P}(\mathcal{C})$ , that assigns a probability distribution over the class set  $\mathcal{C}$  to each unlabeled node  $v$ , where  $\hat{y}_v$  is the predicted class for node  $v$ , identified as the class with the highest probability in  $g(v)$ . This setup, characterized as transductive learning, implies that the model predictions are based on instances both seen and used during training.
+
+The Graph Convolutional Network (GCN), as introduced by Kipf & Welling (2017), provides a foundational model for understanding and analyzing the vulnerabilities exposed by our proposed attack model. GCN employs a message-passing technique that utilizes the features of neighboring nodes, making it susceptible to adversarial manipulations that can alter node connections and lead to misclassifications. As a result, this section will define our attack using the GCN operations, which are detailed in Appendix B.1.
+
+Adversarial Attack. Adversarial attacks on graph data aim to subtly perturb graph structures or node features, causing GCN to misclassify specific nodes. This entails creating a new graph  $\mathcal{G}' = (\mathbf{A}',\mathbf{X}')$  from the original  $\mathcal{G} = (\mathbf{A},\mathbf{X})$ , with changes to  $\mathbf{A}$  (i.e., structural attacks) or  $\mathbf{X}$  (i.e., feature attacks). In an attack, a subset of nodes  $v\in \mathcal{V}_T\subseteq \mathcal{V}$  are targeted to have the GCN misclassify their labels  $\hat{y}_v\neq y_v$  within a specified budget  $\Delta$  as  $\sum_{u}\sum_{f}\left|\mathbf{X}_{uf} - \mathbf{X}_{uf}^{\prime}\right| + \sum_{u <   w}|\mathbf{A}_{uw} - \mathbf{A}_{uw}^{\prime}|\leq \Delta$
+
+The node  $v$  may be directly affected (i.e.,  $u = v$ ), or influence attacks can impact any other node within the graph (i.e.,  $u \neq v$ ). The attacks take various forms and occur during different phases. i)
+
+Poisoning attacks occur during training time, aiming to compromise the model by manipulating the training dataset. Evasion attacks occur at test time, attempting to generate deceptive samples that evade detection by a trained model. ii) In targeted attacks, the objective is to misclassify specific target nodes  $\mathcal{V}_T$ , while in non-targeted attacks, the goal is to reduce the overall accuracy of the model.
+
+# 3 RELATED WORK
+
+Recent interest has grown in adversarial attacks on graph neural networks Gunnemann (2022). These attacks demonstrate how minor changes to input features or graph structure can alter network outputs, often causing incorrect classifications. We begin with an overview of gradient-based attacks and then discuss non-gradient-based methods (refer to App. Table 56 for a complete classification).
+
+Gradient-based attacks. Gradient-based attacks on graph neural networks exploit the gradients of the model to perturb node features or graph structure, aiming to mislead the network into making incorrect predictions. Zügner et al. (2018) proposed Nettack, which marked the inaugural exploration of gradient attacks on attributed graphs, revealing significant accuracy declines even with minor alterations. Another novel approach by Xu et al. significantly reduced classification performance by causing a small number of edge perturbations (Xu et al., 2019a). Similarly, Li et al. (2023) introduced the SGA framework to target nodes by using a smaller subgraph around the target node and leveraging gradient information for attack optimization. Fast Gradient Attack (FGA) used gradient information from GCNs and outperformed baseline methods by efficiently disturbing network embedding with minimal link rewiring (Chen et al., 2018). To describe the robustness of deep learning models for graph-based tasks, Zügner & Gunnemann (2019) introduced training-time attacks using metagradientsto perturb graph structures, which effectively renders the model near-useless for production use, all without direct access to the target classifier. Our approach also uses a gradient-based attack; however, we reduce the amount of costly gradient computations.
+
+Non-gradient-based attacks. Sun et al. (2020) introduced a novel node injection poisoning attack that used hierarchical Q-learning to optimize the injection process. Likewise, Chang et al. (2022) proposed the GF-Attack for conducting black-box adversarial attacks on graph embedding models without access to labels. Hussain et al. (2021) proposed Structack, which uses structural centrality and similarity insights to lower GNN costs efficiently. Similarly, Zou et al. (2021) proposed the topological defective graph injection attack, where adversaries inject adversarial nodes into existing graphs rather than modifying links or node attributes. Zhang et al. (2023) proposed membership inference attacks targeting edges, also known as link-stealing attacks, which used customized attacks by introducing a group-based attack paradigm that is suited to various groups of edges. Mu et al. (2021) proposed the attack as an optimization problem to minimize perturbations to the graph structure, with a particular emphasis on the difficult hard-label black-box attack scenario.
+
+The approach we propose in this paper differs from all the above-mentioned proposals in that none have attempted to identify equivalence groups for graph nodes based on graph orbits to minimize the search space in discrete optimization. Furthermore, our proposed solution introduces a highly effective and efficient algorithm for universal attacks on node classification models, demonstrating significantly faster performance compared to existing methods (e.g., attack training in approximately  $55\%$  of the time required by the fastest competing model).
+
+# 4 METHODOLOGY
+
+We propose the GOattack framework to execute adversarial attacks on node classification GNNs while minimizing changes to the graph's structure. Figure 1 illustrates the overview of the GOattack research workflow.
+
+Challenge. A significant attack challenge in our task is the substantial time complexity, as structural attacks on the underlying graph data might require up to  $O(2^{|\mathcal{V}| \times |\mathcal{V}|})$  steps for finding the optimal set of edges to remove or add. This scale of complexity necessitates the development of efficient methods.
+
+GOtattack Philosophy. GOtattack draws inspiration from the Mapper philosophy of Topological Data Analysis (TDA), as described by Singh et al. (2007). This philosophy posits that data has shape, and finding the shape may allow us to build better models. In our case, we focus on identifying and
+
+![](images/0418976a6a428e456a113841538db12bd702166180ccee14f48f29bc848b1dd8.jpg)  
+Figure 1: Complete research workflow diagram of GOttack.
+
+grouping nodes on the graph so that graph topology can help us select which nodes and edges to attack in GNNs.
+
+Gottack Solution. Gottack utilizes group theory (Bogopolskij, 2008) to identify node equivalence classes (Alon, 2007) on a graph, which guide our decisions on which edges to add or remove. This approach strategically groups nodes according to their positions on the graph in potential attack strategies, thereby enhancing both the precision and time-efficiency of our adversarial interventions.
+
+# 4.1 ATTACK MODEL
+
+We aim to target a specific node  $v \in \mathcal{V}$  in a targeted, structural, direct poisoning attack to alter its predicted class. As the prediction of  $v$  depends not only on its individual attributes but also on the characteristics of neighbouring nodes  $\mathcal{N}(v)$  within the graph, we are focused on perturbations to the initial graph  $\mathcal{G}$  with the condition:  $\exists w, \mathcal{A}_{vw}' \neq \mathcal{A}_{vw}$  where  $w \in \mathcal{V}$ . However, to prevent the attacker from completely modifying the graph, we impose a constraint on the total number of allowable changes, controlled by a specified budget  $\Delta$ :  $\sum_{w \in \mathcal{V}} |\mathcal{A}_{vw} - \mathcal{A}_{vw}'| \leq \Delta$ .
+
+Problem Statement. Consider an initial graph  $\mathcal{G} = (\mathcal{A},\mathcal{X})$ , a target node  $v$ , and its true class  $y_{v}$ . Our goal is to modify the graph's structure such that the classification of  $v$  changes from  $y_{v}$  to  $y_{v'}$ , where  $y_{v}\neq y_{v'}$ , thereby maximizing the difference from its original classification. The proposed attacks can be mathematically formulated as a bi-level optimization problem:
+
+$$
+\arg \max  _ {\left(\mathcal {A} ^ {\prime}, \mathcal {X}\right) \in \mathcal {G} ^ {\prime}} \max  _ {y _ {v ^ {\prime}} \neq y _ {v}} \ln Z _ {v, y _ {v ^ {\prime}}} ^ {*} - \ln Z _ {v, y _ {v}} ^ {*} \tag {1}
+$$
+
+where  $\mathbf{Z}^{*} = f_{\theta^{*}}(\mathcal{A}',\mathcal{X})$  and  $\theta^{*} = \arg \min_{\theta}\mathcal{L}(\theta ;\mathcal{A}',\mathcal{X})$  subject to the budget constraint. Specifically, we aim to find a modified graph  $\mathcal{G}' = (\mathcal{A}',\mathcal{X})$  in which the target node  $v$  is assigned a label  $y_{v'}$  that maximizes the difference from its original label  $y_{v}$  in terms of probability scores.
+
+![](images/aabcb830dbaea45556e0503be656145c0a44e519d29f9246bf6d5ccaaeda3091.jpg)  
+Figure 2: A toy graph where shared node colors imply similar orbit counts. Nodes  $u$ ,  $z$ , and  $w$  have 15 and 18 orbits, respectively.
+
+# 4.2 EQUIVALENCE CLASSES IN STRUCTURAL ATTACKS
+
+We utilize an attack strategy based on node equivalence groups to guide our decisions regarding the addition and deletion of edges. This section begins by defining graphlets, which are instrumental in identifying node equivalence groups. We then discuss orbits, representing the specific positions a node can assume within a graphlet to facilitate effective grouping. As a last step, we compute Graph Orbit Vectors from all graphlets to develop a multi-orbit based attack strategy.
+
+Definition 2 (Graphlet (Kloks et al., 2000)). A graphlet  $\mathcal{G}_{gp}$  within a larger graph  $\mathcal{G} = (\mathcal{V},\mathcal{E},\mathcal{X})$  is a connected induced subgraph  $\mathcal{G}s' = (\mathcal{V}',\mathcal{E}',\mathcal{X}')$ , where  $\mathcal{V}' \subseteq \mathcal{V}$ , and  $\mathcal{E}'$  includes all edges  $e_{uv} \in \mathcal{E}$  with both  $u$  and  $v$  in  $\mathcal{V}'$ , and  $|\mathcal{V}'|$  typically equals 5 (as defined in Appendix Figure 6).
+
+There are 30 distinct graphlets of 5-nodes (see Appendix Figure 6 for the shapes). For instance, consider the nodes  $\{u, x, v, k, y\}$  in Figure 2, which forms a graphlet with  $|\mathcal{V}'| = 5$ .
+
+Orbits are defined by automorphisms of the graphlet; an automorphism  $\sigma$  of a graphlet  $\mathcal{G}_{gp}$  satisfies  $\sigma \cdot \mathcal{G}_{gp} = \mathcal{G}_{gp}$ . Nodes  $v$  and  $w$  in  $\mathcal{V}$  are similar if there exists an automorphism  $\sigma$  such that  $\sigma(v) = w$ .
+
+The orbit of a node  $v$ , denoted by  $\mathrm{Orb}(\mathcal{G}_{gp}, v)$ , is the set of all nodes  $w \in \mathcal{V}$  that can be mapped onto  $v$  by some automorphism of the graphlet:
+
+Definition 3 (Orbit (Alon, 2007)).  $\text{Orb}(\mathcal{G}_{gp}, v) = \{w \in \mathcal{V} \mid \sigma \in \text{Aut}(\mathcal{G}_{gp}) : \sigma(v) = w\}$ .
+
+where  $\mathrm{Aut}(\mathcal{G}_{gp})$  is the group of automorphisms of  $\mathcal{G}_{gp}$ . Each orbit is denoted by  $\mathrm{Orb}_j$ , where  $j$  is a unique identifier for each orbit within a specific graphlet. A node  $v$  touches an orbit  $\mathrm{Orb}_j$  if  $v$  is part of an induced subgraph in the graph and  $v$  belongs to  $\mathrm{Orb}_j$ . By extension, a node may appear in multiple graphlets and, hence, occupy multiple orbits. For example, in Figure 2, node  $x$  appears in graphlets comprising of nodesets  $\{x,v,k,l,w\}$  and  $\{x,v,k,y,l\}$  and so on. Overall, the 30 distinct graphlets create 73 distinct orbits (see Appendix Figure 6 for the orbit positions). The number of graphlets and orbits are all uniquely determined by the choice of using 5-node graphlets.
+
+Definition 4 (Graph Orbit Vector). We propose a Graph Orbit Vector (GOV) as a numerical representation of a node's participation across the 73 orbits in a graph. Consequently,  $\mathbf{GOV}_{\mathbf{v}}$  of a node  $v$  is an  $n = 73$ -dimensional vector, where each dimension corresponds to the count of a specific orbit touched by node  $v$ . This dimensionality reflects the full set of topological positions a node can occupy across all 5-node graphlets, making it a comprehensive description of a node's structural embedding.
+
+We initialize the vector element for  $\mathrm{Orb}_j$  of node  $v$  at zero and increase it by one each time  $v$  appears in orbit  $\mathrm{Orb}_j$  of any graphlet, where  $\mathrm{Orb}_j$  is an induced subgraph containing  $v$ . This count reflects the number of graphlets in which  $v$  participates through orbit  $\mathrm{Orb}_j$ . As a result, the Graph Orbit Vector provides a profile of a node's topological embedding within the graph. Notably, orbit discovery is performed for the entire graph as a pre-processing step, eliminating the need for recomputation for each target node.
+
+![](images/428b49d6d8da5db2ac374b10fd48c095cedafcb71d519bf281d870d30933d4a8.jpg)  
+Figure 3: Graphlets where orbits 15 and 18 are defined.
+
+# 4.3 GOTTACK: GRAPH STRUCTURE POISONING VIA ORBIT LEARNING
+
+In our exploration of graph topology, we have discovered a distinctive feature shaped by orbits 15 and 18: nodes touching these orbits appear in peninsula-like subgraphs (such as the one formed in Figure 2 by nodes  $\{u,x,v,k,t\}$ ). These orbits (see Figure 3) are characteristic of being three or four edges away
+
+from another endpoint in the graphlet and serve as critical indicators of topological peripheries within a graph. This geometric arrangement lends a substantial foundation to our subsequent analyses and adversarial strategies on graph data, as discussed in the following hypotheses and experimental sections.
+
+We start by stating our topological observation as influenced by the Mapper philosophy: 1) Orbit Proxy. Under the homophily assumption, node classification posits that graph neighbors are similar to a node in the label. Consequently, nodes in more distant positions, as can be identified by orbits, are less similar. 2) Periphery Orbits. Orbits 15 and 18 indicate the topological periphery in a graph and provide a useful proxy for identifying distant nodes that differ in labels.
+
+We claim that the path distance within the graph encodes a notion of remoteness, which in turn yields minimal information about a node's label. This indicates that physical proximity within the network strongly influences the predictive accuracy regarding node labels. In our experiments (Section 5), we also provide empirical evidence demonstrating the utility of the Orbit Proxy in heterophilic graph cases, albeit in a weaker form.
+
+In Theorem 1, we formally state that nodes located in orbits 15 and 18, due to their peripheral placement, are particularly effective for establishing paths to remote parts of the graph. This has significant implications for designing network protocols and algorithms that rely on efficient data traversal and retrieval mechanisms.
+
+Theorem 1 (Remote Connection Candidates). Let  $H(v, w)$  denote the expected random walk hitting time from node  $v$  to node  $w$  in  $\mathcal{G}$ . For any target node  $v \in V$ , nodes in orbits 15 and 18 are the most effective candidates of  $w$  for establishing paths to the most remote parts of  $\mathcal{G}$ , due to their longer expected hitting times  $H(v, w)$  compared to other nodes not in these orbits.
+
+Due to space limitations, the proof is given in Appendix A.
+
+The Periphery Orbits observation forms the backbone of our attack strategy; we identify nodes of periphery orbits (i.e., 15 and 18) and affect the adjacency matrix (i.e., add or remove edges to these
+
+nodes) accordingly to confuse a GNN to misclassify a target. Consider the target node  $v$  in Figure 2. Our hypothesis posits that creating an edge from  $v$  (or any other node) to either of the (orbit 15 and 18) nodes  $u, z$  or  $w$  will yield the highest misclassification error in GCN. The selection among periphery nodes uses a gradient-based method, as we detail below in surrogate loss.
+
+Orbits (15, 18). We define two ordered orbit categories based on the highest and second-highest orbit counts. The highest is given by  $Orb_{\mathrm{max}}^v = \arg \max (\mathrm{GOV}_v)$ . If multiple orbits share this count, one is chosen arbitrarily. The second-highest is  $Orb_{\mathrm{sec}}^v = \arg \max (\{j\in \mathrm{GOV}_v\mid j\neq Orb_{\mathrm{max}}^v\})$ . Each node is then assigned an orbit category  $Orb^{v} = Orb_{\mathrm{max}}\| Orb_{\mathrm{sec}}$ , where order does not matter.
+
+Example 1. Consider a node  $v$  in graph  $\mathcal{G}$ . Although GOattack works with  $k = 5$ -node graphlets, for simplicity, this example employs three-node graphlets ( $k = 3$ ) for orbit counting, yielding a 4-dimensional vector to store all possible orbits. Suppose the orbit count vector for node  $v$  is  $GOV_v = [4, 15, 11, 12]$ . The task is to identify the largest and second-largest orbit count values in  $GOV_v$ . The largest orbit count value is 15, denoted by  $Orb_{\text{max}}^v = 01$ , and the second-largest orbit count value is 12, denoted by  $Orb_{\text{sec}}^v = 03$ . Thus, node  $v$  is categorized into the orbit category  $Orb^v = 01|03$  or 0103 in short.
+
+Surrogate loss. Our objective is to maximize the discrepancy in log probabilities for the target node  $v$  within a specified budget  $\Delta$ . The log-probabilities can be simplified to  $\hat{A}^2\mathcal{X}\mathcal{W}$ . We linearize the model by replacing the nonlinearity  $\sigma(.)$  with a simple linear activation function. Therefore, from Eq. 3,  $Z' = \mathrm{softmax}(\hat{A}\hat{A} X W^1 W^2) = \mathrm{softmax}(\hat{A}^2 X W)$ . Therefore, the surrogate loss function,  $\mathcal{L}_s(\mathcal{A},\mathcal{X};\mathcal{W},v)$ , is designed to optimize the following objective:  $\arg \max_{(A',X)\in \mathcal{G}'}\mathcal{L}_s(\mathcal{A}',\mathcal{X};\mathcal{W},v)$ , where,
+
+the surrogate loss function  $\mathcal{L}_s$  is defined as  $\mathcal{L}_s(\mathcal{A}',\mathcal{X};\mathcal{W},v) = \max_{w\neq z}[\hat{A}^2 XW]_{v,z} - [\hat{A}^2 XW]_{v,w}$ . This function aims to solve the maximum loss over a set of permissible changes in  $\mathcal{A}$  of  $\mathcal{G}$ .
+
+Structure poisoning. We compute a candidate node set called the orbit category, denoted as  $Orb_{cat}$ , consisting only of allowable elements  $(v, u)$  where the edge changes from 0 to 1 (i.e., adding an edge) or vice versa. Specifically, for a given target node  $v$ , we create a candidate set such that  $u \in \mathcal{V}$  where  $Orb_{\max}^u = 1518$ . Among the candidate edge changes, we select the one that yields the highest surrogate loss. However, to compute the surrogate loss score, we first need to determine the class prediction of the target node  $v$  after adding or removing an edge  $(u, v)$ . Here, we are optimizing the loss score with respect to  $\mathcal{A}$ ; the term  $\mathcal{XW}$  is constant. The log-probabilities of node  $v$  are then given by  $g(v) = [\hat{\mathcal{A}}^2]_v \cdot C$ , where  $[\hat{\mathcal{A}}^2]_v$  denotes a row vector and  $C$  is the constant term ( $\mathcal{XW}$ ). Thus, we only need to inspect how this row vector changes to determine the optimal edge manipulation. Following the insight developed by Zügner & Gunnemann (2019), we can derive an incremental update, so there is no need to recompute the updated  $[\hat{\mathcal{A}}^2]_v$  from scratch.
+
+We assume access to the complete graph and its training labels, allowing adversaries to exploit its structure but not the target model, focusing instead on transferable attacks. This setting applies to domains like social and transaction networks, where graph structures are publicly visible (e.g., social media friendships, academic citations, and cryptocurrency transactions).
+
+Time Complexity. Orbit discovery is the primary computational cost of GOttack. The time complexity for computing all orbits for all nodes is  $O(|E| \times d + |V| \times d^4)$ , where  $O(|V| \times d^4)$  corresponds to the time required to enumerate all five-node graphlets, and  $d$  denotes the maximum degree in the graph. For instance, orbit discovery on the CORA dataset takes only 0.17 seconds. All time costs for orbit discovery are provided in Appendix Table 52.
+
+# 5 EXPERIMENTS
+
+This section presents the experimental evaluation we carried out to show the effectiveness of the proposed approach. We answer the following questions: i) How effective is the GOttack approach in terms of misclassification rate compared with existing state-of-the-art approaches? ii) How efficient is the proposed model in terms of computation time compared with the existing models? iii) How easy is it to defend against GOttack compared to existing models?
+
+Datasets. We conduct experiments on five widely used node classification datasets, the statistics of which are provided in Table 1. Cora (Yang et al., 2016), Citeseer (Yang et al., 2016) and Pubmed
+
+Table 2: Misclassification rate (in %)  $(\uparrow)$  of target nodes in five datasets where three backbone GNNs (GCN, GIN and GraphSAGE) are attacked in node classification with budget  $\Delta = 1$ . See Appendix D.1 for stds.  
+
+<table><tr><td></td><td colspan="2">Cora</td><td colspan="2">Citeseer</td><td colspan="2">Polblogs</td><td colspan="2">BlogCatalog</td><td colspan="4">Pubmed</td></tr><tr><td>Method</td><td>GSAGE</td><td>GCN</td><td>GIN</td><td>GSAGE</td><td>GCN</td><td>GIN</td><td>GSAGE</td><td>GCN</td><td>GIN</td><td>GSAGE</td><td>GCN</td><td>GIN</td></tr><tr><td>Random</td><td>19.11</td><td>2.07</td><td>17.30</td><td>30.01</td><td>2.01</td><td>10.03</td><td>15.13</td><td>12.04</td><td>17.04</td><td>3.09</td><td>12.09</td><td>4.19</td></tr><tr><td>Nettack</td><td>58.04</td><td>34.06</td><td>46.10</td><td>66.09</td><td>46.04</td><td>57.04</td><td>29.02</td><td>38.04</td><td>13.02</td><td>50.11</td><td>20.02</td><td>55.07</td></tr><tr><td>FGA</td><td>54.08</td><td>32.05</td><td>40.09</td><td>60.11</td><td>31.10</td><td>44.10</td><td>22.08</td><td>31.09</td><td>14.02</td><td>46.15</td><td>10.04</td><td>61.09</td></tr><tr><td>SGA</td><td>61.06</td><td>41.05</td><td>57.05</td><td>60.06</td><td>41.06</td><td>57.06</td><td>35.05</td><td>37.07</td><td>35.08</td><td>51.45</td><td>24.03</td><td>61.02</td></tr><tr><td>PRBCD</td><td>35.02</td><td>41.06</td><td>36.10</td><td>35.04</td><td>46.04</td><td>42.02</td><td>8.01</td><td>42.07</td><td>33.06</td><td>33.05</td><td>5.09</td><td>38.02</td></tr><tr><td rowspan="2">GAttack (ours)</td><td rowspan="2">59.05</td><td rowspan="2">41.52</td><td rowspan="2">37.03</td><td rowspan="2">61.09</td><td rowspan="2">46.07</td><td rowspan="2">57.06</td><td rowspan="2">29.03</td><td rowspan="2">41.08</td><td rowspan="2">15.08</td><td rowspan="2">52.10</td><td rowspan="2">22.04</td><td rowspan="2">63.08</td></tr><tr></tr></table>
+
+(Yang et al., 2016) datasets are citation networks with undirected edges and binary features where nodes are publications and edges are citation links.
+
+In the Polblogs (Adamic & Glance, 2005) dataset, nodes are political blogs, and edges are links between them. In the BlogCatalog (Tang & Liu, 2009) dataset, nodes' attributes are constructed by keywords, which are generated by users as a short description of their blogs. We split the networks into labeled  $(20\%)$  and unlabeled nodes  $(80\%)$ .
+
+We further split the labeled nodes into equal parts training and validation sets to train the surrogate model. We have used the ORCA algorithm (Hocevar & Demsrar, 2014) for the orbit discovery process on these datasets.
+
+Experimental Setup. We have conducted the experiments under the transductive, semi-supervised
+
+Table 1: Dataset statistics.  
+
+<table><tr><td>Dataset</td><td>Hom.</td><td>Nodes</td><td>Edges</td><td>Features</td><td>Labels</td></tr><tr><td>Cora</td><td>0.81</td><td>2,485</td><td>5,069</td><td>1,433</td><td>7</td></tr><tr><td>CiteSeer</td><td>0.74</td><td>2,110</td><td>3,668</td><td>3,703</td><td>6</td></tr><tr><td>Polblogs</td><td>0.91</td><td>1,222</td><td>16,714</td><td>1,490</td><td>2</td></tr><tr><td>Pubmed</td><td>0.81</td><td>19,717</td><td>44,325</td><td>500</td><td>3</td></tr><tr><td>BlogCatalog</td><td>0.40</td><td>5,196</td><td>171,743</td><td>8,189</td><td>6</td></tr></table>
+
+learning setting. We have used both common node classifier GNNs, including GCN (Kipf & Welling, 2017), GIN (Xu et al., 2019b), and GraphSAGE (Hamilton et al., 2017) and defense models, including RobustGCN (Zhu et al., 2019), GCN-Jaccard (Wu et al., 2019), GCN-SVD (Entezari et al., 2020), and MedianGCN (Chen et al., 2021) as the backbone to evaluate our adversarial attacks.
+
+We average over five different random initializations/splits, where for each, we follow these steps: Initially, we train the surrogate model on the labeled data. From the test set, among all nodes correctly classified, we adopt the popular practice of Nettack and select: (i) the 10 nodes with the highest margin of classification, indicating clear correctness, (ii) the 10 nodes with the lowest margin (still correctly classified), and (iii) 20 additional nodes randomly chosen. These selected nodes will be the targets for the attacks. All results presented here are computed by us in the same settings.
+
+In our attack model, the budget  $\Delta$  limits the number of allowed perturbations, such as edge additions or deletions. Its optimal value depends on the graph's structure, particularly node degrees: small  $\Delta$  (e.g., 1 or 2) can significantly impact low-degree nodes, while higher values suit high-degree nodes. To ensure comparability, we adopt fixed budgets ( $\Delta = 1, \ldots, 5$ ), following prior works like Nettack and FGA.
+
+We compare GOtack against five state-of-the-art graph adversarial attack frameworks: Nettack (Zugner et al., 2018), FGAttack (FGA)(Chen et al., 2018), SGAttack (SGA) (Li et al., 2023) and PRBCD (Geisler et al., 2021) as well as a Random (dummy) baseline (see App. Section B.2 for descriptions). We use GCN as the surrogate model for the attack models except for SGA, which suggests SGC. We report the misclassification rate, which is the percentage of nodes that were incorrectly classified by the model in relation to the total number of nodes being classified.
+
+In our experiments, we utilized the PyG (PyTorch Geometric) library, which employs PyTorch as the backend for implementing GNN models. Additionally, we used the PyTorch adversarial library DeepRobust (Li et al., 2020) for robustness evaluations. The experiments were conducted using Python (Version 3.8.19) and PyTorch Version 3.10.0. The computational environment was a Linux cluster equipped with an AMD Ryzen Threadripper 3960X 24-core processor, 2520GB RAM and NVIDIA RTX A6000 with 49GB RAM GPUs. Our Python implementation is shared at https://github.com/cakcora/Gottack.
+
+Parameters setting. Our models were trained using the Adam (Kingma & Ba, 2015) optimization algorithm, employing a fixed learning rate of 0.01. Training sessions were conducted over a span of 200 epochs; we employed the softmax activation function.
+
+![](images/1e7cc2162dfad81b58cf7609f2e29941123c7dd20e7e8898390468f048bde156.jpg)  
+(a) GraphSAGE model
+
+![](images/ed412995701947e62f91c5c524256113ceb130c3f25d1927119fd2db3867de38.jpg)  
+(b) GCN model
+
+![](images/25d7fefbb9d7e9e770c140fcdf0e4f6c4ccf2fecf8405fc83de8d17a34d26872.jpg)  
+(c) GIN model  
+Figure 4: Budgeted attack results on the CiteSeer dataset.
+
+# 5.1 GOTTACK MISCLASSIFICATION RESULTS
+
+Table 2 shows the misclassification rate achieved with a single edge perturbation (addition or deletion). GOattack yields the highest misclassification rates in 7 out of 15 attack settings and ranks second in 5 other settings. SGAttack yields 4 best attacks, while PRBCD and Nettack each perform best in 2 attack settings. PRBCD, a widely used method adopted by PyTorch, yields surprisingly low rates in two datasets for GSAGE and GIN. GOattack yields the highest overall rate of 52.08, whereas the second best Nettack yields 47.02.
+
+Likewise, Table 3 shows the misclassification rates of the top-3 attack models on defense models with a single edge perturbation. GOattack yields the highest misclassification rates in 7 out of 16 attack settings and ranks second in 7 other settings, while SGA achieves the best performance in 7 attack settings. GOattack achieves the highest overall rate of 33.07, whereas SGA has a rate of 32.5.
+
+In Figure 4, we gradually increase the attack budget and represent the corresponding misclassification rates on the Citeseer dataset (see Appendix D for all results). We observe that for GraphSAGE, GOattack yields better misclassification results, reaching a maximum misclassification score of  $97\%$  with 5 perturbations. Similarly, for the GCN and GIN models, the proposed approach attains misclassification scores of  $77\%$  and  $76\%$ , respectively, outperforming the SOTA models.
+
+Extending the analysis of the relationship between increasing budgets ( $\Delta = 1, \dots, 5$ ) and misclassification rates to all datasets, we observe the following behavior (see Section D for complete results): GOattack achieves the highest misclassification rate in 28 out of 65 tasks for GCN, GSAGE and GIN models across all budgets. The numbers are 16 for PRBCD, 16 for SGAttack, and 3 for Nettack. GOattack achieves the highest average rate of 0.58 over all budgets and datasets compared to the second best model of PRBCD and SGAttack with 0.57 (Appendix Table 8).
+
+Furthermore, as shown in Table 4, GOattack demonstrates superior computational efficiency and scalability, making it particularly well-suited for large-scale graph datasets. This efficiency stems from its topological approach to candidate node selection, which reduces the search space for potential attack points without sacrificing effectiveness. For example, in the BlogCatalog dataset, GOattack requires only about  $55\%$  of the time taken by Nettack to execute, significantly reducing computational overhead. Despite its speed, GOattack still maintains a high level of attack effectiveness, generating attack candidates in less than 10 minutes, even for datasets with a large number of nodes and edges. This balance between performance and computational cost highlights GOattack's practical applicability to real-world scenarios.
+
+While both Nettack and GOttack are scalable for large graphs, their methodologies differ: Nettack selects candidates based on degree distribution in each iteration, whereas GOttack leverages orbit structures. Although orbit discovery incurs some overhead, it reduces the candidate set to about  $23\%$  of all nodes (see Appendix Figure 8), making the initial cost worthwhile. Among alternative methods,
+
+Table 3: Misclassification rate (in %) ( $\uparrow$ ) of target nodes in different datasets against four defense models (RGCN, GCN-Jaccard, GCN-SVD and MedianGCN) are attacked in node classification with budget  $\Delta = 1$ . See Appendix D.2 for stds.
+
+<table><tr><td colspan="5">Cora</td><td colspan="4">Citeseer</td><td colspan="4">Polblogs</td><td colspan="4">BlogCatalog</td></tr><tr><td>Method</td><td>RGCN</td><td>JAC</td><td>SVD</td><td>MDGCN</td><td>RGCN</td><td>JAC</td><td>SVD</td><td>MDGCN</td><td>RGCN</td><td>JAC</td><td>SVD</td><td>MDGCN</td><td>RGCN</td><td>JAC</td><td>SVD</td><td>MDGCN</td></tr><tr><td>SGA</td><td>44.01</td><td>33.02</td><td>28.03</td><td>32.05</td><td>53.00</td><td>36.01</td><td>24.04</td><td>36.01</td><td>46.03</td><td>43.05</td><td>16.01</td><td>43.05</td><td>25.02</td><td>25.02</td><td>15.05</td><td>20.01</td></tr><tr><td>Nettack</td><td>48.08</td><td>38.01</td><td>24.01</td><td>32.05</td><td>46.04</td><td>42.02</td><td>28.04</td><td>27.05</td><td>38.05</td><td>46.03</td><td>12.04</td><td>33.02</td><td>35.04</td><td>19.03</td><td>19.02</td><td>17.02</td></tr><tr><td>GÖntack (ours)</td><td>43.04</td><td>39.01</td><td>28.08</td><td>32.07</td><td>48.07</td><td>42.09</td><td>25.03</td><td>28.02</td><td>40.02</td><td>53.06</td><td>10.02</td><td>34.07</td><td>35.05</td><td>20.02</td><td>20.00</td><td>19.03</td></tr></table>
+
+![](images/c6499b24ad7dcf2c9afe3525a37884a1df87bf8ab31bdb21965376f0e958149c.jpg)  
+(a) Computation graph before attack
+
+![](images/12f0730a1a4d4e61d0e8104f591e2d67c75390e13ea8ab6e2686045f4f86e26b.jpg)  
+(b) Computation graph after attack  
+Figure 5: The computation graph for the targeted node 1978 from the CORA datasets, as identified by GNNExplainer (Luo et al., 2020). The edge (1978, 387) is added during the successful attack. Edge importances change considerably after the attack and negative class gains importance due to the newly added nodes.
+
+only SGA is more scalable, as it focuses on local neighborhoods for candidate selection; however, its performance is worse than GOattack.
+
+We compared GOattack to adaptive attacks, which consider specific model architectures during attack generation. Results (see Appendix Section D) reveal that while adaptive attacks outperform in single-model scenarios, GOattack's transferable perturbations exhibit broader applicability across diverse settings, reinforcing its utility in exploratory research on adversarial robustness.
+
+# 5.2 INSIGHTS FROM GOTTACK RESULTS
+
+Gottack strategically selects nodes using the graph topology. This selection criterion prompts several thoughts and questions, which we address below:
+
+The periphery definition. A visual inspection of Figure 6 shows that more orbits, such as 19, 39, and 27, could fit the periphery definition. The primary reason for not considering these orbits is their relative scarcity in all the graph datasets. For example, node orbits from the Cora dataset in Appendix Figure 8 show that most nodes predominantly feature orbits within the 1518 and 1922 groups. Furthermore, as shown in Appendix Section D, attacks based on 1819, 1519 and 1922 yield less powerful attacks.
+
+Higher order orbits. GOttack uses two orbits: 1518. The decision against using  $>2$  orbits is influenced by the fact that nodes typically do not have more orbits. For the single orbit case, our experiments had larger time complexity, as a larger pool of nodes was considered, yet the efficacy of attacks remained similar.
+
+Gradient-based models target 1518 nodes. Our analysis reveals that gradient-based models predominantly target 1518 nodes, as shown for Net
+
+tack in Table 5 and for other models in Appendix Tables 6 and 7. For instance, Table 5 shows that in the highly homophilous Polblogs,  $97.5\%$  of initial attacks involve 1518 nodes, despite these nodes comprising only  $9.41\%$  of the total. A similar trend appears in the heterophilous BlogCatalog dataset  $(2.5\%$  and  $22.5\%$  in  $\Delta = 1,2$  attacks). This highlights the strategic role of orbit 1518 nodes in network attacks.
+
+Table 4: End-to-end time costs in seconds (↓). See Appendix Table 51 for stds.  
+
+<table><tr><td rowspan="2"></td><td colspan="4">Global</td><td>Local</td></tr><tr><td>GObtack</td><td>Nettack</td><td>FGA</td><td>PRBCD</td><td>SGA</td></tr><tr><td>Cora</td><td>48.27</td><td>59.57</td><td>55.63</td><td>242.37</td><td>32.24</td></tr><tr><td>CiteSeer</td><td>42.02</td><td>46.12</td><td>42.43</td><td>210.55</td><td>41.02</td></tr><tr><td>Polblogs</td><td>139.68</td><td>175.23</td><td>165.37</td><td>210.87</td><td>164.07</td></tr><tr><td>BlogCatalog</td><td>512.04</td><td>916.91</td><td>223.02</td><td>259.38</td><td>335.91</td></tr><tr><td>Pubmed</td><td>246.96</td><td>243.78</td><td>533.55</td><td>240.23</td><td>68.23</td></tr><tr><td>Median</td><td>139.68</td><td>175.23</td><td>165.37</td><td>240.23</td><td>68.23</td></tr></table>
+
+Node, Homophily, Distance and Subgraph-based Explanations for GOttack. We conducted a comprehensive analysis to understand how GOattack causes node misclassification. Initially, we used GNN explainers (see Appendix Section E.1), which factor in the subgraph effects and node features in perturbations. Figure 5 shows an example where misclassifications are due to changes in the importance of existing edges, which offers evidence that explanations specific to nodes or edges alone are insufficient to adequately explain an attack, as shown in Figure 5. However, as widely noted in the literature (Li et al., 2024a; Li et al., 2024b), explainers often disagree on the exact interpretation (see Figure 9b).
+
+Next, we focused on node-centric metrics to determine the positional changes of the target node within the graph following the attack. As detailed in Appendix Table 45, the target nodes' clustering coefficient, degree, betweenness, and closeness centralities did not show a significant difference compared to those influenced by other attacks. Secondly, we examined whether the attack brought in nodes with different labels into the computation graph of the target node (see Appendix Table 50). We found that after the attack, both similar and differently labeled nodes increased by 0.92 and 3.36 on average, respectively. However, these values are not as pronounced as those seen in other attacks, suggesting that the induced label diversity change by GOattack is not substantial. Next, we computed the shortest path distances from the target nodes to nodes with similar and different labels in the entire graph (see Appendix Table 48). This analysis provided empirical proof supporting our Theorem 1: the 1518 strategy more significantly reduces the distance to nodes of different labels  $(-0.03)$  than to those of similar labels  $(-0.02)$ . This behavior, which indicates a targeted modification in network dynamics, was not observed with other orbits.
+
+Budget Selection and Structural Implications. The choice of the attack budget  $\Delta$  is important in determining the effectiveness and practicality of adversarial attacks. Fixed budgets, as employed in this study, provide consistency for benchmarking but may oversimplify real-world scenarios where the impact of a perturbation is context-dependent. For example, a budget of 5 for a node with a degree of 2 introduces a disproportionate perturbation compared to the same budget applied to a node with a degree of 2000. Future work could explore dynamic or adaptive budget strategies that account for degree distribution and other structural factors. Tables 42, 43 and, 44 present comparisons of GOattack with established budget settings, specifically considering the percentile of node degrees  $(\epsilon)$ .
+
+Defenses and Availability. GOattack can be defended against by attending to node orbit types in GNN aggregations and reducing the importance of neighbors in 1518 orbits. In that case, topology offers new orbits to attack, such as 1519 and 1922, as we study and report in Appendix D. We have created a graph-algebra-based orbit selection scheme in Appendix C.3 that can attack i) a graph of any size and ii) a graph without the periphery orbits of 1518. However, we note that in all the datasets used, nodes belonging to orbit 1518 were particularly common (see Figure 8).
+
+Limitations. A notable limitation of our study is the assumption of access to complete graph and training labels, which may not always hold in real-world scenarios. Future work could relax these assumptions
+
+to enhance practical applicability while retaining the theoretical contributions. GOattack optimizes candidate node selection for attacks using a topological approach. Our primary hypothesis is that this topological method offers both efficiency and effectiveness. While brute-force methods or gradient-based optimizations can theoretically achieve the same attack success by exhaustively exploring all possible options, these approaches come with significant computational costs. Thus, the tradeoff between attack efficiency and runtime must be carefully balanced. GOattack addresses this by providing a principled strategy based on topology, offering a more computationally feasible solution without sacrificing attack efficacy.
+
+Table 5: Comparison of orbit-based node selection in sequential Nettack phases.  
+
+<table><tr><td>Dataset</td><td>Orbits</td><td>% of nodes</td><td>% in 1stAttack</td><td>% in 2ndAttack</td></tr><tr><td rowspan="3">Cora (h=0.81)</td><td>1518</td><td>24.00%</td><td>77.00%</td><td>71.10%</td></tr><tr><td>1519</td><td>14.41%</td><td>5.70%</td><td>14.29%</td></tr><tr><td>1819</td><td>11.59%</td><td>10.00%</td><td>12.50%</td></tr><tr><td rowspan="3">CiteSeer (h=0.74)</td><td>1518</td><td>21.99%</td><td>51.60%</td><td>61.29%</td></tr><tr><td>1519</td><td>21.18%</td><td>12.50%</td><td>15.00%</td></tr><tr><td>1819</td><td>11.56%</td><td>3.29%</td><td>0.00%</td></tr><tr><td rowspan="3">Polblogs (h=0.91)</td><td>1518</td><td>9.41%</td><td>97.50%</td><td>60.00%</td></tr><tr><td>1519</td><td>2.29%</td><td>0.00%</td><td>0.00%</td></tr><tr><td>1819</td><td>12.93%</td><td>2.50%</td><td>27.50%</td></tr><tr><td rowspan="3">Pubmed (h=0.81)</td><td>1518</td><td>20.14%</td><td>25.00%</td><td>10.00%</td></tr><tr><td>1519</td><td>23.07%</td><td>32.50%</td><td>52.50%</td></tr><tr><td>1618</td><td>2.24%</td><td>22.50%</td><td>10.00%</td></tr><tr><td rowspan="3">BlogCatalog (h=0.40)</td><td>1518</td><td>3.25%</td><td>2.50%</td><td>22.50%</td></tr><tr><td>1519</td><td>61.57%</td><td>62.50%</td><td>37.50%</td></tr><tr><td>1922</td><td>19.77%</td><td>35.00%</td><td>40.00%</td></tr></table>
+
+# 6 CONCLUSION
+
+We have identified a key equivalence group for graph nodes based on their topological positions within the graph and demonstrated that gradient-based attack models frequently target this group in their attacks. Our approach, GOattack, introduces a seminal topological strategy in adversarial graph machine learning. By uncovering this previously unexplored vulnerability tied to graph topology, our work highlights the susceptibility of graph neural networks to topology-based attacks and paves the way for developing efficient attack models. GOattack not only enhances misclassification rates but does so in a scalable manner. For future work, we aim to study topological defenses against attack models.
+
+# ACKNOWLEDGMENTS
+
+This work has received funding from Canadian NSERC Discovery Grant RGPIN-2020-05665: Data Science on Blockchain and Canadian Research Manitoba grant 324278-352400-2000: Bonafide: Decentralized Services for Sharing and Searching User Generated Data, and from the NSF awards DMS-2204795, OAC-2115094, CNS-2331424, ARL/Army Research Office awards W911NF-24-1-0202 and W911NF-24-2-0114 and NIH award 5RM1HG009034-08.
+
+# REFERENCES
+
+Lada A Adamic and Natalie Glance. The political blogosphere and the 2004 us election: divided they blog. In Proceedings of the 3rd international workshop on Link discovery, pp. 36-43, 2005.  
+Uri Alon. Network motifs: theory and experimental approaches. Nature Reviews Genetics, 8(6): 450-461, 2007.  
+Peter W. Battaglia, Jessica B. Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Flores Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, Caglar Gulçehre, H. Francis Song, Andrew J. Ballard, Justin Gilmer, George E. Dahl, Ashish Vaswani, Kelsey R. Allen, Charles Nash, Victoria Langston, Chris Dyer, Nicolas Heess, Daan Wierstra, Pushmeet Kohli, Matthew M. Botvinick, Oriol Vinyals, Yujia Li, and Razvan Pascanu. Relational inductive biases, deep learning, and graph networks. CoRR, abs/1806.01261, 2018. URL http://arxiv.org/abs/1806.01261.  
+Oleg Vladimirović Bogopolskij. Introduction to group theory, volume 6. European Mathematical Society, 2008.  
+Aleksandar Bojchevski and Stephan Gunnemann. Adversarial attacks on node embeddings via graph poisoning. In International Conference on Machine Learning, pp. 695-704. PMLR, 2019.  
+Raffaella Burioni and Davide Cassi. Random walks on graphs: ideas, techniques and results. Journal of Physics A: Mathematical and General, 38(8):R45, 2005.  
+Heng Chang, Yu Rong, Tingyang Xu, Wenbing Huang, Honglei Zhang, Peng Cui, Xin Wang, Wenwu Zhu, and Junzhou Huang. Adversarial attack framework on graph embedding models with limited knowledge. IEEE Transactions on Knowledge and Data Engineering, 35(5):4499-4513, 2022.  
+Jinyin Chen, Yangyang Wu, Xuanheng Xu, Yixian Chen, Haibin Zheng, and Qi Xuan. Fast gradient attack on network embedding. CoRR, abs/1809.02797, 2018. URL http://arxiv.org/abs/1809.02797.  
+Liang Chen, Jintang Li, Qibiao Peng, Yang Liu, Zibin Zheng, and Carl Yang. Understanding structural vulnerability in graph convolutional networks. In Proceedings of the Thirtieth International Joint Conference on Artificial Intelligence, IJCAI 2021, Canada, 19-27 August 2021, pp. 2249-2255. ijcai.org, 2021. doi: 10.24963/IJCAI.2021/310. URL https://doi.org/10.24963/ijcai.2021/310.  
+Hanjun Dai, Hui Li, Tian Tian, Xin Huang, Lin Wang, Jun Zhu, and Le Song. Adversarial attack on graph structured data. In 35th International Conference on Machine Learning, ICML 2018, Stockholm, Sweden, July 10-15, 2018, volume 80, pp. 1123-1132. PMLR, 2018. URL http://proceedings.mlr.press/v80/dao18b.html.  
+Negin Entezari, Saba A. Al-Sayouri, Amirali Darvishzadeh, and Evangelos E. Papalexakis. All you need is low (rank): Defending against adversarial attacks on graphs. In WSDM '20: The Thirteenth ACM International Conference on Web Search and Data Mining, Houston, TX, USA, February 3-7, 2020, pp. 169-177. ACM, 2020. URL https://doi.org/10.1145/3336191.3371789.  
+Wenqi Fan, Yao Ma, Qing Li, Jianping Wang, Guoyong Cai, Jiliang Tang, and Dawei Yin. A graph neural network framework for social recommendations. IEEE Transactions on Knowledge and Data Engineering, 34(5):2033-2047, 2020.
+
+Jian Feng and Shaojian Chen. Link prediction based on orbit counting and graph auto-encoder. IEEE Access, 8:226773-226783, 2020. doi: 10.1109/ACCESS.2020.3045529. URL https://doi.org/10.1109/ACCESS.2020.3045529.  
+Simon Geisler, Tobias Schmidt, Hakan Şirin, Daniel Zügner, Aleksandar Bojchevski, and Stephan Gunnemann. Robustness of graph neural networks at scale. Advances in Neural Information Processing Systems, 34:7637-7649, 2021.  
+Stephan Gunnemann. Graph neural networks: Adversarial robustness. Graph neural networks: foundations, frontiers, and applications, pp. 149-176, 2022.  
+William L. Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pp. 1024-1034, 2017.  
+Shiwen He, Shaowen Xiong, Yeyu Ou, Jian Zhang, Jiaheng Wang, Yongming Huang, and Yaoxue Zhang. An overview on the application of graph neural networks in wireless networks. IEEE Open Journal of the Communications Society, 2:2547-2565, 2021.  
+Tomaz Hocevar and Janez Demsr. A combinatorial approach to graphlet counting. Bioinform., 30 (4):559-565, 2014. URL https://doi.org/10.1093/bioinformatics/btt717.  
+Hussain Hussain, Tomislav Duricic, Elisabeth Lex, Denis Helic, Markus Strohmaier, and Roman Kern. Structack: Structure-based adversarial attacks on graph neural networks. In Proceedings of the 32nd ACM Conference on Hypertext and Social Media, pp. 111-120, 2021.  
+Di Jin, Bingdao Feng, Siqi Guo, Xiaobao Wang, Jianguo Wei, and Zhen Wang. Local-global defense against unsupervised adversarial attacks on graphs. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 37, pp. 8105-8113, 2023.  
+Jeff D Kahn, Nathan Linial, Noam Nisan, and Michael E Saks. On the cover time of random walks on graphs. Journal of Theoretical Probability, 2:121-128, 1989.  
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. URL http://arxiv.org/abs/1412.6980.  
+Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. 5th International Conference on Learning Representations, ICLR 2017, Toulouse, France, April 24-26, 2017, Conference Track Proceedings, 2017. URL https://openreview.net/forum?id=SJU4ayYgl.  
+Ton Kloks, Dieter Kratsch, and Haiko Müller. Finding and counting small induced subgraphs efficiently. Information Processing Letters, 74(3-4):115-121, 2000. doi: 10.1016/S0020-0190(00) 00047-8. URL https://doi.org/10.1016/S0020-0190(00) 00047-8.  
+Miroslaw Kowaluk, Andrzej Lingas, and Eva-Marta Lundell. Counting and detecting small subgraphs via equations. SIAM Journal on Discrete Mathematics, 27(2):892-909, 2013. doi: 10.1137/110859798. URL https://doi.org/10.1137/110859798.  
+Jintang Li, Tao Xie, Liang Chen, Fenfang Xie, Xiangnan He, and Zibin Zheng. Adversarial attack on large scale graph. IEEE Transactions on Knowledge and Data Engineering, 35(1):82-95, 2023. URL https://doi.org/10.1109/TKDE.2021.3078755.  
+Yaxin Li, Wei Jin, Han Xu, and Jiliang Tang. Deeprobust: A pytorch library for adversarial attacks and defenses. CoRR, abs/2005.06149, 2020. URL https://arxiv.org/abs/2005.06149.  
+Dongsheng Luo, Wei Cheng, Dongkuan Xu, Wenchao Yu, Bo Zong, Haifeng Chen, and Xiang Zhang. Parameterized explainer for graph neural network. Annual Conference on Neural Information Processing Systems, 2020.  
+Jiaqi Ma, Shuangrui Ding, and Qiaozhu Mei. Towards more practical adversarial attacks on graph neural networks. Annual Conference on Neural Information Processing Systems, NeurIPS, 2020.
+
+Ine Melckenbeeck, Pieter Audenaert, Didier Colle, and Mario Pickavet. Efficiently counting all orbits of graphlets of any order in a graph using autogenerated equations. Bioinformatics, 34(8): 1372-1380, 2018. URL https://doi.org/10.1093/bioinformatics/btx758.  
+Jiaming Mu, Binghui Wang, Qi Li, Kun Sun, Mingwei Xu, and Zhuotao Liu. A hard label black-box adversarial attack against graph neural networks. In Proceedings of the 2021 ACM SIGSAC Conference on Computer and Communications Security, pp. 108-125, 2021.  
+Gurjeet Singh, Facundo Memoli, and Gunnar E. Carlsson. Topological methods for the analysis of high dimensional data sets and 3d object recognition. 4th Symposium on Point Based Graphics, PBG@Eurographics 2007, Prague, Czech Republic, September 2-3, 2007, pp. 91-100, 2007. URL https://doi.org/10.2312/SPBG/SPBG07/091-100.  
+Mingjie Sun, Jian Tang, Huichen Li, Bo Li, Chaowei Xiao, Yao Chen, and Dawn Song. Data poisoning attack against unsupervised node embedding methods. CoRR, abs/1810.12881, 2018. URL http://arxiv.org/abs/1810.12881.  
+Yiwei Sun, Suhang Wang, Xianfeng Tang, Tsung-Yu Hsieh, and Vasant G. Honavar. Adversarial attacks on graph neural networks via node injections: A hierarchical reinforcement learning approach. WWW '20: The Web Conference 2020, Taipei, Taiwan, pp. 673-683, 2020. URL https://doi.org/10.1145/3366423.3380149.  
+Lei Tang and Huan Liu. Relational learning via latent social dimensions. Proceedings of the 15th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, Paris, France, pp. 817-826, 2009. URL https://doi.org/10.1145/1557019.1557109.  
+Shuchang Tao, Qi Cao, Huawei Shen, Junjie Huang, Yunfan Wu, and Xueqi Cheng. Single node injection attack against graph neural networks. In Proceedings of the 30th ACM International Conference on Information & Knowledge Management, pp. 1794-1803, 2021.  
+Shuchang Tao, Qi Cao, Huawei Shen, Yunfan Wu, Liang Hou, Fei Sun, and Xueqi Cheng. Adversarial camouflage for node injection attack on graphs. Information Sciences, 649:119611, 2023. URL https://doi.org/10.1016/j.ins.2023.119611.  
+Marcin Waniek, Tomasz P. Michalak, Talal Rahwan, and Michael J. Wooldridge. Hiding individuals and communities in a social network. Nature Human Behaviour, abs/1608.00375, 2016. URL http://arxiv.org/abs/1608.00375.  
+Hujun Wu, Chen Wang, Yuriy Tyshetskiy, Andrew Docherty, Kai Lu, and Liming Zhu. Adversarial examples for graph data: Deep insights into attack and defense. Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence, IJCAI, Macao, China, August 10-16, 2019, pp. 4816-4823, 2019. URL https://doi.org/10.24963/ijcai.2019/669.  
+Yihan Wu, Aleksandar Bojchevski, and Heng Huang. Adversarial weight perturbation improves generalization in graph neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 37, pp. 10417-10425, 2023.  
+Kaidi Xu, Hongge Chen, Sijia Liu, Pin-Yu Chen, Tsui-Wei Weng, Mingyi Hong, and Xue Lin. Topology attack and defense for graph neural networks: An optimization perspective. In Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence, IJCAI 2019, Macao, China, August 10-16, 2019, pp. 3961-3967. ijcai.org, 2019a. URL https://doi.org/10.24963/ijcai.2019/550.  
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019, 2019b. URL https://openreview.net/forum?id=ryGs6iA5Km.  
+Zhilin Yang, William W. Cohen, and Ruslan Salakhutdinov. Revisiting semi-supervised learning with graph embeddings. In Proceedings of the 33nd International Conference on Machine Learning, ICML 2016, volume 48, pp. 40-48, 2016. URL http://proceedings.mlr.press/v48/yanga16.html.
+
+Zhitao Ying, Dylan Bourgeois, Jiaxuan You, Marinka Zitnik, and Jure Leskovec. Gnnexplainer: Generating explanations for graph neural networks. Annual Conference on Neural Information Processing Systems, NeurIPS 2019, Vancouver, BC, Canada, pp. 9240-9251, 2019.  
+He Zhang, Bang Wu, Shuo Wang, Xiangwen Yang, Minhui Xue, Shirui Pan, and Xingliang Yuan. Demystifying uneven vulnerability of link stealing attacks against graph neural networks. In International Conference on Machine Learning, pp. 41737-41752. PMLR, 2023.  
+Xiao-Meng Zhang, Li Liang, Lin Liu, and Ming-Jing Tang. Graph neural networks and their current applications in bioinformatics. Frontiers in genetics, 12:690049, 2021.  
+Ziwei Zhang, Peng Cui, and Wenwu Zhu. Deep learning on graphs: A survey. IEEE Transactions on Knowledge and Data Engineering, 34(1):249-270, 2022. URL https://doi.org/10.1109/TKDE.2020.2981333.  
+He Zhao, Zhiwei Zeng, Yongwei Wang, Deheng Ye, and Chunyan Miao. Hgattack: Transferable heterogeneous graph adversarial attack. IEEE International Conference on Agents, ICA 2024, Wollongong, Australia, pp. 100-105, 2024. URL https://doi.org/10.1109/ICA63002.2024.00028.  
+Jie Zhou, Ganqu Cui, Shengding Hu, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, Lifeng Wang, Changcheng Li, and Maosong Sun. Graph neural networks: A review of methods and applications. AI Open, 1:57-81, 2020. URL https://doi.org/10.1016/j.aiopen.2021.01.001.  
+Dingyuan Zhu, Ziwei Zhang, Peng Cui, and Wenwu Zhu. Robust graph convolutional networks against adversarial attacks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD, USA, pp. 1399-1407. ACM, 2019. URL https://doi.org/10.1145/3292500.3330851.  
+Jiong Zhu, Yujun Yan, Lingxiao Zhao, Mark Heimann, Leman Akoglu, and Danai Koutra. Beyond homophily in graph neural networks: Current limitations and effective designs. Annual Conference on Neural Information Processing Systems, NeurIPS, 2020.  
+Xu Zou, Qinkai Zheng, Yuxiao Dong, Xinyu Guan, Evgeny Kharlamov, Jialiang Lu, and Jie Tang. Tdgia: Effective injection attacks on graph neural networks. In Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery & Data Mining, pp. 2461-2471, 2021.  
+Daniel Zügner and Stephan Gümnmann. Adversarial attacks on graph neural networks via meta learning. In 7th International Conference on Learning Representations, ICLR 2019. OpenReview.net, 2019. URL https://openreview.net/forum?id=Bylnx209YX.  
+Daniel Zügner, Amir Akbarnejad, and Stephan Gümnmann. Adversarial attacks on neural networks for graph data. In Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence, IJCAI 2019, Macao, China, pp. 6246-6250. ijcai.org, 2018. URL https://doi.org/10.24963/ijcai.2019/872.

ICLR/2025/GOttack_ Universal Adversarial Attacks on Graph Neural Networks via Graph Orbits Learning/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec4687984e2b97a0bc1ba08504f3661aebdb1fe4578265aac1e098dd05b7fcc9
+size 270460

ICLR/2025/GOttack_ Universal Adversarial Attacks on Graph Neural Networks via Graph Orbits Learning/layout.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7b7c9a6286454af252e1dca0be2fbe9f32345269eeac1448b5bdef5d952155e
+size 523295

ICLR/2025/GPS_ A Probabilistic Distributional Similarity with Gumbel Priors for Set-to-Set Matching/5fe5eaa1-6ae2-4f21-b658-43497f176f0f_content_list.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:649bd20f83c631ff0c1ac3ac5b88d049f66f6f20365f12a22d955338091f5c62
+size 96258

ICLR/2025/GPS_ A Probabilistic Distributional Similarity with Gumbel Priors for Set-to-Set Matching/5fe5eaa1-6ae2-4f21-b658-43497f176f0f_model.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bdc31d4bd9105893be892bbcae79398f439d32465f622223f3efd6664c2ae2e
+size 122647

ICLR/2025/GPS_ A Probabilistic Distributional Similarity with Gumbel Priors for Set-to-Set Matching/5fe5eaa1-6ae2-4f21-b658-43497f176f0f_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4caca5355791d8a012c17336ec21d37b64fc43cd9b3cd21caed9745a1549460f
+size 2172608

ICLR/2025/GPS_ A Probabilistic Distributional Similarity with Gumbel Priors for Set-to-Set Matching/full.md

@@ -0,0 +1,340 @@
+# GPS: A PROBABILISTIC DISTRIBUTIONAL SIMILARITY WITH GUMBEL PRIORS FOR SET-TO-SET MATCHING
+
+Ziming Zhang $^{1,*}$ , Fangzhou Lin $^{1}$ , Haotian Liu $^{1}$ , Jose Morales $^{1}$ , Haichong Zhang $^{1}$ , Kazunori Yamada $^{2}$ , Vijaya B Kolachalama $^{3}$ , Venkatesh Saligrama $^{3}$
+
+$^{1}$ Worcester Polytechnic Institute, USA  $^{2}$ Tohoku University, Japan  $^{3}$ Boston University, USA {zhang15, flin2, hliu8, jamorales, hzhang10}@wpi.edu yamada@tohoku.ac.jp, {vkola, svr} @bu.edu
+
+# ABSTRACT
+
+Set-to-set matching aims to identify correspondences between two sets of unordered items by minimizing a distance metric or maximizing a similarity measure. Traditional metrics, such as Chamfer Distance (CD) and Earth Mover's Distance (EMD), are widely used for this purpose but often suffer from limitations like suboptimal performance in terms of accuracy and robustness, or high computational costs - or both. In this paper, we propose an effective set-to-set matching similarity measure, GPS, based on Gumbel prior distributions. These distributions are typically used to model the extrema of samples drawn from various distributions. Our approach is motivated by the observation that the distributions of minimum distances from CD, as encountered in real-world applications such as point cloud completion, can be accurately modeled using Gumbel distributions. We validate our method on tasks like few-shot image classification and 3D point cloud completion, demonstrating significant improvements over state-of-the-art loss functions across several benchmark datasets. Our demo code is publicly available at https://github.com/Zhang-VISLab/ICLR2025-GPS.
+
+# 1 INTRODUCTION
+
+Problem. Set-to-set matching involves comparing and identifying correspondences between two sets of items, which can be modeled as a bipartite graph matching problem. In this framework, the items in each set are represented as nodes on opposite sides of a bipartite graph, with the edges representing the correspondences. This task is challenging due to several factors: (1) The matching process must be invariant to the order of both the sets and the items within them; (2) Finding effective representations for each set is critical, as it greatly influences performance; (3) Computing a meaningful similarity score between sets, often used as a loss function for learning feature extractors, is a nontrivial problem. Our goal is to develop a similarity measure that is both effective and efficient for set-to-set matching.
+
+Distance Metrics. Set-to-set matching has been extensively studied in various research fields (Chang et al., 2007; Zhou et al., 2017a; Saito et al., 2020; Jurewicz and Derczynski, 2021; Yu et al., 2021a; Kimura et al., 2023). Several distance metrics, such as Chamfer Distance (CD) (Yang et al., 2020), Earth Mover's Distance (EMD) (Zhang et al., 2020a; Yang et al., 2024), and Wasserstein Distance (WD) (Zhu and Koniusz, 2022), are commonly used to evaluate set-matching scores in different applications. These metrics can generally be considered special cases of optimal transportation (OT) for graph matching (Saad-Eldin et al., 2021), which aims to find the most efficient way to move a distribution of "materials" to another distribution of "consumers" by minimizing the total transportation cost. However, it is well known that these distance metrics often face challenges such as poor performance (e.g., matching accuracy and robustness of CD (Lin et al., 2023a)) or high computational complexity (e.g., EMD and WD (Nguyen et al., 2021; Rowland et al., 2019; Kolouri
+
+et al., 2019)), or both, which limit their applicability in large-scale learning. To address this issue, some new distance metrics, such as density-aware CD (DCD) (Wu et al., 2021), HyperCD (Lin et al., 2023b) and InfoCD (Lin et al., 2023a), have been developed as training losses in the literature to improve matching performance while achieving linear complexity similar to CD.
+
+Limitations of Traditional Distance Metrics. Existing metrics fail to adequately capture the similarity between sets in terms of their underlying distributions. In many real-world applications, such as classification, the primary concern is not the direct similarity between individual data instances but rather their similarity in some (latent) space, such as class labels.
+
+For instance, in Figure 1 in the context of Chamfer Distance (CD), the distance between the sets  $\circ$  and  $\times$  is larger than that between the sets  $\circ$  and  $+$ , despite  $\circ$  and  $\times$  being sampled from the same underlying distribution. This highlights a critical issue: when asking "how likely are two sets of points to come from the same distribution?" CD and similar metrics may fail to reflect distributional similarity accurately. Consequently, traditional distance metrics are effective at measuring differences in observations (e.g., point clouds or images) but may struggle to capture deeper, potentially unknown abstractions such as distributions or class labels.
+
+Distributional Similarity. This concept is widely ap-
+
+plied in natural language processing to assess word similarities based on the contexts in which they appear (Lee, 2000). For example, to measure the similarity between words  $u$  and  $v$ , both words can be represented in a vector space by counting their co-occurrences with words from a predefined vocabulary within local contexts such as sentences or paragraphs. Various similarity functions are then applied to these vectors to compute their similarity. To adapt this idea for set-to-set matching, we treat the K nearest neighbors (KNNs) of a point from the opposite set as its "co-occurrences".
+
+![](images/f9bbada0299a6b5d531240d3ba8cde9f4321ae7ed31cfa59407428f1a4e6c1d8.jpg)  
+Figure 1: Illustration of three point sets randomly sampled from a circular distribution (i.e., Distr. 1) and a Gaussian whose mean is conditional on the circle (i.e., Distr. 2).
+
+Gumbel Distributions. In probability theory, Gumbel distributions are used to model the distribution of extreme values (maxima or minima) from various samples. We find that Gumbel distributions effectively model the KNN distances between two sets of feature vectors. This is shown in Figure 2, where the two 2D point sets are sampled from the circular distribution shown in Figure 1. We compute the negative-log distances between each point in one set and its 1st, 2nd, and 3rd nearest neighbors in the other set, transforming these distances into normalized histograms representing probabilities. These probability distributions are then fitted with Gumbel distributions (see Definition 1).
+
+![](images/bbf2868bde271e529b1be6acce08cf832e0c6c62c1bf267331c5b0a5a6355c3e.jpg)  
+Figure 2: Data fitting with Gumbel distributions for 1st, 2nd, 3rd smallest distance distributions between two 2D point sets.
+
+Our Approach and Contributions. We propose a novel probabilistic method for set-to-set matching called GPS (Gumbel Prior Similarity) based on distributional similarity and Gumbel distributions. This method measures the similarity between the underlying distributions generating the sets. Specifically, we use the log-likelihood of Gumbel distributions as our similarity measure, modeling the distributions of negative-log distances between the KNNs of the sets. GPS can be seamlessly integrated into existing neural network training frameworks, for instance, by using the negative of GPS as a loss function, while maintaining the same linear computational complexity as CD. We propose a comprehensive analysis of GPS and its influence on learning behavior. We are the first to leverage statistical information from KNNs for set-to-set matching. To demonstrate the efficacy and efficiency of GPS, we conduct extensive experiments on tasks such as few-shot image classification and 3D point cloud completion, achieving state-of-the-art performance across several benchmark datasets.
+
+# 2 RELATED WORK
+
+Set-to-Set Matching. Many tasks in computer vision and machine learning, such as multiple instance learning (Ilse et al., 2018; Maron and Lozano-Pérez, 1997), shape recognition (Su et al., 2015; Shi et al., 2015), and few-shot image classification (Afrasiyabi et al., 2022), can be framed as set-to-set matching problems, where the goal is to identify correspondences between sets of instances. The unordered nature of these sets requires the extraction of invariant features that are not affected by the sequence of elements (Choi et al., 2018). Some research addresses this challenge by modifying neural network architectures. For example, Vinyals et al. (2016) introduced matching networks for one-shot learning, while Lee et al. (2019) proposed the Set Transformer, which uses an attention-based mechanism to model interactions among elements in input sets. Saito et al. (2020) developed exchangeable deep neural networks. Recently, Kimura (2022) analyzed the generalization bounds for set-to-set matching with neural networks. The loss function for training these networks must also maintain order-invariance to effectively calculate distance functions between pairs of instances within the sets, as seen in DeepEMD (Zhang et al., 2020a).
+
+Similarity (Metric) Learning. This research focuses on developing functions that measure the correlation between two objects (Ma and Manjunath, 1996; Balcan and Blum, 2006; Yu et al., 2008), and has been successfully applied to various applications, including face recognition (Faraki et al., 2021; Cao et al., 2013), few-shot image classification (Zhang et al., 2020a; Oh et al., 2022), emotion matching (Lin et al., 2016), and re-identification (Zhou et al., 2017a; Liao et al., 2017). Recently, these techniques have been integrated into deep learning (Liu et al., 2019; Cheng et al., 2018; Ma et al., 2021; Liao et al., 2017; Zhou et al., 2017b) for representation learning in embedding spaces, where objects from the same set are closer together, and objects from different sets are further apart. However, learning a model from all sample pairs is challenging due to high computational complexity and poor local minima during training (Kaya and Bilge, 2019; Qian et al., 2019; Huang et al., 2016). Thus, designing effective and efficient loss functions is a key issue in deep similarity learning (Elezi et al., 2020; Wang et al., 2019). In contrast, we address this problem by utilizing the statistics of minimum distances between the items of sets to improve computational efficiency and performance.
+
+Few-Shot Classification. This task aims to train a classifier to recognize both seen and unseen classes with limited labeled examples (Chen et al., 2019a). During training, the model learns a generalized classification ability in varying classes (Oreshkin et al., 2018; Finn et al., 2017). In the testing phase, when presented with entirely new classes, the model classifies by calculating the closest similarity measurement (Chen et al., 2019a; Naik and Mammone, 1992). Formally, in few-shot learning, the training set includes many classes, each with multiple samples (Li et al., 2018; Ren et al., 2018). For example,  $C$  classes are randomly selected from the training set and  $K$  samples from each category (totaling  $C \times K$  samples) are used as input to the model. A batch of samples from the remaining data in these  $C$  classes is then used as the model's prediction target (batch set). The model must learn to distinguish these  $C$  classes from  $C \times K$  pieces of data, a task known as a  $C$ -way  $K$ -shot problem.
+
+Point Cloud Completion. This task involves an important objective of inferring the complete shape of an object or scene from incomplete raw point clouds. Recently, numerous deep learning approaches have been developed to address this problem. For example, PCN (Yuan et al., 2018) extracts global features directly from point clouds and generates points using the folding operations from FoldingNet (Yang et al., 2018). Zhang et al. (2020b) proposed extracting multiscale features from different network layers to capture local structures and improve performance. Attention mechanisms, such as the Transformer (Vaswani et al., 2017), excel in capturing long-term interactions. Consequently, SnowflakeNet (Xiang et al., 2021), PointTr (Yu et al., 2021b), and SeedFormer (Zhou et al., 2022) emphasize the decoder component by incorporating Transformer designs. PointAttN (Wang et al., 2022) is built entirely on Transformer foundations. Recently, Lin et al. (2023b) introduced a HyperCD loss for training neural networks that defines traditional CD in a hyperbolic space. Furthermore, Lin et al. (2023a) proposed an InfoCD loss by incorporating the contrastive concept into the CD formula.
+
+Gumbel Distribution. In machine learning and computer vision, the Gumbel distribution has been widely used in sampling methods (Maddison et al., 2014; Kool et al., 2019) and reparameterization techniques (Huijben et al., 2022; Kusner and Hernandez-Lobato, 2016; Potapczynski et al., 2020). For example, Hancock and Khoshgoftaar (2020) introduced the Gumbel-Softmax reparameterization to enable differentiable sampling from a discrete distribution during backpropagation in neural networks.
+
+# 3 APPROACH
+
+# 3.1 PRELIMINARIES
+
+Notations & Problem Definition. We denote  $\mathcal{X}_1 = \{x_{1,i}\} \sim \mathcal{P}_1, \mathcal{X}_2 = \{x_{2,j}\} \sim \mathcal{P}_2$  as two sets of points (or items) that are sampled from two unknown distributions  $\mathcal{P}_1, \mathcal{P}_2$ , respectively, and  $K$  as the number of nearest neighbors considered for each point. Also, we refer to  $|\cdot|$  as the cardinality of a set, and  $\|\cdot\|$  as the  $\ell_2$ -norm of a vector. Given these notations, our goal is to predict the set-to-set similarity,  $\kappa(\mathcal{X}_1, \mathcal{X}_2)$ , based on the conditional probability  $p(\mathcal{P}_1 = \mathcal{P}_2 | \mathcal{X}_1, \mathcal{X}_2)$ .
+
+Gumbel Distributions. Recall that the Gumbel distribution is used to model the distribution of the maximum (or minimum by replacing the maximum with the negative of minimum) of a number of samples from various distributions. Here we list the definition of a Gumbel distribution as follows:
+
+Definition 1 (Gumbel Distribution). The probability density function (PDF) of a Gumbel distribution with parameters  $\mu \in \mathbb{R},\sigma >0$  denoted as  $Gumbel(\mu ,\sigma)$ , for a random variable  $x\in \mathbb{R}$  is defined as
+
+$$
+p (x) = \frac {1}{\sigma} \exp \{- (y + \exp \{- y \}) \}, w h e r e y = \frac {x - \mu}{\sigma}. \tag {1}
+$$
+
+# 3.2 GPS: GUMBEL PRIOR SIMILARITY FOR SET-TO-SET MATCHING
+
+Distributional Signatures. Given two sets of points  $\mathcal{X}_1, \mathcal{X}_2$ , we define the set of Euclidean distances from each point in one set to its KNNs in the other set as their distributional signature:
+
+$$
+\mathcal {D} \left(\mathcal {X} _ {1}, \mathcal {X} _ {2}\right) = \left\{d _ {\text {m i n}} ^ {(k)} \left(x _ {1, i}\right) = \left\| x _ {1, i} - x _ {2, i _ {k}} \right\|, d _ {\text {m i n}} ^ {(k)} \left(x _ {2, j}\right) = \left\| x _ {2, j} - x _ {1, j _ {k}} \right\| \mid \forall k \in [ K ], \forall i, \forall j \right\} \tag {2}
+$$
+
+where  $i_k$  (resp.  $j_k$ ) denotes the index of the  $k$ -th nearest neighbor in  $\mathcal{X}_2$  (resp.  $\mathcal{X}_1$ ) for  $x_{1,i}$  (resp.  $x_{2,j}$ ), leading to an unordered set of  $K(|\mathcal{X}_1| + |\mathcal{X}_2|)$  values.
+
+Probabilistic Modeling. To compute GPS, we introduce the Gumbel distributions and distributional signatures as latent variables, as shown in Figure 3, and propose a probabilistic framework as follows:
+
+$$
+\begin{array}{l} p \left(\mathcal {P} _ {1} = \mathcal {P} _ {2} \mid \mathcal {X} _ {1}, \mathcal {X} _ {2}\right) = \sum_ {q \in \mathcal {Q}} \sum_ {d _ {m i n} \in \mathcal {D}} p \left(\mathcal {P} _ {1} = \mathcal {P} _ {2}, q, d _ {m i n} \mid \mathcal {X} _ {1}, \mathcal {X} _ {2}\right) \\ = \sum_ {q \in \mathcal {Q}} \sum_ {d _ {\min } \in \mathcal {D}} p (q) p \left(\mathcal {P} _ {1} = \mathcal {P} _ {2} \mid q\right) p \left(d _ {\min } \mid q, \mathcal {X} _ {1}, \mathcal {X} _ {2}\right), \tag {3} \\ \end{array}
+$$
+
+where  $q \in \mathcal{Q}$  denotes a Gumbel distribution. Figure 3 illustrates the probability decomposition where a Gumbel distribution  $q$  is selected for measuring set-to-set similarity based on the distributional signatures between sets. Note that the distributions of each  $k$ -th nearest neighbor distances could be modeled using a mixture of  $M$  independent Gumbel distributions. Consequently, Equation (3) can be further rewritten as follows:
+
+![](images/c5ac57691a6c73333777be9caca2ce95e9cf066751a3415f2d4d98a73f53dc4e.jpg)  
+Figure 3: Graphical model for computing the conditional probability  $p\left( {{\mathcal{P}}_{1} = {\mathcal{P}}_{2} \mid  {\mathcal{X}}_{1},{\mathcal{X}}_{2}}\right)$  .
+
+$$
+p \left(\mathcal {P} _ {1} = \mathcal {P} _ {2} \mid \mathcal {X} _ {1}, \mathcal {X} _ {2}\right) \propto \sum_ {k, m} \left[ \sum_ {i} p \left(d _ {\text {m i n}} ^ {(k)} \left(x _ {1, i}\right); \alpha_ {k, m}, \beta_ {k, m}\right) + \sum_ {j} p \left(d _ {\text {m i n}} ^ {(k)} \left(x _ {2, j}\right); \alpha_ {k, m}, \beta_ {k, m}\right) \right], \tag {4}
+$$
+
+where  $k \in [K], m \in [M]$  and  $\{\alpha_{k,m}, \beta_{k,m}\}$  denote the predefined Gumbel parameters of the  $m$ -th mixture for fitting the  $k$ -th nearest neighbor distances. For simplicity, we use the same mixture for both sets (but they can be different). Note that here we take  $p(q)$  and  $p(\mathcal{P}_1 = \mathcal{P}_2 \mid q)$  as two constants with no prior knowledge.
+
+Reparametrization with Minimum Euclidean Distances. The KNN distances are sets of (conditional) minima, not maxima. Therefore, we need to convert these minimum distances to some form of maximum values that can be modeled using Gumbel. Considering both computational complexity and
+
+![](images/fb3fdb1d08f587822ef812eb3d7b6a6f4b49684bbc6f65aaf7f2c2709f2ad2f8.jpg)  
+Figure 4: Illustration of the distributions of minimum distances (with the learned best model) at test time for (left) point cloud completion and (right) few-shot image classification.
+
+![](images/97a306047854b897725b61ec2449da41151a3f2e9670cca23541115811e8d9e2.jpg)
+
+learning objectives, we propose reparametrizing  $x \stackrel{\text{def}}{=} -\log(d_{\min} + \delta)$  in Equation (1), where  $\delta \geq 0$  denotes a distance shift (see Section 3.3 for more discussions), and rewrite Equation (4) accordingly as follows, which formally defines our GPS:
+
+$$
+\begin{array}{l} \kappa (\mathcal {X} _ {1}, \mathcal {X} _ {2}) \\ \stackrel {d e f} {=} \sum_ {k, m} \left[ \sum_ {i} D _ {m i n} ^ {(k, m)} \left(x _ {1, i}\right) \exp \left\{- D _ {m i n} ^ {(k, m)} \left(x _ {1, i}\right) \right\} + \sum_ {j} D _ {m i n} ^ {(k, m)} \left(x _ {2, j}\right) \exp \left\{- D _ {m i n} ^ {(k, m)} \left(x _ {2, j}\right) \right\} \right], \tag {5} \\ \end{array}
+$$
+
+where  $\mu_{k,m} = \frac{\log\alpha_{k,m}}{\beta_{k,m}},\sigma_{k,m} = \frac{1}{\beta_{k,m}} >0,\alpha_{k,m} = e^{\frac{\mu_{k,m}}{\sigma_{k,m}}} > 0,\beta_{k,m} = \frac{1}{\sigma_{k,m}} >0,D_{min}^{(k,m)}(x_{1,i}) = \alpha_{k,m}\Big[d_{min}^{(k,m)}(x_{1,i}) + \delta_{k,m}\Big]^{\beta_{k,m}},D_{min}^{(k,m)}(x_{2,j}) = \alpha_{k,m}\Big[d_{min}^{(k,m)}(x_{2,j}) + \delta_{k,m}\Big]^{\beta_{k,m}}$  , respectively.
+
+# 3.3 ANALYSIS
+
+Proposition 1. Letting  $f(x) = xe^{-x}$ ,  $x > 0$ , then  $f$  has a unique maximum at  $x = 1$ , and is concave when  $0 < x < 2$ , otherwise convex when  $x > 2$ .
+
+Proof. By taking the first-order derivative of  $f$ ,  $\nabla f(x) = (1 - x)e^{-x}$ , and setting it to 0, we can show that  $f$  has a unique extremum at  $x = 1$ . By taking the second-order derivative,  $\nabla^2 f(x) = -(2 - x)e^{-x}$ , we can easily show its convexity and concavity by looking at the signs of the values.
+
+Gradients decrease (exponentially) when minimum distances approach the mode. This can be easily found from the form of the gradient in the proof above. As a result, the contribution of the gradient from a data sample in backpropagation will be smaller if its minimum distance is closer to the mode, making it less important in training. In other words, the training will focus more on correcting poor predictions by adaptively assigning higher weights in backpropagation. Note that all  $\alpha$ 's and  $\beta$ 's in GPS have an impact on the gradients in learning.
+
+Distance Shifting. In many applications, such as point cloud completion, the objective is to minimize the distances between predictions and the ground truth. In these scenarios, the mode of a Gumbel distribution is expected to be 0, which results in  $\delta_{k,m} = (\alpha_{k,m})^{-\frac{1}{\beta_{k,m}}} > 0$ . To maximize similarity during training, all minimum distances should be enforced to approach this mode. Therefore, our reparametrization includes  $d_{min} + \delta_{k,m}$  because, as  $d_{min}$  approaches 0,  $-\log(d_{min})$  would tend toward infinity, contradicting the goal of maximizing similarity by approaching the mode. However,  $-\log(d_{min} + \delta_{k,m})$  avoids this problem. Figure 4 (left) shows an example using a randomly sampled airplane instance from ShapeNet (see our experiments on point cloud completion for more details), where all minimum distances are approaching 0 as well as the Gumbel mode, achieving both goals of minimizing distance and maximizing similarity simultaneously.
+
+Similarity Embedding. Also in many applications, such as few-shot image classification, the objective is to minimize some loss, e.g., cross-entropy for classification, that depends on set-to-set similarity. In such cases, the minimum distances are not necessarily as small as possible, neither matching with the Gumbel distributions, as long as they help distinguish the data towards minimizing the loss, e.g., higher similarities for positive pairs and lower for negative pairs. Therefore, we do
+
+Table 1:  $\alpha$  and  $\beta$  search with 1st nearest neighbors for few-shot classification (%) on CIFAR-FS.  
+
+<table><tr><td>α</td><td>0.5</td><td>1</td><td>1</td><td>2</td><td>2</td><td>2</td><td>2</td><td>5</td><td>2</td><td>2</td><td>5</td><td>2</td><td>2.5</td><td>3</td><td>4</td><td>6</td></tr><tr><td>β</td><td>2</td><td>0.5</td><td>1</td><td>0.5</td><td>2</td><td>1</td><td>1.5</td><td>2</td><td>0.5</td><td>3.5</td><td>4</td><td>2</td><td>2</td><td>2</td><td>2</td><td>2</td></tr><tr><td>Acc</td><td>72.75</td><td>72.51</td><td>73.23</td><td>73.54</td><td>73.67</td><td>73.14</td><td>73.08</td><td>74.22</td><td>72.14</td><td>73.23</td><td>73.89</td><td>73.71</td><td>73.52</td><td>74.14</td><td>74.17</td><td>73.80</td></tr></table>
+
+Table 2:  $\alpha$  and  $\beta$  search using 2nd nearest neighbors performance (%) on CIFAR-FS.  
+
+<table><tr><td>α</td><td>0.1</td><td>0.5</td><td>1</td><td>1</td><td>2</td><td>3</td><td>2</td><td>2</td><td>2</td><td>2</td><td>2.5</td><td>3.5</td><td>4</td><td>5</td></tr><tr><td>β</td><td>2</td><td>2</td><td>0.5</td><td>2</td><td>2</td><td>2</td><td>0.5</td><td>2.5</td><td>3.5</td><td>4</td><td>2</td><td>2</td><td>2</td><td>5</td></tr><tr><td>Acc</td><td>71.67</td><td>72.84</td><td>73.17</td><td>73.04</td><td>73.08</td><td>73.66</td><td>72.45</td><td>72.85</td><td>73.23</td><td>72.67</td><td>73.37</td><td>72.95</td><td>73.44</td><td>60.74</td></tr></table>
+
+not need distance shifting and simply set  $\delta = 0$ . Figure 4 (right) illustrates a distribution of learned minimum distances for few-shot image classification (see our experiments for more details), compared with the Gumbel distribution used in training, where all the minimum distances are close to 1.
+
+# 4 EXPERIMENTS
+
+# 4.1 FEW-SHOT IMAGE CLASSIFICATION
+
+We conduct our experiments on five benchmark datasets: miniImageNet (Vinyals et al., 2016), tieredImageNet (Ren et al., 2018), Fewshot-CIFAR100 (Oreshkin et al., 2018), CIFAR-
+
+Table 3: Performance (%) using mixtures of Gumbels and NNs on CIFAR-FS.  
+
+<table><tr><td rowspan="2">1st NN (α,β)</td><td rowspan="2">(5,2)</td><td>(3,2)</td><td>(3,2)</td><td>(2.5,2)</td><td>(3,2)</td></tr><tr><td>(2,2)</td><td>(2,2)</td><td>(3,2)</td><td>(5,2)</td></tr><tr><td rowspan="2">2nd NN (α,β)</td><td rowspan="2">(3,2)</td><td>(2.5,2)</td><td>(4,2)</td><td>(2,2)</td><td>(4,2)</td></tr><tr><td>(4,2)</td><td>(2,2)</td><td>(4,2)</td><td>(1,2)</td></tr><tr><td>Acc</td><td>73.89</td><td>74.17</td><td>74.09</td><td>74.12</td><td>73.62</td></tr></table>
+
+FewShot (Bertinetto et al., 2018), and Caltech-UCSD Birds-200-2011 (Wah et al., 2011). We follow the standard protocols in the literature to split these datasets for our training and testing.
+
+Network Framework. We take the framework in DeepEMD (Zhang et al., 2020a)<sup>1</sup> for fair comparisons with different losses. Following the literature (Sun et al., 2019; Chen et al., 2021; Liu et al., 2021; Chikontwe et al., 2022), we employ ResNet-12 as our network backbone. We notice that DeepEMD and its extensions have different implementations. Precisely, we use the DeepEMD-FCN network for comparisons and report our results in our experiments. We also observe that GPS with the other implementations of DeepEMD can still significantly improve the performance. For instance, by replacing FCN with Grid and Sampling layers (Zhang et al., 2022), our GPS in 1-shot 5-way can improve  $1.2\%$  over DeepEMD with Grid and  $1.3\%$  with Sampling.
+
+Training Objective. Same as DeepEMD, we optimize the following objective for the few-shot tasks:
+
+$$
+\min  _ {\theta , \omega} \sum_ {u, v} \ell \left(\kappa \left(\mathcal {X} _ {u}, \mathcal {X} _ {v}\right), y _ {u}, y _ {v}; \omega\right), \text {s . t .} \mathcal {X} _ {u} = \left\{f \left(x _ {u, i}; \theta\right) \right\}, \mathcal {X} _ {v} = \left\{f \left(x _ {v, j}; \theta\right) \right\}, \tag {6}
+$$
+
+where  $x_{u,i}, x_{v,j}$  stand for two patches from the  $u$ -th and  $v$ -th images with labels  $y_u, y_v$ , respectively,  $f$  for a neural network parametrized by  $\theta$ , and  $\ell$  for a loss parametrized by  $\omega$ . In our GPS,  $k$  uses KNNs to determine the matches between patches, while in DeepEMD a differentiable EMD was proposed to find the matches. We reuse the framework by replacing the EMD with our GPS.
+
+Training Protocols. Following DeepEMD, we re-implement all pre-training, meta-training, validation and testing stages with different loss functions, and retrain the networks from scratch. We keep all the hyperparameters the same as DeepEMD but fine-tune the loss-related hyperparameters, if exist, to report best performance. For better comparison, we rerun the public code and report our results whenever possible; otherwise, we cite the original results for the remaining methods. In each result table, the top-performing result is highlighted in bold. We conduct all experiments on a server with 10 NVIDIA RTX 6000 11G GPUs and another one with 10 NVIDIA Quadro RTX 6000 24G GPUs.
+
+Ablation Study. We have conducted some experiments for few-shot image classification, including:
+
+- M Gumbels, K Nearest Neighbors, and Mixtures: Table 1, Table 2 and Table 3 list our hyperparameter search results for 1st NN only, 2nd NN only, and mixtures of Gumbels and NNs, respectively. With proper tuning, the best results under different settings are close to each other, and the mixtures seem to be more robust to the data, leading to similar performance with different combinations.
+
+![](images/c80f78a9cf9e18678c5aadf58cd4b9465464f611ace0e1a4769128cb0913e350.jpg)  
+(a)
+
+![](images/b20f961ef942faa8874224fb8ac2cef03874b356ffa4849530f655c67a7deb9e.jpg)  
+(b)
+
+![](images/40e85b27e09a4d921897d41727006dac88db83e2571facae83e81e59fc61c590.jpg)  
+Figure 5: Comparison on (a) validation accuracy during training, and (b) running time per iteration.
+
+![](images/b8b2e5fd122e19e32b0b2407849ac1d7fe854a7b3d8c7cf9edc50bf4e245bf18.jpg)
+
+![](images/9c6e51ceb66bb8e0827ec82131010442da9fce9669f66f3eb7f2117033b7170a.jpg)  
+Figure 6: Visual matching results by (top) our GPS and (bottom) DeepEMD.
+
+![](images/5dcd7c93652428211f40894514c6d5d563d7b831e5a913cf5d294a42ab056f87.jpg)
+
+Table 4: Cross-domain results  $(\%)$  (miniImagenet  $\rightarrow$  CUB) on 1-shot 5-way and 5-shot 5-way tasks.  
+
+<table><tr><td>Model</td><td>1-shot</td><td>5-shot</td></tr><tr><td>ProtoNet</td><td>50.01±0.82</td><td>72.02±0.67</td></tr><tr><td>MatchingNet</td><td>51.65±0.84</td><td>69.14±0.72</td></tr><tr><td>cosine classifier</td><td>44.17±0.78</td><td>69.01±0.74</td></tr><tr><td>linear classifier</td><td>50.37±0.79</td><td>73.30±0.69</td></tr><tr><td>KNN</td><td>50.84±0.81</td><td>71.25±0.69</td></tr><tr><td>DeepEMD</td><td>51.07±0.59</td><td>75.27±0.48</td></tr><tr><td>CD</td><td>51.32±0.46</td><td>75.61±0.54</td></tr><tr><td>HyperCD</td><td>51.76±0.48</td><td>75.98±0.42</td></tr><tr><td>InfoCD</td><td>51.95±0.65</td><td>76.23±0.39</td></tr><tr><td>Ours: GPS</td><td>52.38±0.47</td><td>76.59±0.52</td></tr></table>
+
+- Training Behavior & Running Time: Figure 5 (a) shows the validation accuracy vs. the number of epochs, and our approach consistently outperforms the other two competitors. Figure 5 (b) shows the running time with different loss functions to train the network, where our GPS (using 1 Gumbel and 1st NN only) is the only one that can manage to preserve similar computational time to CD.  
+- Visualization of Matching Results: To understand the matching behavior, we visualize some matching results in Figure 6. Compared with DeepEMD, our approach can effectively establish correspondence between local regions more precisely with just simple nearest neighbor search.
+
+Comparisons with Different Losses. Table 4, Table 5, and Table 6 summarize our comparison results on few-shot image classification on different datasets with  $\alpha = 5$ ,  $\beta = 2$  and 1 NN only. As we see, our approach outperforms all the competitors on all the datasets, and is more robust than the others, in general, which demonstrates the effectiveness and efficiency of GPS.
+
+# 4.2 POINT CLOUD COMPLETION
+
+Datasets & Backbone Networks. We conduct our experiments on the five benchmark datasets: PCN (Yuan et al., 2018), ShapeNet-55/34 (Yu et al., 2021b), ShapeNet-Part (Yi et al., 2016), and KITTI (Geiger et al., 2012). We compare our method using seven different existing backbone networks, i.e., FoldingNet (Yang et al., 2018), PMP-Net (Wen et al., 2021), PoinTr (Yu et al., 2021b), SnowflakeNet (Xiang et al., 2021), CP-Net (Lin et al., 2022), PointAttN (Wang et al., 2022) and SeedFormer (Zhou et al., 2022), by replacing the CD loss with our GPS wherever it occurs.
+
+Training Objective. Similar to InfoCD (Lin et al., 2023a), we optimize the following objective:
+
+$$
+\max  _ {\theta} \sum_ {u} \kappa (f (\mathcal {X} _ {u}; \theta), \mathcal {Y} _ {u}), \tag {7}
+$$
+
+where  $(\mathcal{X}_u,\mathcal{Y}_u)$  denotes a pair of a partial point cloud and its ground-truth complete point cloud and  $f$  is a network (e.g., one of the seven backbone networks) parametrized by  $\theta$ .
+
+Training Protocols. We use the same training hyperparameters such as learning rates, batch sizes and balance factors as the original losses for fair comparisons. We conduct our experiments on a
+
+Table 5: Results of 5-way  $(\%)$  on miniImageNet and tieredImageNet datasets.  
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">miniImageNet</td><td colspan="2">tieredImageNet</td></tr><tr><td>1-shot</td><td>5-shot</td><td>1-shot</td><td>5-shot</td></tr><tr><td>cosine classifier (Chen et al., 2019b)</td><td>55.43±0.31</td><td>71.18±0.61</td><td>61.49±0.91</td><td>82.37±0.67</td></tr><tr><td>ProtoNet (Snell et al., 2017)</td><td>60.37±0.83</td><td>78.02±0.57</td><td>65.65±0.92</td><td>83.40±0.65</td></tr><tr><td>MatchingNet (Vinyals et al., 2016)</td><td>63.08±0.80</td><td>75.99±0.60</td><td>68.50±0.92</td><td>80.60±0.71</td></tr><tr><td>DeepEMD (Zhang et al., 2020a)</td><td>63.36±0.75</td><td>79.15±0.66</td><td>70.48±0.78</td><td>83.89±0.67</td></tr><tr><td>CD</td><td>63.40±0.46</td><td>79.54±0.39</td><td>70.23±0.64</td><td>84.01±0.31</td></tr><tr><td>PWD (Rowland et al., 2019)</td><td>63.92±0.77</td><td>78.77±0.37</td><td>70.69±0.92</td><td>83.88±0.34</td></tr><tr><td>SWD (Kolouri et al., 2019)</td><td>63.15±0.76</td><td>78.46±0.41</td><td>69.72±0.93</td><td>83.02±0.33</td></tr><tr><td>GSWD (Kolouri et al., 2019)</td><td>63.66±0.72</td><td>78.92±0.47</td><td>70.25±0.86</td><td>83.62±0.31</td></tr><tr><td>ASWD (Nguyen et al., 2021)</td><td>63.16±0.75</td><td>78.87±0.45</td><td>69.30±0.91</td><td>83.71±0.38</td></tr><tr><td>HyperCD (Lin et al., 2023b)</td><td>63.63±0.65</td><td>79.78±0.73</td><td>70.58±0.81</td><td>84.27±0.48</td></tr><tr><td>InfoCD (Lin et al., 2023a)</td><td>64.01±0.32</td><td>80.87±0.64</td><td>70.97±0.59</td><td>84.54±0.36</td></tr><tr><td>Ours: GPS</td><td>66.27±0.37</td><td>81.19±0.47</td><td>73.16±0.43</td><td>85.52±0.48</td></tr></table>
+
+Table 6: 1-shot 5-way and 5-shot 5-way performance comparison  $(\%)$  
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">CIFAR-FS</td><td colspan="2">Fewshot-CIFAR100</td><td colspan="2">Caltech-UCSD Birds</td></tr><tr><td>1-shot</td><td>5-shot</td><td>1-shot</td><td>5-shot</td><td>1-shot</td><td>5-shot</td></tr><tr><td>ProtoNet</td><td>-</td><td>-</td><td>41.54±0.76</td><td>57.08±0.76</td><td>66.09±0.92</td><td>82.50±0.58</td></tr><tr><td>DeepEMD</td><td>71.16±0.42</td><td>85.12±0.29</td><td>43.93±0.82</td><td>61.01±0.41</td><td>67.04±0.31</td><td>85.12±0.76</td></tr><tr><td>CD</td><td>71.75±0.55</td><td>85.48±0.51</td><td>44.15±0.46</td><td>61.22±0.58</td><td>67.11±0.46</td><td>85.31±0.59</td></tr><tr><td>PWD</td><td>71.58±0.31</td><td>84.76±0.33</td><td>43.47±0.29</td><td>60.41±0.41</td><td>65.60±0.33</td><td>84.87±0.45</td></tr><tr><td>SWD</td><td>70.99±0.34</td><td>84.52±0.37</td><td>43.32±0.28</td><td>60.31±0.31</td><td>65.44±0.32</td><td>84.38±0.41</td></tr><tr><td>ASWD</td><td>71.45±0.32</td><td>85.26±0.35</td><td>43.83±0.29</td><td>60.89±0.34</td><td>65.45±0.34</td><td>84.76±0.39</td></tr><tr><td>HyperCD</td><td>72.02±0.41</td><td>85.77±0.43</td><td>44.42±0.33</td><td>61.59±0.74</td><td>67.45±0.38</td><td>85.42±0.75</td></tr><tr><td>InfoCD</td><td>72.31±0.23</td><td>85.91±0.39</td><td>44.81±0.43</td><td>61.87±0.66</td><td>67.82±0.42</td><td>85.90±0.68</td></tr><tr><td>Ours: GPS</td><td>74.22±0.22</td><td>86.98±0.23</td><td>46.75±0.28</td><td>62.91±0.47</td><td>69.42±0.33</td><td>86.78±0.62</td></tr></table>
+
+server with 4 NVIDIA A100 80G GPUs and one with 10 NVIDIA Quadro RTX 6000 24G GPUs due to the large model sizes of some baseline networks. Table 9: Performance com
+
+Evaluation. Following the literature, we evaluate the best performance of all the methods using vanilla CD (lower is better). We also use F1-Score@  $1\%$  (Tatarchenko et al., 2019) (higher is better) to evaluate the performance on ShapeNet-55/34. For KITTI, we utilize the metrics of Fidelity and Maximum Mean Discrepancy (MMD) for each method (lower is better for both metrics).
+
+Grid Search on  $(\alpha, \beta)$ . Table 7 summarizes our search results. As we discussed in Section 3.3, all the settings produce similar performance. Considering the running time and hyperparameter search results in few-shot classification, in our experiments on point cloud completion, we only use 1st NNs and a single Gumbel distribution to fit the data, without further tuning.
+
+Table 9: Performance comparison on ShapeNet-Part.  
+
+<table><tr><td>Losses</td><td>L2-CD×103</td></tr><tr><td>L1-CD</td><td>4.16±0.028</td></tr><tr><td>L2-CD</td><td>4.82±0.117</td></tr><tr><td>DCD</td><td>5.74±0.049</td></tr><tr><td>PWD</td><td>14.39±0.024</td></tr><tr><td>SWD</td><td>6.28±0.073</td></tr><tr><td>GSWD</td><td>6.26±0.034</td></tr><tr><td>ASWD</td><td>7.52±0.058</td></tr><tr><td>HyperCD</td><td>4.03±0.007</td></tr><tr><td>InfoCD</td><td>4.01±0.004</td></tr><tr><td>GPS</td><td>3.94±0.003</td></tr></table>
+
+State-of-the-art Result Comparisons. We summarize our comparisons as follows:
+
+- ShapeNet-Part: We begin by presenting our performance comparison in Table 9 on the ShapeNet-Part dataset using CP-Net. Evidently, our approach outperforms all other competitors.  
+- ShapeNet-34: We evaluate performance across 34 seen categories (used during training) and 21 unseen categories (not used during training), detailing our results in Table 8. It is evident that our approach consistently improves the performance of baseline models, indicating its high generalizability for point cloud completion tasks.  
+- ShapeNet-55: We evaluate the adaptability of our method across datasets for tasks with greater diversity. Table 11 lists the L2-CD across three difficulty levels, along with the average. Following the literature, we present results for five categories (Table, Chair, Plane, Car, and Sofa) with over 2,500 training samples each, as shown in the table. Additionally, we provide results using the
+
+Table 7:  $\alpha$  and  $\beta$  search with 1st nearest neighbors on ShapeNet-Part using CP-Net.  
+
+<table><tr><td>α</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>0.5</td><td>2</td><td>4</td><td>2</td></tr><tr><td>β</td><td>0.4</td><td>0.8</td><td>1</td><td>1.2</td><td>1.6</td><td>2</td><td>1</td><td>1</td><td>1</td><td>2</td></tr><tr><td>CD</td><td>4.29</td><td>3.98</td><td>3.94</td><td>4.04</td><td>4.34</td><td>4.68</td><td>4.11</td><td>4.05</td><td>4.13</td><td>4.72</td></tr></table>
+
+Table 8: Results on ShapeNet-34 using L2-CD×1000 and F1 score.  
+
+<table><tr><td rowspan="2">Methods</td><td colspan="5">34 seen categories</td><td colspan="5">21 unseen categories</td></tr><tr><td>CD-S</td><td>CD-M</td><td>CD-H</td><td>Avg.</td><td>F1</td><td>CD-S</td><td>CD-M</td><td>CD-H</td><td>Avg.</td><td>F1</td></tr><tr><td>FoldingNet</td><td>1.86</td><td>1.81</td><td>3.38</td><td>2.35</td><td>0.139</td><td>2.76</td><td>2.74</td><td>5.36</td><td>3.62</td><td>0.095</td></tr><tr><td>HyperCD + FoldingNet</td><td>1.71</td><td>1.69</td><td>3.23</td><td>2.21</td><td>0.148</td><td>2.55</td><td>2.59</td><td>5.19</td><td>3.44</td><td>0.122</td></tr><tr><td>InfoCD + FoldingNet</td><td>1.54</td><td>1.60</td><td>3.10</td><td>2.08</td><td>0.177</td><td>2.42</td><td>2.49</td><td>5.01</td><td>3.31</td><td>0.157</td></tr><tr><td>Ours: GPS + FoldingNet</td><td>1.49</td><td>1.55</td><td>3.02</td><td>2.02</td><td>0.182</td><td>2.39</td><td>2.43</td><td>5.00</td><td>3.27</td><td>0.159</td></tr><tr><td>PoinTr</td><td>0.76</td><td>1.05</td><td>1.88</td><td>1.23</td><td>0.421</td><td>1.04</td><td>1.67</td><td>3.44</td><td>2.05</td><td>0.384</td></tr><tr><td>HyperCD + PoinTr</td><td>0.72</td><td>1.01</td><td>1.85</td><td>1.19</td><td>0.428</td><td>1.01</td><td>1.63</td><td>3.40</td><td>2.01</td><td>0.389</td></tr><tr><td>InfoCD + PoinTr</td><td>0.47</td><td>0.69</td><td>1.35</td><td>0.84</td><td>0.529</td><td>0.61</td><td>1.06</td><td>2.55</td><td>1.41</td><td>0.493</td></tr><tr><td>Ours: GPS + PoinTr</td><td>0.43</td><td>0.64</td><td>1.27</td><td>0.78</td><td>0.533</td><td>0.60</td><td>1.04</td><td>2.52</td><td>1.38</td><td>0.495</td></tr><tr><td>SeedFormer</td><td>0.48</td><td>0.70</td><td>1.30</td><td>0.83</td><td>0.452</td><td>0.61</td><td>1.08</td><td>2.37</td><td>1.35</td><td>0.402</td></tr><tr><td>HyperCD + SeedFormer</td><td>0.46</td><td>0.67</td><td>1.24</td><td>0.79</td><td>0.459</td><td>0.58</td><td>1.03</td><td>2.24</td><td>1.31</td><td>0.428</td></tr><tr><td>InfoCD + SeedFormer</td><td>0.43</td><td>0.63</td><td>1.21</td><td>0.75</td><td>0.581</td><td>0.54</td><td>1.01</td><td>2.18</td><td>1.24</td><td>0.449</td></tr><tr><td>Ours: GPS+ SeedFormer</td><td>0.42</td><td>0.61</td><td>1.20</td><td>0.74</td><td>0.582</td><td>0.52</td><td>1.00</td><td>2.15</td><td>1.22</td><td>0.451</td></tr></table>
+
+F1 metric. Once again, our approach significantly improves the baseline models, especially with simpler networks. We also include some visualization results in Figure 7.
+
+- KITTI: To validate the effectiveness of GPS for point cloud completion on a large-scale real-world benchmark, we follow (Xie et al., 2020) to finetune two baseline models with GPS on ShapeNetCars (Yuan et al., 2018) and evaluate their performance on KITTI. We report the Fidelity and MMD metrics in Table 10, observing that GPS consistently improves the baseline models.  
+- PCN: We also summarize the results on another benchmark dataset, PCN, with additional backbones in Table 12, showcasing state-of-the-art performance in point cloud completion.
+
+Table 10: Results on KITTI in terms of the fidelity and MMD metrics.  
+
+<table><tr><td></td><td>FoldingNet</td><td>HyperCD+F.</td><td>InfoCD+F.</td><td>GPS+F.</td><td>PoinTr</td><td>HyperCD+P.</td><td>InfoCD+P.</td><td>GPS+P.</td></tr><tr><td>Fidelity ↓</td><td>7.467</td><td>2.214</td><td>1.944</td><td>1.883</td><td>0.000</td><td>0.000</td><td>0.000</td><td>0.000</td></tr><tr><td>MMD ↓</td><td>0.537</td><td>0.386</td><td>0.333</td><td>0.302</td><td>0.526</td><td>0.507</td><td>0.502</td><td>0.449</td></tr></table>
+
+# 5 CONCLUSION
+
+In this paper, we present GPS, a novel, effective, and efficient similarity learning framework for set-to-set matching. Our method fits a predefined Gumbel distribution to the negative log minimum distances between set items. Originating from a probabilistic graphical model, our approach allows multiple Gumbel distributions to model the distributions of KNN distances as distributional signatures. We demonstrate superior performance in few-shot image classification and point cloud completion compared to traditional distance metrics, while maintaining a similar running time to CD.
+
+Limitations. Finding optimal hyperparameters for Gumbel distributions to fit the distance distributions can be time-consuming, particularly when dealing with large sets, such as 16,384 points per object in PCN and ShapeNet-55/34. In future work, we plan to develop general guidelines for efficiently determining these hyperparameters.
+
+# ACKNOWLEDGMENT
+
+Vijaya B. Kolachalama is supported by grants from the National Institute on Aging's Artificial Intelligence and Technology Collaboratories (P30-AG073104 & P30-AG073105), the American Heart Association (20SFRN35460031), and the National Institutes of Health (R01-HL159620, R01-AG062109, & R01-AG083735). Venkatesh Saligram was supported by the Army Research Office Grant W911NF2110246, AFRLGrant FA8650-22-C1039, the National Science Foundation grants CCF-2007350, CCF-1955981 and CPS-2317079.
+
+Table 11: Results on ShapeNet-55 using L2-CD×1000 and F1 score.  
+
+<table><tr><td>Methods</td><td>Table</td><td>Chair</td><td>Plane</td><td>Car</td><td>Sofa</td><td>CD-S</td><td>CD-M</td><td>CD-H</td><td>Avg.</td><td>F1</td></tr><tr><td>FoldingNet</td><td>2.53</td><td>2.81</td><td>1.43</td><td>1.98</td><td>2.48</td><td>2.67</td><td>2.66</td><td>4.05</td><td>3.12</td><td>0.082</td></tr><tr><td>HyperCD + FoldingNet</td><td>2.35</td><td>2.62</td><td>1.25</td><td>1.76</td><td>2.31</td><td>2.43</td><td>2.45</td><td>3.88</td><td>2.92</td><td>0.109</td></tr><tr><td>InfoCD + FoldingNet</td><td>2.14</td><td>2.37</td><td>1.03</td><td>1.55</td><td>2.04</td><td>2.17</td><td>2.50</td><td>3.46</td><td>2.71</td><td>0.137</td></tr><tr><td>Ours: GPS + FoldingNet</td><td>2.07</td><td>2.30</td><td>1.02</td><td>1.47</td><td>2.01</td><td>2.13</td><td>2.44</td><td>3.37</td><td>2.64</td><td>0.143</td></tr><tr><td>PoinTr</td><td>0.81</td><td>0.95</td><td>0.44</td><td>0.91</td><td>0.79</td><td>0.58</td><td>0.88</td><td>1.79</td><td>1.09</td><td>0.464</td></tr><tr><td>HyperCD + PoinTr</td><td>0.79</td><td>0.92</td><td>0.41</td><td>0.90</td><td>0.76</td><td>0.54</td><td>0.85</td><td>1.73</td><td>1.04</td><td>0.499</td></tr><tr><td>InfoCD + PoinTr</td><td>0.69</td><td>0.83</td><td>0.33</td><td>0.80</td><td>0.67</td><td>0.47</td><td>0.73</td><td>1.50</td><td>0.90</td><td>0.524</td></tr><tr><td>Ours: GPS + PoinTr</td><td>0.61</td><td>0.79</td><td>0.31</td><td>0.76</td><td>0.64</td><td>0.41</td><td>0.68</td><td>1.44</td><td>0.84</td><td>0.529</td></tr><tr><td>SeedFormer</td><td>0.72</td><td>0.81</td><td>0.40</td><td>0.89</td><td>0.71</td><td>0.50</td><td>0.77</td><td>1.49</td><td>0.92</td><td>0.472</td></tr><tr><td>HyperCD + SeedFormer</td><td>0.66</td><td>0.74</td><td>0.35</td><td>0.83</td><td>0.64</td><td>0.47</td><td>0.72</td><td>1.40</td><td>0.86</td><td>0.482</td></tr><tr><td>InfoCD + SeedFormer</td><td>0.65</td><td>0.72</td><td>0.31</td><td>0.81</td><td>0.62</td><td>0.43</td><td>0.71</td><td>1.38</td><td>0.84</td><td>0.490</td></tr><tr><td>Ours: GPS + SeedFormer</td><td>0.63</td><td>0.70</td><td>0.30</td><td>0.79</td><td>0.61</td><td>0.42</td><td>0.69</td><td>1.37</td><td>0.82</td><td>0.493</td></tr></table>
+
+Table 12: Per-point L1-CD  $\times  {1000}$  (lower is better) on PCN.  
+
+<table><tr><td>Methods</td><td>Plane</td><td>Cabinet</td><td>Car</td><td>Chair</td><td>Lamp</td><td>Couch</td><td>Table</td><td>Boat</td><td>Avg.</td></tr><tr><td>FoldingNet (Yang et al., 2018)</td><td>9.49</td><td>15.80</td><td>12.61</td><td>15.55</td><td>16.41</td><td>15.97</td><td>13.65</td><td>14.99</td><td>14.31</td></tr><tr><td>HyperCD + FoldingNet</td><td>7.89</td><td>12.90</td><td>10.67</td><td>14.55</td><td>13.87</td><td>14.09</td><td>11.86</td><td>10.89</td><td>12.09</td></tr><tr><td>InfoCD + FoldingNet</td><td>7.90</td><td>12.68</td><td>10.83</td><td>14.04</td><td>14.05</td><td>14.56</td><td>11.61</td><td>11.45</td><td>12.14</td></tr><tr><td>Ours: GPS + FoldingNet</td><td>7.38</td><td>12.61</td><td>10.46</td><td>13.12</td><td>11.92</td><td>13.39</td><td>10.86</td><td>10.59</td><td>11.30</td></tr><tr><td>PMP-Net (Wen et al., 2021)</td><td>5.65</td><td>11.24</td><td>9.64</td><td>9.51</td><td>6.95</td><td>10.83</td><td>8.72</td><td>7.25</td><td>8.73</td></tr><tr><td>HyperCD + PMP-Net</td><td>5.06</td><td>10.67</td><td>9.30</td><td>9.11</td><td>6.83</td><td>11.01</td><td>8.18</td><td>7.03</td><td>8.40</td></tr><tr><td>InfoCD + PMP-Net</td><td>4.67</td><td>10.09</td><td>8.87</td><td>8.59</td><td>6.38</td><td>10.48</td><td>7.51</td><td>6.75</td><td>7.92</td></tr><tr><td>Ours: GPS + PMP-Net</td><td>4.52</td><td>10.02</td><td>8.80</td><td>8.45</td><td>6.31</td><td>10.42</td><td>7.46</td><td>6.70</td><td>7.84</td></tr><tr><td>PoinTr (Yu et al., 2021b)</td><td>4.75</td><td>10.47</td><td>8.68</td><td>9.39</td><td>7.75</td><td>10.93</td><td>7.78</td><td>7.29</td><td>8.38</td></tr><tr><td>HyperCD + PoinTr</td><td>4.42</td><td>9.77</td><td>8.22</td><td>8.22</td><td>6.62</td><td>9.62</td><td>6.97</td><td>6.67</td><td>7.56</td></tr><tr><td>InfoCD + PoinTr</td><td>4.06</td><td>9.42</td><td>8.11</td><td>7.81</td><td>6.21</td><td>9.38</td><td>6.57</td><td>6.40</td><td>7.24</td></tr><tr><td>Ours: GPS + PoinTr</td><td>4.03</td><td>9.39</td><td>8.03</td><td>7.78</td><td>6.18</td><td>9.33</td><td>6.56</td><td>6.38</td><td>7.21</td></tr><tr><td>SnowflakeNet (Xiang et al., 2021)</td><td>4.29</td><td>9.16</td><td>8.08</td><td>7.89</td><td>6.07</td><td>9.23</td><td>6.55</td><td>6.40</td><td>7.21</td></tr><tr><td>HyperCD + SnowflakeNet</td><td>3.95</td><td>9.01</td><td>7.88</td><td>7.37</td><td>5.75</td><td>8.94</td><td>6.19</td><td>6.17</td><td>6.91</td></tr><tr><td>InfoCD + SnowflakeNet</td><td>4.01</td><td>8.81</td><td>7.62</td><td>7.51</td><td>5.80</td><td>8.91</td><td>6.21</td><td>6.05</td><td>6.86</td></tr><tr><td>Ours: GPS + SnowflakeNet</td><td>3.97</td><td>8.79</td><td>7.61</td><td>7.47</td><td>5.73</td><td>8.85</td><td>6.15</td><td>6.03</td><td>6.82</td></tr><tr><td>PointAttN (Wang et al., 2022)</td><td>3.87</td><td>9.00</td><td>7.63</td><td>7.43</td><td>5.90</td><td>8.68</td><td>6.32</td><td>6.09</td><td>6.86</td></tr><tr><td>HyperCD + PointAttN</td><td>3.76</td><td>8.93</td><td>7.49</td><td>7.06</td><td>5.61</td><td>8.48</td><td>6.25</td><td>5.92</td><td>6.68</td></tr><tr><td>InfoCD + PointAttN</td><td>3.72</td><td>8.87</td><td>7.46</td><td>7.02</td><td>5.60</td><td>8.45</td><td>6.23</td><td>5.92</td><td>6.65</td></tr><tr><td>Ours: GPS + PointAttN</td><td>3.70</td><td>8.83</td><td>7.42</td><td>7.00</td><td>5.59</td><td>8.43</td><td>6.22</td><td>5.91</td><td>6.63</td></tr><tr><td>SeedFormer (Zhou et al., 2022)</td><td>3.85</td><td>9.05</td><td>8.06</td><td>7.06</td><td>5.21</td><td>8.85</td><td>6.05</td><td>5.85</td><td>6.74</td></tr><tr><td>HyperCD + SeedFormer</td><td>3.72</td><td>8.71</td><td>7.79</td><td>6.83</td><td>5.11</td><td>8.61</td><td>5.82</td><td>5.76</td><td>6.54</td></tr><tr><td>InfoCD + SeedFormer</td><td>3.69</td><td>8.72</td><td>7.68</td><td>6.84</td><td>5.08</td><td>8.61</td><td>5.83</td><td>5.75</td><td>6.52</td></tr><tr><td>Ours: GPS + SeedFormer</td><td>3.68</td><td>8.69</td><td>7.65</td><td>6.80</td><td>5.05</td><td>8.55</td><td>5.72</td><td>5.63</td><td>6.48</td></tr></table>
+
+![](images/c995ba6f0618a04e2383b2eda46ea17b005ed1bf1f97b625f910cfe3ae0b921a.jpg)  
+Figure 7: Row-1: Inputs of incomplete point clouds. Row-2: Outputs of Seedformer with CD. Row-3: Outputs of Seedformer with GPS. Row-4: Ground truth.
+
+# REFERENCES
+
+Jen-Mei Chang, Michael Kirby, and Chris Peterson. Set-to-set face recognition under variations in pose and illumination. In 2007 Biometrics Symposium, pages 1-6. IEEE, 2007.  
+Sanping Zhou, Jinjun Wang, Rui Shi, Qiqi Hou, Yihong Gong, and Nanning Zheng. Large margin learning in set-to-set similarity comparison for person reidentification. IEEE Transactions on Multimedia, 20(3):593-604, 2017a.  
+Yuki Saito, Takuma Nakamura, Hirotaka Hachiya, and Kenji Fukumizu. Exchangeable deep neural networks for set-to-set matching and learning. In European Conference on Computer Vision, pages 626-646. Springer, 2020.  
+Mateusz Jurewicz and Leon Derczynski. Set-to-sequence methods in machine learning: a review. Journal of Artificial Intelligence Research, 71:885-924, 2021.  
+Tan Yu, Jingjing Meng, Ming Yang, and Junsong Yuan. 3d object representation learning: A set-to-set matching perspective. IEEE Transactions on Image Processing, 30:2168-2179, 2021a.  
+Masanari Kimura, Takuma Nakamura, and Yuki Saito. Shift15m: Fashion-specific dataset for set-to-set matching with several distribution shifts. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3507-3512, 2023.  
+Ze Yang, Yinghao Xu, Han Xue, Zheng Zhang, Raquel Urtasun, Liwei Wang, Stephen Lin, and Han Hu. Dense reppoints: Representing visual objects with dense point sets. In Computer Vision-ECCV 2020: 16th European Conference, Glasgow, UK, August 23-28, 2020, Proceedings, Part XXI 16, pages 227-244. Springer, 2020.  
+Chi Zhang, Yujun Cai, Guosheng Lin, and Chunhua Shen. Deepemd: Few-shot image classification with differentiable earth mover's distance and structured classifiers. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 12203-12213, 2020a.  
+Siyuan Yang, Jun Liu, Shijian Lu, Er Meng Hwa, and Alex C Kot. One-shot action recognition via multi-scale spatial-temporal skeleton matching. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2024.  
+Hao Zhu and Piotr Koniusz. Ease: Unsupervised discriminant subspace learning for transductive few-shot learning. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 9078-9088, 2022.  
+Ali Saad-Eldin, Benjamin D Pedigo, Carey E Priebe, and Joshua T Vogelstein. Graph matching via optimal transport. arXiv preprint arXiv:2111.05366, 2021.  
+Fangzhou Lin, Yun Yue, Ziming Zhang, Songlin Hou, Kazunori Yamada, Vijaya Kolachalama, and Venkatesh Saligrama. Infocd: A contrastive chamfer distance loss for point cloud completion. Advances in Neural Information Processing Systems, 36, 2023a.  
+Trung Nguyen, Quang-Hieu Pham, Tam Le, Tung Pham, Nhat Ho, and Binh-Son Hua. Point-set distances for learning representations of 3d point clouds. In Proceedings of the IEEE/CVF international conference on computer vision, pages 10478-10487, 2021.  
+Mark Rowland, Jiri Hron, Yunhao Tang, Krzysztof Choromanski, Tamas Sarlos, and Adrian Weller. Orthogonal estimation of Wasserstein distances. In The 22nd International Conference on Artificial Intelligence and Statistics, pages 186-195. PMLR, 2019.  
+Soheil Kolouri, Kimia Nadjahi, Umut Simsekli, Roland Badeau, and Gustavo Rohde. Generalized sliced Wasserstein distances. Advances in neural information processing systems, 32, 2019.  
+Tong Wu, Liang Pan, Junzhe Zhang, Tai Wang, Ziwei Liu, and Dahua Lin. Density-aware chamfer distance as a comprehensive metric for point cloud completion. In Advances in Neural Information Processing Systems, volume 34, pages 29088-29100, 2021.  
+Fangzhou Lin, Yun Yue, Songlin Hou, Xuechu Yu, Yajun Xu, D Kazunori Yamada, and Ziming Zhang. Hyperbolic chamfer distance for point cloud completion. In Proceedings of the IEEE/CVF international conference on computer vision, 2023b.
+
+Lillian Lee. Measures of distributional similarity. arXiv preprint cs/0001012, 2000.  
+Maximilian Ilse, Jakub Tomczak, and Max Welling. Attention-based deep multiple instance learning. In International conference on machine learning, pages 2127-2136. PMLR, 2018.  
+Oded Maron and Tomás Lozano-Pérez. A framework for multiple-instance learning. Advances in neural information processing systems, 10, 1997.  
+Hang Su, Subhransu Maji, Evangelos Kalogerakis, and Erik Learned-Miller. Multi-view convolutional neural networks for 3d shape recognition. In Proceedings of the IEEE international conference on computer vision, pages 945-953, 2015.  
+Baoguang Shi, Song Bai, Zhichao Zhou, and Xiang Bai. Deeppano: Deep panoramic representation for 3-d shape recognition. IEEE Signal Processing Letters, 22(12):2339-2343, 2015.  
+Arman Afrasiyabi, Hugo Larochelle, Jean-François Lalonde, and Christian Gagné. Matching feature sets for few-shot image classification. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9014-9024, 2022.  
+Jonghyun Choi, Jayant Krishnamurthy, Aniruddha Kembhavi, and Ali Farhadi. Structured set matching networks for one-shot part labeling. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3627-3636, 2018.  
+Oriol Vinyals, Charles Blundell, Tim Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. In NIPS, 2016.  
+Juho Lee, Yoonho Lee, Jungtaek Kim, Adam Kosiorek, Seungjin Choi, and Yee Whye Teh. Set transformer: A framework for attention-based permutation-invariant neural networks. In International conference on machine learning, pages 3744-3753. PMLR, 2019.  
+Masanari Kimura. Generalization bounds for set-to-set matching with negative sampling. In International Conference on Neural Information Processing, pages 468-476. Springer, 2022.  
+Wei-Ying Ma and Bangalore S Manjunath. Texture features and learning similarity. In Proceedings CVPR IEEE Computer Society Conference on Computer Vision and Pattern Recognition, pages 425-430. IEEE, 1996.  
+Maria-Florina Balcan and Avrim Blum. On a theory of learning with similarity functions. In Proceedings of the 23rd international conference on Machine learning, pages 73-80, 2006.  
+Jie Yu, Jaume Amores, Nicu Sebe, Petia Radeva, and Qi Tian. Distance learning for similarity estimation. IEEE transactions on pattern analysis and machine intelligence, 30(3):451-462, 2008.  
+Masoud Faraki, Xiang Yu, Yi-Hsuan Tsai, Yumin Suh, and Manmohan Chandraker. Cross-domain similarity learning for face recognition in unseen domains. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 15292-15301, 2021.  
+Qiong Cao, Yiming Ying, and Peng Li. Similarity metric learning for face recognition. In Proceedings of the IEEE international conference on computer vision, pages 2408-2415, 2013.  
+Jaehoon Oh, Sungnyun Kim, Namgyu Ho, Jin-Hwa Kim, Hwanjun Song, and Se-Young Yun. Understanding cross-domain few-shot learning based on domain similarity and few-shot difficulty. Advances in Neural Information Processing Systems, 35:2622-2636, 2022.  
+Jen-Chun Lin, Wen-Li Wei, and Hsin-Min Wang. Demv-matchmaker: Emotional temporal course representation and deep similarity matching for automatic music video generation. In 2016 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 2772-2776. IEEE, 2016.  
+Wentong Liao, Michael Ying Yang, Ni Zhan, and Bodo Rosenhahn. Triplet-based deep similarity learning for person re-identification. In Proceedings of the IEEE International Conference on Computer Vision Workshops, pages 385–393, 2017.  
+Weiyang Liu, Zhen Liu, James M Rehg, and Le Song. Neural similarity learning. Advances in Neural Information Processing Systems, 32, 2019.
+
+Xi Cheng, Li Zhang, and Yefeng Zheng. Deep similarity learning for multimodal medical images. Computer Methods in Biomechanics and Biomedical Engineering: Imaging & Visualization, 6(3): 248-252, 2018.  
+Guixiang Ma, Nesreen K Ahmed, Theodore L Willke, and Philip S Yu. Deep graph similarity learning: A survey. Data Mining and Knowledge Discovery, 35:688-725, 2021.  
+Sanping Zhou, Jinjun Wang, Jiayun Wang, Yihong Gong, and Nanning Zheng. Point to set similarity based deep feature learning for person re-identification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3741-3750, 2017b.  
+Mahmut Kaya and Hasan Şakir Bilge. Deep metric learning: A survey. Symmetry, 11(9):1066, 2019.  
+Qi Qian, Lei Shang, Baigui Sun, Juhua Hu, Hao Li, and Rong Jin. Softtriple loss: Deep metric learning without triplet sampling. In ICCV, pages 6450-6458, 2019.  
+Chen Huang, Chen Change Loy, and Xiaou Tang. Local similarity-aware deep feature embedding. Advances in neural information processing systems, 29, 2016.  
+Ismail Elezi, Sebastiano Vascon, Alessandro Torcinovich, Marcello Pelillo, and Laura Leal-Taixe. The group loss for deep metric learning. In Computer Vision-ECCV 2020: 16th European Conference, Glasgow, UK, August 23-28, 2020, Proceedings, Part VII 16, pages 277-294. Springer, 2020.  
+Xun Wang, Xintong Han, Weilin Huang, Dengke Dong, and Matthew R Scott. Multi-similarity loss with general pair weighting for deep metric learning. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 5022-5030, 2019.  
+Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Frank Wang, and Jia-Bin Huang. A closer look at few-shot classification. arXiv preprint arXiv:1904.04232, 2019a.  
+Boris N. Oreshkin, Pau Rodríguez, and Alexandre Lacoste. TADAM: task dependent adaptive metric for improved few-shot learning. 2018.  
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In ICML, 2017.  
+Devang K Naik and RJ Mammone. Meta-neural networks that learn by learning. 1992.  
+Zhenguo Li, Fengwei Zhou, Fei Chen, and Hang Li. Meta-sgd: Learning to learn quickly for few shot learning. In ICML, 2018.  
+Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B. Tenenbaum, Hugo Larochelle, and Richard S. Zemel. Meta-learning for semi-supervised few-shot classification. In ICLR, 2018.  
+Wentao Yuan, Tejas Khot, David Held, Christoph Mertz, and Martial Hebert. Pcn: point completion network. In 3DV, 2018.  
+Yaoqing Yang, Chen Feng, Yiru Shen, and Dong Tian. Foldingnet: Point cloud auto-encoder via deep grid deformation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 206-215, 2018.  
+Wenxiao Zhang, Qingan Yan, and Chunxia Xiao. Detail preserved point cloud completion via separated feature aggregation. In European Conference on Computer Vision, pages 512-528. Springer, 2020b.  
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in neural information processing systems, 30, 2017.  
+Peng Xiang, Xin Wen, Yu-Shen Liu, Yan-Pei Cao, Pengfei Wan, Wen Zheng, and Zhizhong Han. Snowflakenet: Point cloud completion by snowflake point deconvolution with skip-transformer. In ICCV, 2021.
+
+Xumin Yu, Yongming Rao, Ziyi Wang, Zuyan Liu, Jiwen Lu, and Jie Zhou. Pointr: Diverse point cloud completion with geometry-aware transformers. In ICCV, 2021b.  
+Haoran Zhou, Yun Cao, Wenqing Chu, Junwei Zhu, Tong Lu, Ying Tai, and Chengjie Wang. Seedformer: Patch seeds based point cloud completion with upsample transformer. arXiv preprint arXiv:2207.10315, 2022.  
+Jun Wang, Ying Cui, Dongyan Guo, Junxia Li, Qingshan Liu, and Chunhua Shen. Pointattn: You only need attention for point cloud completion. arXiv preprint arXiv:2203.08485, 2022.  
+Chris J Maddison, Daniel Tarlow, and Tom Minka. A* sampling. Advances in neural information processing systems, 27, 2014.  
+Wouter Kool, Herke Van Hoof, and Max Welling. Stochastic beams and where to find them: The gumbel-top-k trick for sampling sequences without replacement. In International Conference on Machine Learning, pages 3499-3508. PMLR, 2019.  
+Iris AM Huijben, Wouter Kool, Max B Paulus, and Ruud JG Van Sloun. A review of the gumbel-max trick and its extensions for discrete stochasticity in machine learning. IEEE Transactions on Pattern Analysis and Machine Intelligence, 45(2):1353-1371, 2022.  
+Matt J Kusner and José Miguel Hernández-Lobato. Gans for sequences of discrete elements with the gumbel-softmax distribution. arXiv preprint arXiv:1611.04051, 2016.  
+Andres Potapczynski, Gabriel Loaiza-Ganem, and John P Cunningham. Invertible gaussian reparameterization: Revisiting the gumbel-softmax. Advances in Neural Information Processing Systems, 33:12311-12321, 2020.  
+John T Hancock and Taghi M Khoshgoftaar. Survey on categorical data for neural networks. Journal of big data, 7(1):28, 2020.  
+Luca Bertinetto, Joao F Henriques, Philip HS Torr, and Andrea Vedaldi. Meta-learning with differentiable closed-form solvers. arXiv preprint arXiv:1805.08136, 2018.  
+Catherine Wah, Steve Branson, Peter Welinder, Pietro Perona, and Serge Belongie. The caltech-ucsd birds-200-2011 dataset. 2011.  
+Qianru Sun, Yaoyao Liu, Tat-Seng Chua, and Bernt Schiele. Meta-transfer learning for few-shot learning. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 403-412, 2019.  
+Zitian Chen, Subhransu Maji, and Erik Learned-Miller. Shot in the dark: Few-shot learning with no base-class labels. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2668-2677, 2021.  
+Ge Liu, Linglan Zhao, Wei Li, Dashan Guo, and Xiangzhong Fang. Class-wise metric scaling for improved few-shot classification. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pages 586-595, 2021.  
+Philip Chikontwe, Soopil Kim, and Sang Hyun Park. Cad: Co-adapting discriminative features for improved few-shot classification. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 14554-14563, 2022.  
+Chi Zhang, Yujun Cai, Guosheng Lin, and Chunhua Shen. Deepemd: Differentiable earth mover's distance for few-shot learning. IEEE Transactions on Pattern Analysis and Machine Intelligence, 45(5):5632-5648, 2022.  
+Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Wang, and Jia-Bin Huang. A closer look at few-shot classification. In ICLR, 2019b.  
+Jake Snell, Kevin Swersky, and Richard S. Zemel. Prototypical networks for few-shot learning. 2017.  
+Li Yi, Vladimir G Kim, Duygu Ceylan, I-Chao Shen, Mengyan Yan, Hao Su, Cewu Lu, Qixing Huang, Alla Sheffer, and Leonidas Guibas. A scalable active framework for region annotation in 3d shape collections. ACM Transactions on Graphics (ToG), 35(6):1-12, 2016.
+
+Andreas Geiger, Philip Lenz, and Raquel Urtasun. Are we ready for autonomous driving? the kitti vision benchmark suite. In 2012 IEEE conference on computer vision and pattern recognition, pages 3354-3361. IEEE, 2012.  
+Xin Wen, Peng Xiang, Zhizhong Han, Yan-Pei Cao, Pengfei Wan, Wen Zheng, and Yu-Shen Liu. Pmp-net: Point cloud completion by learning multi-step point moving paths. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 7443-7452, 2021.  
+Fangzhou Lin, Yajun Xu, Ziming Zhang, Chenyang Gao, and Kazunori D Yamada. Cosmos propagation network: Deep learning model for point cloud completion. Neurocomputing, 507: 221-234, 2022.  
+Maxim Tatarchenko, Stephan R Richter, René Ranftl, Zhuwen Li, Vladlen Koltun, and Thomas Brox. What do single-view 3d reconstruction networks learn? In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3405-3414, 2019.  
+Haozhe Xie, Hongxun Yao, Shangchen Zhou, Jiageng Mao, Shengping Zhang, and Wenxiu Sun. Grnet: Gridding residual network for dense point cloud completion. In ECCV, 2020.

ICLR/2025/GPS_ A Probabilistic Distributional Similarity with Gumbel Priors for Set-to-Set Matching/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ccc22a7aa5dc454bdf84de8a10d50f8ee82d763a3f11a908b726fbbcd5bfad6d
+size 971166

ICLR/2025/GPS_ A Probabilistic Distributional Similarity with Gumbel Priors for Set-to-Set Matching/layout.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d3e77b10056b5924e16b52e2e78d443c314bb6ecc851bdcf71d9872043cd0b2
+size 486113

ICLR/2025/GPUDrive_ Data-driven, multi-agent driving simulation at 1 million FPS/d37baa0e-8fb7-4bbd-bfcc-0bfc447fe2db_content_list.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffd32317831d91c5cefaa527c82c6fe522de67bef2db98e9654f051554e597ba
+size 91758

ICLR/2025/GPUDrive_ Data-driven, multi-agent driving simulation at 1 million FPS/d37baa0e-8fb7-4bbd-bfcc-0bfc447fe2db_model.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd99f6a5725fea5b46ed467f0eb72222de9f85208ac92857077ddecea70c6c54
+size 111212

ICLR/2025/GPUDrive_ Data-driven, multi-agent driving simulation at 1 million FPS/d37baa0e-8fb7-4bbd-bfcc-0bfc447fe2db_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eeb139dcd948d70fa8c518a0a8173ca6c1a468e1ed6eda145ad25df7ca39060c
+size 3122594

ICLR/2025/GPUDrive_ Data-driven, multi-agent driving simulation at 1 million FPS/full.md

@@ -0,0 +1,334 @@
+# GPUDRIVE: DATA-DRIVEN, MULTI-AGENT DRIVING SIMULATION AT 1 MILLION FPS
+
+Saman Kazemkhani*†
+
+Aarav Pandya*†
+
+Daphne Cornelisse*†
+
+Brennan Shacklett2
+
+Eugene Vinitsky
+
+# ABSTRACT
+
+Multi-agent learning algorithms have been successful at generating superhuman planning in various games but have had limited impact on the design of deployed multi-agent planners. A key bottleneck in applying these techniques to multi-agent planning is that they require billions of steps of experience. To enable the study of multi-agent planning at scale, we present GPUDrive. GPUDrive is a GPU-accelerated, multi-agent simulator built on top of the Madrona Game Engine capable of generating over a million simulation steps per second. Observation, reward, and dynamics functions are written directly in  $\mathrm{C}++$ , allowing users to define complex, heterogeneous agent behaviors that are lowered to high-performance CUDA. Despite these low-level optimizations, GPUDrive is fully accessible through Python, offering a seamless and efficient workflow for multiagent, closed-loop simulation. Using GPUDrive, we train reinforcement learning agents on the Waymo Open Motion Dataset, achieving efficient goal-reaching in minutes and scaling to thousands of scenarios in hours. We open-source the code and pre-trained agents at
+
+www.github.com/Emerge-Lab/gpudrive
+
+# 1 INTRODUCTION
+
+Multi-agent learning has been impactful across a wide range of fully cooperative and zero-sum games (Cui et al., 2023; Wurman et al., 2022; Pérolat et al., 2022; Silver et al., 2017; Jaderberg et al., 2018; Bakhtin et al., 2023). However, its impact on multi-agent planning for settings that mix humans and robots has been muted. In contrast to the ubiquity of multi-agent learning-based agents in zero-sum games, multi-agent planners for most practical robotic systems are not derived from the output of game-theoretically sound learning algorithms. While it is hard to characterize the space of deployed planners since many of them are proprietary, the majority likely use a mixture of collected data for the prediction of human motion and hand-tuned costs. These are then fed into a cost-based trajectory optimizer or into a planner based on imitation learning (Bronstein et al., 2022; Lu et al., 2023). This approach has been highly effective in scaling up real-world autonomy but can struggle with reasoning about long-term behavior, contingency planning, and interaction with humans in rare, complex scenarios.
+
+The divergence in preferred technique between these two domains is partially the outcome of two distinct, challenging components of real-world multi-agent planning. First, unlike zero-sum games, it is necessary to play a human-compatible strategy that is difficult to identify without data. Second, generating the billions of samples needed for multi-agent learning algorithms is difficult with existing simulators. The former challenge is difficult for multi-agent learning since there is not a clear equilibrium concept that algorithms should be pursuing. The latter problem is a challenge for simulators since it is difficult to simulate embodied multi-agent environments at appropriately high rates.
+
+![](images/8e55a01d494122f99229b1457d9d48158cb3ff33de50812087461e30f407095a.jpg)
+
+![](images/e4d0b0ebfb98c404a5f994808585e60b861a03a141e8b9debd86e1b47545aca8.jpg)
+
+![](images/186d7c48360c6911d94bdf6a2f06d59c649bfed913ab8cbefb2350de78aa3f3d.jpg)
+
+![](images/860b9fcb64a0e56be9020eb2771f2806eff2bf15e4e0445ecdaee251a512e04e.jpg)  
+Figure 1: Extremely fast multi-agent simulation with GPUDrive. Top: Bird's-eye view of Waymo Open Motion Dataset scenarios in GPUDrive, with boxes marking controlled agents and circles denoting their goals. Bottom: Corresponding agent views, centered on one agent. Observations can be easily configured based on the user's objectives. Here, agents are provided with a scene view through a relative coordinate frame. Shown are nearby road points within a configurable radius (set to 50 meters) and the relative positions of other agents in the scene.
+
+![](images/5628b82f53f404dcaa2cf529924eba0a9200ae5bbcd4dab571d45351334454cd.jpg)
+
+![](images/ddd35abba9b914db69c89bf33900c5b8c5cb9513aa60f76d794ed023bb9d5e60.jpg)
+
+To address these challenges and unlock multi-agent learning as a tool for generating capable self-driving planners, we introduce GPUDrive. GPUDrive is a simulator intended to mix real-world driving data with simulation speeds that enable the application of sample-inefficient but effective RL algorithms to the design of autonomous planners. GPUDrive runs at over a million steps per second on both consumer-grade and datacenter-class GPUs and has a sufficiently light memory footprint to support hundreds to thousands of simultaneous worlds (environments) with hundreds of agents per world. GPUDrive supports the simulation of a variety of sensor modalities, from LIDAR to a human-like view cone, enabling GPUDrive to be used for studying the effects of different sensor types on resultant agent characteristics. Finally, GPUDrive takes in driving logs and maps from existing self-driving datasets, enabling the mixing of tools from imitation learning with reinforcement learning algorithms. This enables the study of both the development of autonomous vehicles and the learning of models of human driving, cycling, and walking behavior.
+
+# Our contributions are:
+
+- We provide a multi-agent, GPU-accelerated, and data-driven simulator that runs at over a million steps per second (Section 4.1). Our simulator provides a testbed for:
+
+1. Investigating the capability of learning algorithms to solve challenges related to self-play or autonomous coordination.  
+2. Researching the effects of limited or human-like perception on agent behavior.
+
+- We provide gymnasium (Towers et al., 2024) environments in both torch and jax that can be easily configured with standard open-source multi-agent RL and imitation learning libraries. Additionally, we open-sourced two policy-gradient training loops that can be readily used to develop agents.  
+- We release implementations of tuned RL algorithms that can process 30 million steps of experience per hour on consumer-grade GPUs. These can be used to train  $95\%$  goal-reaching
+
+agents across 1000 different multi-agent scenarios in 15 hours on relatively accessible hardware.
+
+- We open-source these strong driving baseline agents that achieve  $95\%$  of their goals on a subset of scenes. These are integrated into the simulator so that the simulator comes with default, reactive agents.
+
+# 2 RELATED WORK
+
+Frameworks for batched simulators. There are various open-source frameworks available that support hardware-accelerated reinforcement learning environments. These environments are generally written directly in an acceleration framework such as Numpy (Harris et al., 2020), Jax (Bradbury et al., 2018), or Pytorch (Ansel et al., 2024; Makoviychuk et al., 2021; Panerati et al., 2021). In terms of multi-agent accelerated environments, standard benchmarks include JaxMARL(Rutherford et al., 2023), Jumanji (Bonnet et al., 2024), VMAS (Bettini et al., 2022) Gigastep (Lechner et al., 2024) which primarily feature fully cooperative or fully competitive tasks. Each benchmark requires the design of custom accelerated structures per environment. In contrast, GPUDrive focuses on a mixed motive setting and is built atop Madrona, an extensible ECS-based framework in  $\mathrm{C + + }$ , enabling GPU acceleration and parallelization across environments (Shacklett et al., 2023). Madrona comes with vectorization of key components of embodied simulation such as collision checking and sensors such as LIDAR. GPUDrive can support hundreds of controllable agents in more than 100,000 distinct scenarios, offering a distinct generalization challenge and scale relative to existing benchmarks. Moreover, GPUDrive includes a large dataset of human demonstrations, enabling imitation learning, inverse RL, and combined IL-RL approaches.
+
+Simulators for autonomous driving research and development. Table 1 shows an overview of current simulators used in autonomous driving research. The purpose of GPUDrive is to facilitate the systematic study of behavioral, coordination, and control aspects of autonomous driving and multiagent learning more broadly. As such, visual complexity is reduced, which differs from several existing simulators, which (partially) focus on perception challenges in driving (Dosovitskiy et al., 2017; Cai et al., 2020). Driving simulators close to GPUDrive in terms of either features or speed include MetaDrive (Li et al., 2022), nuPlan (Caesar et al., 2021), Nocturne (Vinitsky et al., 2022), and Waymax (Gulino et al., 2024) which all utilize real-world data. Unlike MetaDrive and nuPlan, our simulator is GPU-accelerated. Like GPUDrive, Waymax is a JAX-based GPU-accelerated simulator that achieves high throughput through JIT compilation and efficient use of accelerators. With respect to Waymax, our simulator supports a wider range of possible sensor modalities (Section 3.2) including LIDAR and human-like views, can scale to nearly thirty times more worlds (see Section 4.1), and comes with performant reinforcement learning baselines. However, it does not currently come with reactive IDM agents like Waymax though it does come with pre-trained simulated agents based on RL policies.
+
+Driving agents in simulators and algorithms. Existing simulators often feature baseline agents for interaction, such as low-dimensional car following models that describe vehicle dynamics through a limited set of variables or parameters (Kreutz & Eggert, 2021; Kesting et al., 2007; Treiber et al., 2000). Rule-based agents exhibit predetermined behaviors, like car-following agents (Gulino et al., 2024; Caesar et al., 2021; Lopez et al., 2018; Casas et al., 2010) such as the IDM model, or parameterized behavior agents like CARLA's TrafficManager (Dosovitskiy et al., 2017). Some simulators offer recorded human driving logs for interaction through replaying the human driving logs (Lu et al., 2023; Vinitsky et al., 2022; Gulino et al., 2024; Caesar et al., 2021). Additionally, certain simulators provide learning-based agents, leveraging reinforcement learning techniques (Li et al., 2022). In GPUDrive, we provide both human driving logs and high-performing reinforcement learning agents.
+
+Table 1: Comparison of GPUDrive to related driving simulators. Columns represent whether the simulator supports multi-agent simulation, GPU acceleration, simulation of sensors such as LIDAR or human views, is built atop data, comes with existing driver models, and whether the agents are provided explicit goal points or waypoints along the way to the goal.  
+
+<table><tr><td>Simulator</td><td>Multi-agent</td><td>GPU-Accel</td><td>Sensor Sim</td><td>Expert Data</td><td>Sim-agents</td><td>Routes / Goals</td></tr><tr><td>TORCS (Wymann et al., 2000)</td><td></td><td></td><td>✓</td><td></td><td>✓</td><td>-</td></tr><tr><td>GTA V (Martinez et al., 2017)</td><td></td><td></td><td>✓</td><td></td><td></td><td>-</td></tr><tr><td>CARLA (Dosovitskiy et al., 2017)</td><td></td><td></td><td>✓</td><td></td><td>✓</td><td>Waypoints</td></tr><tr><td>Highway-env (Leurent et al., 2018)</td><td></td><td></td><td></td><td></td><td></td><td>-</td></tr><tr><td>Sim4CV (Müller et al., 2018)</td><td></td><td></td><td>✓</td><td></td><td></td><td>Directions</td></tr><tr><td>SUMMIT (Cai et al., 2020)</td><td>✓ (≥ 400)</td><td></td><td>✓</td><td></td><td>✓</td><td>-</td></tr><tr><td>MACAD (Palanisamy, 2020)</td><td>✓</td><td></td><td>✓</td><td></td><td>✓</td><td>Goal point</td></tr><tr><td>SMARTS (Zhou et al., 2021)</td><td>✓</td><td></td><td></td><td></td><td></td><td>Waypoints</td></tr><tr><td>MADRaaS (Santara et al., 2021)</td><td>✓ (≥ 10)</td><td></td><td>✓</td><td></td><td></td><td>Goal point</td></tr><tr><td>DriverGym (Kothari et al., 2021)</td><td></td><td></td><td></td><td>✓</td><td>✓</td><td>-</td></tr><tr><td>VISTA (Amini et al., 2022)</td><td>✓</td><td></td><td>✓</td><td>✓</td><td></td><td>-</td></tr><tr><td>nuPlan (Caesar et al., 2021)</td><td></td><td></td><td>✓</td><td>✓</td><td>✓</td><td>Waypoints</td></tr><tr><td>Nocturne (Vinitsky et al., 2022)</td><td>✓ (≥ 128)</td><td></td><td></td><td>✓</td><td>✓</td><td>Goal point</td></tr><tr><td>MetaDrive (Li et al., 2022)</td><td>✓</td><td></td><td>✓</td><td>✓</td><td>✓</td><td>-</td></tr><tr><td>InterSim (Sun et al., 2022)</td><td>✓</td><td></td><td></td><td>✓</td><td>✓</td><td>Goal point</td></tr><tr><td>TorchDriveSim (Scibior et al., 2021)</td><td>✓</td><td>✓</td><td></td><td></td><td>✓</td><td>-</td></tr><tr><td>BITS (Xu et al., 2023)</td><td>✓</td><td></td><td></td><td>✓</td><td>✓</td><td>Goal point</td></tr><tr><td>Waymax (Gulino et al., 2024)</td><td>✓ (≥ 128)</td><td>✓</td><td></td><td>✓</td><td>✓</td><td>Waypoints</td></tr><tr><td>GPUDrive (ours)</td><td>✓ (≥ 128)</td><td>✓</td><td>✓</td><td>✓</td><td>✓</td><td>Goal point</td></tr></table>
+
+# 3 SIMULATION DESIGN
+
+# 3.1 SIMULATION ENGINE
+
+Learning to safely navigate complex scenarios in a multi-agent setting requires generating many billions of environment samples. To feed sample-hungry learning algorithms, GPUDrive is built on top of Madrona (Shacklett et al., 2023), an Entity-Component-State system designed for high-throughput reinforcement learning environments. In the Madrona framework, multiple independent worlds (each containing an independent number of agents) are executed in parallel on an accelerator via a shared engine.
+
+However, the simulation of driving poses a unique set of challenges which require careful technical design choices to solve. First, road objects, such as road edges and lane lines are frequently represented as polylines (i.e. connected sets of points). These polylines can consist of hundreds of points as they are sampled at every 0.1 meters, leading to even small maps having upwards of tens of thousands of points. This can blow up the memory requirements of each world as well as lead to significant redundancy in agent observations. Second, the large numbers of agents and road objects can make collision checking a throughput bottleneck. Finally, there is immense variability in the number of agents and road objects in a particular scene. Each world allocates memory to data structures that track its state and accelerate simulation code. Though independent, each world incurs a memory footprint proportional to the maximum number of agents across all worlds. In this way, the performance of GPUDrive is sensitive to the variation in agent counts across all the worlds in a batch.
+
+These challenges are partially resolved via the following mechanisms. First, a primary acceleration data structure leveraged by GPUDrive is a Bounding Volume Hierarchy (BVH). The BVH keeps track of all physics entities and is used to easily exclude candidate pairs for collisions. This allows us to then run a reduced-size collision check on potential collision candidate pairs. The use of a BVH avoids invoking a collision check that would otherwise always be quadratic in the number of agents in a world. Secondly, we observed that a lot of the lines in the geometry of the roads are straight. This allows us to omit many intermediate points while only suffering a minor hit in the quality of the curves. We apply a polyline decimation algorithm (Visvalingham-Whyatt Algorithm) (Visvalingam & Whyatt, 1993) to approximate straight lines and filter out low-importance points in the polylines. With this modification, we can reduce the number of points by 10-15 times and significantly improve the step times while decreasing memory usage. Finally, rather than allocate memory for the maxi
+
+mum number of agents in a scene (as is likely necessary in frameworks like Jax), we only allocate memory equal to the actual number of instantiated agents.
+
+# 3.2 SIMULATOR FEATURES
+
+We provide an overview of some of the pertinent simulator features as well as sharp edges and limitations of the simulator as a guide to potential users.
+
+![](images/da65b88d64eb3dda77e5bed44a0d9446dc15bce66ea01d3c8a9ba0f3e6286baa.jpg)  
+Figure 2: Example scenarios from the Waymo Open Motion Dataset rendered in GPUDrive. The blue boxes and circles indicate agents and their respective destinations.
+
+Dataset. GPUDrive represents its map as a series of polylines and does not require a connectivity map of the lanes. As such, it can be made compatible with most driving datasets given the preprocessing of the roads into the polyline format. Currently, GPUDrive supports the Waymo Open Motion Dataset (WOMD) (Ettinger et al., 2021) which is available under a non-commercial license. We show four representative example scenarios from the WOMD in Figure 2. The WOMD consists of a set of over 100,000 multi-agent traffic scenarios, each of which contains the following key elements: 1) Road map - the layout and structure of a road, such as a highway or parking garage. 2) Logged human trajectories from vehicles, cyclists, and pedestrians. 3) Road objects, such as stop signs and crosswalks. Figure 7 depicts an example of an intersection traffic scenario as rendered in GPUDrive.
+
+Sensor modalities. GPUDrive supports a variety of observation spaces intended to enable heterogeneous types of agents. Fig. 7 depicts the three types of supported state spaces. The first mode is somewhat unphysical in which all agents and road objects within a fixed radius are observable to the agent. This mode is intended primarily for debugging and quick testing, enabling a user to minimize the amount of partial observability in the environment. The other two modes are based on a GPU-accelerated LIDAR scan, representing what an autonomous vehicle would be able to see and what a human would likely be able to see respectively. Both modes are based on casting LIDAR rays; to model human vision we simply restrict the LIDAR rays to emanate in a smaller, controllable-sized cone that can be rotated through an action corresponding to head rotation. Note that since all objects are represented as bounding boxes of fixed height, the LIDAR observations are over-conservative as, in reality, it is frequently possible to see over the hoods of cars as their height is lower than the body of the rest of the car.
+
+Agent dynamics. By default, agents are stepped using a standard Ackermann bicycle model (Details in Appendix B) with actions corresponding to steering and acceleration. This model enables the dynamics of objects to be affected by their length, creating different dynamics for small cars as opposed to large cars like trucks. However, this model is not fully invertible which can make it challenging to use as a model for imitation learning. To enable full invertibility for imitation learning, we also support the simplified bicycle model, taken from Waymax (Gulino et al., 2024), which is a double-integrator in the position and velocity and updates its yaw as:
+
+$$
+\theta_ {t + 1} = \theta + s _ {t} (v _ {t} \Delta t + \frac {1}{2} a _ {t} \Delta t ^ {2})
+$$
+
+where  $\theta$  is the yaw,  $s$  is the steering command,  $v$  is the velocity, and  $a$  is the acceleration at time  $t$  respectively.  $\Delta t$  is the timestep. This model is always invertible given an unbounded set of steering and acceleration actions but is independent of the vehicle length. See the appendix for full details on the models.
+
+Note that this model does not factor in the length of the car, causing both long and short objects to have identical dynamics. However, we have observed that computing the expert actions and then using them to mimic the expert trajectory under this model leads to lower tracking error than the default bicycle model.
+
+Rewards. All agents are given a target goal to reach; this goal is selected by taking the last recorded position in the vehicle's logged trajectory. A goal is reached when agents are within some configurable distance  $\delta$  of the goal. By default, agents in GPUDrive receive a reward of 1 for achieving their goal and otherwise receive a reward of 0. There are additional configurable collision penalties or other rewards based on agent-vehicle distances or agent-road distances though these are not used in the experiments reported in this work.
+
+Termination conditions. We terminate an agent's episode when they achieve their goal position and support an option to also terminate the episode if the agent collides. As it is not clear where an agent should go next after it reaches its goal, we simply remove it from the scene afterwards (we note that an alternative might be to generate a new goal for the agent to drive to). Car and cyclist agents are considered to be in collision when they drive through a road edge while pedestrian agents are allowed to cross road edges.
+
+Environment interface. As GPUDrive is implemented in  $\mathrm{C}++$ , we provide a Pythonic interface through nanobind (Jakob, 2022). We create environments for both torch and jax that conform to the Gymnasium API (Towers et al., 2024) so users can use the simulator entirely through Python if they prefer.
+
+Available driving simulation agents. We use reinforcement learning to train a set of agents that reach their goals  $95\%$  of the time on a subset of 1000 training scenes. While this number is far below the capability of human drivers, these agents are reactive in a distinct fashion from parametrized driver models in other simulators. In particular, many logged-data simulators construct reactivity by having the driver follow along its logged trajectory but decelerate if an agent passes in front of it. In contrast, these agents can maneuver and negotiate without remaining constrained to a logged trajectory. These trained agents are extremely aggressive about reaching their goals and can be used as an out-of-distribution test for proposed driving agents. The training procedure and more details can be found in Section 4.2.
+
+Simulator sharp-edges. We note the following limitations of the benchmark:
+
+- Absence of a map. The current version of the simulator does not have a well-defined notion of lanes or a higher-level road map which makes it challenging for algorithmic approaches that require maps. The absence of this feature also makes it challenging to define rewards such as "stay lane-centered."  
+- Convex objects only. Collision checking relies on the objects being represented as convex objects.  
+- Unsolvable goals. Due to incorrect labels of some road points in the Waymo dataset, such as an exit to a parking lot being labeled as an impassable road edge, some agent goals (roughly  $2\%$ ) are unreachable. For these agents, we default them to simply replaying their logged trajectory and do not treat them as agents.  
+- Initialization modes: In many scenarios, a significant portion of agents (25-75%) are already at or very close to their goal positions, such as parked cars. To highlight the difficulty of controlling agents, GPUDrive supports different initialization modes. By default, the initialization mode is set to "all nontrivial" meaning that only agents more than 2 meters away from their target positions are considered controllable. Note that while this sharply reduces the number of agents in the scene, it more accurately represents actual driving challenges.
+
+# 4 SIMULATOR PERFORMANCE
+
+The following Sections describe the simulator speed. Section 4.1 first shows the raw simulator speed and peak goodput (throughput achieved by the valid number of agents in a scene). Section 4.2 then investigates the impact on reinforcement learning workflows by evaluating the time it takes to train reinforcement learning agents through Independent PPO (IPPO) (Yu et al., 2022), a widely used multi-agent learning algorithm. The performance results here are from IPPO implemented with PufferLib (Suarez, 2024). A slower IPPO implementation based on Stable Baselines 3 (Hill et al., 2018) is also available in the repo.
+
+# 4.1 SIMULATION SPEED
+
+Since scenarios contain a variable number of agents, we introduce a metric called Agent Steps Per Second (ASPS) to measure the sample throughput of the simulator. We define the ASPS as the total number of agents across all worlds in a batch that can be fully stepped in a second:
+
+$$
+\mathrm {A S P S} = \frac {S \times \sum_ {k = 1} ^ {N} \left| A _ {k} \right|}{\Delta T} \tag {1}
+$$
+
+where  $A_{k}$  is the set of agents in the  $k^{th}$  world,  $S$  is the number of steps taken, and  $\Delta T$  is the number of seconds elapsed. Figure 3 examines the scaling of the simulator as the number of simulated worlds, which represents the amount of parallelism, increases. To measure performance, we sample random batches of scenarios of size equal to the number of worlds, so that every world is a unique scenario with  $K$  agents. On the left-hand side of Figure 3, we compare the performance of GPUDrive to Nocturne (Vinitsky et al., 2022) (CPU, no parallelism), a CPU-accelerated version of Nocturne via Pufferlib (16 CPU cores) (Suarez, 2024) and Waymax Gulino et al. (2024). Empirically, the maximum achievable ASPS of Nocturne is 15,000 (blue dotted line) though we note that additional speedups may be possible. GPUDrive achieves a peak ASPS of 2.3 million steps, which is 2 to 3 orders of magnitude faster compared to Nocturne. This performance also surpasses that of Waymax (Gulino et al., 2024), a JAX-based simulator, where we could not run more than 16 environments in parallel due to Out of Memory (OOM) issues.
+
+![](images/69e062082ba56846953d560c7a34f4d454586cf8e37ddc30bc452983efdbe117.jpg)  
+Figure 3: Peak goodput of GPUDrive on a consumer-grade and datacenter-class GPU compared to original, CPU and GPU-based, implementations using the radial filter observation. Left: The total number of agent steps per second (ASPS) is the number of objects for which our system computes observations at each time step. To ensure a fair comparison, we align the conditions with those used in (Gulino et al., 2024), where all cars, bicyclists, and pedestrians are considered valid experience-generating agents. Center: The distribution of controllable agents across 512 scenarios in the Waymo Open Motion Dataset  $\mu \approx 10.8$  (red line),  $\sigma \approx 9.3$ . These numbers are obtained using the "nontrivial" initialization mode in GPUDrive, which initializes only the agents that are more than 2 meters away from their final position. Right: The total number of controllable agent steps per second (CASPS) as we increase the number of worlds (parallelism).
+
+In addition to the ASPS, we report another metric to indicate the number of controllable agents that are stepped per second. In the Waymo Open Motion Dataset, each scenario contains a varying number of moving agents (Examples in Figure 2). By default, our system only classifies something
+
+as a controllable agent if its movement is necessary to achieve the goal. Therefore, parked cars throughout the episode are not considered controllable agents. To illustrate what this looks like, we plot the distribution of controllable agents across a subset of scenes in Figure 3.
+
+Considering the variance of controllable agents per scene, the right-hand side of Figure 3 depicts the Controlled Agent Steps Per Second (CASPS). CASPS reflects the expected performance of our system when utilizing the Waymo Open Motion Dataset with a randomly sampled subset of scenarios. Due to the significant variability in agents throughout the dataset, the highest CASPS is notably lower than the ASPS, at around 200,000. Note that this can be improved by strategically selecting scenes, such as filtering for dense scenes with a high number of controllable agents.
+
+![](images/da88ca5f4b8bd92dfeef1a913e92d67c782253276cb120360c63fc0571bc96e4.jpg)  
+Figure 4: ASPS and CASPS comparison between Radial Filter and LiDAR observation types. The radial filter is slower than lidar due to its linear scan of nearby objects. In contrast, the LiDAR observation type is GPU-accelerated, delivering significantly enhanced performance. As demonstrated in the plots, depending on the scene selection, the LiDAR can achieve a speedup of approximately  $3\mathrm{x}$  over the radial filter.
+
+![](images/101f50eedad899ed36e63bbac80d6c88541c942187a032a1ec4cc3a3e6f44d06.jpg)
+
+![](images/1bdfd84f6fdf104d1ca3223e3736248af696ab9ab5cd49704f2446ceb6ae17cb.jpg)
+
+Lastly, we demonstrate the speed of different observation spaces in Figure 4. We observe that using LiDAR is approximately three times faster than using the radial filter observation (Details about the supported observation spaces are found in Section 3.2).
+
+# 4.2 END-TO-END SPEED AND PERFORMANCE
+
+The purpose of GPUDrive is to facilitate research and development in multi-agent algorithms by 1) reducing the completion time of experiments, and 2) enabling academic research labs to achieve scale on a limited computing budget. Ultimately, we are interested in the rate at which a machine learning researcher or practitioner can iterate on ideas using GPUDrive. This section highlights what our simulator enables in this regard by studying the end-to-end process of learning policies in our simulator.
+
+Figure 5 contrasts the number of steps (experience) and the corresponding time required to solve 10 scenarios from the WOMD between Nocturne (Vinitsky et al., 2022) and GPUDrive. We compare Nocturne to GPUDrive, as it is the closest simulator in functionality, except that it is implemented on the CPU. For benchmarking purposes, we mark a scene as solved when agents can navigate to their designated target position  $95\%$  of the time without colliding or going off-road. Ceteris paribus (Details in Appendix D), GPUDrive achieves a 200 - 300x training speedup, solving 10 scenarios in less than 3 minutes compared to approximately 10 hours in Nocturne.
+
+In absolute terms, the number of controlled agent steps per second for the Pufferlib PPO implementation ranges from 200K to 500K, depending on the hardware used and factors such as the number of visible road points per agent.
+
+As shown in Fig. 5, GPUDrive allows us to solve scenes in minutes. Next, we investigate how the individual scene completion time, the time it takes to solve a single scenario, changes as we increase the total number of scenarios we train on. In practice, it may be desirable to train agents on thousands of scenarios. Therefore, we ask whether it is feasible to fully leverage the simulator's capabilities with a single GPU.
+
+![](images/ba8576eac5fff716af71f15c12b2223c6f7e656f4581c5633f88255453e94c4b.jpg)  
+Figure 5: From hours to seconds. Left: Training performance (goal-reaching rate) as a function of the global step of the controlled agents (CASPS). Center: Training performance as a function of wall-clock time in seconds. Right: Training performance as a function of wall-clock time where the x-axis is on a log scale. Runs are averaged across three seeds, replicating environmental and experimental conditions as closely as possible. See Appendix D for the hyperparameters and training details. The green dotted line marks optimal performance (all agents reach their goal without collisions).
+
+![](images/6bd45d33acb16211e7e6bb15156623fd985139c16dafda5a7710ae9c6c4ab4ca.jpg)
+
+![](images/73046928e12a797c49854f9707cdf3610abcd12b17ab8af4a7f8a89ad42d649e.jpg)
+
+Interestingly, we find that the amortized sample efficiency increases with the size dataset of scenes we train in. Figure 6 shows the average completion time per scenario as we increase the dataset. For instance, using IPPO with 32 scenarios takes 2 minutes per scenario. In contrast, solving 1024 unique scenarios takes about 200 minutes, which amounts to only 15 seconds per scenario. We expect that these scaling benefits will continue as we further increase the size of the training dataset. This suggests that GPUDrive should enable effective utilization of the large WOMD dataset comprising 100,000 diverse traffic scenarios, even with limited computational resources.
+
+![](images/e837860614fe17e9047461b906061edab21445d6e2c604669d89eef072726b11.jpg)  
+Figure 6: Scale reduces individual scene completion time. Left: Total time required to solve a fixed number of scenarios to a goal-reaching rate of  $95\%$ . Note that time-to-completion is sublinear concerning the number of scenes. Right: Each additional scenario costs less to solve than the previous scenario. At 1024 scenes, the per-scene cost of solving an additional scene is on the order of 15 seconds.
+
+![](images/16659d01dce8bb2d14fec6db5abf39a531ce05fcb42384ed5199ae7b7f1ee7a4.jpg)
+
+# 4.3 MEASURING REMAINING UNSOLVED TASKS
+
+The Waymo Open Motion Dataset contains a total of 103,354 traffic scenarios (Ettinger et al., 2021). In this paper, we demonstrate that an agent can achieve  $95\%$  performance on a subset of 1000 scenes after 15 hours of training. Additionally, we show that the time required to solve scenarios decreases as the dataset size increases. Our analysis of the failure rates in the current best-performing policy suggests that the goal-reaching limit is around  $98\%$ , due to mislabeled road edges in the dataset, which render some goals unreachable because they are located beyond uncrossable roads. An important direction for future work is developing agents that achieve near-perfect performance,
+
+with a goal-reaching rate approaching  $100\%$  and a  $0\%$  collision rate while addressing the limitations posed by data inaccuracies in the benchmark.
+
+# 5 CONCLUSION
+
+In this work, we present GPUDrive, a GPU-accelerated, multi-agent, and data-driven simulator. GPUDrive is intended to help generate the billions of samples that are likely needed to achieve effective reinforcement learning for multi-agent driving planners. By building atop the Madrona Engine (Shacklett et al., 2023), we can scale GPUDrive to hundreds of worlds with potentially thousands of agents leading to throughput of millions of steps per second. This throughput occurs while synthesizing complex observations such as LiDAR. We show that this throughput has consequent implications for training reinforcement learning agents, leading to the ability to train agents to solve any particular scene in minutes and in seconds when amortized across many scenes. We release the simulator and integrated trained agents to enable further research.
+
+Future work and simulator extensions. This paper represents an initial step toward scaling reinforcement learning for multi-agent planning in safety-critical, mixed human-autonomous settings. Several important opportunities remain for future work:
+
+- Agent performance: Training agents to navigate without crashing in any scenario, matching human capabilities, remains an unresolved challenge. Currently, agents trained in GPU-Drive achieve a  $95\%$  success rate in a few hours, but this still falls short of the standards we aim for. Getting to  $100\%$  goal reaching performance is left for future work.  
+- Integrating multiple datasets: Future work will focus on integrating various datasets, such as NuPlan or NuScenes (Caesar et al., 2020). This integration will enable training on data from multiple geographic locations, including Boston and Singapore. To achieve this, we need to establish a data-processing pipeline that ensures the datasets are converted into a format compatible with the simulator.  
+- Diverse realistic sim agents: We plan to extend GPUDrive by introducing a variety of simulation agents that represent a broad range of human-like behaviors. This will improve sim realism.
+
+# 6 REPRODUCIBILITY STATEMENT
+
+The simulator's source code and data are available at https://github.com/Emerge-Lab/gpudrive. To ease reproducibility, we provide Dockerfiles to simplify setup. The experiments in the paper can be reproduced using a single file on a single A100 in 16 hours or slightly longer for less performant hardware. The data has been pulled from the Waymo Motion dataset and parsed into JSON files that are used to initialize the simulator; these are all available from Huggingface datasets.
+
+# 7 ETHICS STATEMENT
+
+This paper presents GPUDrive, a GPU-accelerated simulator for multi-agent learning in autonomous driving. We use publicly available datasets, such as the Waymo Open Motion Dataset (Ettinger et al., 2021), which are anonymized to protect privacy. GPUDrive is intended for research purposes and not for real-world deployment without further validation. We recognize the risks of autonomous systems and emphasize the importance of safety and fairness in their application. Although this work does not involve human participants directly, it leverages real-world data that may reflect human behavior, and we strive to avoid harm or discrimination. The codebase, pre-trained agents, and evaluation scripts are openly available to promote transparency. There are no conflicts of interest or external sponsorships affecting this research. We are committed to ethical practices in data handling, model deployment, and research integrity.
+
+# ACKNOWLEDGMENTS
+
+This work is funded by the C2SMARTER Center through a grant from the U.S. DOT's University Transportation Center Program. The contents of this report reflect the views of the authors, who are responsible for the facts and the accuracy of the information presented herein. The U.S. Government assumes no liability for the contents or use thereof. This work was also supported in part through the NYU IT High-Performance Computing resources, services, and staff expertise.
+
+# REFERENCES
+
+Alexander Amini, Tsun-Hsuan Wang, Igor Gilitschenski, Wilko Schwarting, Zhijian Liu, Song Han, Sertac Karaman, and Daniela Rus. Vista 2.0: An open, data-driven simulator for multimodal sensing and policy learning for autonomous vehicles. In 2022 International Conference on Robotics and Automation (ICRA), pp. 2419-2426. IEEE, 2022.  
+Jason Ansel, Edward Z. Yang, Horace He, Natalia Gimelshein, Animesh Jain, Michael Voznesensky, Bin Bao, Peter Bell, David Berard, Evgeni Burovski, Geeta Chauhan, Anjali Chourdia, Will Constable, Alban Desmaison, Zachary DeVito, Elias Ellison, Will Feng, Jiong Gong, Michael Gschwind, Brian Hirsh, Sherlock Huang, Kshitteej Kalambarkar, Laurent Kirsch, Michael Lazos, Mario Lezcano, Yanbo Liang, Jason Liang, Yinghai Lu, C. K. Luk, Bert Maher, Yunjie Pan, Christian Puhrsch, Matthias Reso, Mark Saroufim, Marcos Yukio Siraichi, Helen Suk, Shunting Zhang, Michael Suo, Phil Tillet, Xu Zhao, Eikan Wang, Keren Zhou, Richard Zou, Xiaodong Wang, Ajit Mathews, William Wen, Gregory Chanan, Peng Wu, and Soumith Chintala. Pytorch 2: Faster machine learning through dynamic python bytecode transformation and graph compilation. In Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2, ASPLOS 2024, La Jolla, CA, USA, 27 April 2024-1 May 2024, pp. 929-947. ACM, 2024. doi: 10.1145/3620665.3640366. URL https://doi.org/10.1145/3620665.3640366.  
+Anton Bakhtin, David J. Wu, Adam Lerer, Jonathan Gray, Athul Paul Jacob, Gabriele Farina, Alexander H. Miller, and Noam Brown. Mastering the game of no-press diplomacy via humanregularized reinforcement learning and planning. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023, 2023.  
+Matteo Bettini, Ryan Kortvelesy, Jan Blumenkamp, and Amanda Prorok. VMAS: A vectorized multi-agent simulator for collective robot learning. In Distributed Autonomous Robotic Systems - 16th International Symposium, DARS 2022, Montbéliard, France, 28-30 November 2022, volume 28 of Springer Proceedings in Advanced Robotics, pp. 42-56. Springer, 2022. doi: 10.1007/978-3-031-51497-5\4. URL https://doi.org/10.1007/978-3-031-51497-5_4.  
+Clément Bonnet, Daniel Luo, Donal Byrne, Shikha Surana, Sasha Abramowitz, Paul Duckworth, Vincent Coyette, Laurence I. Midgley, Elshadai Tegegn, Tristan Kalloniatis, Omayma Mahjoub, Matthew Macfarlane, Andries P. Smit, Nathan Grinsztajn, Raphael Boige, Cemlyn N. Waters, Mohamed A. Mimouni, Ulrich A. Mbou Sob, Ruan de Kock, Siddarth Singh, Daniel Furelos-Blanco, Victor Le, Arnu Pretorius, and Alexandre Laterre. Jumanji: a diverse suite of scalable reinforcement learning environments in jax, 2024. URL https://arxiv.org/abs/2306.09884.  
+James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, George Necula, Adam Paszke, Jake VanderPlas, Skye Wanderman-Milne, and Qiao Zhang. JAX: composable transformations of Python+NumPy programs, 2018. URL http://github.com/google/jax.  
+Eli Bronstein, Mark Palatucci, Dominik Notz, Brandyn White, Alex Kuefler, Yiren Lu, Supratik Paul, Payam Nikdel, Paul Mougin, Hongge Chen, Justin Fu, Austin Abrams, Punit Shah, Evan Racah, Benjamin Frenkel, Shimon Whiteson, and Dragomir Anguelov. Hierarchical model-based imitation learning for planning in autonomous driving. In IEEE/RSJ International Conference on Intelligent Robots and Systems, IROS 2022, Kyoto, Japan, October 23-27, 2022, pp. 8652-8659. IEEE, 2022. doi: 10.1109/IROS47612.2022.9981695. URL https://doi.org/10.1109/IROS47612.2022.9981695.
+
+Holger Caesar, Varun Bankiti, Alex H Lang, Sourabh Vora, Venice Erin Liong, Qiang Xu, Anush Krishnan, Yu Pan, Giancarlo Baldan, and Oscar Beijbom. nuscenes: A multimodal dataset for autonomous driving. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 11621-11631, 2020.  
+Holger Caesar, Juraj Kabzan, Kok Seang Tan, Whye Kit Fong, Eric Wolff, Alex Lang, Luke Fletcher, Oscar Beijbom, and Sammy Omari. nuplan: A closed-loop ml-based planning benchmark for autonomous vehicles. arXiv preprint arXiv:2106.11810, 2021.  
+Panpan Cai, Yiyuan Lee, Yuanfu Luo, and David Hsu. Summit: A simulator for urban driving in massive mixed traffic. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pp. 4023-4029. IEEE, 2020.  
+Jordi Casas, Jaime L Ferrer, David Garcia, Josep Perarnau, and Alex Torday. Traffic simulation with aimsun. Fundamentals of traffic simulation, pp. 173-232, 2010.  
+Brandon Cui, Andrei Lupu, Samuel Sokota, Hengyuan Hu, David J. Wu, and Jakob Nicolaus Føerster. Adversarial diversity in hanabi. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023, 2023. URL https://openreview.net/pdf?id=uLE3WF3-H_5.  
+Alexey Dosovitskiy, German Ros, Felipe Codevilla, Antonio Lopez, and Vladlen Koltun. Carla: An open urban driving simulator. In Conference on robot learning, pp. 1-16. PMLR, 2017.  
+Scott Ettinger, Shuyang Cheng, Benjamin Caine, Chenxi Liu, Hang Zhao, Sabeek Pradhan, Yuning Chai, Ben Sapp, Charles R. Qi, Yin Zhou, Zoey Yang, Aurelien Chouard, Pei Sun, Jiquan Ngiam, Vijay Vasudevan, Alexander McCauley, Jonathon Shlens, and Dragomir Anguelov. Large scale interactive motion forecasting for autonomous driving: The waymo open motion dataset. In 2021 IEEE/CVF International Conference on Computer Vision, ICCV 2021, Montreal, QC, Canada, October 10-17, 2021, pp. 9690-9699. IEEE, 2021. doi: 10.1109/ICCV48922.2021.00957. URL https://doi.org/10.1109/ICCV48922.2021.00957.  
+Cole Gulino, Justin Fu, Wenjie Luo, George Tucker, Eli Bronstein, Yiren Lu, Jean Harb, Xinlei Pan, Yan Wang, Xiangyu Chen, et al. Waymax: An accelerated, data-driven simulator for large-scale autonomous driving research. Advances in Neural Information Processing Systems, 36, 2024.  
+Charles R. Harris, K. Jarrod Millman, Stefan van der Walt, Ralf Gommers, Pauli Virtanen, David Cournapeau, Eric Wieser, Julian Taylor, Sebastian Berg, Nathaniel J. Smith, Robert Kern, Matti Picus, Stephan Hoyer, Marten H. van Kerkwijk, Matthew Brett, Allan Haldane, Jaime Fernandez del Río, Mark Wiebe, Pearu Peterson, Pierre Gérard-Marchant, Kevin Sheppard, Tyler Reddy, Warren Weckesser, Hameer Abbasi, Christoph Gohlke, and Travis E. Oliphant. Array programming with numpy. Nat., 585:357-362, 2020. doi: 10.1038/S41586-020-2649-2. URL https://doi.org/10.1038/s41586-020-2649-2.  
+Ashley Hill, Antonin Raffin, Maximilian Ernestus, Adam Gleave, Anssi Kanervisto, Rene Traore, Prafulla Dhariwal, Christopher Hesse, Oleg Klimov, Alex Nichol, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, and Yuhuai Wu. Stable baselines. https://github.com/hill-a/stable-baselines, 2018.  
+Max Jaderberg, Wojciech M. Czarnecki, Iain Dunning, Luke Marris, Guy Lever, Antonio Garcia Castañeda, Charles Beattie, Neil C. Rabinowitz, Ari S. Morcos, Avraham Ruderman, Nicolas Sonnerat, Tim Green, Louise Deason, Joel Z. Leibo, David Silver, Demis Hassabis, Koray Kavukcuoglu, and Thore Graepel. Human-level performance in first-person multiplayer games with population-based deep reinforcement learning. CoRR, abs/1807.01281, 2018. URL http://arxiv.org/abs/1807.01281.  
+Wenzel Jakob. nanobind: tiny and efficient c++/python bindings, 2022. https://github.com/wjakob/nanobind.  
+Arne Kesting, Martin Treiber, and Dirk Helbing. General lane-changing model mobil for car-following models. Transportation Research Record, 1999(1):86-94, 2007.
+
+Parth Kothari, Christian Perone, Luca Bergamini, Alexandre Alahi, and Peter Ondruska. *Drivergym: Democratising reinforcement learning for autonomous driving*. arXiv preprint arXiv:2111.06889, 2021.  
+Karsten Kreutz and Julian Eggert. Analysis of the generalized intelligent driver model (gidm) for uncontrolled intersections. In 2021 IEEE International Intelligent Transportation Systems Conference (ITSC), pp. 3223-3230. IEEE, 2021.  
+Mathias Lechner, Tim Seyde, Tsun-Hsuan Johnson Wang, Wei Xiao, Ramin Hasani, Joshua Rountree, Daniela Rus, et al. Gigastep-one billion steps per second multi-agent reinforcement learning. Advances in Neural Information Processing Systems, 36, 2024.  
+Edouard Leurent et al. An environment for autonomous driving decision-making, 2018.  
+Quanyi Li, Zhenghao Peng, Lan Feng, Qihang Zhang, Zhenghai Xue, and Bolei Zhou. Metadrive: Composing diverse driving scenarios for generalizable reinforcement learning. IEEE transactions on pattern analysis and machine intelligence, 45(3):3461-3475, 2022.  
+Pablo Alvarez Lopez, Michael Behrisch, Laura Bieker-Walz, Jakob Erdmann, Yun-Pang Flotteröd, Robert Hilbrich, Leonhard Lücken, Johannes Rummel, Peter Wagner, and Evamarie Wießner. Microscopic traffic simulation using sumo. In The 21st IEEE International Conference on Intelligent Transportation Systems. IEEE, 2018. URL https://elib.dlr.de/124092/.  
+Yiren Lu, Justin Fu, George Tucker, Xinlei Pan, Eli Bronstein, Rebecca Roelofs, Benjamin Sapp, Brandyn White, Aleksandra Faust, Shimon Whiteson, et al. Imitation is not enough: Robustifying imitation with reinforcement learning for challenging driving scenarios. In 2023 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 7553-7560. IEEE, 2023.  
+Viktor Makoviychuk, Lukasz Wawrzyniak, Yunrong Guo, Michelle Lu, Kier Storey, Miles Macklin, David Hoeller, Nikita Rudin, Arthur Allshire, Ankur Handa, et al. Isaac gym: High performancegpu-based physics simulation for robot learning. arXiv preprint arXiv:2108.10470, 2021.  
+Mark Martinez, Chawin Sitawarin, Kevin Finch, Lennart Meincke, Alex Yablonski, and Alain Kornhauser. Beyond grand theft auto v for training, testing and enhancing deep learning in self driving cars. arXiv preprint arXiv:1712.01397, 2017.  
+Matthias Müller, Vincent Casser, Jean Lahoud, Neil Smith, and Bernard Ghanem. Sim4cv: A photorealistic simulator for computer vision applications. International Journal of Computer Vision, 126:902-919, 2018.  
+Praveen Palanisamy. Multi-agent connected autonomous driving using deep reinforcement learning. In 2020 International Joint Conference on Neural Networks (IJCNN), pp. 1-7. IEEE, 2020.  
+Jacopo Panerati, Hehui Zheng, SiQi Zhou, James Xu, Amanda Prorok, and Angela P Schoellig. Learning to fly—a gym environment with pybullet physics for reinforcement learning of multi-agent quadcopter control. In 2021 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 7512-7519. IEEE, 2021.  
+Julien Pérolat, Bart De Vylder, Daniel Hennes, Eugene Tarassov, Florian Strub, Vincent de Boer, Paul Muller, Jerome T. Connor, Neil Burch, Thomas W. Anthony, Stephen McAleer, Romuald Elie, Sarah H. Cen, Zhe Wang, Audrunas Gruslys, Aleksandra Malysheva, Mina Khan, Sherjil Ozair, Finbarr Timbers, Toby Pohlen, Tom Eccles, Mark Rowland, Marc Lanctot, Jean-Baptiste Lespiau, Bilal Piot, Shayegan Omidshafiei, Edward Lockhart, Laurent Sifre, Nathalie Beauguerlange, Rémi Munos, David Silver, Satinder Singh, Demis Hassabis, and Karl Tuyls. Mastering the game of Stratego with model-free multiagent reinforcement learning. CoRR, abs/2206.15378, 2022. doi: 10.48550/ARXIV.2206.15378. URL https://doi.org/10.48550/arXiv.2206.15378.  
+Rajesh Rajamani. Vehicle dynamics and control. Springer Science & Business Media, 2011.  
+Alexander Rutherford, Benjamin Ellis, Matteo Gallici, Jonathan Cook, Andrei Lupu, Gardar Ingvarsson, Timon Willi, Akbir Khan, Christian Schroeder de Witt, Alexandra Souly, et al. Jaxmarl: Multi-agent rl environments in jax. arXiv preprint arXiv:2311.10090, 2023.
+
+Anirban Santara, Sohan Rudra, Sree Aditya Buridi, Meha Kaushik, Abhishek Naik, Bharat Kaul, and Balaraman Ravindran. Madras: Multi agent driving simulator. Journal of Artificial Intelligence Research, 70:1517-1555, 2021.  
+Adam Scibior, Vasileios Lioutas, Daniele Reda, Peyman Bateni, and Frank Wood. Imagining the road ahead: Multi-agent trajectory prediction via differentiable simulation. In 2021 IEEE International Intelligent Transportation Systems Conference (ITSC), pp. 720-725. IEEE, 2021.  
+Brennan Shacklett, Luc Guy Rosenzweig, Zhiqiang Xie, Bidipta Sarkar, Andrew Szot, Erik Wijmans, Vladlen Koltun, Dhruv Batra, and Kayvon Fatahalian. An extensible, data-oriented architecture for high-performance, many-world simulation. ACM Transactions on Graphics (TOG), 42 (4):1-13, 2023.  
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, Yutian Chen, Timothy P. Lillicrap, Fan Hui, Laurent Sifre, George van den Driessche, Thore Graepel, and Demis Hassabis. Mastering the game of go without human knowledge. Nat., 550(7676):354-359, 2017. doi: 10.1038/NATURE24270. URL https://doi.org/10.1038/nature24270.  
+Joseph Suarez. Pufferlib: Making reinforcement learning libraries and environments play nice. arXiv preprint arXiv:2406.12905, 2024.  
+Qiao Sun, Xin Huang, Brian C Williams, and Hang Zhao. Intersim: Interactive traffic simulation via explicit relation modeling. In 2022 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 11416-11423. IEEE, 2022.  
+Mark Towers, Ariel Kwiatkowski, Jordan Terry, John U Balis, Gianluca De Cola, Tristan Deleu, Manuel Goulão, Andreas Kallinteris, Markus Kimmel, Arjun KG, et al. Gymnasium: A standard interface for reinforcement learning environments. arXiv preprint arXiv:2407.17032, 2024.  
+Martin Treiber, Ansgar Hennecke, and Dirk Helbing. Congested traffic states in empirical observations and microscopic simulations. Physical review E, 62(2):1805, 2000.  
+Eugene Vinitsky, Nathan Lichtlé, Xiaomeng Yang, Brandon Amos, and Jakob Foerster. Nocturne: a scalable driving benchmark for bringing multi-agent learning one step closer to the real world. Advances in Neural Information Processing Systems, 35:3962-3974, 2022.  
+M. Visvalingam and J. D. Whyatt. Line generalisation by repeated elimination of points. The Cartographic Journal, 30:46-51, 1993. doi: 10.1179/000870493786962263.  
+Peter R. Wurman, Samuel Barrett, Kenta Kawamoto, James MacGlashan, Kaushik Subramanian, Thomas J. Walsh, Roberto Capobianco, Alisa Devlic, Franziska Eckert, Florian Fuchs, Leilani Gilpin, Piyush Khandelwal, Varun Kompella, HaoChih Lin, Patrick MacAlpine, Declan Oller, Takuma Seno, Craig Sherstan, Michael D. Thomure, Houmehr Aghabozorgi, Leon Barrett, Rory Douglas, Dion Whitehead, Peter Durr, Peter Stone, Michael Spranger, and Hiroaki Kitano. Outracing champion gran turismo drivers with deep reinforcement learning. Nat., 602(7896): 223-228, 2022. doi: 10.1038/S41586-021-04357-7. URL https://doi.org/10.1038/s41586-021-04357-7.  
+Bernhard Wymann, Eric Espié, Christophe Guionneau, Christos Dimitrakakis, Rémi Coulom, and Andrew Sumner. Torcs, the open racing car simulator. Software available at http://torcs.sourceforge.net, 4(6):2, 2000.  
+Danfei Xu, Yuxiao Chen, Boris Ivanovic, and Marco Pavone. Bits: Bi-level imitation for traffic simulation. In 2023 IEEE International Conference on Robotics and Automation (ICRA), pp. 2929-2936. IEEE, 2023.  
+Chao Yu, Akash Velu, Eugene Vinitsky, Jiaxuan Gao, Yu Wang, Alexandre Bayen, and Yi Wu. The surprising effectiveness of ppo in cooperative multi-agent games. Advances in Neural Information Processing Systems, 35:24611-24624, 2022.  
+Ming Zhou, Jun Luo, Julian Villella, Yaodong Yang, David Rusu, Jiayu Miao, Weinan Zhang, Montgomery Alban, Iman Fadakar, Zheng Chen, et al. Smarts: An open-source scalable multi-agentrl training school for autonomous driving. In Conference on Robot Learning, pp. 264-285. PMLR, 2021.
+
+# A REPRODUCIBILITY
+
+# A.1 EXTRA FIGURES
+
+![](images/8de2476b42b561ecf54ab5ac422879e6719c9ff6950af8784de920aecba9d389.jpg)  
+Figure 7: Visualization of different observation spaces available in GPUDrive. The top scene is an example scenario from the dataset, rendered from the ego-centric perspective of the red vehicle. Grey cars are parked cars while white cars are other controlled agents. From left to right: the Radius Filter returns all objects within 100 meters, the LIDAR observation with 3000 rays spread around 360 degrees, and a view cone consisting of 3000 rays emanating in a 120-degree view cone.
+
+# A.2 CODE REPRODUCIBILITY
+
+All code required to reproduce the paper is open-sourced at https://github.com/Emerge-Lab/gpudrive/tree/main under release number v0.4.0
+
+# A.3 COMPUTATIONAL RESOURCES
+
+All RL experiments in this paper were run on an NVIDIA RTX 4080 or A100. Total resources for the paper correspond to less than 2 GPU days.
+
+# B DYNAMICS MODEL
+
+Agents are driven by a kinematic bicycle model (Rajamani, 2011) which uses the center of gravity as reference point. The dynamics are as follows. Here  $(x_{t},y_{t})$  stands for the coordinate of the vehicle's position at time  $t$ ,  $\theta_t$  stands for the vehicle's heading at time  $t$ ,  $v_{t}$  stands for the vehicle's speed at time  $t$ ,  $a$  stands for the vehicle's acceleration and  $\delta$  stands for the vehicle's steering angle.  $L$  is the distance from the front axle to the rear axle (in this case, just the length of the car) and  $l_{r}$  is the distance from the center of gravity to the rear axle. Here we assume  $l_{r} = 0.5L$ .
+
+$$
+\dot {v} = a
+$$
+
+$$
+\bar {v} = \operatorname {c l i p} \left(v _ {t} + 0. 5 \dot {v} \Delta t, - v _ {\max }, v _ {\max }\right)
+$$
+
+$$
+\begin{array}{l} \beta = \tan^ {- 1} \left(\frac {l _ {r} \tan (\delta)}{L}\right) \\ = \tan^ {- 1} (0. 5 \tan (\delta)) \\ \end{array}
+$$
+
+$$
+\dot {x} = \bar {v} \cos (\theta + \beta)
+$$
+
+$$
+\dot {y} = \bar {v} \sin (\theta + \beta)
+$$
+
+$$
+\dot {\theta} = \frac {\bar {v} \cos (\beta) \tan (\delta)}{L}
+$$
+
+We then step the dynamics as follows:
+
+$$
+x _ {t + 1} = x _ {t} + \dot {x} \Delta t
+$$
+
+$$
+y _ {t + 1} = y _ {t} + \dot {y} \Delta t
+$$
+
+$$
+\theta_ {t + 1} = \theta_ {t} + \dot {\theta} \Delta t
+$$
+
+$$
+v _ {t + 1} = \operatorname {c l i p} \left(v _ {t} + \dot {v} \Delta t, - v _ {\max }, v _ {\max }\right)
+$$
+
+# C LICENSE DETAILS AND ACCESSIBILITY
+
+Our code is released under an MIT License. The Waymo Motion dataset is released under a Apache License 2.0. The code is available at https://github.com/Emerge-Lab/gpudrive.
+
+# D TRAINING DETAILS
+
+# D.1 END-TO-END PERFORMANCE
+
+The Table below depicts the hyperparameters used to produce the results in Section 4.2.
+
+Table 2: Experiment hyperparameters used for comparing the training runs between Nocturne and GPUDrive in Figure 5. The environment configurations are aligned as closely as possible, using the same observations and field of view. The dataset includes the same 10 scenarios. It's important to note that the length of the GPUDrive rollout is approximately equal to the number of worlds multiplied by the rollout length and then multiplied by the number of controllable agents. We have set this value to be  $92 \times 50 \approx 4600$  to approximately match the rollout length in Nocturne.
+
+<table><tr><td>Parameter</td><td>IPPO GPUDrive</td><td>IPPO Nocturne</td></tr><tr><td>γ</td><td>0.99</td><td>0.99</td></tr><tr><td>λGAE</td><td>0.95</td><td>0.95</td></tr><tr><td>PPO rollout length</td><td>92</td><td>4096</td></tr><tr><td>PPO epochs</td><td>5</td><td>5</td></tr><tr><td>PPO mini-batch size</td><td>2048</td><td>2048</td></tr><tr><td>PPO clip range</td><td>0.2</td><td>0.2</td></tr><tr><td>Adam learning rate</td><td>3e-4</td><td>3e-4</td></tr><tr><td>Adam ε</td><td>1e-5</td><td>1e-5</td></tr><tr><td>normalize advantage</td><td>yes</td><td>yes</td></tr><tr><td>entropy bonus coefficient</td><td>0.001</td><td>0.001</td></tr><tr><td>value loss coefficient</td><td>0.5</td><td>0.5</td></tr><tr><td>seeds</td><td>42, 12, 67</td><td>42, 12, 67</td></tr><tr><td>number of worlds</td><td>50</td><td>1</td></tr></table>
+
+![](images/daf679262b1a18383de76da34135a28a389385cb8b36c6f5a57138c584bb6b58.jpg)  
+Figure 8: Key performance metrics as a function of training time grouped by the number of unique scenes in a batch reported in Figure 6. Left: The aggregate percentage of agents that achieved their goal. Center: The aggregate percentage of agents that collided with another vehicle. Right: The aggregate number of vehicles that crossed a road edge.
+
+![](images/cbb9dd83978410750257819c4c025682c06e41a8c15545c579c71b8dc577a818.jpg)
+
+![](images/3f1a91e546aa73f0da22d08d7dba6b8de1be7288197732ef286246a99e23c3d5.jpg)

ICLR/2025/GPUDrive_ Data-driven, multi-agent driving simulation at 1 million FPS/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb7d0685dec5a3aae8351e400acd98bc85d0038ae3b74f1228aa3b6287f01c09
+size 505828

ICLR/2025/GPUDrive_ Data-driven, multi-agent driving simulation at 1 million FPS/layout.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e23e788008777985d74094d65748d591ea595f90262a10cb2f5cdcd0617e9726
+size 392713

ICLR/2025/GPromptShield_ Elevating Resilience in Graph Prompt Tuning Against Adversarial Attacks/9f9147c8-e488-4129-9de2-52339d5b82ba_content_list.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10950d30a0321995131d46e545d03ce11e531c233085153c02f44745dda91fe7
+size 138878

ICLR/2025/GPromptShield_ Elevating Resilience in Graph Prompt Tuning Against Adversarial Attacks/9f9147c8-e488-4129-9de2-52339d5b82ba_model.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e9b9ff48c0d952d9a8fc5f1e1015c3926fc2b69ebd0f2b246380044b25cce5a
+size 164486