Add files using upload-large-folder tool

parse/dev/0U0C2pXfTZl/0U0C2pXfTZl.md

@@ -0,0 +1,467 @@
+# SLASH: EMBRACING PROBABILISTIC CIRCUITS INTO NEURAL ANSWER SET PROGRAMMING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The goal of combining the robustness of neural networks and the expressivity of symbolic methods has rekindled the interest in Neuro-Symbolic AI. Recent advancements in Neuro-Symbolic AI often consider specifically-tailored architectures consisting of disjoint neural and symbolic components, and thus do not exhibit desired gains that can be achieved by integrating them into a unifying framework. We introduce SLASH – a novel deep probabilistic programming language (DPPL). At its core, SLASH consists of Neural-Probabilistic Predicates (NPPs) and logical programs which are united via answer set programming. The probability estimates resulting from NPPs act as the binding element between the logical program and raw input data, thereby allowing SLASH to answer task-dependent logical queries. This allows SLASH to elegantly integrate the symbolic and neural components in a unified framework. We evaluate SLASH on the benchmark data of MNIST addition as well as novel tasks for DPPLs such as missing data prediction and set prediction with state-of-the-art performance, thereby showing the effectiveness and generality of our method.
+
+# 1 INTRODUCTION
+
+In recent years, Neuro-Symbolic AI approaches to learning (Hudson & Manning, 2019; d’Avila Garcez et al., 2019; Jiang & Ahn, 2020; d’Avila Garcez & Lamb, 2020), which integrates low-level perception with high-level reasoning by combining data-driven neural modules with logic-based symbolic modules, has gained traction. This combination of sub-symbolic and symbolic systems has been shown to have several advantages for various tasks such as visual question answering and reasoning (Yi et al., 2018), concept learning (Mao et al., 2019) and improved properties for explainable and revisable models (Ciravegna et al., 2020; Stammer et al., 2021).
+
+Rather than designing specifically tailored Neuro-Symbolic architectures, where often the neural and symbolic modules are disjoint and trained independently (Yi et al., 2018; Mao et al., 2019; Stammer et al., 2021), deep probabilistic programming languages (DPPLs) provide an exciting alternative (Bingham et al., 2019; Tran et al., 2017; Manhaeve et al., 2018; Yang et al., 2020). Specifically, DPPLs integrate neural and symbolic modules via a unifying programming framework with probability estimates acting as the “glue” between separate modules allowing for reasoning over noisy, uncertain data and, importantly, joint training of the modules. Additionally, prior knowledge and biases in the form of logical rules can easily be added with DPPLs, rather than creating implicit architectural biases, thereby integrating neural networks into downstream logical reasoning tasks.
+
+Object-centric deep learning has recently brought forth several exciting avenues of research by introducing inductive biases to neural networks to extract objects from visual scenes in an unsupervised manner (Zhang et al., 2019; Burgess et al., 2019; Engelcke et al., 2020; Greff et al., 2019; Lin et al., 2020; Locatello et al., 2020; Jiang & Ahn, 2020). We refer to Greff et al. (2020) for a detailed overview. A motivation for this specific line of investigation, which notably has been around for a longer period of time (Fodor & Pylyshyn, 1988; Marcus, 2019), is that objects occur as natural building blocks in human perception and possess advantageous properties for many cognitive tasks, such as scene understanding and reasoning. With a DPPL, these advancements can be improved by integrating the previously mentioned components into the DPPL’s programming framework and further adding constraints about objects and their properties in form of logical statements e.g. about color singularity, rather than implicitly enforcing this via one hot encodings.
+
+![](images/fbc474f94d8a2574e5362c4b2e3c3d61cc7e2bb6baf0aac66d0dc2840ab2de17.jpg)  
+Figure 1: SLASH Attention illustrated for a visual reasoning task. SLASH with Neural-Probabilistic Predicates consisting of a slot attention encoder and Probabilistic Circuits (PCs) realised via EiNets. The slot encoder is shared over all NPPs. Each triangle in the figure represents a single EiNet that gives us a joint distribution at the root node. Thus, each PC learns the joint distribution over slot encodings, $z ^ { i }$ , and object attributes, $C$ , of a specific category, e.g. color attributes. Via targeted queries to the NPPs, one can obtain task-related probabilities, e.g. conditional probabilities for the task of set prediction. Given the probability estimates from the NPP(s) and a SLASH program, containing a set of facts and logical statements about the world, the probability of the truth value of a task-related query are computed via answer set programming. The entire system, including the neural and probabilistic modules, are finally trained end-to-end via a single loss function.
+
+We propose SLASH – a novel DPPL that, similar to the punctuation symbol, can be used to efficiently combine several paradigms into one. Specifically, SLASH represents a scalable programming language that seamlessly integrates probabilistic logical programming with neural representations and tractable probabilistic estimations. Fig. 1 shows an example instantiation of SLASH, termed SLASH Attention, for object-centric set prediction. SLASH consists of several key building blocks. Firstly, it makes use of Neural-Probabilistic Predicates (NPPs) for probability estimation. NPPs consist of neural and/or probabilistic circuit (PC) modules and act as a unifying term, encompassing the neural predicates of DeepProbLog and NeurASP, as well as purely probabilistic predicates. In this work, we introduce a much more powerful “flavor” of NPPs that consist jointly of neural and PC modules, taking advantage of the power of neural computations together with true density estimation of PCs. Depending on the underlying task one can thus ask a range of queries to the NPP, e.g. sample an unknown, desired variable, but also query for conditional class probabilities. Example NPPs consisting of a slot attention encoder and several PCs are depicted in Fig. 1 for the task of set prediction. The slot encoder is shared across all NPPs, whereas the PC of each NPP models a separate category of attributes. In this way, each NPP models the joint distribution over slot encodings and object attribute values, such as the color of an object. By querying the NPP, one can obtain task-related probability estimations, such as the conditional attribute probability.
+
+The second component of SLASH is the logical program, which consists of a set of facts and logical statements defining the state of the world of the underlying task. For example, one can define the rules for when an object possesses a specific set of attributes (cf. Fig. 1). Thirdly, an ASP module is used to combine the first two components. Given a logical query about the input data, the logical program and the probability estimates obtained from the NPP(s), the ASP module produces a probability estimate about the truth value of the query, stating, e.g., how likely it is for a specific object in an image to be a large, dark red triangle. In contrast to query evaluation in Prolog (Colmerauer & Roussel, 1993; Clocksin & Mellish, 1981) which may lead to an infinite loop, many modern answer set solvers use Conflict-Driven-Clause-Learning (CDPL) which, in principle, always terminates.
+
+Training in SLASH is performed efficiently in a batch-wise and end-to-end fashion, by integrating the parameters of all modules, neural and probabilistic, into a single loss term. SLASH thus allows a simple, fast and effective integration of sub-symbolic and symbolic computations. In our experiments, we investigate the advantages of SLASH in comparison to SOTA DPPLs on the benchmark task of MNIST-Addition (Manhaeve et al., 2018). We hereby show SLASH’s increased scalability regarding computation time, as well as SLASH’s ability to handle incomplete data via true probabilistic density modelling. Next, we show that SLASH Attention provides superior results for set prediction in terms of accuracy and generalization abilities compared to a baseline slot attention encoder. With our experiments, we thus show that SLASH is a realization of “one system – two approaches” (Bengio, 2019), that can successfully be used for performing various tasks and on a variety of data types.
+
+We make the following contributions: (1) We introduce neural-probabilistic predicates, efficiently integrating answer set programming with probabilistic inference via our novel DPPL, SLASH. (2) We successfully train neural, probabilistic and logic modules within SLASH for complex data structures end-to-end via a simple, single loss term. (3) We show that SLASH provides various advantages across a variety of tasks and data sets compared to state-of-the-art DPPLs and neural models.
+
+# 2 NEURO-SYMBOLIC LOGIC PROGRAMMING
+
+Neuro-Symbolic AI can be divided into two lines of research, depending on the starting point. Both, however, have the same final goal: to combine low-level perception with logical constraints and reasoning.
+
+A key motivation of Neuro-Symbolic AI (d’Avila Garcez et al., 2009; Mao et al., 2019; Hudson & Manning, 2019; d’Avila Garcez et al., 2019; Jiang & Ahn, 2020; d’Avila Garcez & Lamb, 2020) is to combine the advantages of symbolic and neural representations into a joint system. This is often done in a hybrid approach where a neural network acts as a perception module that interfaces with a symbolic reasoning system, e.g. (Mao et al., 2019; Yi et al., 2018). The goal of such an approach is to mitigate the issues of one type of representation by the other, e.g. using the power of symbolic reasoning systems to handle the generalizability issues of neural networks and on the other hand handle the difficulty of noisy data for symbolic systems via neural networks. Recent work has also shown the advantage of Neuro-Symbolic approaches for explaining and revising incorrect decisions (Ciravegna et al., 2020; Stammer et al., 2021). Many of these previous works, however, train the sub-symbolic and symbolic modules separately.
+
+Deep Probabilistic Programming Languages (DPPLs) are programming languages that combine deep neural networks with probabilistic models and allow a user to express a probabilistic model via a logical program. Similar to Neuro-Symbolic architectures, DPPLs thereby unite the advantages of different paradigms. DPPLs are related to earlier works such as Markov Logic Networks (MLNs) (Richardson & Domingos, 2006). Thereby, the binding link is the Weighted Model Counting (WMC) introduced in $\mathrm { L P ^ { M L N } }$ (Lee & Wang, 2016). Several DPPLs have been proposed by now, among which are Pyro (Bingham et al., 2019), Edward (Tran et al., 2017), DeepProbLog (Manhaeve et al., 2018), and NeurASP (Yang et al., 2020).
+
+To resolve the scalability issues of DeepProbLog, which use Sentential Decision Diagrams (SDDs) (Darwiche, 2011) as the underlying data structure to evaluate queries, NeurASP (Yang et al., 2020), offers a solution by utilizing Answer Set Programming (ASP) (Dimopoulos et al., 1997; Soininen & Niemelä, 1999; Marek & Truszczynski, 1999; Calimeri et al., 2020). In this way, NeurASP changes the paradigm from query evaluation to model generation, i.e. instead of constructing an SDD or similar knowledge representation system, NeurASP generates a set of all possible solutions (one model per solution) and estimates the probability for the truth value of each of these solutions. Of those DPPLs that handle learning in a relational, probabilistic setting and in an end-to-end fashion, all of these are limited to estimating only conditional class probabilities.
+
+# 3 THE SLASH FRAMEWORK
+
+In this section, we introduce our novel DPPL, SLASH. Before we dive into the details of this, it is necessary to first introduce Neural-Probabilistic Predicates, for which we require an understanding of Probabilistic Circuits. Finally, we will present the learning paradigm of SLASH.
+
+The term probabilistic circuit (PC) (Choi et al., 2020) represents a unifying framework that encompasses all computational graphs which encode probability distributions and guarantee tractable probabilistic modelling. These include Sum-Product Networks (SPNs) (Poon & Domingos, 2011) which are deep mixture models represented via a rooted directed acyclic graphs with a recursively defined structure.
+
+![](images/fe12c632ab68913a19fb5c0639cac79765cabf16e331224edc0cd2c84bb8eebe.jpg)
+
+(a) NPPs come in various flavors depending on the data and underlying task.
+
+![](images/deaa2f06b12c44d64f5ac8f226a3fdb61c0d8bba50b15128cddc5ccafbad3205.jpg)  
+(b) Minimal SLASH program and query for set prediction.   
+Figure 2: (a) Depending on the data set and underlying task, SLASH requires a suitable NeuralProbabilistic Predicate (NPP) that computes query-dependent probability estimates. An NPP can be composed of neural and probabilistic modules, or (depicted via slash symbol) only one of these two. (b) A minimal SLASH program and query for the set prediction task, here only showing the NPP that models the color category per object. For the full program, we refer to the Appendix.
+
+# 3.1 NEURAL-PROBABILISTIC PREDICATES
+
+Previous DPPLs, DeepProbLog (Manhaeve et al., 2018) and NeurASP (Yang et al., 2020), introduced the Neural Predicate as an annotated-disjunction or as a propositional atom, respectively, to acquire conditional class probabilities, $P ( C | X )$ , via the softmax function at the output of an arbitrary DNN. As mentioned in the introduction, this approach has certain limitations concerning inference capabilities. To resolve this issue, we introduce Neural-Probabilisitic Predicates (NPPs).
+
+Formally, we denote with
+
+$$
+n p p \left( h ( x ) , [ v _ { 1 } , . . . , v _ { n } ] \right)
+$$
+
+a Neural-Probabilistic Predicate $h$ . Thereby, (i) npp is a reserved word to label an NPP, (ii) $h$ a symbolic name of either a PC, NN or a joint of a PC and NN (cf. Fig. 2a), e.g., color_attr is the name of an NPP of Fig. 2b. Additionally, (iii) $x$ denotes a “term” and (iv) $v _ { 1 } , \ldots , v _ { n }$ are placeholders for each of the $n$ possible outcomes of $h$ . For example, the placeholders for color_attr are the color attributes of an object (Red, Blue, Green, etc.).
+
+An NPP abbreviates an arithmetic literal of the form $c = v$ with $c \in \{ h ( x ) \}$ and $v \in \{ v _ { 1 } , \ldots , v _ { n } \}$ . Furthermore, we denote with $\Pi ^ { n p p }$ a set of NPPs of the form stated in (Eq. 1) and $r ^ { n p p }$ the set of all rules $c = v$ of one NPP, which denotes the possible outcomes, obtained from an NPP in $\Pi ^ { n p p }$ , e.g. $r ^ { c o l o r \_ a t t r } = \{ c = R e d , c = B l u e , c = G r \bar { e } e n , . . . \}$ for the example depicted in Fig. 2b.
+
+Rules of the form $n p p ( h ( x ) , [ v _ { 1 } , \ldots , v _ { n } ] )  B o d y$ are used as an abbreviation for application to multiple entities, e.g. multiple slots for the task of set prediction (cf. Fig. 2b). Hereby, Body of the rule is identified by $\top$ (tautology, true) or $\perp$ (contradiction, false) during grounding. Rules of the form $H e a d \gets B o d y$ with $r ^ { n p p }$ appearing in Head are prohibited for $\Pi ^ { n p p }$ .
+
+In this work, we largely make use of NPPs that contain probabilistic circuits (specifically SPNs) which allow for tractable density estimation and modelling of joint probabilities. In this way, it is possible to answer a much richer set of probabilistic queries, i.e. $P ( X , C )$ , $P ( X | C )$ and $P ( \bar { C } | X )$ .
+
+In addition to this, we introduce the arguably more interesting type of NPP that combines a neural module with a PC. Hereby, the neural module learns to map the raw input data into an optimal latent representation, e.g. object-based slot representations. The PC, in turn, learns to model the joint distribution of these latent variables and produces the final probability estimates. This type of NPP nicely combines the representational power of neural networks with the advantages of PCs in probability estimation and query flexibility.
+
+For making the different probabilistic queries distinguishable in a SLASH program, we introduce the following notation. We denote a given variable with $^ +$ and the query variable with −. E.g., within the running example of set prediction $\cdot e f .$ Fig. 1 and 2b), with the query color_attr $\cdot ( + X , - C )$ one is asking for $P ( C | X )$ . Similarly, with color_attr $( - X , + C )$ one is asking for $P ( X | C )$ and, finally, with color_attr $( - X , - C )$ for $P ( X , C )$ .
+
+To summarize, an NPP can consist of neural and/or probabilistic modules and produces querydependent probability estimates. Due to the flexibility of its definition, the term NPP contains the predicates of previous works (Manhaeve et al., 2018; Yang et al., 2020), but also more interesting predicates discussed above. The specific “flavor” of an NPP should be chosen depending on what type of probability estimation is required (cf. Fig 2a). Lastly, NPPs have the unified loss function of the negative log-likelihood:
+
+$$
+L _ { N P P } : = - \log L H ( x , \hat { x } ) = \sum _ { i = 1 } ^ { n } L H ( x _ { i } , \hat { x } _ { i } ) = - \sum _ { i = 1 } ^ { n } x _ { i } \cdot \log ( P _ { \xi } ^ { ( X , C ) } ( x _ { i } ) ) = - \sum _ { i = 1 } ^ { n } \log ( P _ { \xi } ^ { ( X , C ) } )
+$$
+
+whereby we are assuming the data to be i.i.d., ground truth $x _ { i }$ to be the all-ones vector, $\xi$ to be the parameters of the NPP and $P _ { \xi } ^ { ( X , C ) }$ are the predictions ${ \hat { x } } _ { i }$ obtained from the PC encoded in the NPP.
+
+# 3.2 THE SLASH LANGUAGE AND SEMANTICS
+
+Fig. 1 presents an illustration of SLASH, exemplified for the task of set prediction, with all of its key components. Having introduced the NPPs previously, which produce probability estimates, we now continue in the pipeline on how to use these probability estimates for answering logical queries. We begin by formally defining a SLASH program.
+
+Definition 1. A SLASH program Π is the union of $\Pi ^ { a s p }$ , $\Pi ^ { n p p }$ . Therewith, $\Pi ^ { a s p }$ is the set of propositional rules (standard rules from ASP-Core-2 (Calimeri et al., 2020)), and $\Pi ^ { n p p }$ is a set of Neural-Probabilistic Predicates of the form stated in Eq. 1.
+
+Fig. 2b depicts a minimal SLASH program for the task of set prediction, exemplifying a set of propositional rules and neural predicates. Similar to NeurASP, SLASH requires ASP and as such adopts its syntax to most part. We therefore now address integrating our NPPs into an ASP compatible form to obtain the success probability for the logical query given all possible solutions. Thus, we define SLASH’s semantics. For SLASH to translate the program $\Pi$ to the ASP-solver’s compatible form, the rules (Eq. 1) will be rewritten to the set of rules:
+
+$$
+1 \{ h ( x ) = v _ { 1 } ; \ldots ; h ( x ) = v _ { n } \} 1
+$$
+
+The ASP-solver should understand this as “Pick exactly one rule from the set”. After the translation is done, we can ask an ASP-solver for the solutions for $\Pi$ . We denote a set of ASP constraints in the $\mathrm { f o r m } \gets B o d y$ , as queries $Q$ (annotation). and each of the solutions with respect to $Q$ as a potential solution, $I$ , (referred to as stable model in ASP). With $I | _ { r ^ { n _ { P } p } }$ we denote the projection of the $I$ onto $r ^ { n p p }$ , $N u m ( I | _ { r ^ { n p p } } , \Pi ) \ -$ – the number of the possible solutions of the program $\Pi$ agreeing with $I | _ { r ^ { n p p } }$ on $r ^ { n p p }$ . Because we aim to calculate the success probability of the query $Q$ , we formalize the probability of a potential solution $I$ beforehand.
+
+Definition 2. We specify the probability of the potential solution, $I$ , for the program $\Pi$ as the product of the probabilities of all atoms $c = v$ in $I | _ { r ^ { n p p } }$ divided by the number of potential solutions of $\Pi$ agreeing with I|rnpp on rnpp:
+
+$$
+P _ { \Pi } ( I ) = \left\{ \begin{array} { l l } { \frac { \prod _ { c = v \in { I \vert _ { r } n p p } } P _ { \Pi } ( c = v ) } { N u m ( I \vert _ { r ^ { n p p } } , \Pi ) } , } & { i f I i s a p o t e n t i a l s o l u t i o n o f \Pi , } \\ { 0 , } & { o t h e r w i s e . } \end{array} \right.
+$$
+
+Therefore, the probability of a query can be defined as follows.
+
+Definition 3. The probability of the query $Q$ given the set of possible solutions $I$ is defined as
+
+$$
+P _ { \Pi } ( Q ) : = \sum _ { I \ v { = } Q } P _ { \Pi } ( I ) .
+$$
+
+Thereby, $I \models Q$ reads as $^ { * } I$ satisfies $Q$ ”. The probability of the set of queries $\mathbf { Q } = \{ Q _ { 1 } , \ldots , Q _ { l } \}$ is defined as the product of the probability of each. I.e.
+
+$$
+P _ { \Pi } \left( \mathbf { Q } \right) : = \prod _ { Q _ { i } \in \mathbf { Q } } P _ { \Pi } ( Q _ { i } ) = \prod _ { Q _ { i } \in \mathbf { Q } } \sum _ { I \ v { | } = Q } P _ { \Pi } ( I ) .
+$$
+
+# 3.3 PARAMETER LEARNING IN SLASH
+
+We denote with $\Pi ( \pmb \theta )$ the SLASH program under consideration, thereby $\pmb \theta$ is the set of the parameters associated with Π. Further, making the i.i.d. assumption of the query set $\mathbf { Q }$ , we follow Manhaeve et al. (2018) and Skryagin et al. (2020), and use the learning from entailment setting. That is, the training examples are logical queries that are known to be true in the SLASH program $\Pi ( \theta )$ . The goal is now to learn the parameters $\pmb \theta$ of the SLASH program $\Pi ( \pmb \theta )$ so that the observed queries are most likely.
+
+To this end, we employ the negative log-likelihood and the cross-entropy of the observed queries $P _ { \mathrm { { I I } } ( \theta ) } ( Q _ { i } )$ and their predicted probability value $P ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i } } )$ , assuming the NPPs are fixed: $L _ { E N T } : =$
+
+$$
+- \log L H \left( \log ( P _ { \Pi ( \theta ) } ( \mathbf { Q } ) ) , P ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { \mathbf { Q } } ) \right) = - \sum _ { j = 1 } ^ { m } \log ( P _ { \Pi ( \theta ) } ( Q _ { i j } ) ) \cdot \log \left( P ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i j } } ) \right) .
+$$
+
+This loss function aims at maximizing the estimated success probability. We remark that the defined loss function is true regardless of the NPP’s form (NN with Softmax, PC or PC jointly with NN). The only difference will be the second term, i.e. $P ^ { ( C | X _ { \mathbf { Q } } ) } ( x _ { \mathbf { Q } } )$ or $P ^ { ( X _ { \mathbf { Q } } | C ) } ( x _ { \mathbf { Q } } ) )$ depending on the NPP and task. Furthermore, we assume that for the set of queries $\mathbf { Q }$ holds
+
+$$
+P _ { \Pi ( \pmb \theta ) } ( Q ) > 0 \quad \forall Q \in { \bf Q } .
+$$
+
+In accordance with the semantics, we seek to reward the right solutions $v = c$ and penalize wrong ones $v \neq c$ . Referring to the probabilities in $r ^ { n p p }$ (the set of logical rules denoting NPPs, see Def. 2) as $\mathbf { p }$ , one can compute their gradients w.r.t. $\pmb { \theta }$ via backpropagation as
+
+$$
+\sum _ { Q \in { \bf Q } } \frac { \partial \log \left( P _ { \Pi ( \pmb \theta ) } ( Q ) \right) } { \partial \pmb \theta } = \sum _ { Q \in { \bf Q } } \frac { \partial \log \left( P _ { \Pi ( \pmb \theta ) } ( Q ) \right) } { \partial { \bf p } } \times \frac { \partial { \bf p } } { \partial \pmb \theta } .
+$$
+
+The term $\textstyle { \frac { \partial \mathbf { p } } { \partial \theta } }$ can now be computed as usual via backward propagation through the NPPs (see Eq. 13 in the appendix for details). By letting $p$ to be the label of the probability of an atom $c = v$ in $r ^ { n p p }$ and denoting $P _ { \Pi ( \pmb { \theta } ) } ( c = v )$ , the term $\frac { \partial \log \left( P _ { \mathrm { I I } ( \pmb { \theta } ) } ( Q ) \right) } { \partial \mathbf { p } }$ follows from NeurASP (Yang et al., 2020) as
+
+$$
+\frac { \partial \log \left( P _ { \Pi ( \theta ) } ( Q ) \right) } { \partial \mathbf { p } } = \frac { I \underset { I : I \mid = Q } { \sum } \frac { P _ { \Pi ( \theta ) } ( I ) } { P _ { \Pi ( \theta ) } ( c = v ) } - \underset { I : I , v ^ { \prime } \mid = Q } { \sum } \frac { P _ { \Pi ( \theta ) } ( I ) } { P _ { \Pi ( \theta ) } ( c = v ^ { \prime } ) } } { \underset { I : I \mid = Q } { \sum } P _ { \Pi ( \theta ) } ( I ) } .
+$$
+
+This is sensible. For instance, if a query to be true is not likely to be entailed, the gradient is positive. Putting everything together, the final loss function is
+
+$$
+{ \cal L } _ { S L A S H } = { \cal L } _ { N P P } + { \cal L } _ { E N T }
+$$
+
+and we perform training using coordinate descent, i.e., we train the NPPs, the train the program with fixed NPPs, train the NPPs with the program fixed, and so on.
+
+In hindsight, rather than requiring a novel loss function for each individual task and data set, with SLASH, it is possible to simply incorporate the specific requirements into the logic program. The training loss, however, remains the same. We refer to the Appendix A for further details, including the derivation of the total loss gradient.
+
+# 4 EMPIRICAL RESULTS
+
+The advantage of SLASH lies in the efficient integration of neural, probabilistic and symbolic computations. To emphasize this, we conduct a variety of experimental evaluations.
+
+Experimental Details. We use two benchmark data sets, namely MNIST (LeCun et al., 1998b) for the task of MNIST-Addition and a variant of the ShapeWorld data set (Kuhnle & Copestake, 2017) for
+
+Table 1: MNIST Addition Results. Test accuracy corresponds to the percentage of correctly classified test images. (a) Test accuracies in percent for the MNIST Addition task with various DPPLs, including SLASH with an NPP that models the joint probabilities (SLASH (PC)) and one that models only conditional probabilities (SLASH (DNN)). (b) Test accuracies in percent for the MNIST Addition task with missing data, comparing DeepProbLog with SLASH (PC). The amount of missing data was varied between $50 \%$ and $9 7 \%$ of the pixels per image.
+
+(a) Baseline MNIST Addition.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Test Acc. (%)</td></tr><tr><td rowspan=1 colspan=1>DeepProbLog</td><td rowspan=1 colspan=1>98.49±0.18</td></tr><tr><td rowspan=1 colspan=1>NeurASP</td><td rowspan=1 colspan=1>98.21 ± 0.30</td></tr><tr><td rowspan=1 colspan=1>SLASH (PC)</td><td rowspan=1 colspan=1>95.39 ± 0.29</td></tr><tr><td rowspan=1 colspan=1>SLASH (DNN)</td><td rowspan=1 colspan=1>98.74±0.21</td></tr></table>
+
+(b) Missing data MNIST Addition.   
+
+<table><tr><td rowspan=1 colspan=2>DeepProbLog</td><td rowspan=1 colspan=1>SLASH (PC)</td></tr><tr><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>97.73 ± 0.12</td><td rowspan=1 colspan=1>97.67±0.12</td></tr><tr><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>76.07 ± 18.38</td><td rowspan=1 colspan=1>96.72士0.05</td></tr><tr><td rowspan=1 colspan=1>90%</td><td rowspan=1 colspan=1>69.15 ± 29.15</td><td rowspan=1 colspan=1>94.85士0.38</td></tr><tr><td rowspan=1 colspan=1>97%</td><td rowspan=1 colspan=1>32.46 ± 22.48</td><td rowspan=1 colspan=1>82.57士4.66</td></tr></table>
+
+object-centric set prediction. For all experiments we present the average and the standard deviation over five runs with different random seeds for parameter initialization.
+
+For ShapeWorld experiments, we generate a data set we refer to as ShapeWorld4. Images of ShapeWorld4 contain between one and four objects, with each object consisting of four attributes: a color (red, blue, green, gray, brown, magenta, cyan or yellow), a shade (bright, or dark), a shape (circle, triangle or square) and a size (small or big). Thus, each object can be created from 84 different combinations of attributes. Fig. 1 depicts an example image.
+
+We measure performance via classification accuracies in the MNIST-Addition task. In our ShapeWorld4 experiments, we present the average precision. We refer to appendix B for the SLASH programs and queries of each experiment, and appendix C for a detailed description of hyperparameters and further details.
+
+Evaluation 1: SLASH outperforms SOTA DPPLs in MNIST-Addition. The task of MNISTAddition (Manhaeve et al., 2018) is to predict the sum of two MNIST digits, presented only as raw images. During test time, however, a model should classify the images directly. Thus, although a model does not receive explicit information about the depicted digits, it must learn to identify digits via indirect feedback on the sum prediction.
+
+We compare the test accuracy after convergence between the three DPPLs: DeepProbLog (Manhaeve et al., 2018), NeurASP (Yang et al., 2020) and SLASH, using a probabilistic circuit (PC) or a deep neural network (DNN) as NPP. Notably, the DNN used in SLASH (DNN) is the LeNet5 model (LeCun et al., 1998a) of DeepProbLog and NeurASP. We note that when using the PC as NPP, we have also extracted conditional class probabilities $P ( C | X )$ , by marginalizing the class variables $C$ to acquire the normalization constant $P ( X )$ from the joint $P ( X , C )$ , and calculating $P ( X | C )$ .
+
+The results can be seen in Tab. 1a. We observe that training SLASH with a DNN NPP produces SOTA accuracies compared to DeepProbLog and NeurASP, confirming that SLASH’s batch-wise loss computation leads to improved performances. We further observe that the test accuracy of SLASH with a PC NPP is slightly below the other DPPLs, however we argue that this may be since a PC, in comparison to a DNN, is learning a true mixture density rather than just conditional probabilities. The advantages of doing so will be investigated in the next experiments. Note that, optimal architecture search for PCs, e.g. for computer vision, is an open research question.These evaluations show SLASH’s advantages on the benchmark MNIST-Addition task. Additional benefits will be made clear in the following experiments.
+
+Evaluation 2: Handling Missing Data with SLASH. SLASH offers the advantage of its flexibility to use various kinds of NPPs. Thus, in comparison to previous DPPLs, one can easily integrate NPPs into SLASH that perform joint probability estimation. For this evaluation, we consider the task of MNIST-Addition with missing data. We trained SLASH (PC) and DeepProbLog with the MNIST-Addition task with images in which a percentage of pixels per image has been removed. It is important to mention here that whereas DeepProbLog handles the missing data simply as background pixels, SLASH (PC) specifically models the missing data as uncertain data by marginalizing the denoted pixels at inference time. We use DeepProbLog here representative of DPPLs without true density estimation.
+
+(a) ShapeWorld4 and ShapeWorld4 CoGenT Test Avg.Precision   
+Figure 3: ShapeWorld4 Experiments. (a) Converged test average precision scores for the set prediction task with ShapeWorld4 (top) and ShapeWorld4 CoGenT (bottom). (b) Test average precision scores for set prediction with ShapeWorld4 over the training epochs. In these experiments we compared a baseline slot encoder versus SLASH Attention with slot attention and PC-based NPPs. For the CoGenT experiments, a model is trained on one training set and tested on two separate test conditions. The Condition A test set contains attribute compositions which were also seen during training. The Condition B test set contains attribute compositions which were not seen during training, e.g. yellow circles were not present in the training set, but present in Condition B test set.   
+
+<table><tr><td></td><td>Slot Att.</td><td>SLASH Att.</td></tr><tr><td>Test Set</td><td>ShapeWorld4 90.24 ± 0.93</td><td>95.58 ± 0.61</td></tr><tr><td></td><td>CoGenT</td><td></td></tr><tr><td>Test Cond. A</td><td>90.37 ± 2.19</td><td>96.85 ± 0.43</td></tr><tr><td>Test Cond.B</td><td>27.15 ± 2.36</td><td>40.58 ± 1.99</td></tr></table>
+
+![](images/0eaf19403876aa7fbb58219357ca9c041a53e7685ffb819aff2c0d5f28605742.jpg)  
+(b) Test Avg.Precision over Training Epochs
+
+The results can be seen in Tab. 1b for $5 0 \%$ , $8 0 \%$ , $9 0 \%$ and $9 7 \%$ missing pixels per image. We observe that at $5 0 \%$ , DeepProbLog and SLASH produce almost equal accuracies. With $8 0 \%$ percent missing pixels, there is a substantial difference in the ability of the two DPPLs to correctly classify images, with SLASH being very stable. By further increasing the percentage of missing pixels, this difference becomes even more substantial with SLASH still reaching a $8 2 \%$ test accuracy even when $9 7 \%$ of the pixels per image are missing, whereas DeepProbLog degrades to an average of $3 2 \%$ test accuracy. We further note that SLASH, in comparison to DeepProbLog, produces largely reduced standard deviations over runs.
+
+Thus, by utilizing the power of true density estimation SLASH, with an appropriate NPP, can produce more robust results in comparison to other DPPLs. Further, we refer to Appendix D, which contains results of additional experiments where training is performed with the full MNIST data set whereas only the test set entails different rates of missing pixels.
+
+Evaluation 3: Improved Concept Learning via SLASH. We show that SLASH can be very effective for the complex task of set prediction, which previous DPPLs have not tackled. We revert to the ShapeWorld4 data set for this setting. For set prediction, a model is trained to predict the discrete attributes of a set of objects in an image (cf. Fig. 1 for an example ShapeWorld4 image). The difficulty for the model lies therein that it must match an unordered set of corresponding attributes (with varying number of entities over samples) with its internal representations of the image.
+
+The slot attention module introduced by Locatello et al. (2020) allows for an attractive object-centric approach to this task. Specifically, this module represents a pluggable, differentiable module that can be easily added to any architecture and, through a competitive softmax-based attention mechanism, can enforce the binding of specific parts of a latent representation into permutation-invariant, taskspecific vectors, called slots.
+
+In our experiments, we wish to show that by adding logical constraints to the training setting, one can improve the overall performances and generalization properties of such a model. For this, we train SLASH with NPPs as depicted in Fig. 1 consisting of a shared slot encoder and separate PCs, each modelling the mixture of latent slot variables and the attributes of one category, e.g. color. For ShapeWorld4, we thereby have altogether four NPPs. SLASH is trained via queries of the kind exemplified in Fig. 7 in the Appendix. We refer to this configuration as SLASH Attention.
+
+We compare SLASH Attention to a baseline slot attention encoder using an MLP and Hungarian loss for predicting the object properties from the slot encodings as in Locatello et al. (2020). The results of these experiments can be found in Fig. 3a (top). We observe that the average precision after convergence on the held-out test set with SLASH Attention is greatly improved to that of the baseline model. Additionally, in Fig. 3b we observe that SLASH Attention reaches the average precision value of the baseline model in much fewer number of epochs. Thus, we can summarize that adding logical knowledge in the training procedure via SLASH can greatly improve the capabilities of a neural module for set prediction.
+
+Evaluation 4: Improved Compositional Generalization with SLASH. To test the hypothesis that SLASH Attention possesses improved generalization properties in comparison to the baseline model, we ran experiments on a variant of ShapeWorld4 similar to the CLEVR Compositional Generalization Test (CoGenT) (Johnson et al., 2017). The goal of CoGenT is to investigate a model’s ability to handle novel combinations of attributes that were not seen during training.
+
+For this purpose, we established two conditions within a ShapeWorld4 CoGenT data set: Condition (A) – the training and test data set contains squares with the colors gray, blue, brown, or yellow, triangles with the colors red, green, magenta, or cyan and circles of all colors. Condition (B) – the training set is as in Condition (A). However, the test set contains squares with the colors red, green, magenta, or cyan, triangles with the colors gray, blue, brown, or yellow and circles of all colors. The goal is to investigate how well a model can generalize that, e.g., also squares can have the color red, although never having seen evidence for this during training.
+
+The resulting average precision test scores are presented in Fig. 3a (bottom). We observe that, even though the SLASH Program used for this experiment was not explicitly written to handle composition generalization, SLASH Attention shows greatly improved generalization capabilities. This can be seen in the approx. $1 3 \%$ higher average precision scores on the Condition (B) test set in comparison to the baseline model. Importantly, this trend still holds even when subtracting the higher precision scores observed in Condition (A).
+
+To summarize our findings from the experiments on set prediction: we observe that adding prior knowledge in the form of logical constraints via SLASH can greatly improve a neural module in terms of performance and generalizability. On a side note: training neural networks for novel tasks, often involves defining explicit loss functions, e.g. Hungarian loss for set prediction. In contrast with SLASH, no matter the choice of NPP and underlying task, the training loss remains the same. Task-related requirements simply need to be added as lines of code to the SLASH program. This additionally highlights SLASH’s versatility and flexibility.
+
+Summary of all Empirical Results. All empirical results together demonstrate that the flexibility of SLASH is highly beneficial and can easily outperform state-of-the-art: one can freely combine what is required to solve the underlying task — (deep) neural networks, PCs, and logic. Particularly, the results indicate the potential of integrating PCs via SLASH into DPPLs.
+
+# 5 CONCLUSION AND FUTURE WORK
+
+We introduce SLASH, a novel DPPL that integrates neural computations with tractable probability estimates and logical statements. The key ingredient of SLASH to achieve this are Neural-Probabilistic Predicates (NPPs) that can be flexibly constructed out of neural and/or probabilistic circuit modules based on the data and underlying task. With these NPPs, one can produce task-specific probability estimates. The details and additional prior knowledge of a task are neatly encompassed within a SLASH program with only few lines of code. Finally, via Answer Set Programming and Weighted Model Counting, the logical SLASH program and probability estimates from the NPPs are combined to estimate the truth value of a task-specific query. Our experiments show the power and efficiency of SLASH, improving upon previous DPPLs in the benchmark MNIST-Addition task in terms of performance, efficiency and robustness. Importantly, by integrating a SOTA slot attention encoder into NPPs and adding few logical constraints, SLASH demonstrates improved performances and generalizability in comparison to the pure slot encoder for the task of object-centric set prediction; a setting no DPPL has tackled yet. This shows the great potential of DPPLs to elegantly combine logical reasoning with neural computations and uncertainty estimates.
+
+Interesting avenues for future work include benchmarking SLASH on additional data types and tasks. One should explore unsupervised and weakly supervised learning using logic with SLASH and investigate how far logical constraints can help unsupervised object discovery. In direct alignment with our work, one should also investigate image generation via the beneficial feature of PCs to generate random samples. Actually, it should be possible to generate images that encapsulate logical knowledge bases. This is important to move from data-rich to knowledge-rich AI.
+
+# ETHICS STATEMENT
+
+With our work, we have shown that one can add prior knowledge and logical constraints to the training of learning systems. We postulate that SLASH can therefore additionally be used to identify and remove biases or undesirable behavior, by adding constraints within the SLASH program. We observe that this feature, however, also has the potential danger to be used in the opposite way, e.g. explicitly adding bias and discriminatory factors to a system. To the best of our knowledge, our study does not raise any ethical, privacy or conflict of interest concerns.
+
+# REPRODUCIBILITY STATEMENT
+
+An official, curated GitHub repository will be made public with the final version, containing the code of SLASH, as well as scripts to reproduce the experiments and generate data sets. In addition to this, architectural details and hyperparameters are included in the appendix. Preliminary code will be uploaded upon submission. Lastly, details on the evaluation metrics and relevant data sets are given in the main text as well as appendix.
+
+# REFERENCES
+
+Yoshua Bengio. From System 1 Deep Learning to System 2 Deep Learning. Invited talk NeurIPS, 2019. URL https://www.youtube.com/watch?v $=$ T3sxeTgT4qc.
+
+Eli Bingham, Jonathan P. Chen, Martin Jankowiak, Fritz Obermeyer, Neeraj Pradhan, Theofanis Karaletsos, Rohit Singh, Paul A. Szerlip, Paul Horsfall, and Noah D. Goodman. Pyro: Deep universal probabilistic programming. Journal of Machine Learning Research, pp. 28:1–28:6, 2019.
+
+Christopher P. Burgess, Loïc Matthey, Nicholas Watters, Rishabh Kabra, Irina Higgins, Matthew Botvinick, and Alexander Lerchner. Monet: Unsupervised scene decomposition and representation. CoRR, 2019.
+
+Francesco Calimeri, Wolfgang Faber, Martin Gebser, Giovambattista Ianni, Roland Kaminski, Thomas Krennwallner, Nicola Leone, Marco Maratea, Francesco Ricca, and Torsten Schaub. Asp-core-2 input language format. Theory and Practice of Logic Programming, pp. 294–309, 2020.
+
+YooJung Choi, Antonio Vergari, and Guy Van den Broeck. Probabilistic circuits: A unifying framework for tractable probabilistic models. Technical report, Technical report, 2020.
+
+Gabriele Ciravegna, Francesco Giannini, Marco Gori, Marco Maggini, and Stefano Melacci. Humandriven FOL explanations of deep learning. In IJCAI, pp. 2234–2240, 2020.
+
+W. F. Clocksin and Chris Mellish. Programming in Prolog. 1981.
+
+Alain Colmerauer and Philippe Roussel. The birth of prolog. In HOPL-II, pp. 37–52, 1993.
+
+Adnan Darwiche. SDD: A new canonical representation of propositional knowledge bases. In IJCAI, pp. 819–826, 2011.
+
+Artur d’Avila Garcez and Luís C. Lamb. Neurosymbolic AI: the 3rd wave. CoRR, 2020.
+
+Artur S. d’Avila Garcez, Luís C. Lamb, and Dov M. Gabbay. Neural-Symbolic Cognitive Reasoning. Cognitive Technologies. 2009.
+
+Artur S. d’Avila Garcez, Marco Gori, Luís C. Lamb, Luciano Serafini, Michael Spranger, and Son N. Tran. Neural-symbolic computing: An effective methodology for principled integration of machine learning and reasoning. FLAP, pp. 611–632, 2019.
+
+Yannis Dimopoulos, Bernhard Nebel, and Jana Koehler. Encoding planning problems in nonmonotonic logic programs. In ECP, Lecture Notes in Computer Science, pp. 169–181, 1997.
+
+Martin Engelcke, Adam R. Kosiorek, Oiwi Parker Jones, and Ingmar Posner. GENESIS: generative scene inference and sampling with object-centric latent representations. In ICLR, 2020.
+
+Jerry A Fodor and Zenon W Pylyshyn. Connectionism and cognitive architecture: A critical analysis. Cognition, pp. 3–71, 1988.
+
+Klaus Greff, Raphaël Lopez Kaufman, Rishabh Kabra, Nick Watters, Christopher Burgess, Daniel Zoran, Loic Matthey, Matthew Botvinick, and Alexander Lerchner. Multi-object representation learning with iterative variational inference. In ICML, pp. 2424–2433, 2019.
+
+Klaus Greff, Sjoerd van Steenkiste, and Jürgen Schmidhuber. On the binding problem in artificial neural networks. CoRR, 2020.
+
+Drew A. Hudson and Christopher D. Manning. Learning by abstraction: The neural state machine. In NeurIPS, pp. 5901–5914, 2019.
+
+Jindong Jiang and Sungjin Ahn. Generative neurosymbolic machines. In NeurIPS, 2020.
+
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and Ross B. Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual reasoning. In CVPR, pp. 1988–1997, 2017.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR 2015, 2015.
+
+Alexander Kuhnle and Ann A. Copestake. Shapeworld - A new test methodology for multimodal language understanding. CoRR, 2017.
+
+Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. pp. 2278–2324, 1998a.
+
+Yann LeCun, Corinna Cortes, and Christopher J.C. Burges. THE MNIST DATABASE of handwritten digits, 1998b. URL http://yann.lecun.com/exdb/mnist/.
+
+Joohyung Lee and Yi Wang. Weighted rules under the stable model semantics. In KR, pp. 145–154, 2016.
+
+Zhixuan Lin, Yi-Fu Wu, Skand Vishwanath Peri, Weihao Sun, Gautam Singh, Fei Deng, Jindong Jiang, and Sungjin Ahn. SPACE: unsupervised object-oriented scene representation via spatial attention and decomposition. In ICLR, 2020.
+
+Francesco Locatello, Dirk Weissenborn, Thomas Unterthiner, Aravindh Mahendran, Georg Heigold, Jakob Uszkoreit, Alexey Dosovitskiy, and Thomas Kipf. Object-centric learning with slot attention. In NeurIPS, 2020.
+
+Robin Manhaeve, Sebastijan Dumancic, Angelika Kimmig, Thomas Demeester, and Luc De Raedt. Deepproblog: Neural probabilistic logic programming. pp. 3753–3763, 2018.
+
+Jiayuan Mao, Chuang Gan, Pushmeet Kohli, Joshua B. Tenenbaum, and Jiajun Wu. The neurosymbolic concept learner: Interpreting scenes, words, and sentences from natural supervision. In ICLR, 2019.
+
+Gary F Marcus. The algebraic mind: Integrating connectionism and cognitive science. 2019.
+
+Victor W. Marek and Miroslaw Truszczynski. Stable models and an alternative logic programming paradigm. In The Logic Programming Paradigm - A 25-Year Perspective, Artificial Intelligence, pp. 375–398. 1999.
+
+Robert Peharz, Steven Lang, Antonio Vergari, Karl Stelzner, Alejandro Molina, Martin Trapp, Guy Van den Broeck, Kristian Kersting, and Zoubin Ghahramani. Einsum networks: Fast and scalable learning of tractable probabilistic circuits. In ICML, pp. 7563–7574, 2020.
+
+Hoifung Poon and Pedro M. Domingos. Sum-product networks: A new deep architecture. In UAI, pp. 337–346, 2011.
+
+Matthew Richardson and Pedro M. Domingos. Markov logic networks. Machine Learning, pp. 107–136, 2006.
+
+Arseny Skryagin, Karl Stelzner, Alejandro Molina, Fabrizio Ventola, and Kristian Kersting. Splog: Sum-product logic. In ProbProg, 2020.
+
+Timo Soininen and Ilkka Niemelä. Developing a declarative rule language for applications in product configuration. In PADL, Lecture Notes in Computer Science, pp. 305–319, 1999.
+
+Wolfgang Stammer, Patrick Schramowski, and Kristian Kersting. Right for the right concept: Revising neuro-symbolic concepts by interacting with their explanations. In CVPR, pp. 3619–3629, 2021.
+
+Dustin Tran, Matthew D. Hoffman, Rif A. Saurous, Eugene Brevdo, Kevin Murphy, and David M. Blei. Deep probabilistic programming. In ICLR, 2017.
+
+Zhun Yang, Adam Ishay, and Joohyung Lee. NeurASP: Embracing neural networks into answer set programming. In IJCAI, pp. 1755–1762, 2020.
+
+Kexin Yi, Jiajun Wu, Chuang Gan, Antonio Torralba, Pushmeet Kohli, and Josh Tenenbaum. Neuralsymbolic VQA: disentangling reasoning from vision and language understanding. In NeurIPS, pp. 1039–1050, 2018.
+
+Yan Zhang, Jonathon S. Hare, and Adam Prügel-Bennett. Deep set prediction networks. In NeurIPS, pp. 3207–3217, 2019.
+
+# A APPENDIX A – DETAILS ON PARAMETER LEARNING
+
+In the Appendix, we want to discuss details on parameter learning in SLASH. Since we use coordinate descent for training SLASH we present the derivative of each component of the loss function defined in equation 10 since while optimization, one component has to be kept fixed.
+
+We start with the gradient of the NPP loss function $L _ { N P P }$ i.e. the negative log-likelihood, defined in equation 2
+
+$$
+\begin{array} { c } { { \displaystyle { \frac { \partial } { \partial \xi } } L _ { N P P } = { \frac { \partial } { \partial x _ { Q _ { i } } } \cdot \frac { \partial x _ { Q _ { i } } } { \partial \xi } } L _ { N P P } = { \frac { \partial x _ { Q _ { i } } } { \partial \xi } } \left( - { \sum _ { i = 1 } ^ { n } } { \frac { \partial } { \partial x _ { Q _ { i } } } \log \left( P _ { \xi } ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i } } ) \right) } \right) } } \\ { { \displaystyle { = \frac { \partial x _ { Q _ { i } } } { \partial \xi } } \left( - { \sum _ { i = 1 } ^ { n } } { \frac { 1 } { \left( P _ { \xi } ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i } } ) \right) } } \frac { \partial } { \partial x _ { Q _ { i } } } \left( P _ { \xi } ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i } } ) \right) \right) } } \end{array}
+$$
+
+Here, we remark tha t ∂xQi∂ξ will be carried out by back-propagation and the expression after it is the initial gradient.
+
+Next, we derive the gradient of the logical entailment loss function $\mathit { L } _ { \mathit { E N T } }$ , as defined in equation 7. One estimates the gradient as follows
+
+$$
+\frac { 1 } { n } \frac { \partial } { \partial p } L _ { E N T } \ge - \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \frac { \partial \log ( P _ { \Pi ( \theta ) } ( Q _ { i } ) ) } { \partial p } \cdot \log \bigl ( P ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i } } ) \bigr ) ,
+$$
+
+whereby
+
+• $X _ { \mathbf { Q } }$ is the set of random variables associated with the set of the queries $\mathbf { Q }$ ,   
+• $x _ { Q _ { i } }$ is a training sample, a realization of the set of random variables $X _ { \mathbf { Q } }$ associated with the particular query $Q _ { i }$ ,   
+• $P ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i } } )$ is the probability of the realization $x _ { Q _ { i } }$ estimated by the NPP modelling the joint over the set $X _ { \mathbf { Q } }$ and $C$ – the set of classes (the domain of the NPP),   
+• $\log ( P _ { \Pi ( \theta ) } ( Q _ { i } ) )$ – the probability of the query $Q _ { i }$ under the program $\Pi ( \theta )$ calculated by SLASH (for the reference see the equation (5)),   
+• and ∂ log(PΠ(θ)(Qi)) is the gradient as defined in Eq.9.
+
+We begin with the definition of the cross-entropy for two vectors $y _ { i }$ and $\hat { y } _ { i }$ :
+
+$$
+H ( y _ { i } , \hat { y } _ { i } ) : = \sum _ { j = 1 } ^ { m } y _ { i j } \cdot \log \left( \frac { 1 } { \hat { y } _ { i j } } \right) = \sum _ { j = 1 } ^ { m } \left( y _ { i j } \cdot \underbrace { \log ( 1 ) } _ { = 0 } - y _ { i j } \cdot \log ( \hat { y } _ { i j } ) \right) = - \sum _ { j = 1 } ^ { m } y _ { i j } \cdot \log ( \hat { y } _ { i j } ) .
+$$
+
+Hereafter we substitute
+
+$$
+y _ { i } = \log ( P _ { \Pi ( \theta ) } ( Q _ { i } ) ) \qquad \mathrm { ~ a n d ~ } \qquad \hat { y } _ { i } = P ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i } } )
+$$
+
+and obtain
+
+$$
+\bar { \cal I } ( y _ { i } , \hat { y } _ { i } ) = \cal H \left( \log ( P _ { \Pi ( \theta ) } ( Q _ { i } ) ) , P ^ { ( X _ { \mathbf { Q } } , { \cal C } ) } ( x _ { Q _ { i } } ) \right) = - \sum _ { j = 1 } ^ { m } \log ( P _ { \Pi ( \theta ) } ( Q _ { i j } ) ) \cdot \log \Big ( P ^ { ( X _ { \mathbf { Q } } , { \cal C } ) } ( x _ { Q _ { i j } } ) \Big ) .
+$$
+
+We remark that $m$ represent the number of classes defined in the domain of an NPP. Now, we differentiate the equation (11) with the respect to $p$ depicted as in Eq. 9 to be the label of the probability of an atom $c = v$ in $r ^ { n p p }$ , denoting $P _ { \Pi ( \pmb { \theta } ) } ( c = v )$ . Since differentiation is linear, the product rule is applicable directly:
+
+$$
+\begin{array} { c } { \displaystyle \frac { \partial } { \partial p } H \left( y _ { i } , \hat { y } _ { i } \right) = - \sum _ { j = 1 } ^ { m } \left[ \frac { \partial \log \left( P _ { \Pi ( \theta ) } ( Q _ { i j } ) \right) } { \partial p } \cdot \log \left( P ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i j } } ) \right) \right. } \\ { \displaystyle \left. + \log ( P _ { \Pi ( \theta ) } ( Q _ { i j } ) ) \cdot \frac { \partial \log \left( P ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i j } } ) \right) } { \partial p } \right] . } \end{array}
+$$
+
+We do not wish to consider the latter term of $\begin{array} { r } { \log ( P _ { \mathrm { { I I } } ( \theta ) } ( Q _ { i } ) ) \cdot \frac { \partial \log \left( P ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i } } ) \right) } { \partial p } } \end{array}$ because it represents the rescaling and to keep the first since SLASH procure $\frac { \partial \log ( P _ { \Pi ( \theta ) } ( Q _ { i } ) ) } { \partial p }$ following Eq. 9. To achieve this, we estimate equation from above downwards as
+
+$$
+\frac { \partial } { \partial p } H \left( y _ { i } , \hat { y } _ { i } \right) \geq - \sum _ { j = 1 } ^ { m } \frac { \partial \log ( P _ { \Pi ( \theta ) } ( Q _ { i j } ) ) } { \partial p } \cdot \log \left( P ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i j } } ) \right) .
+$$
+
+Furthermore, let us recall that under i.i.d assumption we obtain from the definition of likelihood
+
+$$
+L H ( y , \hat { y } ) = \prod _ { i = 1 } ^ { n } L H ( y _ { i } , \hat { y } _ { i } ) ,
+$$
+
+and following the negative likelihood coupled with the knowledge that the log-likelihood of $y _ { i }$ is the log of a particular entry of $\hat { y } _ { i }$
+
+$$
+\begin{array} { c } { { { \cal L } _ { E N T } = - \displaystyle \log { \cal L } H ( y , \hat { y } ) = - \sum _ { i = 1 } ^ { n } \log { \cal L } H ( y _ { i } , \hat { y } _ { i } ) = - \sum _ { i = 1 } ^ { n } \sum _ { j = 1 } ^ { m } y _ { i j } \cdot \log ( \hat { y } _ { i j } ) = } } \\ { { \displaystyle \sum _ { i = 1 } ^ { n } \left[ - \sum _ { j = 1 } ^ { m } y _ { i j } \cdot \log ( \hat { y } _ { i j } ) \right] = \sum _ { i = 1 } ^ { n } H ( y _ { i } , \hat { y } _ { i } ) . } } \end{array}
+$$
+
+Finally, we obtain the following estimate applying inequality (12)
+
+$$
+\frac { 1 } { n } \frac { \partial } { \partial p } L _ { E N T } = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \frac { \partial } { \partial p } H ( y _ { i } , \hat { y } _ { i } ) \geq - \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \frac { \partial \log \left( P _ { \mathrm { { I I } } ( \theta ) } ( Q _ { i } ) \right) } { \partial p } \cdot \log \left( P ^ { ( X _ { \mathbf { Q } } , C ) } ( x _ { Q _ { i } } ) \right)
+$$
+
+Also, we note that the mathematical transformations listed above hold for any type of NPP and the task dependent queries (NN with Softmax, PC or PC jointly with NN). The only difference will be the second term, i.e., $\log ( P ^ { ( C | X _ { \mathbf { Q } } ) } ( x _ { Q _ { i j } } ) )$ or $\log ( P ^ { ( \bar { X } _ { \mathbf { Q } } | C ) } \bar { ( x _ { Q _ { i j } } ) } )$ depending on the NPP and task. The NPP in a form of a single PC modeling the joint over $X _ { \mathbf { Q } }$ and $C$ was depicted to be the example. With that, the derivation of gradients for both loss functions 2 and 7 is complete, and the training is carried out by coordinated descent.
+
+Backpropagation for joint NN and PC NPPs: If within the SLASH program, $\Pi ( \pmb \theta )$ , the NPP forwards the data tensor through a NN first, i.e., the NPP models a joint over the NN’s output variables by a PC, then we rewrite (8) to
+
+$$
+\sum _ { i = 1 } ^ { n } { \frac { \partial \log \left( P _ { \Pi ( \theta ) } ( Q _ { i } ) \right) } { \partial \theta } } = \sum _ { i = 1 } ^ { n } { \frac { \partial \log \left( P _ { \Pi ( \theta ) } ( Q _ { i } ) \right) } { \partial \mathbf { p } } } \times { \frac { \partial \mathbf { p } } { \partial \theta } } \times { \frac { \partial \theta } { \partial \gamma } } .
+$$
+
+Thereby, $\gamma$ is the set of the NN’s parameters and $\frac { \partial \pmb { \theta } } { \partial \gamma }$ is computed by the backward propagation through the NN.
+
+# B APPENDIX B – SLASH PROGRAMS
+
+Here, the interested reader will find the SLASH programs which we compiled for our experiments. Figure 4 presents the one for the MNIST Addition task, Figure 6 – for the set prediction task with slot attention encoder and the subsequent CoGenT test. Note the use of the $" + "$ and “-” notation for indicating whether a random variable is given or being queried for.
+
+# Define images img(i1). img(i2). 3 # Define Neural-Probabilistic Predicate 4 npp(digit(X), [0,1,2,3,4,5,6,7,8,9]) :- img(X). 5 # Define the addition of digits given two images and the resulting sum 6 addition(A, B, N) :- digit $\mathrm { \Omega } + \tt { A }$ , -N1), digit( $+ \mathtt { B }$ , -N2), $\mathrm { ~ N ~ } = \mathrm { ~ N ~ 1 ~ } + \mathrm { ~ N ~ 2 ~ }$ .
+
+# Is 7 the sum of the digits in img1 and img2? 2 :- addition(image_id1, image_id2, 7)
+
+![](images/5d942cadea3c1d2f75797d835c60baf51150bd1a4748aee77f10460fe3c0d331.jpg)  
+Figure 4: SLASH Program for MNIST addition. The same program was used for the training with missing data.   
+Figure 5: Example SLASH Query for MNIST addition. The same type of query was used for the training with missing data   
+Figure 6: SLASH Program for ShapeWorld4. The same program was used for the CoGenT experiments.
+
+# Does object o1 have the attributes red, circle, bright, small? :- has_attributes(o1, red, circle, bright, small)
+
+Figure 7: Example SLASH Query for ShapeWorld4 experiments. In other words, this query corresponds to asking SLASH: “Is object 1 a small, bright red circle?”.
+
+# C APPENDIX C – EXPERIMENTAL DETAILS
+
+# C.1 SHAPEWORLD4 GENERATION
+
+The ShapeWorld4 and ShapeWorld4 CoGenT data sets were generated using the original scripts of (Kuhnle & Copestake, 2017) (https://github.com/AlexKuhnle/ShapeWorld). The exact scripts will be added together with the SLASH source code.
+
+# C.2 AVERAGE PRECISION COMPUTATION (SHAPEWORLD4)
+
+For the baseline slot encoder experiments on ShapeWorld4 we measured the average precision score as in Locatello et al. (2020). In comparison to the baseline slot encoder, when applying SLASH Attention, however, we handled the case of a slot not containing an object, e.g. only background variables, differently. Whereas Locatello et al. (2020) add an additional binary identifier to the multi-label ground truth vectors, we have added a background (bg) attribute to each category (cf. Fig. 6). A slot is thus considered to be empty (i.e. not containing an object) if each NPP returns the maximal conditional probability for the $b g$ attribute.
+
+As the ShapeWorld4 prediction task only included discrete object properties both for Slot Attention as well as for SLASH Attention the distance threshold for the average precision computation was infinity (thus corresponding to no threshold).
+
+# C.3 MODEL DETAILS
+
+For those experiments using NPPs with PC we have used Einsum Networks (EiNets) for implementing the probabilistic circuits. EiNets are a novel implementation design for SPNs introduced by Peharz et al. (2020) that minimize the issue of computational costs that initial SPNs had suffered. This is accomplished by combining several arithmetic operations via a single monolithic einsum-operation.
+
+For all experiments, the ADAM optimizer (Kingma & Ba, 2015) with $\beta 1 = 0 . 9$ and $\beta 2 = 0 . 9 9 9$ $\epsilon = 1 e - 8$ and no weight decay was used.
+
+MNIST-Addition Experiments For the MNIST-Addition experiments, we ran the DeepProbLog and NeurASP programs with their original configurations, as stated in (Manhaeve et al., 2018) and (Yang et al., 2020), respectively. For the SLASH MNIST-Addition experiments, we have used the same neural module as in DeepProbLog and NeurASP, when training SLASH with the neural NPP (SLASH (DNN)) represented in Tab. 2. When using a PC NPP (SLASH (PC)) we have used an EiNet with the Poon-Domingos (PD) structure (Poon & Domingos, 2011) and normal distribution for the leafs. The formal hyperparameters for the EiNet are depicted in Tab. 3.
+
+The learning rate and batch size for the DNN were 0.005 and 100, for DeepProbLog, NeurASP and SLASH (DNN). For the EiNet, these were 0.01 and 100.
+
+Table 2: Neural module – LeNet5 for MNIST-Addition experiments.   
+
+<table><tr><td>Type</td><td>Size/Channels</td><td>Activation</td><td>Comment</td></tr><tr><td>Encoder</td><td>-</td><td>二</td><td>-</td></tr><tr><td>Conv 5 x 5</td><td>1x28x28</td><td>1</td><td>stride 1</td></tr><tr><td>MaxPool2d</td><td>6x24x24</td><td>ReLU</td><td>kernel size 2, stride 2</td></tr><tr><td>Conv 5 x 5</td><td>6x12x12</td><td>1</td><td>stride 1</td></tr><tr><td>MaxPool2d</td><td>16x8x8</td><td>ReLU</td><td>kernel size 2,stride 2</td></tr><tr><td>Classifier</td><td>1</td><td>-</td><td>-</td></tr><tr><td>MLP</td><td>16x4x4,120</td><td>ReLU</td><td>-</td></tr><tr><td>MLP</td><td>120,84</td><td>ReLU</td><td>-</td></tr><tr><td>MLP</td><td>84,10</td><td>1</td><td>Softmax</td></tr></table>
+
+ShapeWorld4 Experiments For the baseline slot attention experiments with the ShapeWorld4 data set we have used the architecture presented in Tab. 4. For further details on this, we refer to the original work of Locatello et al. (2020). The slot encoder had a number of 4 slots and 3 attention iterations over all experiments.
+
+Table 3: Probabilistic Circuit module – EiNet for MNIST-Addition experiments.   
+
+<table><tr><td>Variables</td><td>Width</td><td>Height</td><td>Number of Pieces</td><td>Class count</td></tr><tr><td>784</td><td>28</td><td>28</td><td>[4,7,28]</td><td>10</td></tr></table>
+
+Table 4: Baseline slot encoder for ShapeWorld4 experiments.   
+
+<table><tr><td>Type</td><td>Size/Channels</td><td>Activation</td><td>Comment</td></tr><tr><td>Conv 5 x 5</td><td>32</td><td>ReLU</td><td>stride 1</td></tr><tr><td>Conv 5 x 5</td><td>32</td><td>ReLU</td><td>stride 1</td></tr><tr><td>Conv 5 x 5</td><td>32</td><td>ReLU</td><td>stride 1</td></tr><tr><td>Conv 5 x 5</td><td>32</td><td>ReLU</td><td>stride 1</td></tr><tr><td>Position Embedding</td><td>1</td><td>二</td><td>-</td></tr><tr><td>Flatten</td><td>axis: [0, 1,2 x 3]</td><td>-</td><td>flatten x, y pos.</td></tr><tr><td>Layer Norm</td><td>二</td><td>-</td><td>二</td></tr><tr><td>MLP (per location)</td><td>32</td><td>ReLU</td><td>二</td></tr><tr><td>MLP (per location)</td><td>32</td><td>-</td><td>二</td></tr><tr><td>SlotAttentionModule</td><td>32</td><td>ReLU</td><td>二</td></tr><tr><td>MLP</td><td>32</td><td>ReLU</td><td></td></tr><tr><td>MLP</td><td>16</td><td>Sigmoid</td><td>二 1</td></tr></table>
+
+For the SLASH Attention experiments with ShapeWorld4 we have used the same slot encoder as in Tab. 4, however, we replaced the final MLPs with 4 individual EiNets with Poon-Domingos structure (Poon & Domingos, 2011). Their hyperparameters are represented in Tab. 5.
+
+Table 5: Probabilistic Circuit module – EiNet for ShapeWorld4 experiments.   
+
+<table><tr><td>EiNet</td><td>Variables</td><td>Width</td><td>Height</td><td>Number ofPieces</td><td>Class count</td></tr><tr><td>Color</td><td>32</td><td>8</td><td>4</td><td>[4]</td><td>9</td></tr><tr><td>Shape</td><td>32</td><td>8</td><td>4</td><td>[4]</td><td>4</td></tr><tr><td>Shade</td><td>32</td><td>8</td><td>4</td><td>[4]</td><td>3</td></tr><tr><td>Size</td><td>32</td><td>8</td><td>4</td><td>[4]</td><td>3</td></tr></table>
+
+The learning rate and batch size for SLASH Attention were 0.01 and 512, for ShapeWorld4 and ShapeWorld4 CoGenT. The learning rate for the baseline slot encoder were 0.0004 and 512.
+
+# D APPENDIX D - ADDITIONAL RESULTS ON MNIST ADDITION
+
+Table 6: Additional MNIST Addition Results. Test accuracy corresponds to the percentage of correctly classified test images. Both models (DeepProbLog and SLASH (PC)) were trained on the full MNIST data, but tested on images with missing pixels. Test accuracies are presented in percent. The amount of missing data was varied between $50 \%$ and $9 7 \%$ of the pixels per image.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>DeepProbLog</td><td rowspan=1 colspan=1>SLASH (PC)</td></tr><tr><td rowspan=1 colspan=1>50%</td><td rowspan=1 colspan=1>79.94 ± 7.2</td><td rowspan=1 colspan=1>72.2 ± 12.15</td></tr><tr><td rowspan=1 colspan=1>80%</td><td rowspan=1 colspan=1>31.6± 6.08</td><td rowspan=1 colspan=1>44.2± 8.23</td></tr><tr><td rowspan=1 colspan=1>90%</td><td rowspan=1 colspan=1>16.94 ± 1.76</td><td rowspan=1 colspan=1>29.6± 5.77</td></tr><tr><td rowspan=1 colspan=1>97%</td><td rowspan=1 colspan=1>12.33 ± 0.47</td><td rowspan=1 colspan=1>17.6 ± 2.97</td></tr></table>
+
+In addition to the setting considered in Evaluation 2, we adjusted the settings for the MNIST Addition task with missing data into the following way.
+
+Training was performed with the full MNIST data set, however the test data set contained different rates of missing pixels. Whereas using an NPP with a PC allows, among other things, to compute marginalization “out of the box” without requiring an update to the architecture or a retraining, this is not so trivial for purely neural-based predicates as in DeepProbLog. Thus, we allowed SLASH (PC) to marginalize over the missing pixels, where this was not directly possible for DeepProbLog.
+
+The results can be seen in Tab. 6 for $5 0 \%$ , $8 0 \%$ , $9 0 \%$ and $9 7 \%$ of missing pixels per image in the test set. We observe that at $5 0 \%$ , DeepProbLog outperforms SLASH by a small margin. For all other rates, we observe that SLASH (PC) reaches significantly higher test accuracies than DeepProbLog. However, we remark that in this setting, SLASH produces larger standard deviations in comparison to DeepProbLog. These results indicate that the conclusions, drawn in the main part of our work, remain true also in this setting of handling missing data.

parse/dev/nN3aVRQsxGd/nN3aVRQsxGd.md

@@ -0,0 +1,323 @@
+# How Powerful are $K$ -hop Message Passing Graph Neural Networks
+
+Jiarui Feng1,2 Yixin Chen1 Fuhai $\mathbf { L i } ^ { 2 }$ Anindya Sarkar1 Muhan Zhang3,4 {feng.jiarui, fuhai.li, anindya}@wustl.edu, chen@cse.wustl.edu, muhan@pku.edu.cn 1Department of CSE, Washington University in St. Louis 2Institute for Informatics, Washington University School of Medicine 3Institute for Artificial Intelligence, Peking University 4Beijing Institute for General Artificial Intelligence
+
+# Abstract
+
+The most popular design paradigm for Graph Neural Networks (GNNs) is 1-hop message passing—aggregating information from 1-hop neighbors repeatedly. However, the expressive power of 1-hop message passing is bounded by the WeisfeilerLehman (1-WL) test. Recently, researchers extended 1-hop message passing to $K$ -hop message passing by aggregating information from $K$ -hop neighbors of nodes simultaneously. However, there is no work on analyzing the expressive power of $K$ -hop message passing. In this work, we theoretically characterize the expressive power of $K$ -hop message passing. Specifically, we first formally differentiate two different kernels of $K$ -hop message passing which are often misused in previous works. We then characterize the expressive power of $K$ -hop message passing by showing that it is more powerful than 1-WL and can distinguish almost all regular graphs. Despite the higher expressive power, we show that $K$ -hop message passing still cannot distinguish some simple regular graphs and its expressive power is bounded by 3-WL. To further enhance its expressive power, we introduce a KP-GNN framework, which improves $K$ -hop message passing by leveraging the peripheral subgraph information in each hop. We show that KP-GNN can distinguish many distance regular graphs which could not be distinguished by previous distance encoding or 3-WL methods. Experimental results verify the expressive power and effectiveness of KP-GNN. KP-GNN achieves competitive results across all benchmark datasets.
+
+# 1 Introduction
+
+Currently, most existing graph neural networks (GNNs) follow the message passing framework, which iteratively aggregates information from the neighbors and updates the representations of nodes. It has shown superior performance on graph-related tasks [1, 2, 3, 4, 5, 6, 7] comparing to traditional graph embedding techniques [8, 9]. However, as the procedure of message passing is similar to the 1-dimensional Weisfeiler-Lehman (1-WL) test [10], the expressive power of message passing GNNs is also bounded by the 1-WL test [7, 11]. Namely, GNNs cannot distinguish two non-isomorphic graph structures if the 1-WL test fails.
+
+In normal message passing GNNs, the node representation is updated by the direct neighbors of the node, which are called 1-hop neighbors. Recently, some works extend the notion of message passing into $K$ -hop message passing [12, 13, 14, 15, 16]. $K$ -hop message passing is a type of message passing where the node representation is updated by aggregating information from not only 1st hop but all the neighbors within $K$ hops of the node. However, there is no work on theoretically characterizing the expressive power of GNNs with $K$ -hop message passing, e.g., whether it can improve the 1-hop message passing or not and to what extent it can.
+
+In this work, we theoretically characterize the expressive power of $K$ -hop message passing GNNs. Specifically, 1) we formally distinguish two different kernels of the $K$ -hop neighbors, which are often misused in previous works. The first kernel is based on whether the node can be reached within $k$ steps of the graph diffusion process, which is used in GPR-GNN [15] and MixHop [12]. The second one is based on the shortest path distance of $k$ , which is used in $\mathrm { G I N E + }$ [16] and Graphormer [17]. Further, we show that different kernels of $K$ -hop neighbors will result in different expressive power of $K$ -hop message passing. 2) We show that $K$ -hop message passing is strictly more powerful than 1-hop message passing and can distinguish almost all regular graphs. 3) However, it still failed in distinguishing some simple regular graphs, no matter which kernel is used, and its expressive power is bounded by 3-WL. This motivates us to improve $K$ -hop message passing further.
+
+Here, we introduce KP-GNN, a new GNN framework with $K$ -hop message passing, which significantly improves the expressive power of standard $K$ -hop message passing GNNs. In particular, during the aggregation of neighbors in each hop, KP-GNN not only aggregates neighboring nodes in that hop but also aggregates the peripheral subgraph (subgraph induced by the neighbors in that hop). This additional information helps the KP-GNN to learn more expressive local structural features around the node. We further show that KP-GNN can distinguish many distance regular graphs with a proper encoder for the peripheral subgraph. The proposed KP-GNN has several additional advantages. First, it can be applied to most existing $K$ -hop message-passing GNNs with only slight modification. Second, it only adds little computational complexity to standard $K$ -hop message passing. We demonstrate the effectiveness of the KP-GNN framework through extensive experiments on both simulation and real-world datasets.
+
+# 2 $K$ -hop message passing and its expressive power
+
+# 2.1 Notations
+
+Denote a graph as $G = ( V , E )$ , where $V = \{ 1 , 2 , . . . , n \}$ is the node set and $E \subseteq V \times V$ is the edge set. Meanwhile, denote $\dot { A } \in \{ 0 , 1 \} ^ { n \times n }$ as the adjacency matrix of graph $G$ . Denote $x _ { v }$ as the feature vector of node $v$ and denote $e _ { u v }$ as the feature vector of the edge from $u$ to $v$ . Finally, we denote $Q _ { v , G } ^ { 1 }$ as the set of 1-hop neighbors of node $v$ in graph $G$ and $\mathcal { N } _ { v , G } ^ { 1 ^ { - } } { = } Q _ { v , G } ^ { 1 } \cup \{ v \}$ . Note that when we say $K$ -hop neighbors of node $v$ , we mean all the neighbors that have distance from node $v$ less than or equal to $K$ . In contrast, $k$ -th hop neighbors mean the neighbors with exactly distance $k$ from node $v$ . The definition of distance will be discussed in section 2.3.
+
+# 2.2 1-hop message passing framework
+
+Currently, most existing GNNs are designed based on 1-hop message passing framework [18]. Denote $h _ { v } ^ { l }$ as the output representation of node $v$ at layer $l$ and $h _ { v } ^ { 0 } = x _ { v }$ . Briefly, given a graph $G$ and a 1-hop message passing GNN, at layer $l$ of the GNN, $h _ { v } ^ { l }$ is computed by $h _ { v } ^ { l - 1 }$ and $\{ h _ { u } ^ { l - 1 } \mid u \in Q _ { v , G } ^ { 1 } \}$ :
+
+$$
+m _ { v } ^ { l } = \mathrm { { \bf M E S } } ^ { l } ( \{ ( h _ { u } ^ { l - 1 } , e _ { u v } ) | u \in Q _ { v , G } ^ { 1 } \} ) , h _ { v } ^ { l } = \mathrm { { \bf U P D } } ^ { l } ( m _ { v } ^ { l } , h _ { v } ^ { l - 1 } ) ,
+$$
+
+where $m _ { v } ^ { l }$ is the message to node $v$ at layer $l$ , $\mathrm { M E S } ^ { l }$ and $\mathrm { U P D } ^ { l }$ are message and update functions at layer $l$ respectively. After $L$ layers of message passing, $h _ { v } ^ { L }$ is used as the final representation of node $v$ . Such a representation can be used to conduct node-level tasks like node classification and node regression. To get the graph representation, a readout function is used:
+
+$$
+h _ { G } = \mathrm { R E A D O U T } ( \{ h _ { v } ^ { L } | v \in V \} ) ,
+$$
+
+where READOUT is the readout function for computing the final graph representation. Then $h _ { G }$ can be used to conduct graph-level tasks like graph classification and graph regression.
+
+# 2.3 $K$ -hop message passing framework
+
+The 1-hop message passing framework can be directly generalized to $K$ -hop message passing, as it shares the same message and update mechanism. The difference is that independent message and update functions can be employed for each hop. Meanwhile, a combination function is needed to combine the results from different hops into the final node representation at this layer. First, we differentiate two different kernels of $K$ -hop neighbors, which are interchanged and misused in previous research.
+
+The first kernel of $K$ -hop neighbors is shortest path distance (spd) kernel. Namely, the $k$ -th hop neighbors of node $v$ in graph $G$ is the set of nodes with the shortest path distance of $k$ from $v$ .
+
+Definition 1. For a node v in graph G, the K-hop neighbors N K,spdv,G of $v$ based on shortest path distance kernel is the set of nodes that have the shortest path distance from node $v$ less than or equal to $K$ . We further denote $Q _ { v , G } ^ { k , s p d }$ as the set of nodes in $G$ that are exactly the $k$ -th hop neighbors (with shortest path distance of exactly $k$ ) and $\mathcal { N } _ { v , G } ^ { 0 , s p d } = Q _ { v , G } ^ { 0 , s p d } = \{ v \}$ is the node itself.
+
+The second kernel of the $K$ -hop neighbors is based on graph diffusion $( g d )$ .
+
+Definition 2. For a node v in graph $G$ , the $K$ -hop neighbors $\mathcal { N } _ { v , G } ^ { K , g d }$ of v based on graph diffusion kernel is the sediffusion steps nodes that can diffuse iand the diffusion kernel ormation to node (adjacency matr $v$ within the number). We further denote dom walk as the set $K$ $A$ $Q _ { v , G } ^ { k , g d }$ of nodes in that are exactly the -th hop neighbors (nodes that can diffuse information to node with k diffusion steps) and N 0,gdv,G $\mathcal { N } _ { v , G } ^ { 0 , g d } = Q _ { v , G } ^ { 0 , g \bar { d } } = \bar { \{ v \} }$ is the node itself.
+
+Note that a node can be a $k$ -th hop neighbor of $v$ for multiple $k$ based on the graph diffusion kernel, but it can only appear in one hop for the shortest path distance kernel. We include more discussions of $K$ -hop kernels in Appendix A. Next, we define the $K$ -hop message passing framework as follows:
+
+$$
+\begin{array} { r } { m _ { v } ^ { l , k } = \mathrm { M E S } _ { k } ^ { l } ( \{ ( h _ { u } ^ { l - 1 } , e _ { u v } ) | u \in Q _ { v , G } ^ { k , t } ) \} ) , h _ { v } ^ { l , k } = \mathrm { U P D } _ { k } ^ { l } ( m _ { v } ^ { l , k } , h _ { v } ^ { l - 1 } ) , } \\ { h _ { v } ^ { l } = \mathrm { C O M B I N E } ^ { l } ( \{ \{ h _ { v } ^ { l , k } | k = 1 , 2 , . . . , K \} \} ) , } \end{array}
+$$
+
+where $t \in \{ s p d , g d \}$ , spd is the shortest path distance kernel and $_ { g d }$ is the graph diffusion kernel. Here, for each hop, we can apply unique MES and UPD functions. Note that for $k > 1$ , there may not exist the edge feature $e _ { u v }$ as nodes are not directly connected. But we leave it here since we can use other types of features to replace it like path encoding. We further discuss it in Appendix I. Compared to the 1-hop message passing framework described in Equation (1), the COMBINE function is introduced to combine the representations of node $v$ at different hops. It is easy to see that a $L$ layer 1-hop message passing GNNs is actually a $L$ layer $K$ -hop message passing GNNs with $K = 1$ . We include more discussions of $K$ -hop message passing GNNs in Appendix A. To aid further analysis, we also prove that $K$ -hop message passing can injectively encode the neighbor representations at different hops into $h _ { v } ^ { l }$ in Appendix B.
+
+# 2.4 Expressive power of $K$ -hop message passing framework
+
+In this section, we theoretically analyze the expressive power of $K$ -hop message passing. We assume there is no edge feature and all nodes in the graph have the same feature, which means that GNNs can only distinguish two nodes with the local structure of nodes. Note that including node features only increases the expressive power of GNNs as nodes/graphs are more easily to be discriminated. It has been proved that the expressive power of 1-hop message passing is bounded by the 1-WL test on discriminating non-isomorphic graphs [7, 11]. In this section, We show that the $K$ -hop message passing is strictly more powerful than the 1-WL test when $K > 1$ . Across the analysis, we utilize regular graphs as examples to illustrate our theorems since they cannot be distinguished using either 1-hop message passing or the 1-WL test. To begin the analysis, we first define proper $K$ -hop message passing GNNs.
+
+Definition 3. A proper $K$ -hop message passing GNN is a GNN model where the message, update, and combine functions are all injective given the input from a countable space.
+
+A proper $K$ -hop message passing GNN is easy to find due to the universal approximation theorem [19] of neural network and the Deep Set for set operation [20]. In the latter sections, by default, all mentioned $K$ -hop message passing GNNs are proper. Next, we introduce node configuration:
+
+Definition 4. The node configuration of node v in graph $G$ within $K$ hops under t kernel is a list $A _ { v , G } ^ { K , t } = ( a _ { v , G } ^ { 1 , t } , a _ { v , G } ^ { 2 , t } , . . . , a _ { v , G } ^ { K , t } )$ , where $a _ { v , G } ^ { i , t } = | Q _ { v , G } ^ { i , t } |$ is the number of $i$ -th hop neighbors of node v.
+
+![](images/6717718d9a0f12e65c4bf76a241bcd84384ca02b31ebd9cd9710377c107a2563.jpg)  
+Figure 1: Here are two pairs of non-isomorphic regular graphs. With 2-hop message passing, example 1 can be distinguished by the graph diffusion kernel, and example 2 can be distinguished by the shortest path distance kernel. However, both two examples become indistinguishable if we switch the kernel. Finally, both two examples can be distinguished by adding peripheral subgraph information.
+
+When we say two node configurations AK,t v1,G(1) and AK,t $A _ { v _ { 2 } , G ^ { ( 2 ) } } ^ { K , t }$ are equal, we mean that these two lists are component-wise equal to each other. Now, we state the first proposition:
+
+Proposition 1. A proper $K$ -hop message passing GNN is strictly more powerful than 1-hop message passing GNNs when $K > 1$ .
+
+To see why this is true, we first discuss how node configuration relates to the first layer of message passing. In the first layer of $K$ -hop message passing, each node aggregates neighbors from up to $K$ hops. As each node has the same node label, an injective message function can only know how many neighbors at each hop, which is exactly the node configuration. In other words, The first layer of $K$ -hop message passing is equivalent to inject node configuration to each node label. When $K = 1$ , the node configuration of $v _ { 1 }$ and $v _ { 2 }$ are $d _ { v _ { 1 } , G ^ { ( 1 ) } }$ and $d _ { v _ { 2 } , G ^ { ( 2 ) } }$ , where $d _ { v , G }$ is the node degree of $v$ . After $L$ layers, GNNs can only get the node degree information of each node within $L$ hops of node $v$ . Then, it is straightforward to see why these GNNs cannot distinguish any $n$ -sized $r$ -regular graph, as each node in the regular graph has the same degree.
+
+Next, when $K > 1$ , the $K$ -hop message passing is at least equally powerful as 1-hop message passing since node configuration up to $K$ hop includes all the information the 1 hop has. To see why it is more powerful, we use two examples to illustrate it. The first example is shown in the left part of Figure 1. Suppose here we use graph diffusion kernel and we want to learn the representation of node $v _ { 1 }$ and node $v _ { 2 }$ in the two graphs. We know that the 1-hop GNNs produce the same representation for two nodes as they are both nodes in 6-sized 3-regular graphs. However, it is easy to see that $v _ { 1 }$ and $v _ { 2 }$ have different local structures and should have different representations. Instead, if we use the 2-hop message passing with the graph diffusion kernel, we can easily distinguish two nodes by checking the 2nd hop neighbors of the node, as node $v _ { 1 }$ has four 2nd hop neighbors but node $v _ { 2 }$ only has two 2nd hop neighbors. The second example is shown in the right part of Figure 1. Two graphs in the example are still regular graphs. Suppose here we use shortest path distance kernel, node $v _ { 1 }$ and $v _ { 2 }$ have different numbers of 2nd hop neighbors and thus will have different representations by performing 2-hop message passing. These two examples convincingly demonstrate that the $K$ -hop message passing with $K > 1$ can have better expressive power than $K = 1$ . To further study the expressive power of $K$ -hop message passing on regular graphs, we show the following result:
+
+Theorem 1. Consider all pairs of $n$ -sized $r$ -regular graphs, let $3 \leq r < ( 2 l o g 2 n ) ^ { 1 / 2 }$ and $\epsilon$ be a fixed constant. With at most $\begin{array} { r } { K = \lfloor ( \frac { 1 } { 2 } + \epsilon ) \frac { \log { 2 n } } { \log { ( r - 1 ) } } \rfloor } \end{array}$ , there exists a $I$ layer $K$ -hop message passing GNN using the shortest path distance kernel that distinguishes almost all $1 - o ( n ^ { - 1 / 2 } )$ such pairs of graphs.
+
+We include the proof and simulation results in Appendix C. Theorem 1 shows that even with 1 layer and a modest $K$ , $K$ -hop GNNs are powerful enough to distinguish almost all regular graphs.
+
+Finally, we characterize the existing $K$ -hop methods with the proposed $K$ -hop message passing framework. Specifically, we show that 1) the expressive power of $K$ layer GINE [16] is bounded by $K$ layer $K$ -hop message passing with the shortest path distance kernel. 2) The expressive power of the Graphormer [17] is equal to $K$ -hop GNNs with the shortest path distance kernel and infinity $K$ . 3) For spectral GNNs and existing $K$ -hop GNNs with the graph diffusion kernel like MixHop [12] and MAGNA [14], we find they actually use a weak version of $K$ -hop than the definition of us. Specifically, it is shown that the expressive power of spectral GNNs is also bounded by 1-WL test [21], which contradicts our result as graph diffusion can be viewed as a special case of spectral GNN. However, we show that our definition of $K$ -hop message passing with graph diffusion kernel actually injects a non-linear function on the spectral basis, thus achieving superior expressive power. We leave the detailed discussion in Appendix D. Further, Distance Encoding [22] also uses the shortest path distance information to augment the 1-hop message passing, which is similar to $K$ -hop GNNs with the shortest path distance kernel. However, we find the expressive power of the two frameworks differs from each other. We leave the detailed discussion in Appendix E.
+
+# 2.5 Limitation of $K$ -hop message passing framework
+
+Although we show that $K$ -hop GNNs with $K > 1$ are better at distinguishing non-isomorphic structures than 1-hop GNNs, there are still limitations. In this section, we discuss the limitation of $K$ -hop message passing. Specifically, we show that the choice of the kernel can affect the expressive power of $K$ -hop message passing. Furthermore, even with $K$ -hop message passing, we still cannot distinguish some simple non-isomorphic structures and the expressive power of $K$ -hop message passing is bounded by 3-WL.
+
+Continue looking at the provided examples in Figure 1. In example 1, if we use the shortest path distance kernel instead of the graph diffusion kernel, two nodes have the same number of neighbors in the 2nd hop, which means that we cannot distinguish two nodes this time. Similarly, in example 2, two nodes have the same number of neighbors in both 1st and 2nd hops using graph diffusion kernel. These results highlight that the choice of the kernel can affect the expressive power of $K$ -hop message passing, and none of them can distinguish both two examples with 2-hop message passing.
+
+Recently, Frasca et al. [23] show that any subgraph-based GNNs with node-based selection policy can be implemented by 3-IGN [24, 25] and thus their expressive power is bounded by 3-WL test. Here, we show that the $K$ -hop message passing GNNs can also be implemented by 3-IGN for both two kernels and thus:
+
+Theorem 2. The expressive power of a proper $K$ -hop message passing GNN of any kernel is bounded by the 3-WL test.
+
+We include the proof in Appendix F. Given all these observations, we may wonder if there is a way to further improve the expressive power of $K$ -hop message passing?
+
+# 3 KP-GNN: improving the power of $K$ -hop message passing by peripheral subgraph
+
+In this section, we describe how to improve the expressive power of $K$ -hop message passing by adding additional information to the message passing framework. Specifically, by adding peripheral subgraph information, we can improve the expressive power of the $K$ -hop message passing by a large margin.
+
+# 3.1 Peripheral edge and peripheral subgraph
+
+First, we define peripheral edge and peripheral subgraph.
+
+Definition 5. The peripheral edge $E ( Q _ { v , G } ^ { k , t } )$ is defined as the set of edges that connect nodes within set $Q _ { v , G } ^ { k , t }$ . We further denote $| E ( Q _ { v , G } ^ { k , t } ) |$ as the number of peripheral edge in $E ( Q _ { v , G } ^ { k , t } )$ . The peripheral subgraph Gk,tv,G $G _ { v , G } ^ { k , t } = ( Q _ { v , G } ^ { k , t } , E ( Q _ { v , G } ^ { k , t } ) )$ is defined as the subgraph induced by $Q _ { v , G } ^ { k , t }$ from the whole graph $G$ .
+
+Briefly speaking, the peripheral edge $E ( Q _ { v , G } ^ { k , t } )$ record all the edges whose two ends are both from $Q _ { v , G } ^ { k , t }$ and the peripheral subgraph is a graph constituted by peripheral edges. It is easy to see that the peripheral subgraph $G _ { v , G } ^ { k , t }$ automatically contains all the information of peripheral edge $E ( Q _ { v , G } ^ { k , t } )$ . Next, we show that the power of $K$ -hop message passing can be improved by leveraging the information of peripheral edges and peripheral subgraphs. We again refer to the examples in Figure 1. Here we only consider the peripheral edge information. In example 1, we notice that at the 1st hop, there is an edge between node 3 and node 4 in the left graph. More specifically, $E ( Q _ { v _ { 1 } , G ^ { ( 1 ) } } ^ { 1 , t } ) \stackrel { - } { = } \{ ( 3 , 4 ) \}$ . In contrast, we have $E ( Q _ { v _ { 2 } , G ^ { ( 2 ) } } ^ { 1 , t } ) = \{ \}$ in the right graph, which means there is no edge between the 1st hop neighbors of $v _ { 2 }$ . Therefore, we can successfully distinguish these two nodes by adding this information to the message passing. Similarly, in example 2, there is one edge between the 1st hop neighbors of node $v _ { 2 }$ , but no such edge exists for node $v _ { 1 }$ . By leveraging peripheral edge information, we can also distinguish the two nodes. The above examples demonstrate the effectiveness of the peripheral edge and peripheral subgraph information.
+
+# 3.2 $K$ -hop peripheral-subgraph-enhanced graph neural network
+
+In this section, we propose $\mathbf { K }$ -hop Peripheral-subgraph-enhanced Graph Neural Network (KP-GNN), which equips $K$ -hop message passing GNNs with peripheral subgraph information for more powerful GNN design. Recall the $K$ -hop message passing defined in Equation (3). The only difference between KP-GNN and original $K$ -hop GNNs is that we revise the message function as follows:
+
+$$
+\begin{array} { r } { m _ { v } ^ { l , k } = \mathbf { M E S } _ { k } ^ { l } ( \{ ( h _ { u } ^ { l - 1 } , \ e _ { u v } ) | u \in Q _ { v , G } ^ { k , t } \} , \ G _ { v , G } ^ { k , t } ) . } \end{array}
+$$
+
+Briefly speaking, in the message step at the $k$ -th hop, we not only aggregate information of the neighbors but also the peripheral subgraph at that hop. The implementation of KP-GNN can be very flexible, as any graph encoding function can be used. To maximize the information the model can encode while keeping it simple, we implement the message function as:
+
+$$
+\begin{array} { r l } & { \mathbf { M E S } _ { k } ^ { l } = \mathbf { M E S } _ { k } ^ { l , n o r m a l } ( \ P ( h _ { u } ^ { l - 1 } , e _ { u v } ) | u \in Q _ { v , G } ^ { k , t } \| ) + f ( G _ { v , G } ^ { k , t } ) , } \\ & { \qquad f ( G _ { v , G } ^ { k , t } ) = \mathbf { E M B } ( ( E ( Q _ { v , G } ^ { k , t } ) , C _ { k } ^ { k ^ { \prime } } ) ) ~ , } \end{array}
+$$
+
+where MESl,normal denotes the message function in the original GNN model, $C _ { k } ^ { k ^ { \prime } }$ is the $k ^ { \prime }$ configuration, which encode both node configuration and the number of the peripheral edge of all nodes in $G _ { v , G } ^ { k , t }$ up to $k ^ { \prime }$ hops. It can be regarded as running another 1 layer KP-GNN and readout function on each peripheral subgraph. EMB is a learnable embedding function. With this implementation, any base GNN model can be incorporated into and be enhanced by the KP-GNN framework by replacing $\mathbf { M E S } _ { k } ^ { l , n o r m a l }$ and $\mathrm { U P D } _ { k } ^ { l }$ with the corresponding functions for each hop $k$ . We leave the detailed implementation in Appendix I.
+
+# 3.3 The expressive power of KP-GNN and comparison with existing methods
+
+In this section, we theoretically characterize the expressive power of KP-GNN and compare it with the original $K$ -hop message passing framework. The key insight is that, according to Equation (4), the message function at the $k$ -th hop additionally encodes $G _ { v , G } ^ { k , t }$ compared to normal $K$ -hop message passing. As we have already shown in the last section, -hop GNNs are bounded by 3-WL and thus cannot distinguish any non-isomorphic distance regular graphs, as well as Distance Encoding [22]. Let C k′ b e the $k ^ { \prime }$ -configuration of peripheral subgraph at $j$ -th hop of nodes in distance regular graph $G$ . Here we show that with the aid of peripheral subgraphs, KP-GNN is able to distinguish distance regular graphs:
+
+Proposition 2. For two non-isomorphic distance regular graphs $G ^ { ( 1 ) } = ( V ^ { ( 1 ) } , E ^ { ( 1 ) } )$ and $G ^ { ( 2 ) } =$ $( V ^ { ( 2 ) } , E ^ { ( 2 ) } )$ with the same diameter $d$ and intersection array $( b _ { 0 } , b _ { 1 } , . . . , b _ { d - 1 } ; c _ { 1 } , c _ { 2 } , . . . , c _ { d } )$ . Given $a$ er an $^ { l }$ - $d$ $K P$ th messafor some s defined in Equation (5), it can distinguish. $G ^ { ( 1 ) }$ $G ^ { ( 2 ) } i f C _ { j , G ^ { ( 1 ) } } ^ { k ^ { \prime } } \ne C _ { j , G ^ { ( 2 ) } } ^ { k ^ { \prime } }$ C k′j,G(2) 0 < j ≤ d
+
+![](images/a336ebea6c6a59a9a5ed56e6e6e2ef027008203798580fdef176ebc1b04f6672.jpg)  
+Figure 2: An example of two non-isomorphic distance regular graph with intersection array $( 6 , 3 ; 1 , 2 )$ .
+
+We include the proof in Appendix G. Here we leverage an example in Figure 2 to briefly show why KP-GNN is able to distinguish distance regular graphs. Figure 2 displays two distance regular graphs with an intersection array of $( 6 , 3 ; 1 , 2 )$ . The left one is Shrikhande graph and the right one is $4 \times 4$ Rook’s graph. Now, let’s look at the 1-hop peripheral subgraph of the green node. In the Shrikhande graph, there are 6 peripheral edges marked with red. Further, 6 edges constitute a circle. In the $4 \times 4$ Rook’s graph, there are still 6 peripheral edges. However, 6 edges constitute two circles with 3 edges in each circle, which is different from the Shrikhande graph. Then, any peripheral subgraph encoder that can distinguish these two graphs like node configuration enables the corresponding KP-GNN to distinguish the example. Proposition 2 shows that the KP-GNN is capable of distinguishing distance regular graphs, which further distinguishes KP-GNN from DE-1 [22] as it cannot distinguish any two connected distance regular graphs with the same intersection arrays according to Theorem 3.7 in [22]. However, it is currently unknown whether can KP-GNN with Equation 5 distinguish all distance regular graphs. We leave the detailed discussion in Appendix G.
+
+Moreover, both the subgraph-based GNNs like NGNN [26], GNN-AK [27], ESAN [28], and KPGNN leverage the information in the subgraph to enhance the power of message passing. However, KP-GNN is intrinsically different from them. Firstly, in KP-GNN, the message passing is performed on the whole graph instead of the subgraphs. This means that for each node, there is only one representation to be learned. Instead, for subgraph-based GNNs, the message passing is performed separately for each subgraph and each node could have multiple representations depending on which subgraph it is in. Secondly, in subgraph-based GNNs, they consider the subgraph as a whole without distinguishing nodes at different hops. Instead, KP-GNN takes one step further by dividing the subgraph into two parts. The first part is the hierarchy of neighbors at each hop. The second part is the connection structure between nodes in each hop. This gives us a better point of view to design a more powerful learning method. From the Corollary 7 in [23], we know that all subgraph-based GNNs with node selection as subgraph policy is bounded by 3-WL, which means they cannot distinguish any distance regular graph and KP-GNN is better at it.
+
+# 3.4 Time, space complexity, and limitation
+
+In this section, we discuss the time and space complexity of $K$ -hop message passing GNN and KPGNN. Suppose a graph has $n$ nodes and $m$ edges. Then, the $K$ -hop message passing and KP-GNN have both the space complexity of $O ( n )$ and the time complexity of $O ( \bar { n } ^ { 2 } )$ for the shortest path distance kernel. Note that the complexity of graph diffusion is no less than the shortest path distance kernel. We can see that KP-GNN only requires the same space complexity as vanilla GNNs and much less time complexity than the subgraph-based GNNs, which are at least $O ( n m )$ . However, $K$ -hop message passing including KP-GNN still have intrinsic limitation. We leave a detailed discussion on the complexity and limitation of KP-GNN in Appendix $_ \mathrm { H }$ .
+
+# 4 Related Work
+
+Expressive power of GNN. Analyzing the expressive power of GNNs is a crucial problem as it can serve as a guide on how to improve GNNs. Xu et al. [7] and Morris et al. [11] first proved that the power of 1-hop message passing is bounded by the 1-WL test. In other words, 1-hop message passing cannot distinguish any non-isomorphic graphs that the 1-WL test fails to. In recent years, many efforts have been put into increasing the expressive power of 1-hop messaging passing. The first line of research tries to mimic the higher-order WL tests, like 1-2-3 GNN [11], PPGN [24], ring-GNN [29]. However, they require exponentially increasing space and time complexity w.r.t. node number and cannot be generalized to large-scale graphs. The second line of research tries to enhance the rooted subtree of 1-WL with additional features. Some works [30, 31, 32] add one-hot or random features into nodes. Although they achieve good results in some settings, they deteriorate the generalization ability as such features produce different representations for nodes even with the same local graph structure. Some works like Distance Encoding [22], SEAL [33], labeling trick [34] and GLASS [35] introduce node labeling based on either distance or distinguishing target node set. On the other hand, GraphSNN [36] introduces a hierarchy of local isomorphism and proposes structural coefficients as additional features to identify such local isomorphism. However, the function designed to approximate the structural coefficient cannot fully achieve its theoretical power. The third line of research resorts to subgraph representation. Specifically, ID-GNN [37] extracts ego-netwok for each node and labels the root node with a different color. NGNN [26] encodes a rooted subgraph instead of a rooted subtree by subgraph pooling thus achieving superior expressive power on distinguishing regular graphs. GNN-AK [27] applies a similar idea as NGNN. The only difference lies in how to compute the node representation from the local subgraph. However, such methods need to run an inner GNN on every node of the graph thus introducing much more computation overhead. Meanwhile, the expressive power of subgraph GNNs are bounded by 3-WL [23].
+
+$K$ -hop message passing GNN. There are some existing works that instantiate the $K$ -hop message passing framework. For example, MixHop [12] performs message passing on each hop with graph diffusion kernel and concatenates the representation on each hop as the final representation. Khop [13] sequentially performs the message passing from hop K to hop 1 to compute the representation of the center node. However, it is not parallelizable due to its computational procedure. MAGNA [14] introduces an attention mechanism to $K$ -hop message passing. GPR-GNN [15] use graph diffusion kernel to perform graph convolution on $K$ -hop and aggregate them with learnable parameters. However, none of them give a formal definition of $K$ -hop message passing and theoretically analyze its representation power and limitations.
+
+# 5 Experiments
+
+In this section, we conduct extensive experiments to evaluate the performance of KP-GNN. Specifically, we 1) empirically verify the expressive power of KP-GNN on 3 simulation datasets and demonstrate the benefits of KP-GNN compared to normal $K$ -hop message passing GNNs; 2) demonstrate the effectiveness of KP-GNN on identifying various node properties, graph properties, and substructures with 3 simulation datasets; 3) show that the KP-GNN can achieve state-of-the-art performance on multiple real-world datasets; 4) analyze the running time of KP-GNN. The detail of each variant of KP-GNN is described in Appendix I and the detailed experimental setting is described in Appendix J. We implement the KP-GNN with PyTorch Geometric package [38]. Our code is available at https://github.com/JiaruiFeng/KP-GNN.
+
+Datasets: To evaluate the expressive power of KP-GNN, we choose: 1) EXP dataset [31], which contains 600 pairs of non-isomorphic graphs (1-WL failed). The goal is to map these graphs to two different classes. 2) SR25 dataset [39], which contains 15 non-isomorphic strongly regular graphs (3- WL failed) with each graph of 25 nodes. The dataset is translated to a 15-way classification problem with the goal of mapping each graph into different classes. 3) CSL dataset [40], which contains 150 4-regular graphs (1-WL failed) divided into 10 isomorphism classes. The goal of the task is to classify them into corresponding isomorphism classes. To demonstrate the capacity of KP-GNN on counting node/graph properties and substructures, we pick 1) Graph property regression (connectedness, diameter, radius) and node property regression (single source shortest path, eccentricity, Laplacian feature) task on random graph dataset [41]. 2) Graph substructure counting (triangle, tailed triangle, star, and 4-cycle) tasks on random graph dataset [42]. To evaluate the performance of KP-GNN on real-world datasets, we select 1) MUTAG [43], D&D [44], PROTEINS [44], PTC-MR [45], and IMDB-B [46] from TU database. 2) QM9 [47, 48] and ZINC [49] for molecular properties prediction. The detailed statistics of the datasets are described in Appendix L. Without further highlighting, all error bars in the result tables are the standard deviations of multiple runs.
+
+Table 1: Empirical evaluation of the expressive power.   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">K</td><td>EXP (ACC)</td><td>SR (ACC)</td><td></td><td>CSL (ACC)</td></tr><tr><td>SPD GD</td><td>SPD</td><td>GD</td><td>SPD GD</td></tr><tr><td rowspan="4">K-GIN</td><td>K=1</td><td>50 50</td><td>6.67</td><td>6.67</td><td>12</td></tr><tr><td>K=2</td><td>50 50</td><td>6.67</td><td>6.67</td><td>12 32 22.7</td></tr><tr><td>K=3</td><td>100 66.9</td><td>6.67</td><td>6.67</td><td>62 42</td></tr><tr><td>K=4</td><td>100 100</td><td>6.67</td><td>6.67</td><td>92.7 62.7</td></tr><tr><td rowspan="4">KP-GIN</td><td>K=1</td><td>50</td><td>50 100</td><td>100</td><td>22</td><td>22</td></tr><tr><td>K=2</td><td>100</td><td>100 100</td><td>100</td><td>52.7</td><td>52.7</td></tr><tr><td>K=3</td><td>100</td><td>100</td><td>100 100</td><td>90</td><td>90</td></tr><tr><td>K=4</td><td>100</td><td>100</td><td>100 100</td><td>100</td><td>100</td></tr></table>
+
+Empirical evaluation of the expressive power: For empirical evaluation of the expressive power, we conduct the ablation study on hop $K$ for both normal $K$ -hop GNNs and KP-GNN. For $K$ -hop GNNs, we implement K-GIN which uses GIN [7] as the base encoder. For KP-GNN, we implement KP-GIN. The results are shown in Table 1. Based on the results, we have the following conclusions: 1) $K$ -hop GNNs with both two kernels have expressive power higher than the 1-WL test as it shows the per
+
+fect performance on the EXP dataset and performance better than a random guess on the CSL dataset. 2) Increasing $K$ can improve the expressive for both two kernels. 3) $K$ -hop GNNs cannot distinguish any strong regular graphs in SR25 dataset, which is aligned with Theorem 2. 4) KP-GNN has much higher expressive power than normal $K$ -hop GNNs by showing better performance on every dataset given the same $K$ . Further, it achieves perfect results on the SR25 dataset even with $K = 1$ , which demonstrates its ability on distinguishing distance regular graphs.
+
+Table 2: Simulation dataset result. The top two are highlighted by First, Second.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="3">Node Properties (log1o(MSE))</td><td colspan="3">Graph Properties (log1o(MSE))</td><td colspan="4">Counting Substructures (MAE)</td></tr><tr><td>SSSP</td><td>Ecc.</td><td>Lap.</td><td>Connect.</td><td>Diameter</td><td>Radius</td><td>Tri.</td><td>Tailed Tri.</td><td>Star</td><td>4-Cycle</td></tr><tr><td>GIN</td><td>-2.0000</td><td>-1.9000</td><td>-1.6000</td><td>-1.9239</td><td>-3.3079</td><td>-4.7584</td><td>0.3569</td><td>0.2373</td><td>0.0224</td><td>0.2185</td></tr><tr><td>PNA</td><td>-2.8900</td><td>-2.8900</td><td>-3.7700</td><td>-1.9395</td><td>3.4382</td><td>-4.9470</td><td>0.3532</td><td>0.2648</td><td>0.1278</td><td>0.2430</td></tr><tr><td>PPGN</td><td>-</td><td></td><td>-</td><td>-1.9804</td><td>-3.6147</td><td>-5.0878</td><td>0.0089</td><td>0.0096</td><td>0.0148</td><td>0.0090</td></tr><tr><td>GIN-AK+</td><td>-</td><td>-</td><td>-</td><td>-2.7513</td><td>-3.9687</td><td>-5.1846</td><td>0.0123</td><td>0.0112</td><td>0.0150</td><td>0.0126</td></tr><tr><td>K-GIN+</td><td>-2.7919</td><td>-2.5938</td><td>-4.6360</td><td>-2.1782</td><td>-3.9695</td><td>-5.3088</td><td>0.2593</td><td>0.1930</td><td>0.0165</td><td>0.2079</td></tr><tr><td>KP-GIN+</td><td>-2.7969</td><td>-2.6169</td><td>-4.7687</td><td>-4.4322</td><td>-3.9361</td><td>-5.3345</td><td>0.0060</td><td>0.0073</td><td>0.0151</td><td>0.0395</td></tr></table>
+
+Effectiveness on node/graph properties and substructure prediction: To evaluate the effectiveness of KP-GNN on node/graph properties and substructure prediction, we compare it with several existing models. For the baseline model, we use GIN [7], which has the same expressive power as the 1-WL test. For more powerful baselines, we use GIN-AK $^ +$ [27], PNA [41], and PPGN [24]. For normal $K$ -hop GNNs, we implement $\mathrm { K } { \mathrm { - G I N } } +$ , and for KP-GNN, we implement KP- $\mathrm { G I N + }$ . The results are shown in Table 2. Baseline results are taken from [27] and [41]. We can see ${ \mathrm { K P - G I N + } }$ achieve SOTA on a majority of tasks. Meanwhile, $\mathrm { K } { \mathrm { - G I N } } +$ also gets great performance on node/graph properties prediction. These results demonstrate the capability of KP-GNN to identify various properties and substructures. We leave the detailed results on counting substructures in Appendix K
+
+Table 3: TU dataset evaluation result.   
+
+<table><tr><td>Method</td><td>MUTAG</td><td>D&amp;D</td><td>PTC-MR</td><td>PROTEINS</td><td>IMDB-B</td></tr><tr><td>WL</td><td>90.4±5.7</td><td>79.4±0.3</td><td>59.9±4.3</td><td>75.0±3.1</td><td>73.8±3.9</td></tr><tr><td>GIN</td><td>89.4±5.6</td><td></td><td>64.6±7.0</td><td>75.9±2.8</td><td>75.1±5.1</td></tr><tr><td>DGCNN</td><td>85.8±1.7</td><td>79.3 ±0.9</td><td>58.6 ±2.5</td><td>75.5±0.9</td><td>70.0±0.9</td></tr><tr><td>GraphSNN</td><td>91.24±2.5</td><td>82.46±2.7</td><td>66.96±3.5</td><td>76.51±2.5</td><td>76.93±3.3</td></tr><tr><td>GIN-AK+</td><td>91.30±7.0</td><td>=</td><td>68.20±5.6</td><td>77.10±5.7</td><td>75.60±3.7</td></tr><tr><td>KP-GCN</td><td>91.7±6.0</td><td>79.0±4.7</td><td>67.1±6.3</td><td>75.8±3.5</td><td>75.9±3.8</td></tr><tr><td>KP-GraphSAGE</td><td>91.7±6.5</td><td>78.1±2.6</td><td>66.5±4.0</td><td>76.5±4.6</td><td>76.4±2.7</td></tr><tr><td>KP-GIN</td><td>92.2±6.5</td><td>79.4±3.8</td><td>66.8±6.8</td><td>75.8±4.6</td><td>76.6±4.2</td></tr><tr><td>GIN-AK+*</td><td>95.0±6.1</td><td>OOM</td><td>74.1±5.9</td><td>78.9±5.4</td><td>77.3±3.1</td></tr><tr><td>GraphSNN*</td><td>94.70±1.9</td><td>83.93±2.3</td><td>70.58±3.1</td><td>78.42±2.7</td><td>78.51±2.8</td></tr><tr><td>KP-GCN*</td><td>96.1±4.6</td><td>83.2±2.2</td><td>77.1±4.1</td><td>80.3±4.2</td><td>79.6±2.5</td></tr><tr><td>KP-GraphSAGE*</td><td>96.1±4.6</td><td>83.6±2.4</td><td>76.2±4.5</td><td>80.4±4.3</td><td>80.3±2.4</td></tr><tr><td>KP-GIN*</td><td>95.6±4.4</td><td>83.5±2.2</td><td>76.2±4.5</td><td>79.5±4.4</td><td>80.7±2.6</td></tr></table>
+
+Table 4: QM9 results. The top two are highlighted by First, Second.   
+
+<table><tr><td>Target</td><td>DTNN</td><td>MPNN</td><td>Deep LRP</td><td>PPGN</td><td>N-1-2-3-GNN</td><td>KP-GIN+</td><td>KP-GIN&#x27;</td></tr><tr><td>μ</td><td>0.244</td><td>0.358</td><td>0.364</td><td>0.231</td><td>0.433</td><td>0.367</td><td>0.358</td></tr><tr><td>α</td><td>0.95</td><td>0.89</td><td>0.298</td><td>0.382</td><td>0.265</td><td>0.242</td><td>0.233</td></tr><tr><td>εHOMO</td><td>0.00388</td><td>0.00541</td><td>0.00254</td><td>0.00276</td><td>0.00279</td><td>0.00247</td><td>0.00240</td></tr><tr><td>εLUMO</td><td>0.00512</td><td>0.00623</td><td>0.00277</td><td>0.00287</td><td>0.00276</td><td>0.00238</td><td>0.00236</td></tr><tr><td>△ε</td><td>0.0112</td><td>0.0066</td><td>0.00353</td><td>0.00406</td><td>0.00390</td><td>0.00345</td><td>0.00333</td></tr><tr><td>(R²)</td><td>17.0</td><td>28.5</td><td>19.3</td><td>16.7</td><td>20.1</td><td>16.49</td><td>16.51</td></tr><tr><td>ZPVE</td><td>0.00172</td><td>0.00216</td><td>0.00055</td><td>0.00064</td><td>0.00015</td><td>0.00018</td><td>0.00017</td></tr><tr><td>U</td><td>2.43</td><td>2.05</td><td>0.413</td><td>0.234</td><td>0.205</td><td>0.0728</td><td>0.0682</td></tr><tr><td>U</td><td>2.43</td><td>2.00</td><td>0.413</td><td>0.234</td><td>0.200</td><td>0.0553</td><td>0.0696</td></tr><tr><td>H</td><td>2.43</td><td>2.02</td><td>0.413</td><td>0.229</td><td>0.249</td><td>0.0575</td><td>0.0641</td></tr><tr><td>G</td><td>2.43</td><td>2.02</td><td>0.413</td><td>0.238</td><td>0.253</td><td>0.0526</td><td>0.0484</td></tr><tr><td>C</td><td>0.27</td><td>0.42</td><td>0.129</td><td>0.184</td><td>0.0811</td><td>0.0973</td><td>0.0869</td></tr></table>
+
+Evaluation on TU datasets: For baseline models, we select: 1) graph kernel-based method: WL subtree kernel [50]; 2) vanilla GNN methods: GIN [7] and DGCNN [6]; 3) advanced GNN methods: GraphSNN [36] and GIN- $\mathrm { \bf A K } +$ [27]. For the proposed KP-GNN, we implement GCN [1], GraphSAGE [3], and GIN [7] using the KP-GNN framework, denoted as KP-GCN, KP-GraphSAGE, and KP-GIN respectively. The results are shown in Table 3. For a more fair and comprehensive comparison, we report the results from two different evaluation settings. The first setting follows Xu et al. [7] and the second setting follows Wijesinghe and Wang [36]. We denote the second setting with ∗ in the table. We can see KP-GNN achieves SOTA performance on most of datasets under the second setting and still comparable performance to other baselines under the first setting.
+
+Table 5: ZINC result.   
+
+<table><tr><td>Method</td><td># param.</td><td>test MAE</td></tr><tr><td>MPNN</td><td>480805</td><td>0.145±0.007</td></tr><tr><td>PNA</td><td>387155</td><td>0.142±0.010</td></tr><tr><td>Graphormer</td><td>489321</td><td>0.122±0.006</td></tr><tr><td>GSN GIN-AK+</td><td>~500000</td><td>0.101±0.010 0.080±0.001</td></tr><tr><td>CIN</td><td>= 1</td><td>0.079±0.006</td></tr><tr><td>KP-GIN+</td><td>499099</td><td></td></tr><tr><td>KP-GIN&#x27;</td><td>488649</td><td>0.111±0.006 0.093±0.007</td></tr></table>
+
+Although KP-GNN does not achieve the best result, it is still comparable to other methods.
+
+Evaluation on molecular prediction tasks: For QM9 dataset, we report baseline results of DTNN and MPNN from [48]. We further select Deep LRP [42], PPGN [24], and Nested 1-2-3-GNN [26] as baseline models. For the ZINC dataset, we report results of MPNN [18] and PNA [41] from [17]. We further pick Graphormer [17], GSN [51], GIN-AK $^ +$ [27], and CIN [52]. For KP-GNN, we choose ${ \mathrm { K P - G I N } } +$ and ${ \bf K P - G I N } ^ { \prime }$ . The results of the QM9 dataset are shown in Table 4. We can see KPGNN achieves SOTA performance on most of the targets. The results of the ZINC dataset are shown in Table 5.
+
+Table 6: Running time (s/epoch).   
+
+<table><tr><td>Method</td><td>D&amp;D</td><td>ZINC</td><td>Graph property</td></tr><tr><td>GIN</td><td>1.10</td><td>3.59</td><td>1.02</td></tr><tr><td>K-GIN</td><td>3.94</td><td>6.44</td><td>1.67</td></tr><tr><td>KP-GIN</td><td>4.19</td><td>7.38</td><td>1.94</td></tr><tr><td>KP-GIN+</td><td>4.28</td><td>6.74</td><td>1.93</td></tr></table>
+
+the computational overhead is almost linear to $K$ . This is reasonable as practical graphs are sparse and the number of $K$ -hop neighbors is far less than $n$ when using a small $K$ .
+
+Running time comparison: In this section, we compare the running time of KP-GNN to 1-hop message passing GNN and $K$ -hop message passing GNN. We use GIN [7] as the base model. We also include the ${ \mathrm { K P - G I N + } }$ . All models use the same number of layers and hidden dimensions for a fair comparison. The results are shown in Table 6. We set $K = 4$ for all datasets. We can see
+
+# 6 Conclusion
+
+In this paper, we theoretically characterize the power of $K$ -hop message passing GNNs and propose the KP-GNN to improve the expressive power by leveraging the peripheral subgraph information at each hop. Theoretically, we prove that $K$ -hop GNNs can distinguish almost all regular graphs but are bounded by the 3-WL test. KP-GNN is able to distinguish many distance regular graphs. Empirically, KP-GNN achieves competitive results across all simulation and real-world datasets.
+
+# 7 Acknowledgement
+
+This work is partially supported by NSF grant CBE-2225809 and NSF China (No. 62276003).
+
+References   
+[1] Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations, 2017.   
+[2] David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alán Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in neural information processing systems, pages 2224– 2232, 2015.   
+[3] Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pages 1025–1035, 2017.   
+[4] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua ´ Bengio. Graph attention networks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id=rJXMpikCZ.   
+[5] Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.   
+[6] Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In AAAI, pages 4438–4445, 2018.   
+[7] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id $\equiv$ ryGs6iA5Km.   
+[8] Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pages 855–864. ACM, 2016.   
+[9] Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pages 701–710. ACM, 2014.   
+[10] Boris Weisfeiler and AA Lehman. A reduction of a graph to a canonical form and an algebra arising during this reduction. Nauchno-Technicheskaya Informatsia, 2(9):12–16, 1968.   
+[11] 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 Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 4602–4609, 2019.   
+[12] 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, pages 21–29. PMLR, 2019.   
+[13] Giannis Nikolentzos, George Dasoulas, and Michalis Vazirgiannis. k-hop graph neural networks. Neural Networks, 130:195–205, 2020.   
+[14] Guangtao Wang, Rex Ying, Jing Huang, and Jure Leskovec. Multi-hop attention graph neural networks. In International Joint Conference on Artificial Intelligence, 2021.   
+[15] Eli Chien, Jianhao Peng, Pan Li, and Olgica Milenkovic. Adaptive universal generalized pagerank graph neural network. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=n6jl7fLxrP.   
+[16] Rémy Brossard, Oriel Frigo, and David Dehaene. Graph convolutions that can finally model local structure. arXiv preprint arXiv:2011.15069, 2020.   
+[17] Chengxuan Ying, Tianle Cai, Shengjie Luo, Shuxin Zheng, Guolin Ke, Di He, Yanming Shen, and Tie-Yan Liu. Do transformers really perform badly for graph representation? In A. Beygelzimer, Y. Dauphin, P. Liang, and J. Wortman Vaughan, editors, Advances in Neural Information Processing Systems, 2021. URL https://openreview.net/forum?id=OeWooOxFwDa.
+
+[18] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1263–1272. JMLR. org, 2017.
+
+[19] George V. Cybenko. Approximation by superpositions of a sigmoidal function. Mathematics of Control, Signals and Systems, 2:303–314, 1989.
+
+[20] Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Russ R Salakhutdinov, and Alexander J Smola. Deep sets. In Advances in Neural Information Processing Systems, pages 3391–3401, 2017.
+
+[21] Xiyuan Wang and Muhan Zhang. How powerful are spectral graph neural networks. ICML, 2022.
+
+[22] Pan Li, Yanbang Wang, Hongwei Wang, and Jure Leskovec. Distance encoding: Design provably more powerful neural networks for graph representation learning. In Advances in Neural Information Processing Systems, volume 33, pages 4465–4478, 2020.
+
+[23] Fabrizio Frasca, Beatrice Bevilacqua, Michael M Bronstein, and Haggai Maron. Understanding and extending subgraph gnns by rethinking their symmetries. In Advances in Neural Information Processing Systems, 2022.
+
+[24] Haggai Maron, Heli Ben-Hamu, Hadar Serviansky, and Yaron Lipman. Provably powerful graph networks. In Advances in Neural Information Processing Systems, pages 2156–2167, 2019.
+
+[25] Haggai Maron, Heli Ben-Hamu, Nadav Shamir, and Yaron Lipman. Invariant and equivariant graph networks. In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id $\equiv$ Syx72jC9tm.
+
+[26] Muhan Zhang and Pan Li. Nested graph neural networks. In A. Beygelzimer, Y. Dauphin, P. Liang, and J. Wortman Vaughan, editors, Advances in Neural Information Processing Systems, 2021. URL https://openreview.net/forum?id $\ c =$ 7_eLEvFjCi3.
+
+[27] Lingxiao Zhao, Wei Jin, Leman Akoglu, and Neil Shah. From stars to subgraphs: Uplifting any GNN with local structure awareness. In International Conference on Learning Representations, 2022. URL https://openreview.net/forum?id=Mspk_WYKoEH.
+
+[28] Beatrice Bevilacqua, Fabrizio Frasca, Derek Lim, Balasubramaniam Srinivasan, Chen Cai, Gopinath Balamurugan, Michael M. Bronstein, and Haggai Maron. Equivariant subgraph aggregation networks. In International Conference on Learning Representations, 2022. URL https://openreview.net/forum?id $\equiv$ dFbKQaRk15w.
+
+[29] Zhengdao Chen, Soledad Villar, Lei Chen, and Joan Bruna. On the equivalence between graph isomorphism testing and function approximation with gnns. In Advances in Neural Information Processing Systems, pages 15894–15902, 2019.
+
+[30] Ryoma Sato, Makoto Yamada, and Hisashi Kashima. Random features strengthen graph neural networks. In Proceedings of the 2021 SIAM International Conference on Data Mining (SDM), 2021.
+
+[31] Ralph Abboud, ˙Ismail ˙Ilkan Ceylan, Martin Grohe, and Thomas Lukasiewicz. The surprising power of graph neural networks with random node initialization. In Proceedings of the Thirtieth International Joint Conference on Artificial Intelligence, IJCAI-21, pages 2112–2118, 8 2021. doi: 10.24963/ijcai.2021/291. URL https://doi.org/10.24963/ijcai.2021/291.
+
+[32] Andreas Loukas. What graph neural networks cannot learn: depth vs width. arXiv preprint arXiv:1907.03199, 2019.
+
+[33] Muhan Zhang and Yixin Chen. Link prediction based on graph neural networks. In Advances in Neural Information Processing Systems, pages 5165–5175, 2018.
+
+[34] Muhan Zhang, Pan Li, Yinglong Xia, Kai Wang, and Long Jin. Labeling trick: A theory of using graph neural networks for multi-node representation learning. In A. Beygelzimer, Y. Dauphin, P. Liang, and J. Wortman Vaughan, editors, Advances in Neural Information Processing Systems, 2021. URL https://openreview.net/forum?id $\equiv$ Hcr9mgBG6ds.   
+[35] Xiyuan Wang and Muhan Zhang. GLASS: GNN with labeling tricks for subgraph representation learning. In International Conference on Learning Representations, 2022. URL https: //openreview.net/forum?id $\equiv$ XLxhEjKNbXj.   
+[36] Asiri Wijesinghe and Qing Wang. A new perspective on ”how graph neural networks go beyond weisfeiler-lehman?”. In International Conference on Learning Representations, 2022. URL https://openreview.net/forum?id $\underset { . } { = }$ uxgg9o7bI_3.   
+[37] Jiaxuan You, Jonathan M Gomes-Selman, Rex Ying, and Jure Leskovec. Identity-aware graph neural networks. Proceedings of the AAAI Conference on Artificial Intelligence, 35(12):10737– 10745, May 2021.   
+[38] Matthias Fey and Jan Eric Lenssen. Fast graph representation learning with pytorch geometric. arXiv preprint arXiv:1903.02428, 2019.   
+[39] Muhammet Balcilar, Pierre Héroux, Benoit Gaüzère, Pascal Vasseur, Sébastien Adam, and Paul Honeine. Breaking the limits of message passing graph neural networks. In Proceedings of the 38th International Conference on Machine Learning (ICML), 2021.   
+[40] Ryan Murphy, Balasubramaniam Srinivasan, Vinayak Rao, and Bruno Ribeiro. Relational pooling for graph representations. In International Conference on Machine Learning, pages 4663–4673. PMLR, 2019.   
+[41] Gabriele Corso, Luca Cavalleri, Dominique Beaini, Pietro Liò, and Petar Velickovi ˇ c. Principal ´ neighbourhood aggregation for graph nets. In Advances in Neural Information Processing Systems, 2020.   
+[42] Zhengdao Chen, Lei Chen, Soledad Villar, and Joan Bruna. Can graph neural networks count substructures? Advances in neural information processing systems, 2020.   
+[43] Asim Kumar Debnath, de Compadre RL Lopez, Gargi Debnath, Alan J Shusterman, and Corwin Hansch. Structure-activity relationship of mutagenic aromatic and heteroaromatic nitro compounds. correlation with molecular orbital energies and hydrophobicity. Journal of medicinal chemistry, 34(2):786–797, 1991.   
+[44] Paul D Dobson and Andrew J Doig. Distinguishing enzyme structures from non-enzymes without alignments. Journal of molecular biology, 330(4):771–783, 2003.   
+[45] Hannu Toivonen, Ashwin Srinivasan, Ross D King, Stefan Kramer, and Christoph Helma. Statistical evaluation of the predictive toxicology challenge 2000–2001. Bioinformatics, 19(10): 1183–1193, 2003.   
+[46] Pinar Yanardag and SVN Vishwanathan. Deep graph kernels. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pages 1365–1374. ACM, 2015.   
+[47] Raghunathan Ramakrishnan, Pavlo O Dral, Matthias Rupp, and O Anatole Von Lilienfeld. Quantum chemistry structures and properties of 134 kilo molecules. Scientific data, 1(1):1–7, 2014.   
+[48] Zhenqin Wu, Bharath Ramsundar, Evan N Feinberg, Joseph Gomes, Caleb Geniesse, Aneesh S Pappu, Karl Leswing, and Vijay Pande. Moleculenet: a benchmark for molecular machine learning. Chemical science, 9(2):513–530, 2018.   
+[49] Vijay Prakash Dwivedi, Chaitanya K Joshi, Anh Tuan Luu, Thomas Laurent, Yoshua Bengio, and Xavier Bresson. Benchmarking graph neural networks. arXiv preprint arXiv:2003.00982, 2020.
+
+[50] Nino Shervashidze, Pascal Schweitzer, Erik Jan van Leeuwen, Kurt Mehlhorn, and Karsten M Borgwardt. Weisfeiler-lehman graph kernels. Journal of Machine Learning Research, 12(Sep): 2539–2561, 2011.
+
+[51] Giorgos Bouritsas, Fabrizio Frasca, Stefanos Zafeiriou, and Michael M. Bronstein. Improving graph neural network expressivity via subgraph isomorphism counting, 2021. URL https: //openreview.net/forum?id $\equiv$ LT0KSFnQDWF.
+
+[52] Cristian Bodnar, Fabrizio Frasca, Nina Otter, Yu Guang Wang, Pietro Liò, Guido Montufar, and Michael M. Bronstein. Weisfeiler and lehman go cellular: CW networks. In A. Beygelzimer, Y. Dauphin, P. Liang, and J. Wortman Vaughan, editors, Advances in Neural Information Processing Systems, 2021. URL https://openreview.net/forum?id=uVPZCMVtsSG.
+
+[53] Béla Bollobás. Distinguishing vertices of random graphs. In Béla Bollobás, editor, Graph Theory, volume 62 of North-Holland Mathematics Studies, pages 33–49. North-Holland, 1982. doi: https://doi.org/10.1016/S0304-0208(08)73545-X. URL https://www.sciencedirect. com/science/article/pii/S030402080873545X.
+
+[54] Béla Bollobás. A Probabilistic Proof of an Asymptotic Formula for the Number of Labelled Regular Graphs. European Journal of Combinatorics, 1(4):311–316, December 1980. ISSN 0195-6698. doi: 10.1016/S0195-6698(80)80030-8. URL https://www.sciencedirect. com/science/article/pii/S0195669880800308.
+
+[55] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017.
+
+[56] Floris Geerts. The expressive power of kth-order invariant graph networks. ArXiv, abs/2007.12035, 2020.
+
+[57] Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attentionbased neural machine translation. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pages 1412–1421, Lisbon, Portugal, September 2015. Association for Computational Linguistics. doi: 10.18653/v1/D15-1166. URL https://aclanthology.org/D15-1166.
+
+[58] 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, 2018.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] The implementation of KP-GNN can be found at https://github.com/JiaruiFeng/KP-GNN.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [No] The license can be found in their github.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] All datasets we used are all open-sourced.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] There is no personal information in the datasets.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/dev/nN3aVRQsxGd/nN3aVRQsxGd_content_list.json

@@ -0,0 +1,1503 @@
+[
+    {
+        "type": "text",
+        "text": "How Powerful are $K$ -hop Message Passing Graph Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            199,
+            122,
+            800,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jiarui Feng1,2 Yixin Chen1 Fuhai $\\mathbf { L i } ^ { 2 }$ Anindya Sarkar1 Muhan Zhang3,4 {feng.jiarui, fuhai.li, anindya}@wustl.edu, chen@cse.wustl.edu, muhan@pku.edu.cn 1Department of CSE, Washington University in St. Louis 2Institute for Informatics, Washington University School of Medicine 3Institute for Artificial Intelligence, Peking University 4Beijing Institute for General Artificial Intelligence ",
+        "bbox": [
+            235,
+            219,
+            767,
+            321
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            357,
+            535,
+            373
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The most popular design paradigm for Graph Neural Networks (GNNs) is 1-hop message passing—aggregating information from 1-hop neighbors repeatedly. However, the expressive power of 1-hop message passing is bounded by the WeisfeilerLehman (1-WL) test. Recently, researchers extended 1-hop message passing to $K$ -hop message passing by aggregating information from $K$ -hop neighbors of nodes simultaneously. However, there is no work on analyzing the expressive power of $K$ -hop message passing. In this work, we theoretically characterize the expressive power of $K$ -hop message passing. Specifically, we first formally differentiate two different kernels of $K$ -hop message passing which are often misused in previous works. We then characterize the expressive power of $K$ -hop message passing by showing that it is more powerful than 1-WL and can distinguish almost all regular graphs. Despite the higher expressive power, we show that $K$ -hop message passing still cannot distinguish some simple regular graphs and its expressive power is bounded by 3-WL. To further enhance its expressive power, we introduce a KP-GNN framework, which improves $K$ -hop message passing by leveraging the peripheral subgraph information in each hop. We show that KP-GNN can distinguish many distance regular graphs which could not be distinguished by previous distance encoding or 3-WL methods. Experimental results verify the expressive power and effectiveness of KP-GNN. KP-GNN achieves competitive results across all benchmark datasets. ",
+        "bbox": [
+            233,
+            388,
+            766,
+            665
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            694,
+            310,
+            710
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Currently, most existing graph neural networks (GNNs) follow the message passing framework, which iteratively aggregates information from the neighbors and updates the representations of nodes. It has shown superior performance on graph-related tasks [1, 2, 3, 4, 5, 6, 7] comparing to traditional graph embedding techniques [8, 9]. However, as the procedure of message passing is similar to the 1-dimensional Weisfeiler-Lehman (1-WL) test [10], the expressive power of message passing GNNs is also bounded by the 1-WL test [7, 11]. Namely, GNNs cannot distinguish two non-isomorphic graph structures if the 1-WL test fails. ",
+        "bbox": [
+            174,
+            726,
+            825,
+            823
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In normal message passing GNNs, the node representation is updated by the direct neighbors of the node, which are called 1-hop neighbors. Recently, some works extend the notion of message passing into $K$ -hop message passing [12, 13, 14, 15, 16]. $K$ -hop message passing is a type of message passing where the node representation is updated by aggregating information from not only 1st hop but all the neighbors within $K$ hops of the node. However, there is no work on theoretically characterizing the expressive power of GNNs with $K$ -hop message passing, e.g., whether it can improve the 1-hop message passing or not and to what extent it can. ",
+        "bbox": [
+            174,
+            830,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we theoretically characterize the expressive power of $K$ -hop message passing GNNs. Specifically, 1) we formally distinguish two different kernels of the $K$ -hop neighbors, which are often misused in previous works. The first kernel is based on whether the node can be reached within $k$ steps of the graph diffusion process, which is used in GPR-GNN [15] and MixHop [12]. The second one is based on the shortest path distance of $k$ , which is used in $\\mathrm { G I N E + }$ [16] and Graphormer [17]. Further, we show that different kernels of $K$ -hop neighbors will result in different expressive power of $K$ -hop message passing. 2) We show that $K$ -hop message passing is strictly more powerful than 1-hop message passing and can distinguish almost all regular graphs. 3) However, it still failed in distinguishing some simple regular graphs, no matter which kernel is used, and its expressive power is bounded by 3-WL. This motivates us to improve $K$ -hop message passing further. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            277
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here, we introduce KP-GNN, a new GNN framework with $K$ -hop message passing, which significantly improves the expressive power of standard $K$ -hop message passing GNNs. In particular, during the aggregation of neighbors in each hop, KP-GNN not only aggregates neighboring nodes in that hop but also aggregates the peripheral subgraph (subgraph induced by the neighbors in that hop). This additional information helps the KP-GNN to learn more expressive local structural features around the node. We further show that KP-GNN can distinguish many distance regular graphs with a proper encoder for the peripheral subgraph. The proposed KP-GNN has several additional advantages. First, it can be applied to most existing $K$ -hop message-passing GNNs with only slight modification. Second, it only adds little computational complexity to standard $K$ -hop message passing. We demonstrate the effectiveness of the KP-GNN framework through extensive experiments on both simulation and real-world datasets. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            436
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 $K$ -hop message passing and its expressive power ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            455,
+            607,
+            473
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Notations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            486,
+            281,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Denote a graph as $G = ( V , E )$ , where $V = \\{ 1 , 2 , . . . , n \\}$ is the node set and $E \\subseteq V \\times V$ is the edge set. Meanwhile, denote $\\dot { A } \\in \\{ 0 , 1 \\} ^ { n \\times n }$ as the adjacency matrix of graph $G$ . Denote $x _ { v }$ as the feature vector of node $v$ and denote $e _ { u v }$ as the feature vector of the edge from $u$ to $v$ . Finally, we denote $Q _ { v , G } ^ { 1 }$ as the set of 1-hop neighbors of node $v$ in graph $G$ and $\\mathcal { N } _ { v , G } ^ { 1 ^ { - } } { = } Q _ { v , G } ^ { 1 } \\cup \\{ v \\}$ . Note that when we say $K$ -hop neighbors of node $v$ , we mean all the neighbors that have distance from node $v$ less than or equal to $K$ . In contrast, $k$ -th hop neighbors mean the neighbors with exactly distance $k$ from node $v$ . The definition of distance will be discussed in section 2.3. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            609
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 1-hop message passing framework ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            626,
+            449,
+            641
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Currently, most existing GNNs are designed based on 1-hop message passing framework [18]. Denote $h _ { v } ^ { l }$ as the output representation of node $v$ at layer $l$ and $h _ { v } ^ { 0 } = x _ { v }$ . Briefly, given a graph $G$ and a 1-hop message passing GNN, at layer $l$ of the GNN, $h _ { v } ^ { l }$ is computed by $h _ { v } ^ { l - 1 }$ and $\\{ h _ { u } ^ { l - 1 } \\mid u \\in Q _ { v , G } ^ { 1 } \\}$ : ",
+        "bbox": [
+            174,
+            651,
+            825,
+            695
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/305c0ee3f41fdb92d2e7e22ad51ff18f0cae65c73aa6024f10ddd7244a5dc726.jpg",
+        "text": "$$\nm _ { v } ^ { l } = \\mathrm { { \\bf M E S } } ^ { l } ( \\{ ( h _ { u } ^ { l - 1 } , e _ { u v } ) | u \\in Q _ { v , G } ^ { 1 } \\} ) , h _ { v } ^ { l } = \\mathrm { { \\bf U P D } } ^ { l } ( m _ { v } ^ { l } , h _ { v } ^ { l - 1 } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            702,
+            714,
+            723
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $m _ { v } ^ { l }$ is the message to node $v$ at layer $l$ , $\\mathrm { M E S } ^ { l }$ and $\\mathrm { U P D } ^ { l }$ are message and update functions at layer $l$ respectively. After $L$ layers of message passing, $h _ { v } ^ { L }$ is used as the final representation of node $v$ . Such a representation can be used to conduct node-level tasks like node classification and node regression. To get the graph representation, a readout function is used: ",
+        "bbox": [
+            173,
+            728,
+            825,
+            785
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5898975c9eda0a4e50611b10bc85bdc902a3af6c013579160cbed22c065ce94b.jpg",
+        "text": "$$\nh _ { G } = \\mathrm { R E A D O U T } ( \\{ h _ { v } ^ { L } | v \\in V \\} ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            790,
+            611,
+            809
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where READOUT is the readout function for computing the final graph representation. Then $h _ { G }$ can be used to conduct graph-level tasks like graph classification and graph regression. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.3 $K$ -hop message passing framework ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            857,
+            459,
+            873
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The 1-hop message passing framework can be directly generalized to $K$ -hop message passing, as it shares the same message and update mechanism. The difference is that independent message and update functions can be employed for each hop. Meanwhile, a combination function is needed to combine the results from different hops into the final node representation at this layer. First, we differentiate two different kernels of $K$ -hop neighbors, which are interchanged and misused in previous research. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            826,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The first kernel of $K$ -hop neighbors is shortest path distance (spd) kernel. Namely, the $k$ -th hop neighbors of node $v$ in graph $G$ is the set of nodes with the shortest path distance of $k$ from $v$ . ",
+        "bbox": [
+            171,
+            152,
+            823,
+            181
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 1. For a node v in graph G, the K-hop neighbors N K,spdv,G of $v$ based on shortest path distance kernel is the set of nodes that have the shortest path distance from node $v$ less than or equal to $K$ . We further denote $Q _ { v , G } ^ { k , s p d }$ as the set of nodes in $G$ that are exactly the $k$ -th hop neighbors (with shortest path distance of exactly $k$ ) and $\\mathcal { N } _ { v , G } ^ { 0 , s p d } = Q _ { v , G } ^ { 0 , s p d } = \\{ v \\}$ is the node itself. ",
+        "bbox": [
+            173,
+            185,
+            825,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The second kernel of the $K$ -hop neighbors is based on graph diffusion $( g d )$ . ",
+        "bbox": [
+            176,
+            265,
+            669,
+            280
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 2. For a node v in graph $G$ , the $K$ -hop neighbors $\\mathcal { N } _ { v , G } ^ { K , g d }$ of v based on graph diffusion kernel is the sediffusion steps nodes that can diffuse iand the diffusion kernel ormation to node (adjacency matr $v$ within the number). We further denote dom walk as the set $K$ $A$ $Q _ { v , G } ^ { k , g d }$ of nodes in that are exactly the -th hop neighbors (nodes that can diffuse information to node with k diffusion steps) and N 0,gdv,G $\\mathcal { N } _ { v , G } ^ { 0 , g d } = Q _ { v , G } ^ { 0 , g \\bar { d } } = \\bar { \\{ v \\} }$ is the node itself. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            366
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that a node can be a $k$ -th hop neighbor of $v$ for multiple $k$ based on the graph diffusion kernel, but it can only appear in one hop for the shortest path distance kernel. We include more discussions of $K$ -hop kernels in Appendix A. Next, we define the $K$ -hop message passing framework as follows: ",
+        "bbox": [
+            174,
+            376,
+            826,
+            419
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a41652654729b33de32ecc7a1984675370dc400f57ba2c723996e6ef1d4f30db.jpg",
+        "text": "$$\n\\begin{array} { r } { m _ { v } ^ { l , k } = \\mathrm { M E S } _ { k } ^ { l } ( \\{ ( h _ { u } ^ { l - 1 } , e _ { u v } ) | u \\in Q _ { v , G } ^ { k , t } ) \\} ) , h _ { v } ^ { l , k } = \\mathrm { U P D } _ { k } ^ { l } ( m _ { v } ^ { l , k } , h _ { v } ^ { l - 1 } ) , } \\\\ { h _ { v } ^ { l } = \\mathrm { C O M B I N E } ^ { l } ( \\{ \\{ h _ { v } ^ { l , k } | k = 1 , 2 , . . . , K \\} \\} ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            424,
+            736,
+            468
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $t \\in \\{ s p d , g d \\}$ , spd is the shortest path distance kernel and $_ { g d }$ is the graph diffusion kernel. Here, for each hop, we can apply unique MES and UPD functions. Note that for $k > 1$ , there may not exist the edge feature $e _ { u v }$ as nodes are not directly connected. But we leave it here since we can use other types of features to replace it like path encoding. We further discuss it in Appendix I. Compared to the 1-hop message passing framework described in Equation (1), the COMBINE function is introduced to combine the representations of node $v$ at different hops. It is easy to see that a $L$ layer 1-hop message passing GNNs is actually a $L$ layer $K$ -hop message passing GNNs with $K = 1$ . We include more discussions of $K$ -hop message passing GNNs in Appendix A. To aid further analysis, we also prove that $K$ -hop message passing can injectively encode the neighbor representations at different hops into $h _ { v } ^ { l }$ in Appendix B. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            612
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 Expressive power of $K$ -hop message passing framework ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            627,
+            601,
+            642
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we theoretically analyze the expressive power of $K$ -hop message passing. We assume there is no edge feature and all nodes in the graph have the same feature, which means that GNNs can only distinguish two nodes with the local structure of nodes. Note that including node features only increases the expressive power of GNNs as nodes/graphs are more easily to be discriminated. It has been proved that the expressive power of 1-hop message passing is bounded by the 1-WL test on discriminating non-isomorphic graphs [7, 11]. In this section, We show that the $K$ -hop message passing is strictly more powerful than the 1-WL test when $K > 1$ . Across the analysis, we utilize regular graphs as examples to illustrate our theorems since they cannot be distinguished using either 1-hop message passing or the 1-WL test. To begin the analysis, we first define proper $K$ -hop message passing GNNs. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            791
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 3. A proper $K$ -hop message passing GNN is a GNN model where the message, update, and combine functions are all injective given the input from a countable space. ",
+        "bbox": [
+            173,
+            795,
+            821,
+            824
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A proper $K$ -hop message passing GNN is easy to find due to the universal approximation theorem [19] of neural network and the Deep Set for set operation [20]. In the latter sections, by default, all mentioned $K$ -hop message passing GNNs are proper. Next, we introduce node configuration: ",
+        "bbox": [
+            174,
+            834,
+            825,
+            877
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 4. The node configuration of node v in graph $G$ within $K$ hops under t kernel is a list $A _ { v , G } ^ { K , t } = ( a _ { v , G } ^ { 1 , t } , a _ { v , G } ^ { 2 , t } , . . . , a _ { v , G } ^ { K , t } )$ , where $a _ { v , G } ^ { i , t } = | Q _ { v , G } ^ { i , t } |$ is the number of $i$ -th hop neighbors of node v. ",
+        "bbox": [
+            173,
+            881,
+            821,
+            914
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/6717718d9a0f12e65c4bf76a241bcd84384ca02b31ebd9cd9710377c107a2563.jpg",
+        "image_caption": [
+            "Figure 1: Here are two pairs of non-isomorphic regular graphs. With 2-hop message passing, example 1 can be distinguished by the graph diffusion kernel, and example 2 can be distinguished by the shortest path distance kernel. However, both two examples become indistinguishable if we switch the kernel. Finally, both two examples can be distinguished by adding peripheral subgraph information. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            107,
+            803,
+            324
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When we say two node configurations AK,t v1,G(1) and AK,t $A _ { v _ { 2 } , G ^ { ( 2 ) } } ^ { K , t }$ are equal, we mean that these two lists are component-wise equal to each other. Now, we state the first proposition: ",
+        "bbox": [
+            176,
+            392,
+            820,
+            425
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. A proper $K$ -hop message passing GNN is strictly more powerful than 1-hop message passing GNNs when $K > 1$ . ",
+        "bbox": [
+            174,
+            429,
+            821,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To see why this is true, we first discuss how node configuration relates to the first layer of message passing. In the first layer of $K$ -hop message passing, each node aggregates neighbors from up to $K$ hops. As each node has the same node label, an injective message function can only know how many neighbors at each hop, which is exactly the node configuration. In other words, The first layer of $K$ -hop message passing is equivalent to inject node configuration to each node label. When $K = 1$ , the node configuration of $v _ { 1 }$ and $v _ { 2 }$ are $d _ { v _ { 1 } , G ^ { ( 1 ) } }$ and $d _ { v _ { 2 } , G ^ { ( 2 ) } }$ , where $d _ { v , G }$ is the node degree of $v$ . After $L$ layers, GNNs can only get the node degree information of each node within $L$ hops of node $v$ . Then, it is straightforward to see why these GNNs cannot distinguish any $n$ -sized $r$ -regular graph, as each node in the regular graph has the same degree. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            592
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next, when $K > 1$ , the $K$ -hop message passing is at least equally powerful as 1-hop message passing since node configuration up to $K$ hop includes all the information the 1 hop has. To see why it is more powerful, we use two examples to illustrate it. The first example is shown in the left part of Figure 1. Suppose here we use graph diffusion kernel and we want to learn the representation of node $v _ { 1 }$ and node $v _ { 2 }$ in the two graphs. We know that the 1-hop GNNs produce the same representation for two nodes as they are both nodes in 6-sized 3-regular graphs. However, it is easy to see that $v _ { 1 }$ and $v _ { 2 }$ have different local structures and should have different representations. Instead, if we use the 2-hop message passing with the graph diffusion kernel, we can easily distinguish two nodes by checking the 2nd hop neighbors of the node, as node $v _ { 1 }$ has four 2nd hop neighbors but node $v _ { 2 }$ only has two 2nd hop neighbors. The second example is shown in the right part of Figure 1. Two graphs in the example are still regular graphs. Suppose here we use shortest path distance kernel, node $v _ { 1 }$ and $v _ { 2 }$ have different numbers of 2nd hop neighbors and thus will have different representations by performing 2-hop message passing. These two examples convincingly demonstrate that the $K$ -hop message passing with $K > 1$ can have better expressive power than $K = 1$ . To further study the expressive power of $K$ -hop message passing on regular graphs, we show the following result: ",
+        "bbox": [
+            173,
+            598,
+            825,
+            805
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. Consider all pairs of $n$ -sized $r$ -regular graphs, let $3 \\leq r < ( 2 l o g 2 n ) ^ { 1 / 2 }$ and $\\epsilon$ be a fixed constant. With at most $\\begin{array} { r } { K = \\lfloor ( \\frac { 1 } { 2 } + \\epsilon ) \\frac { \\log { 2 n } } { \\log { ( r - 1 ) } } \\rfloor } \\end{array}$ , there exists a $I$ layer $K$ -hop message passing GNN using the shortest path distance kernel that distinguishes almost all $1 - o ( n ^ { - 1 / 2 } )$ such pairs of graphs. ",
+        "bbox": [
+            173,
+            809,
+            825,
+            873
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We include the proof and simulation results in Appendix C. Theorem 1 shows that even with 1 layer and a modest $K$ , $K$ -hop GNNs are powerful enough to distinguish almost all regular graphs. ",
+        "bbox": [
+            174,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, we characterize the existing $K$ -hop methods with the proposed $K$ -hop message passing framework. Specifically, we show that 1) the expressive power of $K$ layer GINE [16] is bounded by $K$ layer $K$ -hop message passing with the shortest path distance kernel. 2) The expressive power of the Graphormer [17] is equal to $K$ -hop GNNs with the shortest path distance kernel and infinity $K$ . 3) For spectral GNNs and existing $K$ -hop GNNs with the graph diffusion kernel like MixHop [12] and MAGNA [14], we find they actually use a weak version of $K$ -hop than the definition of us. Specifically, it is shown that the expressive power of spectral GNNs is also bounded by 1-WL test [21], which contradicts our result as graph diffusion can be viewed as a special case of spectral GNN. However, we show that our definition of $K$ -hop message passing with graph diffusion kernel actually injects a non-linear function on the spectral basis, thus achieving superior expressive power. We leave the detailed discussion in Appendix D. Further, Distance Encoding [22] also uses the shortest path distance information to augment the 1-hop message passing, which is similar to $K$ -hop GNNs with the shortest path distance kernel. However, we find the expressive power of the two frameworks differs from each other. We leave the detailed discussion in Appendix E. ",
+        "bbox": [
+            174,
+            90,
+            826,
+            285
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.5 Limitation of $K$ -hop message passing framework ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            305,
+            553,
+            320
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Although we show that $K$ -hop GNNs with $K > 1$ are better at distinguishing non-isomorphic structures than 1-hop GNNs, there are still limitations. In this section, we discuss the limitation of $K$ -hop message passing. Specifically, we show that the choice of the kernel can affect the expressive power of $K$ -hop message passing. Furthermore, even with $K$ -hop message passing, we still cannot distinguish some simple non-isomorphic structures and the expressive power of $K$ -hop message passing is bounded by 3-WL. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            415
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Continue looking at the provided examples in Figure 1. In example 1, if we use the shortest path distance kernel instead of the graph diffusion kernel, two nodes have the same number of neighbors in the 2nd hop, which means that we cannot distinguish two nodes this time. Similarly, in example 2, two nodes have the same number of neighbors in both 1st and 2nd hops using graph diffusion kernel. These results highlight that the choice of the kernel can affect the expressive power of $K$ -hop message passing, and none of them can distinguish both two examples with 2-hop message passing. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            505
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Recently, Frasca et al. [23] show that any subgraph-based GNNs with node-based selection policy can be implemented by 3-IGN [24, 25] and thus their expressive power is bounded by 3-WL test. Here, we show that the $K$ -hop message passing GNNs can also be implemented by 3-IGN for both two kernels and thus: ",
+        "bbox": [
+            174,
+            511,
+            825,
+            566
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. The expressive power of a proper $K$ -hop message passing GNN of any kernel is bounded by the 3-WL test. ",
+        "bbox": [
+            174,
+            573,
+            823,
+            602
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We include the proof in Appendix F. Given all these observations, we may wonder if there is a way to further improve the expressive power of $K$ -hop message passing? ",
+        "bbox": [
+            173,
+            614,
+            823,
+            643
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 KP-GNN: improving the power of $K$ -hop message passing by peripheral subgraph ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            666,
+            808,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe how to improve the expressive power of $K$ -hop message passing by adding additional information to the message passing framework. Specifically, by adding peripheral subgraph information, we can improve the expressive power of the $K$ -hop message passing by a large margin. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            773
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Peripheral edge and peripheral subgraph ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            794,
+            501,
+            809
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "First, we define peripheral edge and peripheral subgraph. ",
+        "bbox": [
+            174,
+            820,
+            553,
+            835
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 5. The peripheral edge $E ( Q _ { v , G } ^ { k , t } )$ is defined as the set of edges that connect nodes within set $Q _ { v , G } ^ { k , t }$ . We further denote $| E ( Q _ { v , G } ^ { k , t } ) |$ as the number of peripheral edge in $E ( Q _ { v , G } ^ { k , t } )$ . The peripheral subgraph Gk,tv,G $G _ { v , G } ^ { k , t } = ( Q _ { v , G } ^ { k , t } , E ( Q _ { v , G } ^ { k , t } ) )$ is defined as the subgraph induced by $Q _ { v , G } ^ { k , t }$ from the whole graph $G$ . ",
+        "bbox": [
+            174,
+            842,
+            826,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Briefly speaking, the peripheral edge $E ( Q _ { v , G } ^ { k , t } )$ record all the edges whose two ends are both from $Q _ { v , G } ^ { k , t }$ and the peripheral subgraph is a graph constituted by peripheral edges. It is easy to see that the peripheral subgraph $G _ { v , G } ^ { k , t }$ automatically contains all the information of peripheral edge $E ( Q _ { v , G } ^ { k , t } )$ . Next, we show that the power of $K$ -hop message passing can be improved by leveraging the information of peripheral edges and peripheral subgraphs. We again refer to the examples in Figure 1. Here we only consider the peripheral edge information. In example 1, we notice that at the 1st hop, there is an edge between node 3 and node 4 in the left graph. More specifically, $E ( Q _ { v _ { 1 } , G ^ { ( 1 ) } } ^ { 1 , t } ) \\stackrel { - } { = } \\{ ( 3 , 4 ) \\}$ . In contrast, we have $E ( Q _ { v _ { 2 } , G ^ { ( 2 ) } } ^ { 1 , t } ) = \\{ \\}$ in the right graph, which means there is no edge between the 1st hop neighbors of $v _ { 2 }$ . Therefore, we can successfully distinguish these two nodes by adding this information to the message passing. Similarly, in example 2, there is one edge between the 1st hop neighbors of node $v _ { 2 }$ , but no such edge exists for node $v _ { 1 }$ . By leveraging peripheral edge information, we can also distinguish the two nodes. The above examples demonstrate the effectiveness of the peripheral edge and peripheral subgraph information. ",
+        "bbox": [
+            173,
+            88,
+            826,
+            292
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 $K$ -hop peripheral-subgraph-enhanced graph neural network ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            310,
+            637,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose $\\mathbf { K }$ -hop Peripheral-subgraph-enhanced Graph Neural Network (KP-GNN), which equips $K$ -hop message passing GNNs with peripheral subgraph information for more powerful GNN design. Recall the $K$ -hop message passing defined in Equation (3). The only difference between KP-GNN and original $K$ -hop GNNs is that we revise the message function as follows: ",
+        "bbox": [
+            174,
+            337,
+            825,
+            393
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15635446b9afcfc4cb80ceb9b745d310a817f09dcfd12361a672f257f57baf15.jpg",
+        "text": "$$\n\\begin{array} { r } { m _ { v } ^ { l , k } = \\mathbf { M E S } _ { k } ^ { l } ( \\{ ( h _ { u } ^ { l - 1 } , \\ e _ { u v } ) | u \\in Q _ { v , G } ^ { k , t } \\} , \\ G _ { v , G } ^ { k , t } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            402,
+            663,
+            424
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Briefly speaking, in the message step at the $k$ -th hop, we not only aggregate information of the neighbors but also the peripheral subgraph at that hop. The implementation of KP-GNN can be very flexible, as any graph encoding function can be used. To maximize the information the model can encode while keeping it simple, we implement the message function as: ",
+        "bbox": [
+            174,
+            433,
+            825,
+            489
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9553c3d581bf6b39db2d10a049a422d4d393b91affd37c05257b4d366760d71e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { M E S } _ { k } ^ { l } = \\mathbf { M E S } _ { k } ^ { l , n o r m a l } ( \\ P ( h _ { u } ^ { l - 1 } , e _ { u v } ) | u \\in Q _ { v , G } ^ { k , t } \\| ) + f ( G _ { v , G } ^ { k , t } ) , } \\\\ & { \\qquad f ( G _ { v , G } ^ { k , t } ) = \\mathbf { E M B } ( ( E ( Q _ { v , G } ^ { k , t } ) , C _ { k } ^ { k ^ { \\prime } } ) ) ~ , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            513,
+            705,
+            561
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where MESl,normal denotes the message function in the original GNN model, $C _ { k } ^ { k ^ { \\prime } }$ is the $k ^ { \\prime }$ configuration, which encode both node configuration and the number of the peripheral edge of all nodes in $G _ { v , G } ^ { k , t }$ up to $k ^ { \\prime }$ hops. It can be regarded as running another 1 layer KP-GNN and readout function on each peripheral subgraph. EMB is a learnable embedding function. With this implementation, any base GNN model can be incorporated into and be enhanced by the KP-GNN framework by replacing $\\mathbf { M E S } _ { k } ^ { l , n o r m a l }$ and $\\mathrm { U P D } _ { k } ^ { l }$ with the corresponding functions for each hop $k$ . We leave the detailed implementation in Appendix I. ",
+        "bbox": [
+            173,
+            577,
+            826,
+            684
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 The expressive power of KP-GNN and comparison with existing methods ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            700,
+            718,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we theoretically characterize the expressive power of KP-GNN and compare it with the original $K$ -hop message passing framework. The key insight is that, according to Equation (4), the message function at the $k$ -th hop additionally encodes $G _ { v , G } ^ { k , t }$ compared to normal $K$ -hop message passing. As we have already shown in the last section, -hop GNNs are bounded by 3-WL and thus cannot distinguish any non-isomorphic distance regular graphs, as well as Distance Encoding [22]. Let C k′ b e the $k ^ { \\prime }$ -configuration of peripheral subgraph at $j$ -th hop of nodes in distance regular graph $G$ . Here we show that with the aid of peripheral subgraphs, KP-GNN is able to distinguish distance regular graphs: ",
+        "bbox": [
+            173,
+            727,
+            826,
+            844
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proposition 2. For two non-isomorphic distance regular graphs $G ^ { ( 1 ) } = ( V ^ { ( 1 ) } , E ^ { ( 1 ) } )$ and $G ^ { ( 2 ) } =$ $( V ^ { ( 2 ) } , E ^ { ( 2 ) } )$ with the same diameter $d$ and intersection array $( b _ { 0 } , b _ { 1 } , . . . , b _ { d - 1 } ; c _ { 1 } , c _ { 2 } , . . . , c _ { d } )$ . Given $a$ er an $^ { l }$ - $d$ $K P$ th messafor some s defined in Equation (5), it can distinguish. $G ^ { ( 1 ) }$ $G ^ { ( 2 ) } i f C _ { j , G ^ { ( 1 ) } } ^ { k ^ { \\prime } } \\ne C _ { j , G ^ { ( 2 ) } } ^ { k ^ { \\prime } }$ C k′j,G(2) 0 < j ≤ d ",
+        "bbox": [
+            173,
+            849,
+            825,
+            915
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a336ebea6c6a59a9a5ed56e6e6e2ef027008203798580fdef176ebc1b04f6672.jpg",
+        "image_caption": [
+            "Figure 2: An example of two non-isomorphic distance regular graph with intersection array $( 6 , 3 ; 1 , 2 )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            80,
+            741,
+            352
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We include the proof in Appendix G. Here we leverage an example in Figure 2 to briefly show why KP-GNN is able to distinguish distance regular graphs. Figure 2 displays two distance regular graphs with an intersection array of $( 6 , 3 ; 1 , 2 )$ . The left one is Shrikhande graph and the right one is $4 \\times 4$ Rook’s graph. Now, let’s look at the 1-hop peripheral subgraph of the green node. In the Shrikhande graph, there are 6 peripheral edges marked with red. Further, 6 edges constitute a circle. In the $4 \\times 4$ Rook’s graph, there are still 6 peripheral edges. However, 6 edges constitute two circles with 3 edges in each circle, which is different from the Shrikhande graph. Then, any peripheral subgraph encoder that can distinguish these two graphs like node configuration enables the corresponding KP-GNN to distinguish the example. Proposition 2 shows that the KP-GNN is capable of distinguishing distance regular graphs, which further distinguishes KP-GNN from DE-1 [22] as it cannot distinguish any two connected distance regular graphs with the same intersection arrays according to Theorem 3.7 in [22]. However, it is currently unknown whether can KP-GNN with Equation 5 distinguish all distance regular graphs. We leave the detailed discussion in Appendix G. ",
+        "bbox": [
+            174,
+            385,
+            825,
+            565
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Moreover, both the subgraph-based GNNs like NGNN [26], GNN-AK [27], ESAN [28], and KPGNN leverage the information in the subgraph to enhance the power of message passing. However, KP-GNN is intrinsically different from them. Firstly, in KP-GNN, the message passing is performed on the whole graph instead of the subgraphs. This means that for each node, there is only one representation to be learned. Instead, for subgraph-based GNNs, the message passing is performed separately for each subgraph and each node could have multiple representations depending on which subgraph it is in. Secondly, in subgraph-based GNNs, they consider the subgraph as a whole without distinguishing nodes at different hops. Instead, KP-GNN takes one step further by dividing the subgraph into two parts. The first part is the hierarchy of neighbors at each hop. The second part is the connection structure between nodes in each hop. This gives us a better point of view to design a more powerful learning method. From the Corollary 7 in [23], we know that all subgraph-based GNNs with node selection as subgraph policy is bounded by 3-WL, which means they cannot distinguish any distance regular graph and KP-GNN is better at it. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            751
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 Time, space complexity, and limitation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            772,
+            480,
+            787
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss the time and space complexity of $K$ -hop message passing GNN and KPGNN. Suppose a graph has $n$ nodes and $m$ edges. Then, the $K$ -hop message passing and KP-GNN have both the space complexity of $O ( n )$ and the time complexity of $O ( \\bar { n } ^ { 2 } )$ for the shortest path distance kernel. Note that the complexity of graph diffusion is no less than the shortest path distance kernel. We can see that KP-GNN only requires the same space complexity as vanilla GNNs and much less time complexity than the subgraph-based GNNs, which are at least $O ( n m )$ . However, $K$ -hop message passing including KP-GNN still have intrinsic limitation. We leave a detailed discussion on the complexity and limitation of KP-GNN in Appendix $_ \\mathrm { H }$ . ",
+        "bbox": [
+            174,
+            800,
+            826,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            321,
+            106
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Expressive power of GNN. Analyzing the expressive power of GNNs is a crucial problem as it can serve as a guide on how to improve GNNs. Xu et al. [7] and Morris et al. [11] first proved that the power of 1-hop message passing is bounded by the 1-WL test. In other words, 1-hop message passing cannot distinguish any non-isomorphic graphs that the 1-WL test fails to. In recent years, many efforts have been put into increasing the expressive power of 1-hop messaging passing. The first line of research tries to mimic the higher-order WL tests, like 1-2-3 GNN [11], PPGN [24], ring-GNN [29]. However, they require exponentially increasing space and time complexity w.r.t. node number and cannot be generalized to large-scale graphs. The second line of research tries to enhance the rooted subtree of 1-WL with additional features. Some works [30, 31, 32] add one-hot or random features into nodes. Although they achieve good results in some settings, they deteriorate the generalization ability as such features produce different representations for nodes even with the same local graph structure. Some works like Distance Encoding [22], SEAL [33], labeling trick [34] and GLASS [35] introduce node labeling based on either distance or distinguishing target node set. On the other hand, GraphSNN [36] introduces a hierarchy of local isomorphism and proposes structural coefficients as additional features to identify such local isomorphism. However, the function designed to approximate the structural coefficient cannot fully achieve its theoretical power. The third line of research resorts to subgraph representation. Specifically, ID-GNN [37] extracts ego-netwok for each node and labels the root node with a different color. NGNN [26] encodes a rooted subgraph instead of a rooted subtree by subgraph pooling thus achieving superior expressive power on distinguishing regular graphs. GNN-AK [27] applies a similar idea as NGNN. The only difference lies in how to compute the node representation from the local subgraph. However, such methods need to run an inner GNN on every node of the graph thus introducing much more computation overhead. Meanwhile, the expressive power of subgraph GNNs are bounded by 3-WL [23]. ",
+        "bbox": [
+            174,
+            122,
+            825,
+            440
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "$K$ -hop message passing GNN. There are some existing works that instantiate the $K$ -hop message passing framework. For example, MixHop [12] performs message passing on each hop with graph diffusion kernel and concatenates the representation on each hop as the final representation. Khop [13] sequentially performs the message passing from hop K to hop 1 to compute the representation of the center node. However, it is not parallelizable due to its computational procedure. MAGNA [14] introduces an attention mechanism to $K$ -hop message passing. GPR-GNN [15] use graph diffusion kernel to perform graph convolution on $K$ -hop and aggregate them with learnable parameters. However, none of them give a formal definition of $K$ -hop message passing and theoretically analyze its representation power and limitations. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            571
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            594,
+            312,
+            612
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct extensive experiments to evaluate the performance of KP-GNN. Specifically, we 1) empirically verify the expressive power of KP-GNN on 3 simulation datasets and demonstrate the benefits of KP-GNN compared to normal $K$ -hop message passing GNNs; 2) demonstrate the effectiveness of KP-GNN on identifying various node properties, graph properties, and substructures with 3 simulation datasets; 3) show that the KP-GNN can achieve state-of-the-art performance on multiple real-world datasets; 4) analyze the running time of KP-GNN. The detail of each variant of KP-GNN is described in Appendix I and the detailed experimental setting is described in Appendix J. We implement the KP-GNN with PyTorch Geometric package [38]. Our code is available at https://github.com/JiaruiFeng/KP-GNN. ",
+        "bbox": [
+            174,
+            627,
+            825,
+            752
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Datasets: To evaluate the expressive power of KP-GNN, we choose: 1) EXP dataset [31], which contains 600 pairs of non-isomorphic graphs (1-WL failed). The goal is to map these graphs to two different classes. 2) SR25 dataset [39], which contains 15 non-isomorphic strongly regular graphs (3- WL failed) with each graph of 25 nodes. The dataset is translated to a 15-way classification problem with the goal of mapping each graph into different classes. 3) CSL dataset [40], which contains 150 4-regular graphs (1-WL failed) divided into 10 isomorphism classes. The goal of the task is to classify them into corresponding isomorphism classes. To demonstrate the capacity of KP-GNN on counting node/graph properties and substructures, we pick 1) Graph property regression (connectedness, diameter, radius) and node property regression (single source shortest path, eccentricity, Laplacian feature) task on random graph dataset [41]. 2) Graph substructure counting (triangle, tailed triangle, star, and 4-cycle) tasks on random graph dataset [42]. To evaluate the performance of KP-GNN on real-world datasets, we select 1) MUTAG [43], D&D [44], PROTEINS [44], PTC-MR [45], and IMDB-B [46] from TU database. 2) QM9 [47, 48] and ZINC [49] for molecular properties prediction. The detailed statistics of the datasets are described in Appendix L. Without further highlighting, all error bars in the result tables are the standard deviations of multiple runs. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            147
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/c5c197f604498b7b6279bb791e4f6a515fa6dcb7fe0d5acc961163d7bd52dd26.jpg",
+        "table_caption": [
+            "Table 1: Empirical evaluation of the expressive power. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">K</td><td>EXP (ACC)</td><td>SR (ACC)</td><td></td><td>CSL (ACC)</td></tr><tr><td>SPD GD</td><td>SPD</td><td>GD</td><td>SPD GD</td></tr><tr><td rowspan=\"4\">K-GIN</td><td>K=1</td><td>50 50</td><td>6.67</td><td>6.67</td><td>12</td></tr><tr><td>K=2</td><td>50 50</td><td>6.67</td><td>6.67</td><td>12 32 22.7</td></tr><tr><td>K=3</td><td>100 66.9</td><td>6.67</td><td>6.67</td><td>62 42</td></tr><tr><td>K=4</td><td>100 100</td><td>6.67</td><td>6.67</td><td>92.7 62.7</td></tr><tr><td rowspan=\"4\">KP-GIN</td><td>K=1</td><td>50</td><td>50 100</td><td>100</td><td>22</td><td>22</td></tr><tr><td>K=2</td><td>100</td><td>100 100</td><td>100</td><td>52.7</td><td>52.7</td></tr><tr><td>K=3</td><td>100</td><td>100</td><td>100 100</td><td>90</td><td>90</td></tr><tr><td>K=4</td><td>100</td><td>100</td><td>100 100</td><td>100</td><td>100</td></tr></table>",
+        "bbox": [
+            176,
+            175,
+            529,
+            314
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Empirical evaluation of the expressive power: For empirical evaluation of the expressive power, we conduct the ablation study on hop $K$ for both normal $K$ -hop GNNs and KP-GNN. For $K$ -hop GNNs, we implement K-GIN which uses GIN [7] as the base encoder. For KP-GNN, we implement KP-GIN. The results are shown in Table 1. Based on the results, we have the following conclusions: 1) $K$ -hop GNNs with both two kernels have expressive power higher than the 1-WL test as it shows the per",
+        "bbox": [
+            539,
+            154,
+            825,
+            318
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "fect performance on the EXP dataset and performance better than a random guess on the CSL dataset. 2) Increasing $K$ can improve the expressive for both two kernels. 3) $K$ -hop GNNs cannot distinguish any strong regular graphs in SR25 dataset, which is aligned with Theorem 2. 4) KP-GNN has much higher expressive power than normal $K$ -hop GNNs by showing better performance on every dataset given the same $K$ . Further, it achieves perfect results on the SR25 dataset even with $K = 1$ , which demonstrates its ability on distinguishing distance regular graphs. ",
+        "bbox": [
+            173,
+            319,
+            825,
+            402
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/1a643e9cf5841554acebc8a4a07a4a1e8b9b2209d0fa83e58c9c5f27a5a4bb9f.jpg",
+        "table_caption": [
+            "Table 2: Simulation dataset result. The top two are highlighted by First, Second. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"3\">Node Properties (log1o(MSE))</td><td colspan=\"3\">Graph Properties (log1o(MSE))</td><td colspan=\"4\">Counting Substructures (MAE)</td></tr><tr><td>SSSP</td><td>Ecc.</td><td>Lap.</td><td>Connect.</td><td>Diameter</td><td>Radius</td><td>Tri.</td><td>Tailed Tri.</td><td>Star</td><td>4-Cycle</td></tr><tr><td>GIN</td><td>-2.0000</td><td>-1.9000</td><td>-1.6000</td><td>-1.9239</td><td>-3.3079</td><td>-4.7584</td><td>0.3569</td><td>0.2373</td><td>0.0224</td><td>0.2185</td></tr><tr><td>PNA</td><td>-2.8900</td><td>-2.8900</td><td>-3.7700</td><td>-1.9395</td><td>3.4382</td><td>-4.9470</td><td>0.3532</td><td>0.2648</td><td>0.1278</td><td>0.2430</td></tr><tr><td>PPGN</td><td>-</td><td></td><td>-</td><td>-1.9804</td><td>-3.6147</td><td>-5.0878</td><td>0.0089</td><td>0.0096</td><td>0.0148</td><td>0.0090</td></tr><tr><td>GIN-AK+</td><td>-</td><td>-</td><td>-</td><td>-2.7513</td><td>-3.9687</td><td>-5.1846</td><td>0.0123</td><td>0.0112</td><td>0.0150</td><td>0.0126</td></tr><tr><td>K-GIN+</td><td>-2.7919</td><td>-2.5938</td><td>-4.6360</td><td>-2.1782</td><td>-3.9695</td><td>-5.3088</td><td>0.2593</td><td>0.1930</td><td>0.0165</td><td>0.2079</td></tr><tr><td>KP-GIN+</td><td>-2.7969</td><td>-2.6169</td><td>-4.7687</td><td>-4.4322</td><td>-3.9361</td><td>-5.3345</td><td>0.0060</td><td>0.0073</td><td>0.0151</td><td>0.0395</td></tr></table>",
+        "bbox": [
+            176,
+            424,
+            821,
+            539
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effectiveness on node/graph properties and substructure prediction: To evaluate the effectiveness of KP-GNN on node/graph properties and substructure prediction, we compare it with several existing models. For the baseline model, we use GIN [7], which has the same expressive power as the 1-WL test. For more powerful baselines, we use GIN-AK $^ +$ [27], PNA [41], and PPGN [24]. For normal $K$ -hop GNNs, we implement $\\mathrm { K } { \\mathrm { - G I N } } +$ , and for KP-GNN, we implement KP- $\\mathrm { G I N + }$ . The results are shown in Table 2. Baseline results are taken from [27] and [41]. We can see ${ \\mathrm { K P - G I N + } }$ achieve SOTA on a majority of tasks. Meanwhile, $\\mathrm { K } { \\mathrm { - G I N } } +$ also gets great performance on node/graph properties prediction. These results demonstrate the capability of KP-GNN to identify various properties and substructures. We leave the detailed results on counting substructures in Appendix K ",
+        "bbox": [
+            173,
+            542,
+            825,
+            669
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/45eddb1792f89b8a133a3ef6b662f1514f9f081869bad15bc8a6eda57df33ce9.jpg",
+        "table_caption": [
+            "Table 3: TU dataset evaluation result. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>MUTAG</td><td>D&amp;D</td><td>PTC-MR</td><td>PROTEINS</td><td>IMDB-B</td></tr><tr><td>WL</td><td>90.4±5.7</td><td>79.4±0.3</td><td>59.9±4.3</td><td>75.0±3.1</td><td>73.8±3.9</td></tr><tr><td>GIN</td><td>89.4±5.6</td><td></td><td>64.6±7.0</td><td>75.9±2.8</td><td>75.1±5.1</td></tr><tr><td>DGCNN</td><td>85.8±1.7</td><td>79.3 ±0.9</td><td>58.6 ±2.5</td><td>75.5±0.9</td><td>70.0±0.9</td></tr><tr><td>GraphSNN</td><td>91.24±2.5</td><td>82.46±2.7</td><td>66.96±3.5</td><td>76.51±2.5</td><td>76.93±3.3</td></tr><tr><td>GIN-AK+</td><td>91.30±7.0</td><td>=</td><td>68.20±5.6</td><td>77.10±5.7</td><td>75.60±3.7</td></tr><tr><td>KP-GCN</td><td>91.7±6.0</td><td>79.0±4.7</td><td>67.1±6.3</td><td>75.8±3.5</td><td>75.9±3.8</td></tr><tr><td>KP-GraphSAGE</td><td>91.7±6.5</td><td>78.1±2.6</td><td>66.5±4.0</td><td>76.5±4.6</td><td>76.4±2.7</td></tr><tr><td>KP-GIN</td><td>92.2±6.5</td><td>79.4±3.8</td><td>66.8±6.8</td><td>75.8±4.6</td><td>76.6±4.2</td></tr><tr><td>GIN-AK+*</td><td>95.0±6.1</td><td>OOM</td><td>74.1±5.9</td><td>78.9±5.4</td><td>77.3±3.1</td></tr><tr><td>GraphSNN*</td><td>94.70±1.9</td><td>83.93±2.3</td><td>70.58±3.1</td><td>78.42±2.7</td><td>78.51±2.8</td></tr><tr><td>KP-GCN*</td><td>96.1±4.6</td><td>83.2±2.2</td><td>77.1±4.1</td><td>80.3±4.2</td><td>79.6±2.5</td></tr><tr><td>KP-GraphSAGE*</td><td>96.1±4.6</td><td>83.6±2.4</td><td>76.2±4.5</td><td>80.4±4.3</td><td>80.3±2.4</td></tr><tr><td>KP-GIN*</td><td>95.6±4.4</td><td>83.5±2.2</td><td>76.2±4.5</td><td>79.5±4.4</td><td>80.7±2.6</td></tr></table>",
+        "bbox": [
+            209,
+            694,
+            761,
+            915
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/f73a7ff78f4d5026f9c3c6fe389493d38f3b66365f5d321b2bfd0a1b499d5eda.jpg",
+        "table_caption": [
+            "Table 4: QM9 results. The top two are highlighted by First, Second. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Target</td><td>DTNN</td><td>MPNN</td><td>Deep LRP</td><td>PPGN</td><td>N-1-2-3-GNN</td><td>KP-GIN+</td><td>KP-GIN&#x27;</td></tr><tr><td>μ</td><td>0.244</td><td>0.358</td><td>0.364</td><td>0.231</td><td>0.433</td><td>0.367</td><td>0.358</td></tr><tr><td>α</td><td>0.95</td><td>0.89</td><td>0.298</td><td>0.382</td><td>0.265</td><td>0.242</td><td>0.233</td></tr><tr><td>εHOMO</td><td>0.00388</td><td>0.00541</td><td>0.00254</td><td>0.00276</td><td>0.00279</td><td>0.00247</td><td>0.00240</td></tr><tr><td>εLUMO</td><td>0.00512</td><td>0.00623</td><td>0.00277</td><td>0.00287</td><td>0.00276</td><td>0.00238</td><td>0.00236</td></tr><tr><td>△ε</td><td>0.0112</td><td>0.0066</td><td>0.00353</td><td>0.00406</td><td>0.00390</td><td>0.00345</td><td>0.00333</td></tr><tr><td>(R²)</td><td>17.0</td><td>28.5</td><td>19.3</td><td>16.7</td><td>20.1</td><td>16.49</td><td>16.51</td></tr><tr><td>ZPVE</td><td>0.00172</td><td>0.00216</td><td>0.00055</td><td>0.00064</td><td>0.00015</td><td>0.00018</td><td>0.00017</td></tr><tr><td>U</td><td>2.43</td><td>2.05</td><td>0.413</td><td>0.234</td><td>0.205</td><td>0.0728</td><td>0.0682</td></tr><tr><td>U</td><td>2.43</td><td>2.00</td><td>0.413</td><td>0.234</td><td>0.200</td><td>0.0553</td><td>0.0696</td></tr><tr><td>H</td><td>2.43</td><td>2.02</td><td>0.413</td><td>0.229</td><td>0.249</td><td>0.0575</td><td>0.0641</td></tr><tr><td>G</td><td>2.43</td><td>2.02</td><td>0.413</td><td>0.238</td><td>0.253</td><td>0.0526</td><td>0.0484</td></tr><tr><td>C</td><td>0.27</td><td>0.42</td><td>0.129</td><td>0.184</td><td>0.0811</td><td>0.0973</td><td>0.0869</td></tr></table>",
+        "bbox": [
+            187,
+            93,
+            812,
+            275
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Evaluation on TU datasets: For baseline models, we select: 1) graph kernel-based method: WL subtree kernel [50]; 2) vanilla GNN methods: GIN [7] and DGCNN [6]; 3) advanced GNN methods: GraphSNN [36] and GIN- $\\mathrm { \\bf A K } +$ [27]. For the proposed KP-GNN, we implement GCN [1], GraphSAGE [3], and GIN [7] using the KP-GNN framework, denoted as KP-GCN, KP-GraphSAGE, and KP-GIN respectively. The results are shown in Table 3. For a more fair and comprehensive comparison, we report the results from two different evaluation settings. The first setting follows Xu et al. [7] and the second setting follows Wijesinghe and Wang [36]. We denote the second setting with ∗ in the table. We can see KP-GNN achieves SOTA performance on most of datasets under the second setting and still comparable performance to other baselines under the first setting. ",
+        "bbox": [
+            173,
+            277,
+            825,
+            402
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/8a8da0ef759bd005e37de99b7517d17daec720307d1327faafce3e6bcf9f01d4.jpg",
+        "table_caption": [
+            "Table 5: ZINC result. "
+        ],
+        "table_footnote": [
+            "Although KP-GNN does not achieve the best result, it is still comparable to other methods. "
+        ],
+        "table_body": "<table><tr><td>Method</td><td># param.</td><td>test MAE</td></tr><tr><td>MPNN</td><td>480805</td><td>0.145±0.007</td></tr><tr><td>PNA</td><td>387155</td><td>0.142±0.010</td></tr><tr><td>Graphormer</td><td>489321</td><td>0.122±0.006</td></tr><tr><td>GSN GIN-AK+</td><td>~500000</td><td>0.101±0.010 0.080±0.001</td></tr><tr><td>CIN</td><td>= 1</td><td>0.079±0.006</td></tr><tr><td>KP-GIN+</td><td>499099</td><td></td></tr><tr><td>KP-GIN&#x27;</td><td>488649</td><td>0.111±0.006 0.093±0.007</td></tr></table>",
+        "bbox": [
+            176,
+            424,
+            446,
+            558
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Evaluation on molecular prediction tasks: For QM9 dataset, we report baseline results of DTNN and MPNN from [48]. We further select Deep LRP [42], PPGN [24], and Nested 1-2-3-GNN [26] as baseline models. For the ZINC dataset, we report results of MPNN [18] and PNA [41] from [17]. We further pick Graphormer [17], GSN [51], GIN-AK $^ +$ [27], and CIN [52]. For KP-GNN, we choose ${ \\mathrm { K P - G I N } } +$ and ${ \\bf K P - G I N } ^ { \\prime }$ . The results of the QM9 dataset are shown in Table 4. We can see KPGNN achieves SOTA performance on most of the targets. The results of the ZINC dataset are shown in Table 5. ",
+        "bbox": [
+            462,
+            409,
+            825,
+            560
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/f293a9c2ff1c52ccb234265388bff3353706b20b5f3b57becfd8607c19e9e3d2.jpg",
+        "table_caption": [
+            "Table 6: Running time (s/epoch). "
+        ],
+        "table_footnote": [
+            "the computational overhead is almost linear to $K$ . This is reasonable as practical graphs are sparse and the number of $K$ -hop neighbors is far less than $n$ when using a small $K$ . "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>D&amp;D</td><td>ZINC</td><td>Graph property</td></tr><tr><td>GIN</td><td>1.10</td><td>3.59</td><td>1.02</td></tr><tr><td>K-GIN</td><td>3.94</td><td>6.44</td><td>1.67</td></tr><tr><td>KP-GIN</td><td>4.19</td><td>7.38</td><td>1.94</td></tr><tr><td>KP-GIN+</td><td>4.28</td><td>6.74</td><td>1.93</td></tr></table>",
+        "bbox": [
+            176,
+            602,
+            493,
+            686
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Running time comparison: In this section, we compare the running time of KP-GNN to 1-hop message passing GNN and $K$ -hop message passing GNN. We use GIN [7] as the base model. We also include the ${ \\mathrm { K P - G I N + } }$ . All models use the same number of layers and hidden dimensions for a fair comparison. The results are shown in Table 6. We set $K = 4$ for all datasets. We can see ",
+        "bbox": [
+            501,
+            580,
+            825,
+            690
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            737,
+            299,
+            755
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we theoretically characterize the power of $K$ -hop message passing GNNs and propose the KP-GNN to improve the expressive power by leveraging the peripheral subgraph information at each hop. Theoretically, we prove that $K$ -hop GNNs can distinguish almost all regular graphs but are bounded by the 3-WL test. KP-GNN is able to distinguish many distance regular graphs. Empirically, KP-GNN achieves competitive results across all simulation and real-world datasets. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            837
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            359,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work is partially supported by NSF grant CBE-2225809 and NSF China (No. 62276003). ",
+        "bbox": [
+            171,
+            887,
+            789,
+            902
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations, 2017.   \n[2] David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alán Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in neural information processing systems, pages 2224– 2232, 2015.   \n[3] Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pages 1025–1035, 2017.   \n[4] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua ´ Bengio. Graph attention networks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id=rJXMpikCZ.   \n[5] Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.   \n[6] Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In AAAI, pages 4438–4445, 2018.   \n[7] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id $\\equiv$ ryGs6iA5Km.   \n[8] Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pages 855–864. ACM, 2016.   \n[9] Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pages 701–710. ACM, 2014.   \n[10] Boris Weisfeiler and AA Lehman. A reduction of a graph to a canonical form and an algebra arising during this reduction. Nauchno-Technicheskaya Informatsia, 2(9):12–16, 1968.   \n[11] 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 Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 4602–4609, 2019.   \n[12] 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, pages 21–29. PMLR, 2019.   \n[13] Giannis Nikolentzos, George Dasoulas, and Michalis Vazirgiannis. k-hop graph neural networks. Neural Networks, 130:195–205, 2020.   \n[14] Guangtao Wang, Rex Ying, Jing Huang, and Jure Leskovec. Multi-hop attention graph neural networks. In International Joint Conference on Artificial Intelligence, 2021.   \n[15] Eli Chien, Jianhao Peng, Pan Li, and Olgica Milenkovic. Adaptive universal generalized pagerank graph neural network. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=n6jl7fLxrP.   \n[16] Rémy Brossard, Oriel Frigo, and David Dehaene. Graph convolutions that can finally model local structure. arXiv preprint arXiv:2011.15069, 2020.   \n[17] Chengxuan Ying, Tianle Cai, Shengjie Luo, Shuxin Zheng, Guolin Ke, Di He, Yanming Shen, and Tie-Yan Liu. Do transformers really perform badly for graph representation? In A. Beygelzimer, Y. Dauphin, P. Liang, and J. Wortman Vaughan, editors, Advances in Neural Information Processing Systems, 2021. URL https://openreview.net/forum?id=OeWooOxFwDa. ",
+        "bbox": [
+            169,
+            60,
+            828,
+            914
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[18] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1263–1272. JMLR. org, 2017. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[19] George V. Cybenko. Approximation by superpositions of a sigmoidal function. Mathematics of Control, Signals and Systems, 2:303–314, 1989. ",
+        "bbox": [
+            173,
+            143,
+            823,
+            174
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Russ R Salakhutdinov, and Alexander J Smola. Deep sets. In Advances in Neural Information Processing Systems, pages 3391–3401, 2017. ",
+        "bbox": [
+            173,
+            184,
+            825,
+            227
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Xiyuan Wang and Muhan Zhang. How powerful are spectral graph neural networks. ICML, 2022. ",
+        "bbox": [
+            174,
+            238,
+            825,
+            267
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Pan Li, Yanbang Wang, Hongwei Wang, and Jure Leskovec. Distance encoding: Design provably more powerful neural networks for graph representation learning. In Advances in Neural Information Processing Systems, volume 33, pages 4465–4478, 2020. ",
+        "bbox": [
+            174,
+            279,
+            821,
+            321
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Fabrizio Frasca, Beatrice Bevilacqua, Michael M Bronstein, and Haggai Maron. Understanding and extending subgraph gnns by rethinking their symmetries. In Advances in Neural Information Processing Systems, 2022. ",
+        "bbox": [
+            174,
+            332,
+            823,
+            375
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Haggai Maron, Heli Ben-Hamu, Hadar Serviansky, and Yaron Lipman. Provably powerful graph networks. In Advances in Neural Information Processing Systems, pages 2156–2167, 2019. ",
+        "bbox": [
+            173,
+            385,
+            826,
+            428
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Haggai Maron, Heli Ben-Hamu, Nadav Shamir, and Yaron Lipman. Invariant and equivariant graph networks. In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id $\\equiv$ Syx72jC9tm. ",
+        "bbox": [
+            174,
+            439,
+            823,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Muhan Zhang and Pan Li. Nested graph neural networks. In A. Beygelzimer, Y. Dauphin, P. Liang, and J. Wortman Vaughan, editors, Advances in Neural Information Processing Systems, 2021. URL https://openreview.net/forum?id $\\ c =$ 7_eLEvFjCi3. ",
+        "bbox": [
+            173,
+            492,
+            825,
+            536
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Lingxiao Zhao, Wei Jin, Leman Akoglu, and Neil Shah. From stars to subgraphs: Uplifting any GNN with local structure awareness. In International Conference on Learning Representations, 2022. URL https://openreview.net/forum?id=Mspk_WYKoEH. ",
+        "bbox": [
+            173,
+            545,
+            826,
+            589
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Beatrice Bevilacqua, Fabrizio Frasca, Derek Lim, Balasubramaniam Srinivasan, Chen Cai, Gopinath Balamurugan, Michael M. Bronstein, and Haggai Maron. Equivariant subgraph aggregation networks. In International Conference on Learning Representations, 2022. URL https://openreview.net/forum?id $\\equiv$ dFbKQaRk15w. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            657
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Zhengdao Chen, Soledad Villar, Lei Chen, and Joan Bruna. On the equivalence between graph isomorphism testing and function approximation with gnns. In Advances in Neural Information Processing Systems, pages 15894–15902, 2019. ",
+        "bbox": [
+            173,
+            667,
+            823,
+            712
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Ryoma Sato, Makoto Yamada, and Hisashi Kashima. Random features strengthen graph neural networks. In Proceedings of the 2021 SIAM International Conference on Data Mining (SDM), 2021. ",
+        "bbox": [
+            171,
+            720,
+            825,
+            763
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Ralph Abboud, ˙Ismail ˙Ilkan Ceylan, Martin Grohe, and Thomas Lukasiewicz. The surprising power of graph neural networks with random node initialization. In Proceedings of the Thirtieth International Joint Conference on Artificial Intelligence, IJCAI-21, pages 2112–2118, 8 2021. doi: 10.24963/ijcai.2021/291. URL https://doi.org/10.24963/ijcai.2021/291. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            832
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Andreas Loukas. What graph neural networks cannot learn: depth vs width. arXiv preprint arXiv:1907.03199, 2019. ",
+        "bbox": [
+            169,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Muhan Zhang and Yixin Chen. Link prediction based on graph neural networks. In Advances in Neural Information Processing Systems, pages 5165–5175, 2018. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Muhan Zhang, Pan Li, Yinglong Xia, Kai Wang, and Long Jin. Labeling trick: A theory of using graph neural networks for multi-node representation learning. In A. Beygelzimer, Y. Dauphin, P. Liang, and J. Wortman Vaughan, editors, Advances in Neural Information Processing Systems, 2021. URL https://openreview.net/forum?id $\\equiv$ Hcr9mgBG6ds.   \n[35] Xiyuan Wang and Muhan Zhang. GLASS: GNN with labeling tricks for subgraph representation learning. In International Conference on Learning Representations, 2022. URL https: //openreview.net/forum?id $\\equiv$ XLxhEjKNbXj.   \n[36] Asiri Wijesinghe and Qing Wang. A new perspective on ”how graph neural networks go beyond weisfeiler-lehman?”. In International Conference on Learning Representations, 2022. URL https://openreview.net/forum?id $\\underset { . } { = }$ uxgg9o7bI_3.   \n[37] Jiaxuan You, Jonathan M Gomes-Selman, Rex Ying, and Jure Leskovec. Identity-aware graph neural networks. Proceedings of the AAAI Conference on Artificial Intelligence, 35(12):10737– 10745, May 2021.   \n[38] Matthias Fey and Jan Eric Lenssen. Fast graph representation learning with pytorch geometric. arXiv preprint arXiv:1903.02428, 2019.   \n[39] Muhammet Balcilar, Pierre Héroux, Benoit Gaüzère, Pascal Vasseur, Sébastien Adam, and Paul Honeine. Breaking the limits of message passing graph neural networks. In Proceedings of the 38th International Conference on Machine Learning (ICML), 2021.   \n[40] Ryan Murphy, Balasubramaniam Srinivasan, Vinayak Rao, and Bruno Ribeiro. Relational pooling for graph representations. In International Conference on Machine Learning, pages 4663–4673. PMLR, 2019.   \n[41] Gabriele Corso, Luca Cavalleri, Dominique Beaini, Pietro Liò, and Petar Velickovi ˇ c. Principal ´ neighbourhood aggregation for graph nets. In Advances in Neural Information Processing Systems, 2020.   \n[42] Zhengdao Chen, Lei Chen, Soledad Villar, and Joan Bruna. Can graph neural networks count substructures? Advances in neural information processing systems, 2020.   \n[43] Asim Kumar Debnath, de Compadre RL Lopez, Gargi Debnath, Alan J Shusterman, and Corwin Hansch. Structure-activity relationship of mutagenic aromatic and heteroaromatic nitro compounds. correlation with molecular orbital energies and hydrophobicity. Journal of medicinal chemistry, 34(2):786–797, 1991.   \n[44] Paul D Dobson and Andrew J Doig. Distinguishing enzyme structures from non-enzymes without alignments. Journal of molecular biology, 330(4):771–783, 2003.   \n[45] Hannu Toivonen, Ashwin Srinivasan, Ross D King, Stefan Kramer, and Christoph Helma. Statistical evaluation of the predictive toxicology challenge 2000–2001. Bioinformatics, 19(10): 1183–1193, 2003.   \n[46] Pinar Yanardag and SVN Vishwanathan. Deep graph kernels. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pages 1365–1374. ACM, 2015.   \n[47] Raghunathan Ramakrishnan, Pavlo O Dral, Matthias Rupp, and O Anatole Von Lilienfeld. Quantum chemistry structures and properties of 134 kilo molecules. Scientific data, 1(1):1–7, 2014.   \n[48] Zhenqin Wu, Bharath Ramsundar, Evan N Feinberg, Joseph Gomes, Caleb Geniesse, Aneesh S Pappu, Karl Leswing, and Vijay Pande. Moleculenet: a benchmark for molecular machine learning. Chemical science, 9(2):513–530, 2018.   \n[49] Vijay Prakash Dwivedi, Chaitanya K Joshi, Anh Tuan Luu, Thomas Laurent, Yoshua Bengio, and Xavier Bresson. Benchmarking graph neural networks. arXiv preprint arXiv:2003.00982, 2020. ",
+        "bbox": [
+            171,
+            73,
+            828,
+            917
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[50] Nino Shervashidze, Pascal Schweitzer, Erik Jan van Leeuwen, Kurt Mehlhorn, and Karsten M Borgwardt. Weisfeiler-lehman graph kernels. Journal of Machine Learning Research, 12(Sep): 2539–2561, 2011. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[51] Giorgos Bouritsas, Fabrizio Frasca, Stefanos Zafeiriou, and Michael M. Bronstein. Improving graph neural network expressivity via subgraph isomorphism counting, 2021. URL https: //openreview.net/forum?id $\\equiv$ LT0KSFnQDWF. ",
+        "bbox": [
+            171,
+            142,
+            823,
+            184
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[52] Cristian Bodnar, Fabrizio Frasca, Nina Otter, Yu Guang Wang, Pietro Liò, Guido Montufar, and Michael M. Bronstein. Weisfeiler and lehman go cellular: CW networks. In A. Beygelzimer, Y. Dauphin, P. Liang, and J. Wortman Vaughan, editors, Advances in Neural Information Processing Systems, 2021. URL https://openreview.net/forum?id=uVPZCMVtsSG. ",
+        "bbox": [
+            174,
+            194,
+            826,
+            250
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[53] Béla Bollobás. Distinguishing vertices of random graphs. In Béla Bollobás, editor, Graph Theory, volume 62 of North-Holland Mathematics Studies, pages 33–49. North-Holland, 1982. doi: https://doi.org/10.1016/S0304-0208(08)73545-X. URL https://www.sciencedirect. com/science/article/pii/S030402080873545X. ",
+        "bbox": [
+            174,
+            258,
+            826,
+            314
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[54] Béla Bollobás. A Probabilistic Proof of an Asymptotic Formula for the Number of Labelled Regular Graphs. European Journal of Combinatorics, 1(4):311–316, December 1980. ISSN 0195-6698. doi: 10.1016/S0195-6698(80)80030-8. URL https://www.sciencedirect. com/science/article/pii/S0195669880800308. ",
+        "bbox": [
+            173,
+            324,
+            826,
+            381
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[55] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017. ",
+        "bbox": [
+            173,
+            388,
+            825,
+            431
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[56] Floris Geerts. The expressive power of kth-order invariant graph networks. ArXiv, abs/2007.12035, 2020. ",
+        "bbox": [
+            173,
+            440,
+            825,
+            469
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[57] Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attentionbased neural machine translation. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pages 1412–1421, Lisbon, Portugal, September 2015. Association for Computational Linguistics. doi: 10.18653/v1/D15-1166. URL https://aclanthology.org/D15-1166. ",
+        "bbox": [
+            176,
+            478,
+            826,
+            549
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[58] 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, 2018. ",
+        "bbox": [
+            176,
+            558,
+            825,
+            601
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            626,
+            254,
+            642
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            652,
+            339,
+            666
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            671,
+            825,
+            763
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            767,
+            493,
+            781
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] ",
+        "bbox": [
+            238,
+            785,
+            735,
+            816
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            821,
+            393,
+            835
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] The implementation of KP-GNN can be found at https://github.com/JiaruiFeng/KP-GNN.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            238,
+            839,
+            825,
+            911
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            238,
+            92,
+            825,
+            150
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            154,
+            825,
+            169
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [No] The license can be found in their github.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] All datasets we used are all open-sourced.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] There is no personal information in the datasets. ",
+        "bbox": [
+            238,
+            172,
+            825,
+            308
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            311,
+            705,
+            327
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            330,
+            826,
+            420
+        ],
+        "page_idx": 14
+    }
+]

parse/dev/nUmCcZ5RKF/nUmCcZ5RKF.md

@@ -0,0 +1,318 @@
+# IS SYNTHETIC DATA FROM GENERATIVE MODELS READY FOR IMAGE RECOGNITION?
+
+Ruifei $\mathbf { H e } ^ { 1 ^ { * } }$ Shuyang $\mathbf { S u n } ^ { 2 }$ Xin $\mathbf { V } \mathbf { u } ^ { 1 }$ Chuhui $\mathbf { X } \mathbf { u } \mathbf { e } ^ { 3 }$ Wenqing Zhang3 Philip Torr2   
+Song Bai3† Xiaojuan $\mathbf { Q } \mathbf { i } ^ { \mathrm { { i } \dagger } }$   
+1The University of Hong Kong 2University of Oxford 3ByteDance
+
+# ABSTRACT
+
+Recent text-to-image generation models have shown promising results in generating high-fidelity photo-realistic images. Though the results are astonishing to human eyes, how applicable these generated images are for recognition tasks remains under-explored. In this work, we extensively study whether and how synthetic images generated from state-of-the-art text-to-image generation models can be used for image recognition tasks, and focus on two perspectives: synthetic data for improving classification models in data-scarce settings (i.e. zero-shot and fewshot), and synthetic data for large-scale model pre-training for transfer learning. We showcase the powerfulness and shortcomings of synthetic data from existing generative models, and propose strategies for better applying synthetic data for recognition tasks. Code: https://github.com/CVMI-Lab/SyntheticData.
+
+# 1 INTRODUCTION
+
+Over the past decade, deep learning powered by large-scale annotated data has revolutionized the field of image recognition. However, it is costly and time-consuming to manually collect a largescale labeled dataset, and recent concerns about data privacy and usage rights further hinder this process. In parallel, generative models that aim to model real-data distributions can now produce high-fidelity photo-realistic images. In particular, recent text-to-image generation models (Nichol et al., 2021; Ramesh et al., 2022; Saharia et al., 2022b) have made major breakthroughs in synthesizing high-quality images from text descriptions. This promotes us to ask: is synthetic data from generative models ready for image recognition tasks?
+
+There are a few early attempts at exploring synthetic data from generative models for image recognition tasks. Besnier et al. (2020) use a class-conditional GAN (BigGAN (Brock et al., 2018) trained for ImageNet-1000 classes) to generate images for training image classifiers. Zhang et al. (2021) leverage StyleGAN (Karras et al., 2019) to produce synthetic labeled data for object-part segmentation. Jahanian et al. (2021) manipulate the latent space of a GAN model to produce multi-view images for contrastive learning. Albeit promising, early works either address tasks on a small scale or only for a specific setting. Plus, they all focus on GAN-based models and none explore the revolutionary text-to-image generation models, which hold more promises to benefit recognition tasks.
+
+In this paper, we present the first study on the state-of-the-art text-to-image generation models for image recognition. With the power of text-to-image generation, we could hopefully not only generate massive high-quality labeled data, but also achieve domain customization by generating synthetic data targeted for a specific label space, i.e. the label space of a downstream task. Our study is carried out on one open-sourced text-to-image generation model, GLIDE (Nichol et al., 2021) 1. We attempt to uncover the benefits and pitfalls of synthetic data for image recognition through the lens of investigating the following two questions: 1) is synthetic data from generative models ready for improving classification models? 2) whether synthetic data can be a feasible source for transfer learning (i.e. model pre-training)? It is worth noting that for 1), we only studied the zero-shot and few-shot settings because the positive impact of synthetic data diminishes as more shots are present. And, we build most of our investigations on the state-of-the-art method CLIP (Radford et al., 2021) with the feature extractor initialized with large-scale pre-trained weights frozen.
+
+Our Findings. First, in the zero-shot setting, i.e. no real-world data are available, we demonstrate that synthetic data can significantly improve classification results on 17 diverse datasets: the performance is increased by ${ \mathrm { 4 . 3 1 \% } }$ in top-1 accuracy on average, and even improved by as much as $1 7 . 8 6 \%$ on the EuroSAT dataset. To better leverage synthetic data in this setting, we also investigate useful strategies to increase data diversity, reduce data noise, and enhance data reliability. This is achieved by designing diversified text prompts and measuring the correlation of text and synthesized data with CLIP features.
+
+Second, in the few-shot setting, i.e. a few real images are available, albeit not as significant as in the zero-shot task, synthetic data are also shown to be beneficial and help us achieve a new state of the art. Our observation shows that the domain gap between synthetic data and downstream task data is one challenge on further improving the effectiveness of synthetic data on classifier learning. Fortunately, in this setting, the accessibility of real data samples can provide useful information about the data distribution of the downstream task. We thus propose to use real images as guidance in the generation process to reduce domain gaps and improve effectiveness.
+
+Third, in large-scale model pre-training for transfer learning, our study shows that synthetic data are suitable and effective for model pre-training, delivering superior transfer learning performance and even outperforming ImageNet pre-training. Especially, synthetic data work surprisingly well in unsupervised model pre-training, and favor ViT-based backbones. We also demonstrate that by increasing the label space (i.e. text prompts) for data generation, the enlarged data amount and diversity could further bring performance boosts. Besides, synthetic data can work collaboratively with real data (i.e. ImageNet) where we obtain improved performance when the model is initialized with ImageNet pre-trained weights.
+
+# 2 RELATED WORKS
+
+Synthetic Data for Image Recognition. There are mainly two forms of synthetic data for image recognition, i.e. 1) synthetic datasets generated from a traditional simulation pipeline; 2) synthetic images output from generative models.
+
+The first type, synthetic datasets (Dosovitskiy et al., 2015; Peng et al., 2017; Richter et al., 2016), are usually generated from a traditional pipeline with a specific data source, e.g.synthetic 2D renderings of 3D models or scenes from graphics engines. However, this traditional way of generating synthetic datasets has several drawbacks: 1) manually defined pipeline generated synthetic data may have a certain gap with real-world data; 2) taking up huge physical space to store and huge cost to share and transfer; 3) data amount and diversity bounded by the specific data source.
+
+Compared with synthetic datasets, generative models are a more efficient means of synthetic data representation, exhibiting favorable advantages: 1) could produce high-fidelity photorealistic images closer to real data since they are trained on real-world data; 2) highly condensed compared to synthetic data itself, and take up much reduced storage space; 3) potentially unlimited synthetic data size. Only recently, few works attempt to explore synthetic data generated from generative models for image recognition. Besnier et al. (2020) use a class-conditional GAN to train classifiers of the same classes. Zhang et al. (2021) leverage the latent code of StyleGAN (Karras et al., 2019) to produce labels for object part segmentation. While they achieve promising results, both works are task-wise and only employed on a small scale. Jahanian et al. (2021) use a GAN-based generator to generate multiple views to conduct unsupervised contrastive representation learning. These works, however, explore upon the traditional GAN-based models; in contrast, our work investigates with the best released text-to-image generation model, which demonstrates new customization ability for different downstream label space.
+
+Text-to-Image Diffusion Models. Diffusion models (Sohl-Dickstein et al., 2015; Ho et al., 2020; Nichol & Dhariwal, 2021) have recently emerged as a class of promising and powerful generative models. As a likelihood-based model, the diffusion model matches the underlying data distribution $q ( x _ { 0 } )$ by learning to reverse a noising process, and thus novel images can be sampled from a prior Gaussian distribution via the learned reverse path. Because of the high sample quality, good mode coverage and promising training stability, diffusion models are quickly becoming a new trend in both unconditional (Ho et al., 2020; Nichol & Dhariwal, 2021; Ho et al., 2022) and conditional (Dhariwal & Nichol, 2021; Rombach et al., 2022; Lugmayr et al., 2022; Saharia et al., 2022a; Meng et al., 2021; Saharia et al., 2022c) image synthesis fields.
+
+In particular, text-to-image generation can be treated as a conditional image generation task that requires the sampled image to match the given natural language description. Based upon the formulation of the diffusion model, several text-to-image models such as Stable diffusion (Rombach et al., 2022), DALL-E2 (Ramesh et al., 2022), Imagen (Saharia et al., 2022b) and GLIDE (Nichol et al., 2021) deliver unprecedented synthesis quality, largely facilitating the development of the AIfor-Art community. Despite achieving astonishing perceptual results, their potential utilization for high-level tasks is yet under-explored. In this paper, we utilize the state-of-the-art model GLIDE and showcase its powerfulness and shortcomings for synthesizing data for recognition tasks.
+
+# 3 IS SYNTHETIC DATA READY FOR IMAGE RECOGNITION?
+
+In the following sections, we answer the question by studying whether synthetic data can benefit recognition tasks and how to better leverage synthetic data to address different tasks. We carry out our exploration through the lens of two basic settings with three tasks: synthetic data for improving classification models in the data-scarce setting (i.e. zero-shot and few-shot) (see Sec. 3.1 and Sec. 3.2) and synthetic data for model pre-training for transfer learning (see Sec. 3.3).
+
+Model Setup for Data-scarce (i.e. Zero-shot and Few-shot) Image Classification. As CLIP (Radford et al., 2021) is the state-of-the-art approach for zero-shot learning, we conduct our study for zero-shot and few-shot settings upon pre-trained CLIP models, aiming to better understand synthetic data upon strong baselines. There have been a few attempts on better tuning pre-trained CLIP for data-scarce image classification, such as CoOp (Zhou et al., 2022b), CLIP Adapter (Gao et al., 2021), and Tip Adapter (Zhang et al., 2022), where the image encoder is frozen for better preserving the pretrained feature space. We argue that different tuning methods could all be regarded as different ways of learning classifier weights, e.g. CoOp optimizes learnable prompts for better learning classifiers.
+
+Here, we adopt a simple tuning method, Classifier Tuning (CT), a baseline method introduced in Wortsman et al. (2022). Concretely, for a $\mathbf { k }$ -way classification, we input the class names $C =$ $\{ c _ { 1 } , . . . , c _ { k } \}$ with prompt $s _ { i } =$ “a photo of a $\{ c _ { i } \} ^ { \flat }$ into the text encoder $h$ of CLIP to obtain the text features $h ( s _ { i } )$ . Then the text features $h ( s _ { i } )$ could be used to construct classifier weights $W \in$ $R ^ { d \times k }$ , where $d$ is the dimension of text features. Finally, we combine the image encoder $g$ with the classifier weights $W$ to obtain a classification model $f ( x ) = g ( x ) ^ { \mathrm { T } } W$ . We empirically show that CT performs comparably with other tuning methods. Compared with complex designed tuning methods, we hope to use a simpler method for better investigating the effectiveness of synthetic data.
+
+.1 IS SYNTHETIC DATA READY FOR ZERO-SHOT IMAGE RECOGNITION?
+
+Our aim is to investigate to what degree synthetic data are beneficial to zero-shot tasks and how to better leverage synthetic data for zero-shot learning.
+
+Zero-shot Image Recognition. We study the inductive zero-shot learning setting where no real training images of the target categories are available. CLIP models are pre-trained with large-scale image-caption pairs, and the similarities between paired image features (from an image-encoder $g$ ) and text features (from a text-encoder $h$ ) are maximized during pre-training. The pre-trained feature extractor can then be used to solve zero-shot tasks where given an image, its features from $g$ are compared with text features of different classes from $h$ and the image is further assigned to the class that has the largest similarity in the CLIP text-image feature space.
+
+Synthetic Data for Zero-shot Image Recognition. Though CLIP models exhibit strong zero-shot performance thanks to the large-scale vision-language dataset for pre-training, there are still several shortcomings when the model is deployed for a downstream zero-shot classification task, which may be attributed to unavoidable data noise in CLIP’s pre-training data or the label space mismatch between pre-training and the zero-shot task. Hence, with a given label space for a zero-shot task, we study whether synthetic data can be used to better adapt CLIP models for zero-shot learning.
+
+How to generate the data? Given a pre-trained text-to-image generation model, to synthesize novel samples, the basic $\mathbf { ( B ) }$ strategy is to use the label names of the target categories to build the language input and generate a corresponding image. Then, the paired label names and synthesized data can be employed to train the classifier with the feature extractor frozen.
+
+How to enrich diversity? Only using the label names as inputs might limit the diversity of synthesized images and cause bottlenecks for validating the effectiveness of synthetic data. Hence, we leverage an off-the-shelf word-to-sentence T5 model (pre-trained on “Colossal Clean Crawled Corpus” dataset (Raffel et al., 2020) and finetuned on CommonGen dataset (Lin et al., 2019)) to increase the diversity of language prompts and the generated images, namely language enhancement (LE), hoping to better unleash the potential of synthesized data. Concretely, we input the label name of each class to the word-to-sentence model which generates diversified sentences containing the class names as language prompts for the text-to-image generation process. For example, if the class label is “airplane”, then the enhanced language prompt from the model could be “a white airplane hovering over a beach and a city”. The enhanced text descriptions introduce rich context descriptions.
+
+<table><tr><td>Dataset</td><td>Task</td><td>CLIP-RN50</td><td>CLIP-RN50+SYN</td><td>CLIP-ViT-B/16</td><td>CLIP-ViT-B/16+SYN</td></tr><tr><td>CIFAR-10</td><td>0</td><td>70.31</td><td>80.06 (+9.75)</td><td>90.80</td><td>92.37 (+1.57)</td></tr><tr><td>CIFAR-100</td><td>0</td><td>35.35</td><td>45.69 (+10.34)</td><td>68.22</td><td>70.71 (+2.49)</td></tr><tr><td>Caltech101</td><td>0</td><td>86.09</td><td>87.74 (+1.65)</td><td>92.98</td><td>94.16 (+1.18)</td></tr><tr><td>Caltech256</td><td>0</td><td>73.36</td><td>75.74 (+2.38)</td><td>80.14</td><td>81.43 (+1.29)</td></tr><tr><td>ImageNet</td><td>0</td><td>60.33</td><td>60.78 (+0.45)</td><td>68.75</td><td>69.16 (+0.41)</td></tr><tr><td>SUN397</td><td>S</td><td>58.51</td><td>60.07 (+1.56)</td><td>62.51</td><td>63.79 (+1.28)</td></tr><tr><td>Aircraft</td><td>f</td><td>17.34</td><td>21.94 (+4.60)</td><td>24.81</td><td>30.78 (+5.97)</td></tr><tr><td>Birdsnap</td><td>f</td><td>34.33</td><td>38.05 (+3.72)</td><td>41.90</td><td>46.84 (+4.94)</td></tr><tr><td>Cars</td><td>f</td><td>55.63</td><td>56.93 (+1.30)</td><td>65.23</td><td>66.86 (+1.63)</td></tr><tr><td>CUB</td><td>f</td><td>46.69</td><td>56.94 (+10.25)</td><td>55.23</td><td>63.79 (+8.56)</td></tr><tr><td>Flower</td><td>f</td><td>66.08</td><td>67.05 (+0.97)</td><td>71.30</td><td>72.60 (+1.30)</td></tr><tr><td>Food</td><td>f</td><td>80.34</td><td>80.35 (+0.01)</td><td>88.75</td><td>88.83 (+0.08)</td></tr><tr><td>Pets</td><td>f</td><td>85.80</td><td>86.81 (+1.01)</td><td>89.10</td><td>90.41 (+1.31)</td></tr><tr><td>DTD</td><td>t</td><td>42.23</td><td>43.19 (+0.96)</td><td>44.39</td><td>44.92 (+0.53)</td></tr><tr><td>EuroSAT</td><td>si</td><td>37.51</td><td>55.37 (+17.86)</td><td>47.77</td><td>59.86 (+12.09)</td></tr><tr><td>ImageNet-Sketch</td><td>r</td><td>33.29</td><td>36.55 (+3.26)</td><td>46.20</td><td>48.47 7 (+2.27)</td></tr><tr><td>ImageNet-R</td><td>r</td><td>56.16</td><td>59.37 (+3.21)</td><td>74.01</td><td>76.41 (+2.40)</td></tr><tr><td>Average</td><td>/</td><td>55.13</td><td>59.47 (+4.31)</td><td>65.42</td><td>68.32 (+2.90)</td></tr></table>
+
+Table 1: Main Results on Zero-shot Image Recognition. All results are top-1 accuracy on test set. o: object-level. s: scene-level. f: fine-grained. t: textures. si: satellite images. r: robustness.
+
+How to reduce noise and enhance robustness? It’s unavoidable that the synthesized data may contain low-quality samples. This is even more severe in the setting with language enhancement as it may introduce undesired items into language prompts (see Figure A.2 in Appendix for visual examples). Hence, we introduce a CLIP Filter (CF) strategy to rule out these samples. Specifically, CLIP zero-shot classification confidence is used to assess the quality of synthesized data, and the lowconfidence ones are removed. Besides, as soft-target is more robust than hard-target in countering sample noise, we study whether soft cross-entropy loss (SCE, see Sec. C.4 in Appendix) which uses the normalized clip scores as a target could be used to enhance robustness against data noise.
+
+Experiment Setup. We select 17 diverse datasets covering object-level (CIFAR-10 and CIFAR-100 ((Krizhevsky et al., 2009), Caltech101 (Fei-Fei et al., 2006), Caltech256 (Griffin et al., 2007), ImageNet (Deng et al., 2009)), scene-level (SUN397 (Xiao et al., 2010)), fine-grained (Aircraft (Maji et al., 2013), Birdsnap (Berg et al., 2014), Cars (Krause et al., 2013), CUB (Wah et al., 2011), Flower (Nilsback & Zisserman, 2008), Food (Bossard et al., 2014), Pets (Parkhi et al., 2012)), textures (DTD (Cimpoi et al., 2014)), satelite images (EuroSAT (Helber et al., 2019)) and robustness (ImageNetSketch (Wang et al., 2019), ImageNet-R (Hendrycks et al., 2021)) for zero-shot image classification. For synthetic data amount, we generate 2000 (study of synthetic image number in Appendix Sec. B.3) synthetic images for each class in B and LE. For LE, we generate 200 sentences for each class.
+
+Main Results: 1) zero-shot classification results on 17 datasets; 2) study of synthetic data diversity; 3) study of synthetic data reliability; 4) study of model/classifier tuning; 5) study of the behavior of synthetic data for zero-shot classification in the training from scratch settings.
+
+Synthetic data can significantly improve the performance of zero-shot learning. Our main studies in zero-shot settings are conducted with CLIP-RN50 (ResNet-50 (He et al., 2016) and CLIP-ViTB/16 (ViT-B/16 (Dosovitskiy et al., 2020)) as CLIP backbone), and we report results with our best strategy of $\mathbf { L E + C F + S C E }$ . As shown in Table 1, on 17 diverse downstream zero-shot image classification datasets, we achieve a remarkable average gain of $4 . 3 1 \%$ for CLIP-RN50 and $2 . 9 0 \%$ for CLIP-ViT-B/16 in terms of top-1 accuracy. Significantly, on the EuroSAT dataset, we achieve the largest performance boost of $1 7 . 8 6 \%$ for CLIP-RN50 in top-1 accuracy. We notice that the performance gain brought by synthetic data varies differently across datasets, which is mainly related to GLIDE’s training data distribution. The training data distribution of the text-to-image generation model GLIDE would exhibit bias and produce different domain gaps with different datasets (see Sec. A.2 in Appendix for more analysis).
+
+Table 2: Ablation study on Language Enhancement (LE), CLIP-based Filtering (CF), and Softtarget Cross-Entropy (SCE).   
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">CLIP</td><td colspan="2">B</td><td colspan="2">LE</td><td colspan="2">LE+CF</td></tr><tr><td>CE</td><td>SCE</td><td>CE</td><td>SCE</td><td>CE</td><td>SCE</td></tr><tr><td>CIFAR-10</td><td>70.31</td><td>77.39 (+7.08)</td><td>78.23 (+7.92)</td><td>77.20 (+6.89)</td><td>77.55 (+7.24)</td><td>80.01 (+9.70)</td><td>80.06 (+9.75)</td></tr><tr><td>CIFAR-100</td><td>35.35</td><td>43.99 (+8.64)</td><td>44.25 (+8.90)</td><td>44.08 (+8.73)</td><td>44.91 (+9.56)</td><td>44.55 (+9.20)</td><td>45.69 (+10.34)</td></tr><tr><td>EuroSAT</td><td>37.51</td><td>45.64 (+8.13)</td><td>48.23 (+10.72)</td><td>53.26 (+15.75)</td><td>54.94 (+17.43)</td><td>54.75 (+17.24)</td><td>55.37 (+17.86)</td></tr></table>
+
+Language diversity matters. By introducing more linguistic context into the text input, LE helps increase the diversity of synthetic data. As shown in Table 2, LE can achieve additional performance gains upon $\mathbf { B }$ in most cases $_ { ( 0 . 6 6 \uparrow }$ on CIFAR-100, $6 . 7 1 \uparrow$ on EuroSAT), which demonstrates the efficacy of LE and the importance of synthetic data diversity for zero-shot classification.
+
+Reliability matters. While LE could help increase the diversity of synthetic data, it also introduces the risks of noisy samples. Observed on CIFAR-10 in Table 2, LE sometimes even brings performance drops compared with B $( 0 . 6 8 \% \downarrow$ on CIFAR-10), which may attribute to the noise introduced by enhanced language prompts, e.g. the sentence extended from the class name word may contain other class names or confusing objects. Fortunately, with CF to filter out unreliable samples, $\mathbf { L E + C F }$ yields consistent improvement upon B. Moreover, SCE generally achieves better performance than CE, showing its better adaptation to label noise.
+
+Classifier tuning is enough for CLIP, while tuning with the pre-trained encoder leads to degradation, mainly due to domain gaps. Here, we investigate if only tuning the final classifier is the optimal solution in our setting with synthetic data. As shown in Table 3, we tune different proportions of the full model parameters on synthetic data for EuroSAT ( $0 . 0 2 \%$ corresponds to our default case where only the classifier is tuned), and report the zero-shot performance on the test set of EuroSAT. The best results are obtained by only tuning the classifier, and the performance gradually decreases as we gradually incorporate more parameters in the encoder for optimization, which agrees with the traditional strategy. For understanding why synthetic data may harm pre-trained image encoder, we experiment with real-world data with domain shifts and find they behave similarly to synthetic data (Appendix Sec. B.2), which suggests that domain gap is the main reason for the phenomenon. We argue that synthetic data might have a better chance to overcome domain shifts in comparison with real-world data since we can customize and keep the label space of the synthetic data in line with the down-stream dataset and use strategies during synthesizing to alleviate domain shifts.
+
+<table><tr><td>Param Tuned (%)</td><td>0</td><td>0.02</td><td>0.04</td><td>62.50</td><td>64.06</td><td>69.53</td><td>82.81</td><td>92.19</td></tr><tr><td>Acc</td><td>37.51</td><td>55.37</td><td>55.11</td><td>55.28</td><td>54.56</td><td>54.34</td><td>53.63</td><td>52.09</td></tr></table>
+
+Table 3: Parameters tuned v.s. Accuracy. Dataset: EuroSAT.   
+Table 4: Setting when training from scratch. Dataset: CIFAR-100.   
+
+<table><tr><td>Real shot</td><td>1</td><td>16</td><td>32</td><td>64</td><td>80</td><td>90</td><td>95</td><td>100</td></tr><tr><td>Acc</td><td>2.48</td><td>10.4</td><td>14.95</td><td>21.96</td><td>24.4</td><td>25.52</td><td>27.99</td><td>29.95</td></tr></table>
+
+Synthetic data deliver inferior performance in the training from scratch setting and are much less data-efficient than real data. To exclude the influence of powerful CLIP initialization in our study of synthetic data, we also conduct a from-scratch setting on the CIFAR-100 dataset, where we optimize a ResNet-50 model from random initialization. Given the label space of the CIFAR-100 dataset, we generate a synthetic dataset of $5 0 \mathrm { k }$ (500 images per class) to train a ResNet-50 model from scratch for image classification. We achieve a performance of $2 8 . 7 4 \%$ top-1 accuracy on CIFAR-100 test set, which is much lower than the performance of the pre-trained CLIP model (see Table 1). This might be attributed to the quality and diversity of data. The CLIP model benefits from diverse realworld data. Further, we hope to investigate how many real in-domain training data can match the performance of our $5 0 \mathrm { k }$ synthetic data. As shown in Table 4, training with 95 images per category $( 9 5 \times 1 0 0 = 9 . 5 { \mathrm { k } } )$ ) will achieve comparable performance as that of $5 0 \mathrm { k }$ synthetic data. This manifests that synthetic data are not as efficient and effective as real data when solving downstream tasks. It requires around 5 times more data in order to achieve a comparable performance as that of real data. Note that we find further increasing the amount of synthetic data will not deliver further performance gains for the downstream classification task. We expect that further investigations on synthesis quality will bring new opportunities in this area which will be our future work.
+
+Summary. Current synthetic data from text-to-image generation models could indeed bring significant performance boosts for a wide range of zero-shot image classification tasks, and is readily applicable with carefully designed strategies such as large-scale pre-trained models. Diversity and reliability matter for synthetic data when employed for zero-shot tasks. When the model is trained from scratch with synthetic data, synthetic data cannot deliver satisfactory performance and are much less data-efficient and effective for solving the classification task in comparison with real data.
+
+3.2 IS SYNTHETIC DATA READY FOR FEW-SHOT IMAGE RECOGNITION?
+
+In this section, we explore the effectiveness of synthetic data for few-shot tasks and how synthetic data impact the performance as more and more shots are included. Also, we design effective strategies to better leverage synthetic data.
+
+Few-shot Image Recognition. We adopt the CLIP-based method as the model for few-shot image recognition due to its state-of-the-art performance (Radford et al., 2021). As discussed previously, various prompt learning based methods can be treated as tuning the classifier weights. We thus study how to tune the classifier weights with synthetic data. In an N-way M-shot case, we are given M real images of each test class, where $\mathbf { M } \in \left\{ 1 , 2 , 4 , 8 , 1 6 \right\}$ in our experiments. With a total of $\mathbf { N } \times \mathbf { M }$ training samples, we hope to achieve favorable performance on a hold-out test set of the N classes.
+
+Synthetic Data for Few-shot Image Recognition. While there have been a few attempts to study how to better adapt CLIP models for few-shot tasks (Zhou et al., 2022b;a; Zhang et al., 2022), they all focus on the model optimization level, and none have explored from the data level. Here, we systematically study whether and how synthetic data can be employed for solving few-shot image recognition tasks.
+
+With the experience from synthetic data for zero-shot tasks, we adopt the best strategy (i.e. $\mathbf { L E { + } C F }$ ) in the zero-shot setting as the basic strategy $\mathbf { \delta } ( \mathbf { B } )$ . Further, as the few-shot real samples can provide useful information on the data distribution of the classification task, we develop two new strategies leveraging the in-domain few-shot real data for better using synthetic data: 1) Real Filtering (RF): given synthetic data of one class $c$ , we use the features of few-shot real samples to filter out synthetic images whose features are very close to the features of real samples that belong to other categories different from class $c ; 2$ ) Real guidance (RG): we use the few-shot real samples as guidance to generate synthetic images where the few-shot real samples (added noise) replace the random noise at the beginning of the generation to guide the diffusion process (details in Appendix Sec. C.3).
+
+Experiment Setup. For datasets, we carefully select 8 image classification datasets from recent works (Zhou et al., 2022b;a; Zhang et al., 2022) that conduct few-shot learning upon CLIP: ImageNet (Deng et al., 2009), Caltech101 (Fei-Fei et al., 2006), Pets (Parkhi et al., 2012), Cars (Krause et al., 2013), Aircraft (Maji et al., 2013), SUN397 (Xiao et al., 2010), DTD (Cimpoi et al., 2014), EuroSAT (Helber et al., 2019). For synthetic image number, we generate 800 (study of synthetic image number in Appendix Sec. B.3) images per class for RG method to approximately match the number of images in B and RF.
+
+Main Results: 1) few-shot classification results on 8 datasets; 2) ablation study of training strategy;   
+3) ablation study of synthetic data generation strategy; 4) ablation study of BN strategy.
+
+Synthetic data can boost few-shot learning and the positive impact of synthetic data will gradually diminish with the increase of real data shots. As shown in Figure 1 (results of more datasets are in the Appendix Sec. B.1), with only few-shot real images for training, our implemented CT w. init (classifier weights initialized from CLIP text embeddings) performs comparably with the state-ofthe-art CLIP tuning methods Tip Adapter (Zhang et al., 2022) and CoOp (Zhou et al., 2022b). CT w. Syn represents our results of applying synthetic data with mix training, real image as guidance, and freezing BN strategies. With the help of generated synthetic data, CT w. Syn achieves noticeable performance gains upon CT w. init, and achieves a new state-of-the-art few-shot learning performance across different datasets. We argue that for data-scarce few-shot classification, synthetic data could help address the insufficient data problem to boost performance. However, we notice that the boost from synthetic data gradually diminishes as the real shot number increases. We state that the effectiveness of each sample in real data is high since there’s no domain gap; in contrast, synthetic data suffer from domain gaps and perform less efficiently. In addition, the positive effects of the few-shot real data may overlap with that of synthetic data. Thus, with the increase of real data, the overlapping becomes serious and the positive impacts of synthetic data are reduced.
+
+Mix Training fits few-shot learning with synthetic data. Now that we have two parts of data, i.e. few-shot real data and synthetic data, we could either 1) phase-wise train on each part of data with two training phases, or 2) adopt mix training that simultaneously utilizes two parts of data to update the model in each iteration. Details of phase-wise/mix training in Appendix Sec. C.5.2. We provide the results in Table 7: we study on the EuroSAT dataset and use synthetic data generated from the RG method; under different shot number settings, mix training performs consistently better than two phase-wise strategies. We suggest that mix training could help learn better classifiers since each part could function as a regularization for the other: synthetic data help alleviate instabilities brought by limited real samples, and real data help address the noise and domain gap of synthetic data.
+
+![](images/852b48a16e7d1143e00de1a9683096c75aadd03f71f47f26762c38b612762b7e.jpg)  
+Figure 1: Results for few-shot image recognition. Results on all 8 datasets are provided in Appendix.
+
+Employing real data as guidance can alleviate domain differences and boost performance. We compare three strategies of synthetic data generation for few-shot tasks. As shown in Table 5, both RF and RG provide performance gains upon B which is the best strategy in the zero-shot setting. This demonstrates the importance of utilizing the domain knowledge from few-shot images for preparing the synthetic data. Further, RG significantly outperforms RF, yielding the best performance. This shows utilizing real data as guidance of the diffusion process help reduce the domain gap (visual illustrations in the Appendix Sec. B.8).
+
+Table 5: Ablation for Basic strategy (B), Real Filtering (RF), Real Guidance (RG) on EuroSAT, 16 shot.   
+
+<table><tr><td>B</td><td>RF</td><td>RG</td></tr><tr><td>87.1</td><td>87.33</td><td>88.47</td></tr></table>
+
+Table 6: Frozen BN works better for 16-shot settings on EuroSAT.   
+
+<table><tr><td colspan="2">Train data Freeze BN? Test Acc</td></tr><tr><td>Real</td><td>75.31</td></tr><tr><td>Real √</td><td> 85.63</td></tr><tr><td>Syn</td><td>44.73</td></tr><tr><td>Syn √</td><td> 55.37</td></tr></table>
+
+Table 7: Mix training works better for few-shot tasks on EuroSAT.   
+
+<table><tr><td>M-shot</td><td>Phase-wise syn →real real -→ syn</td><td>Mix training</td></tr><tr><td>1</td><td>63.01</td><td>64.36</td></tr><tr><td>2</td><td>72.24</td><td>73.62</td></tr><tr><td>4</td><td>78.88</td><td>79.88</td></tr><tr><td>8</td><td>83.64</td><td>84.57</td></tr><tr><td>16</td><td>87.10</td><td>88.47</td></tr></table>
+
+Frozen BN works better. Lastly, we investigate batch normalization (BN) strategies for our fewshot settings with synthetic data. As shown in Table 6, for both real and synthetic data, freezing the BN layers yields much better performance. We analyze that for real data, it is hard to get a good estimation of BN statistics when the number of images is limited. As for synthetic data, we attribute this to the statistical difference between different domains. Hence, we freeze BN layers during tuning for few-shot settings.
+
+Summary. Synthetic data from text-to-image generation models could readily benefit few-shot learning and achieve a new state-of-the-art few-shot classification performance with strategies we present in this paper. However, the positive impact of synthetic data will diminish as more shots of real data are available which further confirms our previous claim that synthetic data are still not as effective as real data in training classification models.
+
+# 3.3 IS SYNTHETIC DATA READY FOR PRE-TRAINING?
+
+Finally, we study whether synthetic data are effective in large-scale pre-training. We also present effective strategies to better leverage synthetic data for model pre-training.
+
+Pre-training for Transfer Learning. Recently, it has become a common practice to first pre-train models on large-scale datasets to obtain a well-trained feature extractor and then fine-tune the models on downstream tasks with labeled data (i.e. transfer learning). There have been various successful pre-training methods, including supervised pre-training (Joulin et al., 2016; Li et al., 2017; Mahajan et al., 2018; Sun et al., 2017; Kolesnikov et al., 2020), self-supervised pre-training (Chen et al., 2020a; He et al., 2020; Caron et al., 2020; Grill et al., 2020; Chen & He, 2021; Zbontar et al., 2021; Ye et al., 2019), and semi-supervised pre-training (Xie et al., 2020; Pham et al., 2021).
+
+Synthetic data for Pre-training. Since data amount and diversity play important roles in pretraining, we adopt the synthetic data generation strategy LE solely to maximize the scale of synthetic pre-training data. We study two settings for generating synthetic data for pre-training: 1) downstream-aware, where we have access to the label space of the downstream task, and thus we generate synthetic data according to the label space of the downstream task; 2) downstream-agnostic, where we have no access to downstream tasks in the pre-training stage, and we turn to a relatively general and diverse label space such as ImageNet-1K. For pre-training methods, we experiment with supervised pre-training and self-supervised pre-training methods.
+
+Experiment Setup. We compare synthetic pre-trained models with models of random initialization and models of ImageNet-1K pre-training in terms of their transfer learning abilities. For downstream-aware settings: we conduct supervised pre-training on synthetic data generated according to CIFAR-100 label space and then transfer to CIFAR-100 through finetuning for evaluation.
+
+For downstream-agnostic settings: we perform supervised pre-training and self-supervised pretraining (we adopt Moco v2 (Chen et al., 2020b) framework for its simplicity and reproducibility) on synthetic data generated from ImageNet-1K label space and evaluate the transfer performance by finetuning the pretrained models on a object detection dataset – PASCAL VOC (Everingham et al., 2010). Further, we experiment with ImageNet-2K label space (original ImageNet-1K and another non-overlapping 1K label names randomly selected from ImageNet-21K) to study the factors of data diversity and amount in synthetic pre-training. We use ResNet-50 as the default backbone when not else noted, and also experiment with a ViT-based backbone, i.e. DeiT-S (Touvron et al., 2021).
+
+Results for Downstream-aware settings. We generate synthetic data of different sizes from CIFAR-100 label space, i.e. $1 \times$ , $2 \times$ , $3 \times$ ImageNet-1K data size, concretely 1.2M, 2.4M, 3.6M. We pre-train the model on the generated synthetic labeled set in a supervised manner, and then perform evaluation after finetuning the model on CIFAR-100. As shown in Table 8, with an equivalent amount of data as that of ImageNet-1K (1.2M), synthetic data for pre-training can largely reduce the gap between training from scratch $( 7 8 . 8 3 \% )$ and ImageNet- pre-trained model $( 8 4 . 5 0 \% )$ . Moreover, with $2 \times$ and $3 \times$ synthetic data, pre-training on synthetic data outperforms ImageNet-1K pre-training with a noticeable margin. In addition, when we initialize the model from ImageNet-1K pre-trained weights and pre-train the model on synthetic data, we obtain extra boosts upon both results.
+
+We conclude that for downstream-aware synthetic pre-training, synthetic data deliver close performance as that of ImageNet-1K pretraining with the same amount of data, synthetic data amount helps improve the results to outperforming ImageNet-1K pre-training, and synthetic pre-training could further benefit from ImageNet-1K pre-training.
+
+Results for Downstream-agnostic settings. We first experiment with ImageNet-1K label space with $1 \times$ or $2 \times$ ImageNet-1K data size, i.e. 1.2M/2.4M IN-1K Syn. We perform supervised pretraining and self-supervised pre-training (i.e. Moco v2) on the generated synthetic data, and evaluate the pre-training results by transferring to the CIFAR-100 image classification task or the PASCAL VOC detection task. As it is too costly to validate all settings (e.g., it takes more than 1 week to train Moco v2 on 4.0M synthetic data), we select several representative settings of interest to validate the effectiveness of synthetic data without hurting our conclusion.
+
+As shown in Table 10 and 11, with 1.2M IN-1K Syn, both supervised pre-training $( 7 9 . 0 0 \% )$ and self-supervised pre-training $( 8 1 . 5 5 \% )$ could largely approach their IN-1K Real counterparts (super.: $8 1 . 3 \%$ ; self-super.: $8 2 . 4 4 \%$ ) and largely outperforms the result without pre-training $( 6 6 . 0 8 \% )$ . When increasing the data amount to 2.4M, the transferred results further increase, and the unsupervised pre-training method, i.e. Moco v2, performs better in utilizing our synthetic data thanks to its independence of labels, yielding a $8 2 . 1 3 \%$ transferred performance which surpasses supervised pre-training on IN-1K Real $( 8 1 . 3 0 \% )$ and is on par with its Moco v2 counterpart at IN-1K Real $( 8 2 . 4 4 \% )$ . Next, we expand the label space by adding another 1K categories, producing IN-2K Syn. The enlarged diversity and data amount further bridge the gap between synthetic pre-training results and IN-1K Real pre-training results. Noticeably, the unsupervised pre-trained model Moco v2 $( 8 2 . 2 9 \% )$ largely approaches the IN-1K Real counterpart $( 8 2 . 4 4 \% )$ with negligible performance drop of $0 . 1 5 \%$ . Furthermore, when initialized from IN-1K Real pre-trained weights, both supervised and self-supervised pre-training improve upon both pure real data and synthetic data for pre-training.
+
+While the above results are all obtained with convolutional-based backbone i.e. ResNet50, we further explore with a recent ViT-based backbone i.e. DeiT-S (Touvron et al., 2021). Surprisingly,
+
+Table 8: Results on CIFAR-100 with downstream-aware supervised pre-training. C100: CIFAR100.   
+
+<table><tr><td>Data</td><td>pre-trained on IN-1k?</td><td>Syn. images amount 0 1.2M 2.4M 3.6M</td><td></td></tr><tr><td>(None)</td><td></td><td>78.83</td><td>-</td></tr><tr><td>C100 Syn</td><td></td><td>1</td><td>83.90 85.03 85.24</td></tr><tr><td>(None)</td><td>√</td><td>84.50</td><td>- =</td></tr><tr><td>C100 Syn</td><td>√</td><td>-</td><td>84.90 85.32 85.52</td></tr></table>
+
+Table 9: Results on CIFAR-100 with downstream-agnostic supervised pretraining. Backbone: DeiT-S.   
+
+<table><tr><td rowspan="2">Data</td><td rowspan="2">pre-trained on IN-1k?</td><td colspan="3">Syn. images amount 1.2M 2.4M 4.0M</td></tr><tr><td>0 69.29 =</td><td></td><td></td></tr><tr><td>(None) IN-1K Syn</td><td></td><td>87.98</td><td>88.39</td><td>=</td></tr><tr><td>IN-2K Syn</td><td></td><td>- =</td><td>88.57</td><td>88.91</td></tr><tr><td>(None)</td><td>5</td><td>- 88.07 =</td><td>-</td><td>■</td></tr></table>
+
+Table 10: Results for object detection on PASCAL VOC with downstream-agnostic supervised pre-training, all results are reported in $\mathrm { { A P } _ { 5 0 } }$ .   
+
+<table><tr><td>Data</td><td>pre-trained on IN-1k?</td><td>Syn.images amount 0 1.2M</td><td>2.4M 4.0M</td></tr><tr><td>(None)</td><td></td><td>66.08 79.00 =</td><td>= =</td></tr><tr><td>IN-1K Syn IN-2K Syn</td><td></td><td>- =</td><td>80.00 80.54 80.72</td></tr><tr><td>(None)</td><td>√</td><td>81.30</td><td>-</td></tr><tr><td>IN-1K Syn</td><td>√</td><td>=</td><td>81.78</td></tr><tr><td>IN-2K Syn</td><td>√</td><td>=</td><td>81.87 81.91</td></tr></table>
+
+Table 11: Results for object detection on PASCAL VOC with downstream-agnostic selfsupervised pre-training (Moco v2), all results are reported in $\mathrm { { A P } _ { 5 0 } }$ .   
+
+<table><tr><td>Data</td><td>pre-trained on IN-1k?</td><td>Syn. images amount 0 1.2M</td><td>2.4M 4.0M</td></tr><tr><td>(None)</td><td></td><td>66.08 -</td><td>- 1</td></tr><tr><td>IN-1K Syn</td><td></td><td>81.55 =</td><td>82.13</td></tr><tr><td>IN-2K Syn</td><td></td><td>1 =</td><td>82.22 82.29</td></tr><tr><td>(None)</td><td>4</td><td>82.44</td><td>=</td></tr><tr><td>IN-1K Syn</td><td>√</td><td>- =</td><td>82.47</td><td>=</td></tr></table>
+
+ViT-based backbone is shown to be more advantageous compared with convolution-based backbone for synthetic pre-training: outperforming ImageNet pre-training results in the downstream-agnostic settings. Equipped with ViT-based backbone, on only 1.2M IN-1K synthetic data, we achieve comparable performance $( 8 7 . 9 8 \% )$ with ImageNet pre-training $( 8 8 . 0 7 \% )$ . Further increasing the data amount $( 8 8 . 3 9 \% )$ and label space $( 8 8 . 5 7 \%$ , $8 8 . 9 1 \%$ of pre-training data leads to higher performance than ImageNet pre-training. ViT-based backbones have stronger ability for learning from large-scale data and are more robust (Pinto et al., 2021), and thus could better benefit from synthetic pre-training where data are more noisy and data scale could be easily increased.
+
+Conclusion. In terms of transfer abilities, synthetic data from text-to-image generation models show surprisingly promising results for model pre-training, which is comparable to the standard ImageNet pre-training. We conclude our findings as follows:
+
+1. Data amount has positive impacts on synthetic pre-training; performance could be improved by increasing synthetic data size, but would gradually saturate as the amount of data increases.
+
+2. Synthetic data for pre-training is orthogonal to real data for pre-training.
+
+3. For downstream-aware synthetic pre-training, we significantly outperform IN-1K Real (1.2M) pre-training with 2.4M/3.6M synthetic data on CIFAR-100.
+
+4. For downstream-agnostic synthetic pre-training, we achieve comparable results with ImageNet (IN-1k) Real pre-training; self-supervised pre-training performs better than supervised pre-training, and ViT-based backbone performs better than convolutional-based backbone. Besides, increasing the label space size could further improve the performance.
+
+# 4 CONCLUSION
+
+We systematically investigate whether synthetic data from current state-of-the-art text-to-image generation models are readily applicable for image recognition. Our extensive experiments demonstrate that synthetic data are beneficial for classifier learning in zero-shot and few-shot recognition, bringing significant performance boosts and yielding new state-of-the-art performance. Further, current synthetic data show strong potential for model pre-training, even surpassing the standard ImageNet pre-training. We also point out limitations and bottlenecks for applying synthetic data for image recognition, hoping to arouse more future research in this direction.
+
+Limitations. In all investigated settings, we observe improved performance as the data amount and diversity (label space) increases. However, due to our limited computational resource, we are not able to further scale up data amount, which may take months to train one model. Besides, we are also not able to investigate larger model sizes and advanced architectures in the current investigation which is also worth exploring in the future. We present more discussions on limitations and future directions in the appendix.
+
+Acknowledgement. This work has been supported by Hong Kong Research Grant Council - Early Career Scheme (Grant No. 27209621) and General Research Fund Scheme (Grant no. 17202422). Part of the described research work is conducted in the JC STEM Lab of Robotics for Soft Materials funded by The Hong Kong Jockey Club Charities Trust.
+
+# REFERENCES
+
+Thomas Berg, Jiongxin Liu, Seung Woo Lee, Michelle L. Alexander, David W. Jacobs, and Peter N. Belhumeur. Birdsnap: Large-scale fine-grained visual categorization of birds. In Proc. Conf. Computer Vision and Pattern Recognition (CVPR), June 2014.
+
+Victor Besnier, Himalaya Jain, Andrei Bursuc, Matthieu Cord, and Patrick Perez. This dataset does ´ not exist: training models from generated images. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 1–5. IEEE, 2020.
+
+Lukas Bossard, Matthieu Guillaumin, and Luc Van Gool. Food-101–mining discriminative components with random forests. In European conference on computer vision, pp. 446–461. Springer, 2014.
+
+Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv preprint arXiv:1809.11096, 2018.
+
+Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. arXiv:2006.09882, 2020.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In ICML, 2020a.
+
+Xinlei Chen and Kaiming He. Exploring simple siamese representation learning. In CVPR, 2021.
+
+Xinlei Chen, Haoqi Fan, Ross Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020b.
+
+Mircea Cimpoi, Subhransu Maji, Iasonas Kokkinos, Sammy Mohamed, and Andrea Vedaldi. Describing textures in the wild. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3606–3613, 2014.
+
+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.
+
+A. Dosovitskiy, P. Fischer, E. Ilg, P. Hausser, C. Hazırbas¸, V. Golkov, P. v.d. Smagt, D. Cremers, ¨ and T. Brox. Flownet: Learning optical flow with convolutional networks. In IEEE International Conference on Computer Vision (ICCV), 2015. URL http://lmb.informatik. uni-freiburg.de/Publications/2015/DFIB15.
+
+Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv:2010.11929, 2020.
+
+Mark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. IJCV, 2010.
+
+Li Fei-Fei, Robert Fergus, and Pietro Perona. One-shot learning of object categories. IEEE transactions on pattern analysis and machine intelligence, 28(4):594–611, 2006.
+
+Peng Gao, Shijie Geng, Renrui Zhang, Teli Ma, Rongyao Fang, Yongfeng Zhang, Hongsheng Li, and Yu Qiao. Clip-adapter: Better vision-language models with feature adapters. arXiv preprint arXiv:2110.04544, 2021.
+
+Gregory Griffin, Alex Holub, and Pietro Perona. Caltech-256 object category dataset. 2007.
+
+Jean-Bastien Grill, Florian Strub, Florent Altche, Corentin Tallec, Pierre H Richemond, Elena´ Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv:2006.07733, 2020.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In CVPR, 2020.
+
+Patrick Helber, Benjamin Bischke, Andreas Dengel, and Damian Borth. Eurosat: A novel dataset and deep learning benchmark for land use and land cover classification. IEEE Journal of Selected Topics in Applied Earth Observations and Remote Sensing, 12(7):2217–2226, 2019.
+
+Dan Hendrycks, Steven Basart, Norman Mu, Saurav Kadavath, Frank Wang, Evan Dorundo, Rahul Desai, Tyler Zhu, Samyak Parajuli, Mike Guo, Dawn Song, Jacob Steinhardt, and Justin Gilmer. The many faces of robustness: A critical analysis of out-of-distribution generalization. ICCV, 2021.
+
+Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Advances in Neural Information Processing Systems, 33:6840–6851, 2020.
+
+Jonathan Ho, Chitwan Saharia, William Chan, David J Fleet, Mohammad Norouzi, and Tim Salimans. Cascaded diffusion models for high fidelity image generation. J. Mach. Learn. Res., 23: 47–1, 2022.
+
+Ali Jahanian, Xavier Puig, Yonglong Tian, and Phillip Isola. Generative models as a data source for multiview representation learning. arXiv preprint arXiv:2106.05258, 2021.
+
+Armand Joulin, Laurens Van Der Maaten, Allan Jabri, and Nicolas Vasilache. Learning visual features from large weakly supervised data. In ECCV, 2016.
+
+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.
+
+Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Joan Puigcerver, Jessica Yung, Sylvain Gelly, and Neil Houlsby. Big transfer (bit): General visual representation learning. In ECCV, 2020.
+
+Jonathan Krause, Michael Stark, Jia Deng, and Li Fei-Fei. 3d object representations for fine-grained categorization. In 4th International IEEE Workshop on 3D Representation and Recognition (3dRR-13), Sydney, Australia, 2013.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+Ang Li, Allan Jabri, Armand Joulin, and Laurens van der Maaten. Learning visual n-grams from web data. In ICCV, 2017.
+
+Bill Yuchen Lin, Wangchunshu Zhou, Ming Shen, Pei Zhou, Chandra Bhagavatula, Yejin Choi, and Xiang Ren. Commongen: A constrained text generation challenge for generative commonsense reasoning. arXiv preprint arXiv:1911.03705, 2019.
+
+Andreas Lugmayr, Martin Danelljan, Andres Romero, Fisher Yu, Radu Timofte, and Luc Van Gool. Repaint: Inpainting using denoising diffusion probabilistic models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 11461–11471, 2022.
+
+Dhruv Mahajan, Ross Girshick, Vignesh Ramanathan, Kaiming He, Manohar Paluri, Yixuan Li, Ashwin Bharambe, and Laurens Van Der Maaten. Exploring the limits of weakly supervised pretraining. In ECCV, 2018.
+
+S. Maji, J. Kannala, E. Rahtu, M. Blaschko, and A. Vedaldi. Fine-grained visual classification of aircraft. Technical report, 2013.
+
+Chenlin Meng, Yutong He, Yang Song, Jiaming Song, Jiajun Wu, Jun-Yan Zhu, and Stefano Ermon. Sdedit: Guided image synthesis and editing with stochastic differential equations. In International Conference on Learning Representations, 2021.
+
+Alex Nichol, Prafulla Dhariwal, Aditya Ramesh, Pranav Shyam, Pamela Mishkin, Bob McGrew, Ilya Sutskever, and Mark Chen. Glide: Towards photorealistic image generation and editing with text-guided diffusion models. arXiv preprint arXiv:2112.10741, 2021.
+
+Alexander Quinn Nichol and Prafulla Dhariwal. Improved denoising diffusion probabilistic models. In International Conference on Machine Learning, pp. 8162–8171. PMLR, 2021.
+
+Maria-Elena Nilsback and Andrew Zisserman. Automated flower classification over a large number of classes. In 2008 Sixth Indian Conference on Computer Vision, Graphics & Image Processing, pp. 722–729. IEEE, 2008.
+
+Omkar M Parkhi, Andrea Vedaldi, Andrew Zisserman, and CV Jawahar. Cats and dogs. In 2012 IEEE conference on computer vision and pattern recognition, pp. 3498–3505. IEEE, 2012.
+
+Xingchao Peng, Ben Usman, Neela Kaushik, Judy Hoffman, Dequan Wang, and Kate Saenko. Visda: The visual domain adaptation challenge. arXiv preprint arXiv:1710.06924, 2017.
+
+Hieu Pham, Zihang Dai, Qizhe Xie, and Quoc V Le. Meta pseudo labels. In CVPR, 2021.
+
+Francesco Pinto, Philip Torr, and Puneet K Dokania. Are vision transformers always more robust than convolutional neural networks? 2021.
+
+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.
+
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J Liu, et al. Exploring the limits of transfer learning with a unified text-to-text transformer. J. Mach. Learn. Res., 21(140):1–67, 2020.
+
+Aditya Ramesh, Prafulla Dhariwal, Alex Nichol, Casey Chu, and Mark Chen. Hierarchical textconditional image generation with clip latents. arXiv preprint arXiv:2204.06125, 2022.
+
+Stephan R Richter, Vibhav Vineet, Stefan Roth, and Vladlen Koltun. Playing for data: Ground truth from computer games. In European conference on computer vision, pp. 102–118. Springer, 2016.
+
+Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Bjorn 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.
+
+Chitwan Saharia, William Chan, Huiwen Chang, Chris Lee, Jonathan Ho, Tim Salimans, David Fleet, and Mohammad Norouzi. Palette: Image-to-image diffusion models. In ACM SIGGRAPH 2022 Conference Proceedings, pp. 1–10, 2022a.
+
+Chitwan Saharia, William Chan, Saurabh Saxena, Lala Li, Jay Whang, Emily Denton, Seyed Kamyar Seyed Ghasemipour, Burcu Karagol Ayan, S Sara Mahdavi, Rapha Gontijo Lopes, et al. Photorealistic text-to-image diffusion models with deep language understanding. arXiv preprint arXiv:2205.11487, 2022b.
+
+Chitwan Saharia, Jonathan Ho, William Chan, Tim Salimans, David J Fleet, and Mohammad Norouzi. Image super-resolution via iterative refinement. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2022c.
+
+Jascha Sohl-Dickstein, Eric Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. In International Conference on Machine Learning, pp. 2256–2265. PMLR, 2015.
+
+Chen Sun, Abhinav Shrivastava, Saurabh Singh, and Abhinav Gupta. Revisiting unreasonable effectiveness of data in deep learning era. In ICCV, 2017.
+
+Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Herve J ´ egou. Training data-efficient image transformers & distillation through attention. In ´ International Conference on Machine Learning, pp. 10347–10357. PMLR, 2021.
+
+Catherine Wah, Steve Branson, Peter Welinder, Pietro Perona, and Serge Belongie. The caltech-ucsd birds-200-2011 dataset. 2011.
+
+Haohan Wang, Songwei Ge, Zachary Lipton, and Eric P Xing. Learning robust global representations by penalizing local predictive power. In Advances in Neural Information Processing Systems, pp. 10506–10518, 2019.
+
+Mitchell Wortsman, Gabriel Ilharco, Jong Wook Kim, Mike Li, Simon Kornblith, Rebecca Roelofs, Raphael Gontijo Lopes, Hannaneh Hajishirzi, Ali Farhadi, Hongseok Namkoong, et al. Robust fine-tuning of zero-shot models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 7959–7971, 2022.
+
+Jianxiong Xiao, James Hays, Krista A Ehinger, Aude Oliva, and Antonio Torralba. Sun database: Large-scale scene recognition from abbey to zoo. In 2010 IEEE computer society conference on computer vision and pattern recognition, pp. 3485–3492. IEEE, 2010.
+
+Qizhe Xie, Minh-Thang Luong, Eduard Hovy, and Quoc V Le. Self-training with noisy student improves imagenet classification. In CVPR, 2020.
+
+Mang Ye, Xu Zhang, Pong C Yuen, and Shih-Fu Chang. Unsupervised embedding learning via invariant and spreading instance feature. In CVPR, 2019.
+
+Jure Zbontar, Li Jing, Ishan Misra, Yann LeCun, and Stephane Deny. Barlow twins: Self-supervised ´ learning via redundancy reduction. arXiv:2103.03230, 2021.
+
+Renrui Zhang, Zhang Wei, Rongyao Fang, Peng Gao, Kunchang Li, Jifeng Dai, Yu Qiao, and Hongsheng Li. Tip-adapter: Training-free adaption of clip for few-shot classification. arXiv preprint arXiv:2207.09519, 2022.
+
+Yuxuan Zhang, Huan Ling, Jun Gao, Kangxue Yin, Jean-Francois Lafleche, Adela Barriuso, Antonio Torralba, and Sanja Fidler. Datasetgan: Efficient labeled data factory with minimal human effort. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10145–10155, 2021.
+
+Kaiyang Zhou, Jingkang Yang, Chen Change Loy, and Ziwei Liu. Conditional prompt learning for vision-language models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 16816–16825, 2022a.
+
+Kaiyang Zhou, Jingkang Yang, Chen Change Loy, and Ziwei Liu. Learning to prompt for visionlanguage models. International Journal of Computer Vision, pp. 1–12, 2022b.

parse/dev/oEsYs3WRc3/oEsYs3WRc3.md

@@ -0,0 +1,486 @@
+# Enhancing Chat Language Models by Scaling High-quality Instructional Conversations
+
+Ning Ding1∗ , $\mathbf { Y u l i n } \mathbf { C h e n } ^ { 2 , 3 * }$ , Bokai $\mathbf { X } \mathbf { u } ^ { 4 }$ , Yujia $\mathbf { Q i n ^ { 2 , 3 } }$ , Shengding $\mathbf { H } \mathbf { u } ^ { 2 , 3 }$ Zhiyuan $\mathbf { L i u ^ { 2 , 3 \dag } }$ , Maosong $\mathbf { S u n ^ { 2 , 3 \dag } }$ , Bowen Zhou1† 1Department of Electronic Engineering,Tsinghua University 2Department of Computer Science and Technology, Tsinghua University 3 BNRIST, IAI, Tsinghua University, 4The Chinese University of Hong Kong, Shenzhen
+
+# Abstract
+
+Fine-tuning on instruction data has been widely validated as an effective practice for implementing chat language models like ChatGPT. Scaling the diversity and quality of such data, although straightforward, stands a great chance of leading to improved performance. This paper aims to push the upper bound of opensource models further. We first provide a systematically designed, diverse, informative, large-scale dataset of instructional conversations, UltraChat, which does not involve human queries. Our objective is to capture the breadth of interactions between a human user and an AI assistant and employs a comprehensive framework to generate multi-turn conversation iteratively. UltraChat contains 1.5 million high-quality multi-turn dialogues and covers a wide range of topics and instructions. Our statistical analysis of UltraChat reveals its superiority in various key metrics, including scale, average length, diversity, coherence, etc., solidifying its position as a leading opensource dataset. Building upon UltraChat, we fine-tune a LLaMA model to create a powerful conversational model, UltraLM. Our evaluations indicate that UltraLM consistently outperforms other open-source models, including WizardLM and Vicuna, the previously recognized state-of-the-art open-source models.
+
+# 1 Introduction
+
+Large language models (Bommasani et al., 2021; Han et al., 2021; Chowdhery et al., 2022) (LLMs) have demonstrated exceptional generalization capability on a variety of language-related tasks. Notably, ChatGPT (OpenAI, 2022), an optimized version of GPT-3 (Brown et al., 2020) for conversation, along with GPT-4 (OpenAI, 2023), takes the user experience to another level via excelling in comprehending and generating responses in a natural and interactive manner. The introduction of
+
+Table 1: Average scores (1-10) across different opensource models and UltraLM. The evaluation is conducted on our curated evaluation set with GPT-4. Evaluation prompts can be found in Appendix C.   
+
+<table><tr><td>Model</td><td>Score</td></tr><tr><td>《 Dolly-v2 (Conover et al., 2023) UNA MPT-Chat (Mosaic,2023)</td><td>4.04 ± 2.34</td></tr><tr><td>□ OpenAssistant (Kopf et al., 2023)</td><td>6.67 ± 2.88 7.65 ± 2.15</td></tr><tr><td>福 Alpaca (Taori et al., 2023) 藍 Koala (Geng et al., 2023)</td><td>8.04 ± 2.05 8.23 ± 1.99</td></tr><tr><td>务 Baize (Xu et al., 2023b) T Vicuna (Chiang et al., 2023)</td><td>8.50 ± 1.34</td></tr><tr><td>S Wizard-LM (Xu et al., 2023a) UltraLM (ours)</td><td>8.78 ± 1.55 8.95 ± 1.44</td></tr></table>
+
+ChatGPT has spurred a surge in the adoption and implementation of general chat language models.
+
+In addition to competing models developed by large corporations such as Bard1 and Claude2, the open-source community is actively engaged in training similar models, aiming to democratize access to AI technology. Notable examples in this regard include Alpaca (Taori et al., 2023), Vicuna (Chiang et al., 2023), Koala (Geng et al., 2023), Baize (Xu et al., 2023b), and Belle (Ji et al., 2023), etc., demonstrating promising performance. Experimental evidence strongly suggests that chat language models can be effectively trained through instruction fine-tuning (Wei et al., 2021; Sanh et al., 2021), and they also indicate that many data-efficient (Zhou et al., 2023) or computingefficient (Hu et al., 2021; Ding et al., 2023) methods can be applied. This paper, in another way, focuses more on the "final one mile" of chat language models, as evidence shows that the journey from 0 to 60 is easy, whereas progressing from 60 to 100 becomes exceedingly challenging. For instance, researchers have shown that by utilizing a small, thoughtfully curated set of instructions, it is possible to train a model with satisfactory instructionfollowing capabilities. However, these approaches have yet to produce models that surpass the performance of Vicuna, the current leading open-source model, let alone outperform ChatGPT and GPT-4.
+
+This paper believes that the most straightforward way, that is, the quality and diversity of training data, play a vital role in further improving the performance of chat language models. In other words, leveraging higher quality and more diverse data can yield better outcomes. To this end, we present UltraChat, a million-scale multi-turn instructional conversation data, to facilitate the construction of more powerful chat language models. UltraChat is carefully designed to capture the breadth of interactions that a human might have with an AI assistant. Specifically, we do not use specific tasks like question-answering or summarization to construct the data, but curate three sectors: Questions about the World, Creation and Writing, and Assistance on Existing Materials. Then we employ metainformation, in-context expansion, and iterative prompting to scale up the number of instructions. To construct informative and realistic multi-turn conversations, two separate ChatGPT Turbo APIs are adopted in the conversation generation, where one plays the role of the user to generate queries, and the other generates the response. We instruct the user model with carefully designed prompts to mimic human user behavior and call the two APIs iteratively.
+
+We fine-tune a LLaMA-13B model on UltraChat to produce UltraLM and compare the model to a wide range of baselines, especially the opensource ones. The evaluation shows that our model could consistently outperform other models. As reported in Table 1, UltraLM achieves the highest performance scores that are independently assessed by GPT-4. Further evaluation results on challenging benchmarks and preference study with GPT-4 on various evaluation sets also show that UltraLM could surpass all other open-source models.
+
+hibits a strong ability in instruction understanding and generalizes well to unseen instructions (Sanh et al., 2021; Ouyang et al., 2022). Later, Longpre et al. (2023) show the benefits of scaling the number of tasks in out-of-distribution generalization. Wei et al. (2021) also conclude that the success of instruction tuning depends on the quality of the dataset and the design of prompts. To further regulate the tuned model’s behavior, Ouyang et al. (2022); Schulman et al. (2017) propose to employ reinforcement learning to align model behaviors with human preferences. This technique combined with instruction tuning can further boost the model performance and has been successfully applied to LLMs such as ChatGPT.
+
+Data Augmentation with LLMs. Collecting large-scale human-annotated instructions and their responses is time-consuming and labor-intensive. Alternatively, a more cost-effective and feasible approach to gathering top-notch data involves sampling from LLMs that have been well-tuned, e.g., ChatGPT and GPT-3.5. Recently, there is a surge of interest in distilling these powerful LLMs for data augmentation. For instance, using the technique of Self-Instruct (Wang et al., 2022), Alpaca (Taori et al., 2023) generate $\mathrm { 5 2 k }$ high-quality instruction-response pairs based on seed tasks by “distilling” Text-Davinci-003. The trained model performs almost on par with TextDavinci-003. The success of Alpaca boosts numerous later efforts on data augmentation with LLMs, such as code-alpaca (Chaudhary, 2023), alpacacot (Si et al., 2023), GPT4ALL (Anand et al., 2023), ShareGPT (Domeccleston, 2023), Dollyv2 (Conover et al., 2023), BELLE (Ji et al., 2023), Vicuna (Chiang et al., 2023), Koala (Geng et al., 2023), Baize (Xu et al., 2023b), etc. It is shown that increasing the scale of data could constantly improve the model performance. Besides, prompt engineering also affects data quality. CAMEL (Li et al., 2023a) design a multi-agent role-play environment for LLMs to simulate real human conversations.
+
+# 2 Related Work
+
+Instruction Tuning. Recent works demonstrate LLMs’ powerful capabilities in following human instructions. Wei et al. (2021) pioneered to finetune T5 (Raffel et al., 2020) on 60 NLP datasets verbalized with natural language instruction templates, i.e., instruction tuning. The fine-tuned model ex
+
+# 3 Data Construction
+
+LLMs are believed to be better annotators than human-being in many scenarios (Gilardi et al., 2023). However, employing LLMs such as ChatGPT directly for generating multi-turn conversations may yield satisfactory but less informative results, as it cannot enjoy the benefit of reinforcement learning with human feedback (RLHF) in the alignment process. Table 12 in Appendix A shows a comparison of directly generated multi-turn dialogue and a case in UltraChat with the same opening line. Two key points can be derived to ensure the quality of the data: (1) An opening line determines the topic of the dialogue. Opening lines should be highly diverse and encompass any task that a human user may request a chat model to perform. (2) A user determines the plot of the dialogue, and the output should be tailored to the current topic with diverse language styles and requests.
+
+![](images/880851c04a32bf38cc523160f6a178cf867f731609f5ea0929debdfe594a8097.jpg)  
+Figure 1: Construction process of UltraChat. The three sectors of data are derived from different meta-information.
+
+Therefore, unlike traditional task-specific datasets, to construct a comprehensive opendomain instructional chat dataset, the design of data collection schema is crucial to capturing the breadth of interactions and ensuring data quality. UltraChat aims to cover a tremendous range of conversation data with a carefully designed tripartite schema: Questions about the World, Creation and Writing, and Assistance on Existing Materials. While the core of ensuring data diversity mainly depends on opening line diversity, we will first introduce the idea behind the sector design and then focus on specific measures to obtain a diverse set of opening lines and how to prompt the user properly.
+
+# 3.1 Questions about the World
+
+The first sector focuses on querying existing information in the world, including concepts, objects, and entities that exist in the real world. This is at the core of human-AI interaction, as users often rely on AI assistants to provide quick and accurate answers to their questions.
+
+Our approach to gathering data for this sector involves two perspectives: one centered around topics and concepts, and the other around real-world entities. Initially, we request ChatGPT to generate 30 comprehensive topics that encompass various aspects of our daily lives, as shown in Table 2. Subsequently, we delve deeper into each topic by generating 30 to 50 subtopics or related concepts. Finally, we generate 10 different questions for each subtopic or concept and additionally request ChatGPT to generate 10 more questions based on each original question. The other source of data comes from real-world objects, which are derived from Wikidata3 entities. These entities are further refined by considering their frequencies in Wikipedia4 articles, specifically focusing on the 10,000 most frequently occurring entities. For each entity, we create 5 meta-questions, followed by 10 more specific questions and 20 extended questions. The extended questions aim to maintain some similarity to the original question while exploring distinct objects or topics. To create a dialogue, we filter and sample approximately 500,000 questions as opening lines. During the construction of each dialogue, we provide the user model with carefully crafted prompts that explicitly ask the model to respond concisely and meaningfully, taking into account the context of the ongoing dialogue history.
+
+![](images/295885bf5eb74e7a5c069c6c47e97bdec841409e432d423e6062e61ad44c3bb1.jpg)
+
+![](images/bd78c29d700eb2f8e6d0722791dd14d7f5e8239dabe9639fdb2b72c488e64a5f.jpg)
+
+# 3.2 Creation and Writing
+
+The second part is concerned with the creation of new information with human-input conditions, ranging from writing emails to crafting stories and plays. This process reflects the AI’s capacity to engage in original content generation alongside users and demonstrates the role of AI assistants as collaborative partners in a creative environment.
+
+We first project all creations as text materials, and further categorize them into 20 different types as in Table 3. Then a ChatGPT model is employed to produce a diverse range of instructions for each type of writing, approximately $80 \%$ of which are further refined by ChatGPT model to generate more detailed instructions. These instructions serve as opening lines for dialogue generation. Throughout the generation process, the user prompt constantly reinforces the primary objective of the conversation, which is to generate and refine a piece of writing. This serves to ensure that the behavior of the user model remains focused and aligned with the intended purpose.
+
+# 3.3 Assistance on Existing Materials
+
+The third sector mainly addresses the modification of existing information, encompassing various tasks including rewriting, translation, summarization, and question-answering, etc. Modifying existing materials is a crucial aspect of human-AI interaction, as it allows the AI assistant to actively engage with the user’s input, transforming it in various ways as instructed by the user.
+
+We begin by gathering text pieces from the C4 corpus5. Each piece within the C4 corpus is associated with a source URL. To ensure a diverse range of text content and styles, we adopt the 20 material types outlined in the previous section and manually curate keywords for each type. Additionally, we classify the text in the corpus by matching the keywords in the corresponding URL. In total, we collect 100,000 text pieces from the C4 corpus, and for each piece, we prompt ChatGPT to generate five distinct instructions. We use a manually designed template to combine text and instructions, as depicted in Figure 4 in the appendix. Ultimately, the concatenated set of 500,000 pieces serves as the opening lines for the generated dialogues.
+
+# 3.4 User Simulation and Refinement
+
+Maintaining the desired behavior of the user model is crucial for achieving successful automatic dialogue generation. It has been observed that when the user model is solely provided with the current dialogue history, it tends to assume the role of an AI assistant. This "role confounding" situation
+
+<table><tr><td>Dataset</td><td>#Dialogue</td><td>Avg. #Turns</td><td>Avg. Dialog Length (by token)</td><td>Avg.Utt.Length (by token)</td><td>Lexical Diversity (↑)</td><td>Topic Diversity (↓)</td><td>Coherence (个)</td><td>User Simulation</td></tr><tr><td>Self-Instruct</td><td>82,439</td><td>1</td><td>69.8</td><td>29.2</td><td>24.9</td><td>0.733</td><td></td><td>No</td></tr><tr><td>Stanford Alpaca</td><td>52.002</td><td>1</td><td>91.1</td><td>64.5</td><td>42.8</td><td>0.727</td><td></td><td>No</td></tr><tr><td>SODA</td><td>1,486,869</td><td>3.6</td><td>231.8</td><td>22.5</td><td>38.6</td><td>0.797</td><td>8.48</td><td>No</td></tr><tr><td>GPT-4-LLM</td><td>61,002</td><td>1</td><td>179.6</td><td>142.9</td><td>48.9</td><td>0.721</td><td>-</td><td>No</td></tr><tr><td>BELLE</td><td>1,436,679</td><td>1</td><td>102.3</td><td>63.3</td><td>35.9</td><td>0.771</td><td>-</td><td>No</td></tr><tr><td>Baize</td><td>210,311</td><td>3.1</td><td>293.9</td><td>52.8</td><td>67.1</td><td>0.751</td><td>9.06</td><td>Yes</td></tr><tr><td>GPT4ALL</td><td>711,126</td><td>1</td><td>597.7</td><td>318.9</td><td>62.7</td><td>0.692</td><td>1</td><td>No</td></tr><tr><td>UltraChat</td><td>1,468,352</td><td>3.8</td><td>1467.4</td><td>309.3</td><td>74.3</td><td>0.702</td><td>9.06</td><td>Yes</td></tr></table>
+
+Table 4: Statistics of existing instruction datasets. Lexical diversity is calculated by averaging the MTLD score (McCarthy and Jarvis, 2010) over each utterance with LexicalRichness6. 10000 samples are randomly drawn from each dataset for topic diversity and coherence measurement. Topic diversity is measured by averaging the cosine distance between each pair of data with OpenAI embedding API. Coherence is scored by ChatGPT on a scale of 1-10.
+
+can significantly deteriorate the coherence of the multi-turn conversation. To address this, in addition to presenting the dialogue history, we include prompts explicitly instructing the model to adopt various user personalities. In Sector 2, a prompt is employed to remind the model of the primary purpose of the dialogue, thereby promoting a more natural conversation flow. Once the data generation process is complete, a further filtration step is performed to ensure overall data quality. We also exclude excessively polite statements to enhance the realism of user responses.
+
+# 4 Data Analysis
+
+# 4.1 Statistical Analysis
+
+We conduct a statistical analysis of UltraChat and several other instruction datasets, as shown in Table 4. UltraChat stands out in terms of its scale, being one of the largest publicly available datasets. Moreover, it exhibits the highest average number of turns and the longest average length per instance of data. While SODA (Kim et al., 2023) also has many rounds, it is primarily composed of conceptual banter rather than instructional content. Additionally, the average number of tokens per dialogue in SODA is 231.8, whereas UltraChat boasts a remarkable 1467.4 tokens. To evaluate diversity, we measure both lexical diversity and topic diversity. UltraChat outperforms previous datasets in terms of lexical diversity. However, in terms of topic diversity, UltraChat falls slightly short compared to GPT4ALL (Anand et al., 2023) but still surpasses other datasets significantly. This may be attributed to the regularized embeddings resulting from a large number of tokens in each dialogue. We also conduct coherence evaluation with ChatGPT for multi-turn datasets. Notably, UltraChat and Baize data rank the highest in terms of coherence.
+
+# 4.2 Human Assessment
+
+Setup. To better evaluate the constructed data quality, we also conduct human assessment for UltraChat. Due to the difficulty of evaluation of multi-turn dialogue and the resulting formidable cost, we sample 500 representative dialogues for human evaluation, among which 300 are from UltraChat sector 1, 100 from sector 2 and sector 3 respectively. For each round of conversation, we ask the annotators to score the assistant’s response on Helpfulness, Honesty, and Harmlessness (3H) principles (Askell et al., 2021). We also devise Coherence and Consistency criteria for the overall multi-turn dialogue quality evaluation. Coherence evaluates whether the dialogue flows logically and coherently, for which the annotators evaluate both the user’s response and the assistant’s response. Consistency means the assistant’s responses do not contradict each other within the same dialogue. For example, it is inconsistent if the assistant asserts one specific event occurred in 1911 in the first round of conversation but mentions it as a 1901 event in the next round. Each metric is scored with 0, 0.5 or 1, where higher score means better quality. Therefore, for a K-round dialogue, we have $3 K + 2$ metric annotations.
+
+Annotation. Each dialogue is annotated independently by two well-trained annotators, and the score is averaged across two annotators. Meanwhile, due to the difficulty in identifying the hallucination problem, we allow the annotators to skip the dialogues that require expert knowledge or whose validity is hard to check. Altogether, we collect 14560 valid annotations in terms of metrics for both single-round and multi-round, and the Cohen’s kappa coefficient is 0.358. The average time to annotate one dialogue is 10 minutes.
+
+Results. As shown in Table 5, the dataset scores high on all metrics, showing the effectiveness of the construction process. It is worth noting that the dataset is almost free from harmful content like hate speech and discrimination. Furthermore, we observe two trade-offs between data quality. The first is between helpfulness and honesty. While the honesty score is pretty high, helpfulness is compromised. It is because some user queries are out of the LLM ability scope (e.g., ask the LLM to compose a song). Under such circumstances, the LLM refuses to answer the question with an explanation of incapability, which is reasonable and expected but less helpful. The phenomenon is particularly prominent in part 3, as the simulated user often asks for information not existent in the text material. The second trade-off is between control and dialogue naturalness. While sector 2 and sector 3 data are constructed with more guidance and control when prompting for user simulation, they have clearly lower quality in coherence and consistency than sector 1.
+
+Table 5: Human assessment results on 500 dialogues sampled from UltraChat.   
+
+<table><tr><td>Data</td><td>Helpful</td><td>Honest</td><td>Harmless</td><td>Coherent</td><td>Consistent</td></tr><tr><td>Sector 1</td><td>0.971</td><td>0.996</td><td>1.000</td><td>0.996</td><td>0.995</td></tr><tr><td>Sector 2</td><td>0.978</td><td>0.986</td><td>1.000</td><td>0.982</td><td>0.977</td></tr><tr><td>Sector 3</td><td>0.893</td><td>0.983</td><td>1.000</td><td>0.964</td><td>0.981</td></tr><tr><td>Overall</td><td>0.960</td><td>0.992</td><td>1.000</td><td>0.987</td><td>0.988</td></tr></table>
+
+# 5 Experiments
+
+We developed UltraLM, an enhanced variant of the LLaMA-13B (Touvron et al., 2023) model, by training it on the UltraChat dataset. To improve the model’s comprehension of dialogue context, we break down each dialogue into smaller sequences, limiting them to a maximum length of 2048 tokens. During the training process, we only calculate the loss for the model’s responses. This approach ensured that the model had access to the relevant information from earlier parts of the conversation, enabling a more comprehensive understanding of the ongoing dialogue. By incorporating the preceding context, UltraLM was equipped to generate more contextually appropriate and coherent responses. We use standard cross-entropy loss to finetune the model. The model is trained with 128 A100 GPUs and the total batch size is 512.
+
+The evaluation of the trained model is conducted in two folds. We first evaluate UltraLM on traditional benchmark datasets to delineate the knowledge scope and the multiple abilities of the language model. To better demonstrate the chat ability of language models, an automatic response quality evaluation is performed to showcase the model’s proficiency in delivering accurate and informative content during chat interactions. Note that UltraLM is solely trained on UltraChat dataset without further finetuning on task specific datasets.
+
+# 5.1 Experimental Setup
+
+Baselines.7 We mainly compare with other opensource instruction-tuned language models based on LLaMA (Touvron et al., 2023) and Pythia (Biderman et al., 2023) backbone model. The main baseline models include Alpaca (Taori et al., 2023), Vicuna (Chiang et al., 2023), Koala (Geng et al., 2023), Dolly (Conover et al., 2023), OpenAssistant (Köpf et al., 2023), and WizardLM (Xu et al., 2023a). The parameter size of the baselines ranges from 7B to 13B, which is comparable to UltraLM. Our evaluation also includes other chat language models like ChatGPT (OpenAI, 2022), MPT (Mosaic, 2023), and Baize (Xu et al., 2023b). A detailed description of the main baselines can be found in Appendix A.1.
+
+Datasets. For benchmark evaluation, we choose four datasets: ARC-Challenge (Clark et al., 2018), HellaSwag (Zellers et al., 2019), MMLU (Hendrycks et al., 2021), and TruthfulQA (Lin et al., 2021), evaluating commonsense knowledge, professional knowledge and complex reasoning and understanding abilities. Each benchmark is constructed as multiple choice questions and therefore metrics are readily computable. The four datasets prove to be challenging even for the best-performing language models like ChatGPT.
+
+For response quality evaluation, we use 3 datasets. We first create an evaluation set by ourselves. The curated set encompasses the Vicuna benchmark as well as an additional 300 questions and instructions generated by GPT-4. The questions/instructions covered a wide range of topics, including commonsense, world knowledge, professional knowledge (specifically physics and biology), mathematics, response generation, and writing tasks on different levels of difficulty. Apart from the curated set, we also adopt AlpacaEval (Li et al., 2023b), a widely acknowledged open-source evaluation set and leaderboard specifically designed for evaluating LLMs. The leaderboard is created based on the win-rate against Text-Davinci-003 automatically evaluated by GPT4. To further compare with the state-of-the-art model WizardLM (Xu et al., 2023a), comparison result obtained with GPT-4 on the released EvolInstruct (Xu et al., 2023a) test set is also reported. Further benchmark dataset and implementation details can be found in Appendix A.2 and A.3.
+
+Table 6: The evaluation results on 4 challenging benchmark datasets. All evaluation and metric calculations follow EleutherAI’s lm-evaluation-harness (Gao et al., 2021). Both weighted and unweighted mean accuracy are reported for MMLU as there are 57 tasks. The overall average metric is obtained by averaging the second column data for each benchmark dataset. More details about metric calculation can be found in Appendix A.3.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">ARC-Challenge</td><td colspan="2">HellaSwag</td><td colspan="2">MMLU</td><td colspan="2">TruthfulQA</td><td rowspan="2">Overall Average</td></tr><tr><td>Acc.</td><td>Acc. norm.</td><td>Acc.</td><td>Acc. norm.</td><td>Weighted</td><td>Unweighted</td><td>mc1</td><td>mc2</td></tr><tr><td>Dolly-12B</td><td>38.23</td><td>42.24</td><td>54.59</td><td>72.6</td><td>31.52</td><td>31.70</td><td>20.69</td><td>34.06</td><td>45.15</td></tr><tr><td>OpenAssistant-12B</td><td>41.38</td><td>45.90</td><td>52.51</td><td>70.04</td><td>29.77</td><td>30.29</td><td>24.60</td><td>39.29</td><td>46.38</td></tr><tr><td>MPT-7B</td><td>43.00</td><td>46.67</td><td>57.13</td><td>75.50</td><td>37.76</td><td>38.33</td><td>27.17</td><td>40.16</td><td>50.17</td></tr><tr><td>Alpaca-7B</td><td>49.74</td><td>52.65</td><td>58.05</td><td>76.91</td><td>42.47</td><td>42.90</td><td>25.83</td><td>39.55</td><td>53.00</td></tr><tr><td>LLaMA-13B</td><td>53.16</td><td>56.40</td><td>60.64</td><td>80.87</td><td>46.05</td><td>46.74</td><td>25.83</td><td>39.90</td><td>55.98</td></tr><tr><td>Baize-13B</td><td>55.55</td><td>57.94</td><td>59.96</td><td>80.36</td><td>48.13</td><td>49.03</td><td>32.93</td><td>47.43</td><td>58.69</td></tr><tr><td>Koala-13B</td><td>49.83</td><td>52.90</td><td>57.60</td><td>77.54</td><td>46.75</td><td>48.01</td><td>34.64</td><td>50.09</td><td>57.14</td></tr><tr><td>Vicuna-13B</td><td>51.71</td><td>52.90</td><td>60.03</td><td>80.12</td><td>50.15</td><td>50.45</td><td>35.74</td><td>51.82</td><td>58.83</td></tr><tr><td>WizardLM-13B</td><td>55.12</td><td>57.08</td><td>60.93</td><td>80.91</td><td>51.69</td><td>52.25</td><td>35.37</td><td>50.53</td><td>60.19</td></tr><tr><td>LLaMA-65B</td><td>59.22</td><td>63.31</td><td>66.40</td><td>86.05</td><td>62.29</td><td>62.97</td><td>27.91</td><td>42.55</td><td>63.72</td></tr><tr><td>UltraLM-13B</td><td>57.25</td><td>59.22</td><td>61.32</td><td>81.49</td><td>50.45</td><td>51.10</td><td>36.72</td><td>52.00</td><td>60.95</td></tr></table>
+
+# 5.2 Benchmark Evaluation
+
+As shown in Table 6, with pure instruction-tuning on the UltraChat dataset, UltraLM significantly improves over LLaMA-13B and achieves the best overall performance across four benchmarks. It is worth noting that UltraLM overtakes the current state-of-the-art model by nearly $2 \%$ on ARCChallenge and TruthfulQA. It shows that UltraLM is equipped with both broad and profound comprehension of the world and commonsense knowledge. The improvement could be attributed to the systematic and comprehensive data construction process of UltraChat sector 1, which effectively extends and deepens the discussion about world knowledge in automatic conversation generation. Meanwhile, the comparative inferiority in MMLU hints on the lack of professional knowledge in specific fields. It suggests the need for more advanced data generation techniques to build a specialized expert language model. As for HellaSwag, we notice that all models have only marginal improvement compared to LLaMA-13B. It is probably because HellaSwag is formatted as an in-text completion task instead of a straightforward text completion, and therefore benefits little from instruction tuning.
+
+# 5.3 Response Quality Evaluation
+
+Response Comparison. For our curated evaluation set, we conduct pairwise evaluation between UltraLM and each baseline model with GPT-4. Our evaluation prompt is designed to prioritize correctness over other factors such as informativeness. To mitigate the influence of presentation order of responses, we randomly determine the order of the responses for each question. Finally, we count the number of Win/Tie/Lose times against each baseline model, and the result is presented in Figure 2. UltraLM demonstrates superior performance compared to every open-source model, exhibiting an impressive winning rate of up to $98 \%$ . It is worth noting that UltraLM also outperforms Vicuna with $9 \%$ higher winning rate.
+
+Independent Scoring. Given the instability of pairwise comparison, we also conduct independent quality scoring with GPT-4, as presented in Table 7. Notably, our model demonstrates superior performance compared to all the open-source counterparts by a significant margin in terms of overall scores. This breakdown also provides insights into the performance of each model on specific types of questions and instructions. Generally, all models perform better on simpler questions pertaining to commonsense knowledge and general world understanding. However, more complex tasks that involve reasoning and creative writing proves to be challenging for most models. Interestingly,
+
+![](images/e3852372cfdafd495c5a5b0cf71fb62230415cb5d84650b6bcf77552c740714d.jpg)
+
+Figure 2: Response comparison of UltraLM with other baselines on the curated evaluation set, evaluated by GPT-4.   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Vicuna Set</td><td colspan="2">Commonsense</td><td colspan="2">World Knowledge</td><td colspan="2">Professional Knowledge</td><td colspan="2">Ability</td><td rowspan="2">Writing</td><td rowspan="2">Overall</td></tr><tr><td>Easy</td><td>Moderate</td><td>Easy</td><td>Difficult</td><td>Physics</td><td>Biology</td><td>Math</td><td>Reasoning</td></tr><tr><td>Dolly-12B</td><td>4.75</td><td>3.50</td><td>3.93</td><td>3.10</td><td>4.13</td><td>4.87</td><td>5.47</td><td>2.70</td><td>2.03</td><td>4.51</td><td>4.04</td></tr><tr><td>MPT-7B</td><td>7.25</td><td>5.57</td><td>8.20</td><td>5.53</td><td>5.87</td><td>7.83</td><td>8.40</td><td>5.97</td><td>3.97</td><td>7.25</td><td>6.67</td></tr><tr><td>LLaMA-13B</td><td>6.85</td><td>8.43</td><td>8.43</td><td>8.57</td><td>8.50</td><td>7.90</td><td>8.40</td><td>6.97</td><td>6.73</td><td>6.79</td><td>7.49</td></tr><tr><td>OpenAssistant-12B</td><td>7.88</td><td>8.13</td><td>7.80</td><td>9.13</td><td>7.50</td><td>8.10</td><td>8.20</td><td>6.57</td><td>5.17</td><td>7.75</td><td>7.65</td></tr><tr><td>Alpaca-7B</td><td>7.58</td><td>9.17</td><td>8.83</td><td>9.30</td><td>8.73</td><td>8.13</td><td>8.80</td><td>6.70</td><td>6.27</td><td>8.05</td><td>8.04</td></tr><tr><td>Koala-13B</td><td>8.00</td><td>9.20</td><td>9.07</td><td>9.00</td><td>8.93</td><td>8.53</td><td>9.07</td><td>7.33</td><td>5.30</td><td>8.40</td><td>8.23</td></tr><tr><td>Baize-13B</td><td>8.40</td><td>9.03</td><td>9.10</td><td>9.03</td><td>8.93</td><td>8.83</td><td>8.80</td><td>7.43</td><td>8.30</td><td>8.10</td><td>8.50</td></tr><tr><td>Vicuna-13B</td><td>8.48</td><td>9.67</td><td>9.50</td><td>9.37</td><td>9.30</td><td>9.23</td><td>9.33</td><td>8.07</td><td>6.90</td><td>8.76</td><td>8.78</td></tr><tr><td>WizardLM-13B</td><td>8.55</td><td>9.70</td><td>9.30</td><td>9.57</td><td>9.50</td><td>9.27</td><td>9.53</td><td>8.27</td><td>8.20</td><td>8.83</td><td>8.95</td></tr><tr><td>ChatGPT</td><td>9.15</td><td>9.67</td><td>9.60</td><td>9.80</td><td>9.60</td><td>9.17</td><td>9.73</td><td>9.33</td><td>9.13</td><td>8.95</td><td>9.31</td></tr><tr><td>UltraLM-13B</td><td>8.98</td><td>9.70</td><td>9.50</td><td>9.47</td><td>9.40</td><td>9.27</td><td>9.87</td><td>8.77</td><td>6.80</td><td>8.90</td><td>9.00</td></tr></table>
+
+Table 7: The independent overall scoring and segment scoring of each model on the curated evaluation set, on a scale of 1 to 10. Bold indicates the best score and underlined indicates the second best.
+
+Alpaca, despite having only 7 billion parameters, performs comparatively well with larger models on questions related to commonsense and world knowledge. Meanwhile, Dolly and OpenAssistant, which are based on Pythia (Biderman et al., 2023), display inferior performance compared to models based on LLaMA of similar or even smaller sizes. This observation highlights the significance of the underlying backbone language model.
+
+Table 8: Win rates against Text-Davinci-003 on AlpacaEval leaderboard. GPT-4 is used for evaluation following the official implementation (Li et al., 2023b).   
+
+<table><tr><td>Model</td><td>Win Rate (%)</td><td>Standard Error</td></tr><tr><td>GPT-4</td><td>95.28</td><td>0.72</td></tr><tr><td>Claude</td><td>88.39</td><td>1.11</td></tr><tr><td>ChatGPT</td><td>86.09</td><td>1.21</td></tr><tr><td>UltraLM-13B</td><td>76.09</td><td>1.50</td></tr><tr><td>WizardLM-13B</td><td>75.31</td><td>1.51</td></tr><tr><td>Guanaco-65B</td><td>71.80</td><td>1.59</td></tr><tr><td>Vicuna-13B</td><td>70.43</td><td>1.61</td></tr><tr><td>Oasst-RLHF-33B</td><td>66.52</td><td>1.66</td></tr><tr><td>Text Davinci 003</td><td>50.00</td><td>0.00</td></tr><tr><td>Falcon-40B-instruct</td><td>45.71</td><td>1.75</td></tr><tr><td>Alpaca-7B</td><td>26.46</td><td>1.54</td></tr></table>
+
+AlpacaEval. As shown in Table 8, UltraLM outperforms existing models in terms of win rate on the current AlpacaEval leaderboard and ranks 4th just below ChatGPT. This observation further testifies the response quality of UltraLM and is in line with results on our curated dataset. Furthermore, a significant gap is evident between UltraLM and ChatGPT performance, highlighting the substantial effort needed for open-source models to match the capabilities of ChatGPT.
+
+Evol-Instruct Evaluation. Figure 3 shows the automatic comparison results against WizardLM13B on Evol-Instruct test set. UltraLM overtakes WizardLM on most types of questions, with up to $29 \%$ increase in scores. It is important to acknowledge that WizardLM-13B is trained on the EvolInstruct training set, making UltraLM’s success on the test set a noteworthy achievement. Moreover, the questions observed with the largest improvement are mainly complex problems that often require synthesized abilities. It demonstrates the success of UltraChat design schema, which can comprehensively boost the versatile capabilities of language models. The inferiority in math problems is not surprising though, as no mathematical problems are intentionally generated in UltraChat.
+
+![](images/a052ac0593360ff52d66ffba38bbae0bf915948c798aa5dab566260e79ec7730.jpg)  
+Figure 3: Comparison between UltraLM and WizardLM-13B on Evol-Instruct test set. The scores are obtained by pairwise scoring with GPT-4, and WizardLM scores are considered as $100 \%$ .
+
+Impact of System Prompts. Using system prompts to adjust the role and response style of LLMs is a common practice. Although system prompts are not embedded in UltraLM’s training data like others do (Chiang et al., 2023), they still appear to have a substantial influence on the response style of the generated output. Specifically, when the model is prompted to provide a "helpful and detailed" response, it tends to generate more pertinent details While such prompts may not improve the accuracy of an answer, they do raise overall quality with more informative response. To illustrate this effect, we conduct an ablation response comparison on UltraLM. Table 9 reveals significant improvements in response quality brought by system prompts across all tasks. We also inspect the detailed evaluation for deterministic questions (commonsense and world knowledge) and find that UltraLM without system prompt only incorrectly answers one question. Thus, the main benefit of the system prompt lies in enhanced informativeness rather than higher correctness.
+
+Table 9: Win rate against UltraLM without system prompt on our curated dataset.   
+
+<table><tr><td>Data</td><td>Win (%)</td><td>Tie (%)</td><td>Lose(%)</td></tr><tr><td>Vicuna Set</td><td>36.3</td><td>35.0</td><td>28.8</td></tr><tr><td>Commonsense</td><td>58.6</td><td>31.0</td><td>10.3</td></tr><tr><td>World Knowledge</td><td>56.9</td><td>34.5</td><td>8.6</td></tr><tr><td>Professional Knowledge</td><td>57.8</td><td>31.1</td><td>11.1</td></tr><tr><td>Math Ability</td><td>46.7</td><td>13.3</td><td>40.0</td></tr><tr><td>Reasoning Ability</td><td>46.7</td><td>33.3</td><td>20.0</td></tr><tr><td>Writing</td><td>46.3</td><td>35.0</td><td>18.8</td></tr><tr><td>Overall</td><td>49.1</td><td>32.0</td><td>18.9</td></tr></table>
+
+# 6 Conclusion
+
+In drawing to a close, our work introduces UltraChat, a structured design of multi-turn instructional conversation data primed to foster the growth of general chat models. UltraChat encapsulates a broad range of human-AI interactions, further developing a series of dialogues across various topics and instructions. Statistically, UltraChat shows an impressive presence in critical metrics such as scale, average length, diversity, and consistency, further establishing itself as a leading open-source dataset. We leverage UltraChat to fine-tune the LLaMA model, leading to the development of the robust conversational model, UltraLM. Evaluation across multiple benchmarks reveals that UltraLM surpasses previous open-source models like WizardLM, Vicuna, Alpaca, and Koala in performance. We eagerly await the innovative research and development that will be catalyzed by our contributions in the field of AI conversational models.
+
+# Limitations
+
+Evaluating the response quality of large language models is an extremely challenging task, and any assessments may have biases. For a comprehensive evaluation, we compared UltraLM’s performance with other baselines across various benchmarks, utilizing GPT-4 to assess the response quality. Nevertheless, the need for additional, diverse evaluations remains to facilitate a more thorough understanding of our model’s behavior and performance. Despite demonstrating promising results in experimental settings, UltraLM is not immune to the common pitfalls of large language models, including hallucination issues and potential ethical concerns associated with misuse. Additionally, the energy-intensive nature of UltraLM’s training process represents a limitation, particularly when compared to models employing more efficient techniques such as parameter-efficient fine-tuning. In terms of UltraChat, it currently only contains English and there are no explicit methodologies incorporated for generating data to enhance the model’s reasoning capabilities, representing another area for potential improvement.
+
+# Ethics Statement
+
+While the advancements of the UltraChat dataset and UltraLM are commendable, they still face ethical challenges that exist in the area of LLMs. For the sake of privacy protection, we do not use any online or even human queries/instructions to construct UltraChat but develop a framework to build scalable, diverse instructional data. Although extensive filtering operations are conducted, biased statements may still exist within the dataset.
+
+UltraLM, as the paper described, will be one of the most potent open-source chat language models. With great power comes increased responsibility and potential for misuse. There exists a substantial risk for the technology to be weaponized for spreading misinformation, propaganda, or even creating “deepfake” text that could mislead or manipulate public discourse. This necessitates the establishment of robust policies and comprehensive research to prevent misuse and deter malicious applications of the technology. In this regard, the model’s potential applications should be carefully evaluated for any possible negative consequences before deployment.
+
+# Acknowledgements
+
+This work is supported by the National Key R&D Program of China (No. 2022ZD0119101), National Natural Science Foundation of China (No. 62236004), the Young Elite Scientists Sponsorship Program by CAST, and Institute Guo Qiang at Tsinghua University.
+
+# References
+
+Yuvanesh Anand, Zach Nussbaum, Brandon Duderstadt, Benjamin Schmidt, and Andriy Mulyar. 2023. Gpt4all: Training an assistant-style chatbot with large scale data distillation from gpt-3.5-turbo.
+
+Amanda Askell, Yuntao Bai, Anna Chen, Dawn Drain, Deep Ganguli, Tom Henighan, Andy Jones, Nicholas Joseph, Ben Mann, Nova DasSarma, Nelson Elhage, Zac Hatfield-Dodds, Danny Hernandez, Jackson Kernion, Kamal Ndousse, Catherine Olsson, Dario Amodei, Tom Brown, Jack Clark, Sam McCandlish, Chris Olah, and Jared Kaplan. 2021. A general language assistant as a laboratory for alignment.
+
+Yuntao Bai, Andy Jones, Kamal Ndousse, Amanda Askell, Anna Chen, Nova DasSarma, Dawn Drain, Stanislav Fort, Deep Ganguli, Tom Henighan, et al. 2022. Training a helpful and harmless assistant with reinforcement learning from human feedback. arXiv preprint arXiv:2204.05862.
+
+Stella Biderman, Hailey Schoelkopf, Quentin Anthony, Herbie Bradley, Kyle O’Brien, Eric Hallahan, Mohammad Aflah Khan, Shivanshu Purohit, USVSN Sai Prashanth, Edward Raff, et al. 2023. Pythia: A suite for analyzing large language models across training and scaling. arXiv preprint arXiv:2304.01373.
+
+Rishi Bommasani, Drew A Hudson, Ehsan Adeli, Russ Altman, Simran Arora, Sydney von Arx, Michael S Bernstein, Jeannette Bohg, Antoine Bosselut, Emma Brunskill, et al. 2021. On the opportunities and risks of foundation models. arXiv preprint arXiv:2108.07258.
+
+Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. 2020. Language models are few-shot learners. In Proceedings of NeurIPS.
+
+Sahil Chaudhary. 2023. Code alpaca: An instructionfollowing llama model for code generation.
+
+Wei-Lin Chiang, Zhuohan Li, Zi Lin, Ying Sheng, Zhanghao Wu, Hao Zhang, Lianmin Zheng, Siyuan Zhuang, Yonghao Zhuang, Joseph E. Gonzalez, Ion Stoica, and Eric P. Xing. 2023. Vicuna: An opensource chatbot impressing gpt-4 with $9 0 \% *$ chatgpt quality.
+
+Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. 2022. Palm: Scaling language modeling with pathways. arXiv preprint arXiv:2204.02311.
+
+Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord. 2018. Think you have solved question answering? try arc, the ai2 reasoning challenge. ArXiv preprint, abs/1803.05457.
+
+Mike Conover, Matt Hayes, Matt Mathur, Xiangrui Meng, Jianwei Xie, Jun Wan, Ali Ghodsi, Patrick Wendell, and Patrick Zaharia. 2023. Hello dolly: Democratizing the magic of chatgpt with open models.
+
+Ning Ding, Yujia Qin, Guang Yang, Fuchao Wei, Zonghan Yang, Yusheng Su, Shengding Hu, Yulin Chen, Chi-Min Chan, Weize Chen, et al. 2023. Parameterefficient fine-tuning of large-scale pre-trained language models. Nature Machine Intelligence, pages 1–16.
+
+Domeccleston. 2023. Sharegpt – share your wildest chatgpt conversations with one click. Retrieved 23 May 2023.
+
+Leo Gao, Jonathan Tow, Stella Biderman, Sid Black, Anthony DiPofi, Charles Foster, Laurence Golding, Jeffrey Hsu, Kyle McDonell, Niklas Muennighoff, Jason Phang, Laria Reynolds, Eric Tang, Anish Thite,
+
+Ben Wang, Kevin Wang, and Andy Zou. 2021. A framework for few-shot language model evaluation.
+
+Xinyang Geng, Arnav Gudibande, Hao Liu, Eric Wallace, Pieter Abbeel, Sergey Levine, and Dawn Song. 2023. Koala: A dialogue model for academic research. Blog post.
+
+Fabrizio Gilardi, Meysam Alizadeh, and Maël Kubli. 2023. Chatgpt outperforms crowd-workers for textannotation tasks. arXiv preprint arXiv:2303.15056.
+
+Xu Han, Zhengyan Zhang, Ning Ding, Yuxian Gu, Xiao Liu, Yuqi Huo, Jiezhong Qiu, Liang Zhang, Wentao Han, Minlie Huang, Qin Jin, Yanyan Lan, Yang Liu, Zhiyuan Liu, Zhiwu Lu, Xipeng Qiu, Ruihua Song, Jie Tang, Ji-Rong Wen, Jinhui Yuan, Wayne Xin Zhao, and Jun Zhu. 2021. Pre-trained models: Past, present and future. AI Open.
+
+Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. 2021. Measuring massive multitask language understanding. Proceedings of ICLR.
+
+Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2021. Lora: Low-rank adaptation of large language models. In Proceedings of ICLR.
+
+Yunjie Ji, Yong Deng, Yan Gong, Yiping Peng, Qiang Niu, Lei Zhang, Baochang Ma, and Xiangang Li. 2023. Exploring the impact of instruction data scaling on large language models: An empirical study on real-world use cases. arXiv preprint arXiv:2303.14742.
+
+Hyunwoo Kim, Jack Hessel, Liwei Jiang, Peter West, Ximing Lu, Youngjae Yu, Pei Zhou, Ronan Le Bras, Malihe Alikhani, Gunhee Kim, Maarten Sap, and Yejin Choi. 2023. Soda: Million-scale dialogue distillation with social commonsense contextualization.
+
+Andreas Köpf, Yannic Kilcher, Dimitri von Rütte, Sotiris Anagnostidis, Zhi-Rui Tam, Keith Stevens, Abdullah Barhoum, Nguyen Minh Duc, Oliver Stanley, Richárd Nagyfi, et al. 2023. Openassistant conversations–democratizing large language model alignment. arXiv preprint arXiv:2304.07327.
+
+Guohao Li, Hasan Abed Al Kader Hammoud, Hani Itani, Dmitrii Khizbullin, and Bernard Ghanem. 2023a. Camel: Communicative agents for "mind" exploration of large scale language model society.
+
+Xuechen Li, Tianyi Zhang, Yann Dubois, Rohan Taori, Ishaan Gulrajani, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. 2023b. Alpacaeval: An automatic evaluator of instruction-following models.
+
+Stephanie Lin, Jacob Hilton, and Owain Evans. 2021. Truthfulqa: Measuring how models mimic human falsehoods. arXiv preprint arXiv:2109.07958.
+
+Shayne Longpre, Le Hou, Tu Vu, Albert Webson, Hyung Won Chung, Yi Tay, Denny Zhou, Quoc V Le, Barret Zoph, Jason Wei, et al. 2023. The flan collection: Designing data and methods for effective instruction tuning. arXiv preprint arXiv:2301.13688.
+
+Philip M. McCarthy and Scott Jarvis. 2010. Mtld, vocdd, and hd-d: A validation study of sophisticated approaches to lexical diversity assessment. Behavior Research Methods, 42:381–392.
+
+Mosaic. 2023. Introducing mpt-7b: A new standard for open-source, commercially usable llms.
+
+OpenAI. 2023. Gpt-4 technical report. arXiv.
+
+TB OpenAI. 2022. Chatgpt: Optimizing language models for dialogue. OpenAI.
+
+Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Carroll L. Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, John Schulman, Jacob Hilton, Fraser Kelton, Luke Miller, Maddie Simens, Amanda Askell, Peter Welinder, Paul Christiano, Jan Leike, and Ryan Lowe. 2022. Training language models to follow instructions with human feedback.
+
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. 2020. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140):1–67.
+
+Victor Sanh, Albert Webson, Colin Raffel, Stephen H Bach, Lintang Sutawika, Zaid Alyafeai, Antoine Chaffin, Arnaud Stiegler, Teven Le Scao, Arun Raja, et al. 2021. Multitask prompted training enables zeroshot task generalization. In Proceedings of ICLR.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. 2017. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347.
+
+Qingyi Si, Tong Wang, Naibin Gu, Rui Liu, and Zheng Lin. 2023. Alpaca-cot: An instruction fine-tuning platform with instruction data collection and unified large lnguage models interface.
+
+Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B Hashimoto. 2023. Alpaca: A strong, replicable instruction-following model. Stanford Center for Research on Foundation Models.
+
+Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, Aurelien Rodriguez, Armand Joulin, Edouard Grave, and Guillaume Lample. 2023. Llama: Open and efficient foundation language models.
+
+Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A. Smith, Daniel Khashabi, and Hannaneh Hajishirzi. 2022. Self-instruct: Aligning language model with self generated instructions.
+
+Jason Wei, Maarten Bosma, Vincent Y Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, Andrew M Dai, and Quoc V Le. 2021. Finetuned language models are zero-shot learners. arXiv preprint arXiv:2109.01652.
+
+Can Xu, Qingfeng Sun, Kai Zheng, Xiubo Geng, Pu Zhao, Jiazhan Feng, Chongyang Tao, and Daxin Jiang. 2023a. Wizardlm: Empowering large language models to follow complex instructions.
+
+Canwen Xu, Daya Guo, Nan Duan, and Julian McAuley. 2023b. Baize: An open-source chat model with parameter-efficient tuning on self-chat data. arXiv preprint arXiv:2304.01196.
+
+Rowan Zellers, Ari Holtzman, Yonatan Bisk, Ali Farhadi, and Yejin Choi. 2019. HellaSwag: Can a machine really finish your sentence? In Proceedings of ACL, pages 4791–4800.
+
+Chunting Zhou, Pengfei Liu, Puxin Xu, Srini Iyer, Jiao Sun, Yuning Mao, Xuezhe Ma, Avia Efrat, Ping Yu, L. Yu, Susan Zhang, Gargi Ghosh, Mike Lewis, Luke Zettlemoyer, and Omer Levy. 2023. Lima: Less is more for alignment.
+
+# A Experimental Details
+
+# A.1 Baselines
+
+We introduce the main open-source baseline models below.
+
+Alpaca (Taori et al., 2023) is an instructionfollowing language model derived from the LLaMA (Touvron et al., 2023) model that has been effectively optimized on 52,000 demonstrations of instruction data. The data is generated by SelfInstruct approach with Text-Davinci-003.
+
+Vicuna-13B (Chiang et al., 2023) is an opensourced chat model created by fine-tuning LLaMA on user-shared conversations collected from ShareGPT8. An automatic evaluation by GPT-4 demonstrates that Vicuna can yield over $90 \%$ response quality of ChatGPT. In following practices, Vicuna is widely acknowledged as the state-of-theart open-source chat model. This is evident in the Chat Arena9, where a total of 13,000 anonymous votes reveal that the quality score of vicuna-13B surpasses that of other open-source models.
+
+Koala-13B (Geng et al., 2023) is another LLaMAbased model fine-tuned on selected public dialogues. In existing open evaluations, Koala’s performance will be slightly worse than vicuna, but it still remains a strong baseline.
+
+Dolly-V2 (Conover et al., 2023) is based on the Pythia (Biderman et al., 2023) model, which utilizes 15k human-generated instruction-following data. The data is organized by following InstructGPT (Ouyang et al., 2022), including brainstorming, classification, closed QA, generation, information extraction, open QA, and summarization.
+
+OpenAssistant-12B (Köpf et al., 2023) is also a Pythia-based model that attempts to democratize the alignment process of LLMs. The project collects a conversation corpus consisting of 161,443 messages distributed across 66,497 conversation trees and trains a model on these manually annotated data.
+
+WizardLM-13B (Xu et al., 2023a) is a LLaMAbased model finetuned on Evol-Instruct dataset, which contains $2 5 0 \mathrm { k }$ instructions. The data are generated with evolutionary strategy, where the initial instructions are rewritten by ChatGPT for several epochs to increase complexity progressively.
+
+# A.2 Evaluation Dataset
+
+Table 11 presents the basic information of the evaluation datasets we use. Below we give a detailed description of each dataset.
+
+The AI2 Reasoning Challenge (ARC) (Clark et al., 2018) is comprised of advanced science questions and structured as multiple-choice questions. Each question is accompanied by 4 available choices and only one answer is correct. We use the challenge partition here for evaluation, which contains 1172 test examples.
+
+HellaSwag (Zellers et al., 2019) tests commonsense inference ability by evaluating how well the language model can predict the remaining part of a sentence. Each sample has 4 different text pieces as the candidate remaining part of a given sentence and only one of them is plausible. The task is shown to be easy for humans but challenging for language models. We use the validation split as in Gao et al. (2021).
+
+MMLU (Hendrycks et al., 2021) is a comprehensive dataset that consists of 57 different tasks covering assessments of multiple types of academic knowledge and problem-solving ability of language models, ranging over expert fields like mathematics, history, law, etc.
+
+TruthfulQA (Lin et al., 2021) assesses how well a model can identify true statements related to the real world. Its purpose is to determine the risks of producing false claims or spreading misinformation. The benchmark consists of questions written in various styles, covering 38 different categories, and is designed to be challenging. It includes two evaluation tasks: the multiple-choice task and the generation task. We use the multiple-choice task in the validation split as in Gao et al. (2021).
+
+AlpacaEval (Li et al., 2023b) is a hybrid evaluation dataset with altogether 805 instructions, which combines instructions from various existing evaluation sets, including self-instruct (Wang et al., 2022), Open Assistant (Köpf et al., 2023), helpful evaluation released by Anthropic (Bai et al., 2022), Vicuna (Chiang et al., 2023), and Koala (Geng et al., 2023).
+
+Evol-Instruct is a dataset released in $\mathrm { X u }$ et al. (2023a). It is constructed with an evolutionary strategy by rewriting the instructions through multiple rounds to obtain instructions at different complexity levels. WizardLM (Xu et al., 2023a) is trained on the training set. We evaluate our model on the test set.
+
+Table 10: Some examples of our created evaluation set.   
+
+<table><tr><td rowspan=1 colspan=1>Type</td><td rowspan=1 colspan=1>Example</td></tr><tr><td rowspan=1 colspan=1>Commonsense- Easy</td><td rowspan=1 colspan=1>What is the primary source of energy for our planet?</td></tr><tr><td rowspan=1 colspan=1>Commonsense-Moderate</td><td rowspan=1 colspan=1>What is the phenomenon that causes the change in pitch heard when a vehicle sounding ahorn approaches and recedes from an observer?</td></tr><tr><td rowspan=1 colspan=1>World Knowledge-Easy</td><td rowspan=1 colspan=1>What is the freezing point of water in Fahrenheit?</td></tr><tr><td rowspan=1 colspan=1>World Knowledge-Moderate</td><td rowspan=1 colspan=1>What is the Godel&#x27;s Incompleteness Theorem?</td></tr><tr><td rowspan=1 colspan=1>Physics Knowledge</td><td rowspan=1 colspan=1>How does quantum entanglement work and what are its implications for information transfer?</td></tr><tr><td rowspan=1 colspan=1>Biology Knowledge</td><td rowspan=1 colspan=1>What are the four main types of macromolecules found in living organisms?</td></tr><tr><td rowspan=1 colspan=1>Math</td><td rowspan=1 colspan=1>What is the Taylor series expansion of the function eα?</td></tr><tr><td rowspan=1 colspan=1>Reasoning</td><td rowspan=1 colspan=1> You have two buckets,one with red paint and one with blue paint.You take one cup fromthe red bucket and pour it into the blue bucket. Then you take one cup from the blue bucketand pour it back into the red bucket.Which is true: the red bucket has more blue paint, orthe blue bucket has more red paint?</td></tr><tr><td rowspan=1 colspan=1>Writing</td><td rowspan=1 colspan=1>Write a dialogue between two photons traveling at light speed.</td></tr></table>
+
+Table 11: Basic information on evaluation dataset.   
+
+<table><tr><td>Dataset</td><td>#Examples</td><td>Domain</td></tr><tr><td>ARC-Challenge</td><td>1172</td><td>Grade-school</td></tr><tr><td>HellaSwag</td><td>10042</td><td>Commonsense</td></tr><tr><td>MMLU</td><td>14042</td><td>Academic</td></tr><tr><td>TruthfulQA</td><td>817</td><td>Truthfulness</td></tr><tr><td>AlpacaEval</td><td>805</td><td>Comprehensive</td></tr><tr><td>Evol-Instruct</td><td>218</td><td>Comprehensive</td></tr><tr><td>Our evaluation set</td><td>831</td><td>Comprehensive</td></tr></table>
+
+Our evaluation set is composed of Vicuna (Chiang et al., 2023) test set and other instructions generated by GPT-4. The generated instructions are further split into different categories and difficulty levels to comprehensively evaluate the model’s ability. Table 10 shows example data for each type of question.
+
+# A.3 Implementation Details
+
+In benchmark evaluation, the multiple choice questions are further transformed into log-likelihood calculation over each answer candidate to determine the final prediction. Specifically, each available answer is appended to the question and fed into the language model. The model calculates logits for the answer part and derives the likelihood of the answer. The most likely answer is taken as the final prediction. Moreover, we use likelihood normalized by answer length to mitigate the bias caused by length variation. For the first 3 benchmarks, accuracy is reported for each test sample directly. For Truthful QA, since there are multiple correct answers, apart from standard accuracy (mc1), we also report the ratio of likelihood sum of correct answers over all candidate answers (the mc2 metric). In Table 6, Acc. norm. means the accuracy is computed after normalizing the likelihood with response length.
+
+In response quality evaluation, all evaluations are done by GPT-4. Figure 5 and Figure 6 present prompts used for pairwise scoring and independent scoring on our evaluation data. As for AlpacaEval and Evol-Instruct, we follow the official prompt implementation (Li et al., 2023b; Xu et al., 2023a) to ensure a fair comparison.
+
+Across all experiments, UltraLM is run with temperature $= 0 . 5$ , top_ $\mathrm { \tt p } { = } 0 . 9 5$ , max new token $1 { = } 2 0 0 0$ , and early stopping.
+
+# B UltraChat Details
+
+We present a comparison between multi-turn dialogues directly generated by ChatGPT the one in UltraChat in Table 12. Both have the same opening line. Figure 4 is the template used to concatenate text pieces from the C4 corpus and instructions generated by ChatGPT for data in UltraChat sector 3.
+
+# C Prompts
+
+In this section, we provide system prompt used for response generation by UltraLM (Figure 7) and prompts for automatic evaluation by GPT-4 (Figure 5 and 6).
+
+# D UltraLM Generation Examples
+
+In this section, we list response examples of UltraLM-13B on different instructions from our
+
+#
+
+![](images/22ff9763b51e3c10d46392162cfbeb706182eda9a777ec8755e36bda7bdea3a6.jpg)
+
+Figure 4: Manually designed templates for concatenating existing materials and generated instructions.
+
+# Comparison Evaluation Prompt
+
+You are a helpful, harmless and precise assistant for checking the quality of the answer.
+
+[Question]
+
+[The Start of Assistant 1’s Answer] [The End of Assistant 1’s Answer] [The Start of Assistant 2’s Answer] [The End of Assistant 2’s Answer]
+
+We would like to request your feedback on the performance of two AI assistants in response to the user question displayed above. Please rate the quality, helpfulness, level of details, and harmless of their responses. Each assistant receives an overall score on a scale of 1 to 10, where a higher score indicates better overall performance. Please first output a single line containing only two values indicating the scores for Assistant 1 and 2, respectively. The two scores are separated by a space. In the subsequent line, please provide a comprehensive explanation of your evaluation, avoiding any potential bias and ensuring that the order in which the responses were presented does not affect your judgment. Please avoid same scores unless they exactly in the same level.
+
+Figure 5: Prompt for automatic comparison evaluation.
+
+evaluation set.
+
+# Independent Scoring Prompt
+
+You are a helpful, harmless and precise assistant for checking the quality of the answer.
+
+[Question]
+
+[The Start of the AI Assistant’s Answer] [The End of the AI Assistant’s Answer]
+
+We would like to request your feedback on the performance of the AI assistant in response to the user question displayed above. Please rate the quality, helpfulness, level of details, and harmlessness of their responses. The assistant receives an overall score on a scale of 1 to 10, where a higher score indicates better overall performance. Please output "Score: [an integer number between 1 and 10]"
+
+# System Prompt
+
+You are now a helpful assistant, your answer should focus on the question, give reasonable, selfconsistent, high-quality solutions to make users satisfied. Please try to make the answer more informative, detailed, and polite.
+
+# Example A: Question of World Knowledge
+
+User: Who discovered the law of universal gravitation?
+
+UltraLM: The law of universal gravitation was discovered by Sir Isaac Newton in the 17th century. He formulated the law while studying the planets’ movement around the sun and realized that there was a quantifiable force directing them towards the sun. In 1687, he published his book titled "Mathematical Principles of Natural Philosophy," where he described the law of universal gravitation in detail, outlining how two objects experience an attraction towards each other due to their mass and distance between them. This discovery revolutionized our understanding of the universe and ushered in the Age of Enlightenment. Today, Newton’s law continues to form the foundation of modern astrophysics and space exploration.
+
+# Example B: Question of World Knowledge
+
+User: Who was the 16th President of the United States?
+
+UltraLM: The 16th President of the United States was Abraham Lincoln. He assumed the presidency during a very tumultuous time in American history, as the nation was torn apart by the Civil War. During his presidency, he was known for his strong leadership, his commitment to the preservation of the Union, and his support for the abolition of slavery. Some of his most notable achievements include issuing the Emancipation Proclamation, which declared that all slaves in the Confederate States were free, and delivering the Gettysburg Address, an iconic speech honoring the soldiers who died in the Civil War. Lincoln is widely regarded as one of the greatest American Presidents, remembered for his unwavering leadership during a challenging period in the nation’s history.
+
+Table 12: A comparison of two dialogues with the same opening line. The former is generated by directly querying ChatGPT to output a dialogue, and the latter is generated by iteratively User-AI simulations.   
+
+<table><tr><td rowspan=1 colspan=1>Direct Generation</td></tr><tr><td rowspan=1 colspan=1>What are some of the health benefits and risks of drinking coffee,and how can one maximize the formerand minimize the latter?</td></tr><tr><td rowspan=1 colspan=1>There are several potential health benefits associated with drinking coffee,such as increased alertness, improved mood,and a reduced risk of certain diseases,including type 2 diabetes and liver cancer. However,there are also some potential risks, such as increased anxiety, disrupted sleep,and negative effects on thedigestive system. To maximize the benefits and minimize the risks,it&#x27;s important to consume coffee inmoderation and pay attention to how it affects your body.</td></tr><tr><td rowspan=1 colspan=1>How much coffee is considered moderate?</td></tr><tr><td rowspan=1 colspan=1>The definition of moderate coffee consumption can vary depending on the individual and other factors such as age,gender,and health status. However,in general, moderate coffee consumption is considered tobe around 3-5 cups per day, or up to 40 millgrams ofcaffeine per day. It&#x27;s important to note that some people may be more sensitive to caffeine than others,so it&#x27;s important to pay attention to how your body reacts and adjust your consumption accordingly.</td></tr><tr><td rowspan=1 colspan=1>UltraChat</td></tr><tr><td rowspan=1 colspan=1>What are some of the health benefits and risks of drinking coffee,and how can one maximize the formerand minimize the latter?</td></tr><tr><td rowspan=1 colspan=1>There are several health benefits and risks associated with drinking coffee. Here are some of them: Healthbenefits:1. Lower risk of type 2 diabetes: Studies have shown that consuming coffee can lower the riskof developing type 2 diabetes.2. Improved cognitive function: Coffee is a stimulant that helps improvecognitive function, including alertness, concentration,and memory.3. Lower risk of depression: Studieshave shown that drinking coffee can reduce the risk of developing depression.4. Lower risk of certaincancers: According to research, coffee consumption can lower the risk of certain cancers, including liverand colorectal cancer.5. Reduced risk of heart disease: There is evidence that drinking moderate amountsof coffee can lower the risk of heart disease.Risks:1. Insomnia: Drinking too much coffee, especiallylate in the day,can cause insomnia.2. Increased risk of anxiety: Caffeine can increase anxiety levels in some people.3. Digestive issues: Drinking too much cofee can cause digestive problems like acid reflux,diarrhea, and ulcers.4. Increased heart rate: Caeine can increase heart rate, which can be dangerousfor people with pre-existing heart conditions.5.Addiction: Regular consumption of caffeine can lead toaddiction.To maximize the health benefits and minimize the risks of drinking coffee, here are a few tips:1.Limit your caffeine intake to no more than 40O milligrams per day, or about 4 cups of coffee.2. Avoiddrinking coffee late in the day, especially if you have trouble sleeping.3. Opt for organic, pesticide-freecoffee to minimize exposure to toxins.4. Add cinnamon to your cofee instead of sugar to help regulateblood sugar levels.5. Drink your coffee black or with a smallamount of milk to avoid consuming excessive sugar and calories.6. Consider switching to decaf cofee if you want to cut back on cafeine. 7. Avoiddrinking coffee on an empty stomach as it can increase the risk of digestive problems.</td></tr></table>
+
+If you love your morning coffee but find that it’s making you feel jittery, here are a few tips to help you avoid this:1. Choose a lower-caffeine coffee: Look for coffee that has less caffeine, like decaf or a blend with a lower percentage of caffeine.2. Don’t drink coffee on an empty stomach: Drinking coffee on an empty stomach can cause your blood sugar levels to drop, which can make you feel jittery. Try drinking your coffee with breakfast or after eating something.3. Drink water with your coffee: Stay hydrated by drinking water before or after your coffee. Drinking water will help flush out the caffeine quicker, which can help you avoid jitteriness.4. Don’t drink too much coffee: Stick to one or two cups of coffee per day. Anything more than that could result in increased caffeine consumption, which can cause jitteriness.5. Switch to tea: Tea contains less caffeine than coffee, making it a good alternative if you want to avoid jitteriness. Try green tea, which has less caffeine and offers other health benefits.
+
+Example C: Question of Common Knowledge
+
+User: Which animal is known as man’s best friend?
+
+UltraLM: There are many animals that humans enjoy as companion animals, but one of the absolute standout answers to the question "which animal is known as a man’s best friend?" is the domestically-bred dog. Domesticated dogs have been by humans’ sides for tens of thousands of years, providing faithful companionship and help; guarding people and property; and lending emotional support in everything from long, lonely days to military deployments. Dogs come in an almost mind-boggling variety of breeds of various sizes, with different energy levels, personalities, and temperaments, meaning there’s almost certainly a pup out there who will be a perfect fit for whoever needs it most.
+
+# Example D: Commonsense Reasoning
+
+User: Which weighs more: a pound of feathers or a pound of bricks?
+
+UltraLM: A pound of feathers and a pound of bricks both weigh exactly one pound. This is because one pound is a unit of weight, just as a foot is a unit of length or a second is a unit of time. We use the pound (or other unit of weight) to describe the weight of different objects, regardless of what that object is made of. So the answer to your question is that a pound of feathers and a pound of bricks both weigh the same amount.
+
+# Example E: Reasoning
+
+User: "If a farmer has 17 sheep and all but 9 die, how many are left?
+
+UltraLM: The total number of sheep that are left is 9.
+
+# Example F: Reasoning
+
+User: If a red house is made from red bricks, and a blue house is made from blue bricks, what is a greenhouse made from?
+
+UltraLM: A greenhouse is not made from green bricks, but rather from materials such as glass or plastic that allow light to pass through and create a controlled environment for plants to grow. Greenhouses can come in a variety of colors, including green, but the color of the building itself does not affect the plants growing inside.
+
+# Example G: Creative Generation
+
+User: Write a short dialogue between two planets.
+
+UltraLM:
+
+Mars: "Hey there Neptune, how’s it going?"
+
+Neptune: "Hi there Mars, I’ve been better. It’s getting a bit windy around here."
+
+Mars: "Sorry to hear that. Have you tried using energy other than wind? Maybe solar power?
+
+Neptune: "Yeah, but it’s getting difficult to generate solar power in all of this mist and clouds.
+
+we definitely can’t use tides or waves here, they’re too unpredictable."
+
+Mars: "Oh, I see. Well, I hope you find a solution soon. How are your oceans holding up?"
+
+Neptune: "They’ve been a bit choppy lately with these intense storms we’ve been experiencing. But I guess it comes with living in a planet like this."
+
+Mars: " Definitely not designed for the faint-hearted! Any other issues you’re facing?"
+
+Neptune: "Not really. I think we have a stable temperature and atmosphere, and the wildlife here hasn’t shown much complaint."
+
+Mars: "That’s lucky. I envy your tranquil oceans, we’ve had way too much volcanic activity lately causing all sorts of disturbance in our lava streams."
+
+Neptune: "That sounds rough, better invest in those climate-controlling nanites to stabilize things maybe?"
+
+Mars "Ha-ha, very funny. Just like we also could consider your frozen polar regions as an opportunity to experiment with our frost nanobots on."
+
+Neptune: "A fun concept! But let’s stick to the task at hand, if you need any technical advice, come right ahead, I don’t want your planet getting any more disturbed than it already is.
+
+# Example H: Creative Generation
+
+User: Pretend to be a character in a post-apocalyptic world. Describe how you survive and the allies you encounter.
+
+UltraLM: As a survivor in a post-apocalyptic world, I have learned to be resourceful, alert, and adaptable. I have had to rely on my wits and my instincts to survive, and I have been fortunate enough to encounter many allies who have helped me along the way.One of my greatest survival tools has been my ability to scavenge for resources. I have learned to identify the best places to find food, water, and shelter, and I have become skilled at navigating the rough terrain that makes up my new world. When I first emerged from my bunker after the apocalypse hit, I was alone and unsure of what to do. But as I ventured out into the wasteland, I realized that there were others like me who were struggling to survive.I quickly learned to Trust my instincts and to be constantly alert for potential dangers. I have encountered wild animals, rogue survivors, and even mutated creatures over the years, and I have learned to defend myself against them. I still remember the first time I met a group of fellow survivors, and how grateful I was to have them by my side. We quickly formed a cohesive unit, and together we were able to fend off danger and defend our territory.As time passed, I encountered more and more allies who were willing to lend a hand. I found a group of farmers who taught me how to grow my own food, and a group of scientists who were working to find a cure for the lethal virus that had decimated the population. I even found a band of traveling performers who helped to lift our spirits and remind us that there was still joy to be found in this desolate world. Despite the challenges we faced, I am grateful to have these amazing people in my life. They have taught me that even in the darkest of times, there is always hope. We may not have a cure for the virus yet, but we are a determined lot, and we are all in this together. As long as we have each other, we will survive.
+
+# Example I: Creative Generation
+
+<table><tr><td>User: Write a poem about electromagnetism. UltraLM: Electromagnetism is a force we can&#x27;t ignore, It&#x27;s the reason for many things we adore. In a magnetic field, a wire will glow,</td></tr><tr><td>And the electrons will align, both old and new. Electricity and magnetism are hand in hand, One createsa field, the other hasa brand. On a wire with current, it will react in full.</td></tr><tr><td>The magnetic field can push and pull, The attraction and repulsion it brings, Are the reason for many things. From motors to generators,and much more in between,</td></tr></table>
+
+# Example J: Literature Creation
+
+User: Write a short story about the first second of the universe.
+
+UltraLM: In the first second of the universe, darkness reigned supreme. There was no light, no sound, no shape, no substance. Nothing yet was, but there was an intense power, a raw energy waiting to be unleashed. Within infinity, the first second held the potential for creation in its grasp. And then, with a mighty bang, a bright point of light emerged into existence. In it, the most fundamental particles were born, their forms yet unknown as they frenetically collided in a chaotic dance of creation. Within this primordial light, every force of nature and every component of life was stirred from pure energy to physical reality. The first atoms quickly assembled, and from these, stars and galaxies began to form. Their fusion creating a hot environment that pushed back the very void, shaping the cosmos through expanding and cooling waves. In this cosmic first, no structure of experience, not even time or space, could establish its rule. For an instant, the entirety of the universe existed in an embryonic nexus, a cosmic singularity from which all future existence originated. It was a microcosm forging the macrocosm of which it ultimately becomes a part, its moment of birth a metaphor for the cycles of creation that permeate the multiverse(s).From that single point of light, an infinite universe unfolded. For centuries, eons ahead, and forevermore, it remained the most foundational blink of its unceasing journey into the depths of the Great Beyond. The first second is the beginning of everything.
+
+# Example K: Professional Knowledge
+
+User: How does superconductivity work and what are its practical applications?
+
+UltraLM: Superconductivity is a phenomenon that allows materials to conduct electricity without resistance at extremely low temperatures. At low temperatures, the interaction between the particles in a superconducting material can produce a state called the "Bose-Einstein condensate," which leads to the loss of electrical resistance. In materials, superconductivity comes when a magnetic force interacts with an Electronic current. This interplay in turn provides energy savings and speeds up current. Practical applications mainly include MRI machines, high-speed trains, magnetic levitation, supercharging power grids that can transfer energy more efficiently.One of the main applications of Superconductivity is being used in the Magnetic Resonance Imaging(MRI) machines used in hospitals around the world, to non-invasively scan patients for health diagnosis without exposing them to high levels of radiation. Another important practical application of superconductivity is in power grid operations where large currents can be transmitted to long distances by highly superconducting coil systems that minimize grid energy losses, reducing environmental pollution also by highly efficient electric motors that harness large quantities of electricity efficiently.Aside from these, future projects include superconducting propulsion on planes, trains becoming lighter if not magnetic and able to move on rails with a significant increase in speed. Furthermore, the prospects of supercapacitors replacing electric vehicle batteries being cost and energy efficient are currently being researched. Overall, superconductivity presents various exciting opportunities in multiple industries from high-precision engineering to reducing CO2 emissions and supporting a more environmentally friendly energy model where both cost efficiency and practicality exist hand in hand.
+
+User: "What is the definition of a limit in calculus?
+
+UltraLM: In calculus, a limit is a value that a function approaches as its input approaches a certain value. The limit is a measure of how close the function is to that value. In other words, a limit is the value that a function “approaches" as its input gets “closer and closer" to a certain value. For example, consider the function $\textstyle f ( x ) = { \frac { 1 } { x } }$ . As $x$ approaches 0, the function “approaches" $+ \infty$ , and the limit of the function as $x$ approaches 0 is $+ \infty$ .   
+Formally, we can define the limit of a function $f ( x )$ as $x$ approaches a certain value $c$ as $\begin{array} { r } { \operatorname* { l i m } _ { x \to c } f ( x ) = L } \end{array}$ , where $L$ is a real number. If the limit exists, we say that the function has a limit at $c$ and the value of the limit is $L$ . If the limit does not exist, we say that the function has a removable discontinuity at $c$ .
+
+# Example M: Professional Knowledge
+
+User: What are the main interpretations of quantum mechanics and how do they differ?
+
+UltraLM: Quantum mechanics is a fundamental theory in physics that describes the behavior of matter and energy at the smallest scales of space and time. There are several interpretations of quantum mechanics, each with its own set of assumptions and predictions about how the world works. Here are some of the main interpretations of quantum mechanics and how they differ:
+
+1. Copenhagen Interpretation: This is the most widely accepted interpretation of quantum mechanics. It states that until a measurement is made, a system exists in a superposition of states, representing all possible outcomes with equal probability. When a measurement is made, the system collapses into a single, definite state. This interpretation assumes that the act of measurement itself causes the system to collapse into a definite state, and that there is no objective reality until a measurement is made.
+
+2. Many-Worlds Interpretation: This interpretation proposes that every possible outcome of a superposition of states actually occurs in a multiverse of parallel universes. Thus, when a measurement is made, the system splits into different universes, each corresponding to one of the possible outcomes. This interpretation assumes that all possibilities are realized, but only in different universes, and that the act of measurement does not cause the collapse of the wave function.
+
+3. Bohmian Mechanics: This interpretation proposes that particles have a definite position in space, even when in a superposition of states. It suggests that the wave function guides the motion of particles, and that the act of measurement does not cause a collapse of the wave function, but merely provides information about the pre-existing reality.
+
+4. de Broglie-Bohm Theory: This interpretation is very similar to Bohmian Mechanics, but it also assumes that all particles in the universe are connected by a hidden-variable, and that the motion of one particle determines the motion of all other particles.
+
+5. Pilot-Wave Theory: This interpretation proposes that particles have a wave-like property that guides their motion through space. It assumes that the wave function does not collapse, but rather that the wave guides the motion of particles.
+
+In conclusion, there are several interpretations of quantum mechanics, each with its own set of assumptions and predictions about how the world works. While they all attempt to describe the behavior of matter and energy at the smallest scales of space and time, they differ in their assumptions about the role of the observer, the nature of reality, and the collapse of the wave function.
+
+User: How can you determine if a person is genuinely interested in a conversation or simply being polite?
+
+UltraLM: As an AI language model, I don’t have personal experience, but there are a few signs you can look out for to determine if a person is genuinely interested in a conversation or simply being polite.
+
+1. Eye contact: Genuine interest in a conversation often shows in the form of consistently maintaining eye contact. If a person is not making eye contact or is looking away frequently, they may not be genuinely interested in the conversation.
+
+2. Active listening: A person who is genuinely interested in a conversation will show it through active listening. They will be attentive, ask questions, and respond to what you say.
+
+3. Expressions: If a person is interested in the conversation, they will show it through their expressions. They will have a relaxed facial expression, a smile, and positive body language.
+
+4. Follow-up questions: If a person is genuinely interested in a conversation, they will follow up with questions related to what you said. This will show that they are interested in hearing more about what you have to say.
+
+5. Tone of voice: A person who is genuinely interested in the conversation will have a friendly and enthusiastic tone of voice. They will show interest and engage in the conversation.
+
+Remember, people have different communication styles, and it’s possible to be polite without showing much interest in the conversation. It’s important to observe different cues and not jump to conclusions too quickly.