Title: A*Net: A Scalable Path-based Reasoning Approach for Knowledge Graphs
Venue: NeurIPS 2023
Accepted: yes
Keywords: Knowledge Graph Reasoning

Path-based Methods

Scalability

A* Algorithm
Abstract: Reasoning on large-scale knowledge graphs has been long dominated by embedding methods. While path-based methods possess the inductive capacity that embeddings lack, their scalability is limited by the exponential number of paths. Here we present A\*Net, a scalable path-based method for knowledge graph reasoning. Inspired by the A\* algorithm for shortest path problems, our A\*Net learns a priority function to select important nodes and edges at each iteration, to reduce time and memory footprint for both training and inference. The ratio of selected nodes and edges can be specified to trade off between performance and efficiency. Experiments on both transductive and inductive knowledge graph reasoning benchmarks show that A\*Net achieves competitive performance with existing state-of-the-art path-based methods, while merely visiting 10% nodes and 10% edges at each iteration. On a million-scale dataset ogbl-wikikg2, A\*Net not only achieves a new state-of-the-art result, but also converges faster than embedding methods. A\*Net is the first path-based method for knowledge graph reasoning at such scale.

A*Net: A Scalable Path-based Reasoning Approach for Knowledge Graphs

Abstract

Reasoning on large-scale knowledge graphs has been long dominated by embedding methods. While path-based methods possess the inductive capacity that embeddings lack, their scalability is limited by the exponential number of paths. Here we present A*Net, a scalable path-based method for knowledge graph reasoning. Inspired by the A* algorithm for shortest path problems, our A*Net learns a priority function to select important nodes and edges at each iteration, to reduce time and memory footprint for both training and inference . The ratio of selected nodes and edges can be specified to trade off between performance and efficiency. Experiments on both transductive and inductive knowledge graph reasoning benchmarks show that A*Net achieves competitive performance with existing state-of-the-art path-based methods, while merely visiting 10% nodes and 10% edges at each iteration. On a million-scale dataset ogbl-wikikg2, A*Net not only achieves a new state-of-the-art result, but also converges faster than embedding methods. A*Net is the first path-based method for knowledge graph reasoning at such scale.

1 Introduction

Reasoning, the ability to apply logic to draw new conclusions from existing facts, has been long pursued as a goal of artificial intelligence [32, 20]. Knowledge graphs encapsulate facts in relational edges between entities, and serve as a foundation for reasoning. Reasoning over knowledge graphs is usually studied in the form of knowledge graph completion, where a model is asked to predict missing triplets based on observed triplets in the knowledge graph. Such a task can be used to not only populate existing knowledge graphs, but also improve downstream applications like multi-hop logical reasoning [34], question answering [5] and recommender systems [53].

One challenge central to knowledge graph reasoning is the scalability of reasoning methods, as many real-world knowledge graphs [2, 44] contain millions of entities and

triplets. Typically, large-scale knowledge graph reasoning is solved by embedding methods [6, 42, 38], which learn an embedding for each entity and relation to reconstruct the structure of the knowledge

Mother?

Mother

a

b

c

d

e

f

……

…… …

a

b

c

d

a

f

a

f

a

e

d

f

(b) Exhaustive search

(c) Bellman-Ford

(d) A*

a

b

c

d

e

f

a

b

c

d

e

f

a

b

c

d

e

f

a

b

c

d

e

f

(a) Path-based reasoning

a

b

c

d

e

f

a

b

d

e

f

a

b

c

d

e

f

a

b

c

d

e

f

c

graph. Due to its simplicity, embedding methods have become the de facto standard for knowledge graphs with millions of entities and triplets. With the help of multi-GPU embedding systems [57, 56], they can further scale to knowledge graphs with billions of triplets.

Another stream of works, path-based methods [28, 31, 11, 58], predicts the relation between a pair of entities based on the paths between them. Take the knowledge graph in Fig. 2(a) as an example, we can prove that Mother(a, f) holds, because there are two paths a Father - - - → b Wife - - → f and a Brother ← - - - -c Mother - - - - → f . As the semantics of paths are purely determined by relations rather than entities, path-based methods naturally generalize to unseen entities (i.e., inductive setting), which cannot be handled by embedding methods. However, the number of paths grows exponentially w.r.t. the path length, which hinders the application of path-based methods on large-scale knowledge graphs.

Here we propose A*Net to tackle the scalability issue of path-based methods. The key idea of our method is to search for important paths rather than use all possible paths for reasoning, thereby reducing time and memory in training and inference. Inspired by the A* algorithm [22] for shortest path problems, given a head entity u and a query relation q , we compute a priority score for each entity to guide the search towards more important paths. At each iteration, we select K nodes and L edges according to their priority, and use message passing to update nodes in their neighborhood. Due to the complex semantics of knowledge graphs, it is hard to use a handcrafted priority function like the A* algorithm without a significant performance drop (Tab. 6a). Instead, we design a neural priority function based on the node representations at the current iteration, which can be end-to-end trained by the objective function of the reasoning task without any additional supervision.

We verify our method on 4 transductive and 2 inductive knowledge graph reasoning datasets. Experiments show that A*Net achieves competitive performance against state-of-the-art path-based methods on FB15k-237, WN18RR and YAGO3-10, even with only 10% of nodes and 10% edges at each iteration (Sec. 4.2). To verify the scalability of our method, we also evaluate A*Net on ogbl-wikikg2, a million-scale knowledge graph that is 2 magnitudes larger than datasets solved by previous path-based methods. Surprisingly, with only 0.2% nodes and 0.2% edges, our method outperforms existing embedding methods and establishes new state-of-the-art results (Sec. 4.2) as the first non-embedding method on ogbl-wikikg2. By adjusting the ratios of selected nodes and edges, one can trade off between performance and efficiency (Sec. 4.3). A*Net also converges significantly faster than embedding methods (Fig. 1), which makes it a promising model for deployment on large-scale knowledge graphs. Additionally, A*Net offers interpretability that embeddings do not possess. Visualization shows that A*Net captures important paths for reasoning (Sec. 4.4).

2 Preliminary

Knowledge Graph Reasoning A knowledge graph G = ( V , E , R ) consists of sets of entities (nodes) V , facts (edges) E and relation types R . Each fact is a triplet ( x, r, y ) ∈ V × R × V , which indicates a relation r from entity x to entity y . The task of knowledge graph reasoning aims at answering queries like ( u, q, ?) or (? , q, u ) . Without loss of generality, we assume the query is

( u, q, ?) , since (? , q, u ) equals to ( u, q -1 , ?) with q -1 being the inverse of q . Given a query ( u, q, ?) , we need to predict the answer set V ( u,q, ?) , such that ∀ v ∈ V ( u,q, ?) the triplet ( u, q, v ) should be true.

Path-based Methods Path-based methods [28, 31, 11, 58] solve knowledge graph reasoning by looking at the paths between a pair of entities in a knowledge graph. For example, a path a Father - - - → b Wife - - → f may be used to predict Mother(a, f) in Fig. 2(a). From a representation learning perspective, path-based methods aim to learn a representation h q ( u, v ) to predict the triplet ( u, q, v ) based on all paths P u ⇝ v from entity u to entity v . Following the notation in [58] 3 , h q ( u, v ) is defined as

where ⊕ is a permutation-invariant aggregation function over paths (e.g., sum or max), ⊗ is an aggregation function over edges that may be permutation-sensitive (e.g., matrix multiplication) and w q ( x, r, y ) is the representation of triplet ( x, r, y ) conditioned on the query relation q . ⊗ is computed before ⊕ . Typically, w q ( x, r, y ) is designed to be independent of the entities x and y , which enables path-based methods to generalize to the inductive setting. However, it is intractable to compute Eqn. 1, since the number of paths usually grows exponentially w.r.t. the path length.

Path-based Reasoning with Bellman-Ford algorithm To reduce the time complexity of pathbased methods, recent works [50, 35, 58, 54] borrow the Bellman-Ford algorithm [4] from shortest path problems to solve path-based methods. Instead of enumerating each possible path, the BellmanFord algorithm iteratively propagates the representations of t -1 hops to compute the representations of t hops, which achieves a polynomial time complexity. Formally, let h ( t ) q ( u, v ) be the representation of t hops. The Bellman-Ford algorithm can be written as

where ✶ q is a learnable indicator function that defines the representations of 0 hops h (0) q ( u, v ) , also known as the boundary condition of the Bellman-Ford algorithm. E ( v ) is the neighborhood of node v . Despite the polynomial time complexity achieved by the Bellman-Ford algorithm, Eqn. 3 still needs to visit |V| nodes and |E| edges to compute h ( t ) q ( u, v ) for all v ∈ V in each iteration, which is not feasible for large-scale knowledge graphs.

A* Algorithm A* algorithm [22] is an extension of the Bellman-Ford algorithm for shortest path problems. Unlike the Bellman-Ford algorithm that propagates through every node uniformly, the A* algorithm prioritizes propagation through nodes with higher priority according to a heuristic function specified by the user. With an appropriate heuristic function, A* algorithm can reduce the search space of paths. Formally, with the notation from Eqn. 1, the priority function for node x is

where d ( u, x ) is the length of current shortest path from u to x , and g ( x, v ) is a heuristic function estimating the cost from x to the target node v . For instance, for a grid-world shortest path problem (Fig. 4(a)), g ( x, v ) is usually defined as the L 1 distance from x to v , ⊗ is the addition operator, and s ( x ) is a lower bound for the shortest path length from u to v through x . During each iteration, the A* algorithm prioritizes propagation through nodes with smaller s ( x ) .

3 Proposed Method

We propose A*Net to scale up path-based methods with the A* algorithm. We show that the A* algorithm can be derived from the observation that only a small set of paths are important for reasoning (Sec. 3.1). Since it is hard to handcraft a good priority function for knowledge graph reasoning (Tab. 6a), we design a neural priority function, and train it end-to-end for reasoning (Sec. 3.2).

3.1 Path-based Reasoning with A* Algorithm

As discussed in Sec. 2, the Bellman-Ford algorithm visits all |V| nodes and |E| edges. However, in real-world knowledge graphs, only a small portion of paths is related to the query. Based on this observation, we introduce the concept of important paths. We then show that the representations of important paths can be iteratively computed with the A* algorithm under mild assumptions.

Important Paths for Reasoning Given a query relation and a pair of entities, only some of the paths between the entities are important for answering the query. Consider the example in Fig. 2(a), the path a Friend - - - → d Mother - - - - → e Friend - - - → f cannot determine whether f is an answer to Mother(a, ?) due to the use of the Friend relation in the path. On the other hand, kinship paths like a Father - - - → b Wife - - → f or a Brother ← - - - -c Mother - - - - → f are able to predict that Mother(a, f) is true. Formally, we define P u ⇝ v | q ⊆ P u ⇝ v to be the set of paths from u to v that is important to the query relation q . Mathematically, we have

In other words, any path P ∈ P u ⇝ v \ P u ⇝ v | q has negligible contribution to h q ( u, v ) . In real-world knowledge graphs, the number of important paths |P u ⇝ v | q | may be several orders of magnitudes smaller than the number of paths |P u ⇝ v | [11]. If we compute the representation h q ( u, v ) using only the important paths, we can scale up path-based reasoning to large-scale knowledge graphs.

Iterative Computation of Important Paths Given a query ( u, q, ?) , we need to discover the set of important paths P u ⇝ v | q for all v ∈ V . However, it is challenging to extract important paths from P u ⇝ v , since the size of P u ⇝ v is exponentially large. Our solution is to explore the structure of important paths and compute them iteratively. We first show that we can cover important paths with iterative path selection (Eqn. 6 and 7). Then we approximate iterative path selection with iterative node selection (Eqn. 8).

Notice that paths in P u ⇝ v form a tree structure (Fig. 3). On the tree, a path is not important if any

d

f

c

b

d

c

b

d

c

b

d

a

b

c

d

a

f

a

f

a

e

�

𝒫𝒫

𝑎𝑎⇝𝑥𝑥

|

𝑞𝑞

1

|

𝑥𝑥 ∈

{

𝑏𝑏

,

𝑐𝑐

,

𝑑𝑑

}

�

𝒫𝒫

𝑎𝑎⇝𝑥𝑥

|

𝑞𝑞

2

|

𝑥𝑥 ∈

{

𝑎𝑎

,

𝑓𝑓

}

�

𝒫𝒫

𝑎𝑎⇝𝑥𝑥

|

𝑞𝑞

0

|

𝑥𝑥 ∈

{

𝑎𝑎

}

prefix of this path is not important for the query. For example, in Fig. 2(a), a Friend - - - → d Mother - - - - → e Friend - - - → f is not important, as its prefix a Friend - - - → d is not important for the query Mother . Therefore, we assume there exists a path selection function m q : 2 P ↦→ 2 P that selects important paths from a set of paths given the query relation q . 2 P is the set of all subsets of P . With m q , we construct the following set of paths ˆ P ( t ) u ⇝ v | q iteratively

where P + { ( x, r, v ) } concatenates the path P and the edge ( x, r, v ) . The paths ˆ P ( t ) u ⇝ v | q computed by the above iteration is a superset of the important paths P ( t ) u ⇝ v | q of length t (see Thm. A.1 in App. A). Due to the tree structure of paths, the above iterative path selection still requires exponential time. Hence we further approximate iterative path selection with iterative node selection, by assuming paths with the same length and the same stop node can be merged. The iterative node selection replacing Eqn. 7 is (see Prop. A.3 in App. A)

where n ( t ) uq : 2 V ↦→ 2 V selects ending nodes of important paths of length t from a set of nodes.

Reasoning with A* Algorithm Eqn. 8 iteratively computes the set of important paths ˆ P u ⇝ v | q . In order to perform reasoning, we need to compute the representation h q ( u, v ) based on the important paths, which can be achieved by an iterative process similar to Eqn. 8 (see Thm. A.4 in App. A)

Eqn. 9 is the A* iteration (Fig. 2(d)) for path-based reasoning. Note the A* iteration uses the same boundary condition as Eqn. 2. Inspired by the classical A* algorithm, we parameterize n ( t ) uq ( V ) with a node priority function s ( t ) uq : V ↦→ [0 , 1] and select topK nodes based on their priority. However, there does not exist an oracle for the priority function s ( t ) uq ( x ) . We will discuss how to learn the priority function s ( t ) uq ( x ) in the following sections.

3.2 Path-based Reasoning with A*Net

Both the performance and the efficiency of the A* algorithm heavily rely on the heuristic function. While it is straightforward to use L 1 distance as the heuristic function for grid-world shortest path problems, it is not clear what a good priority function for knowledge graph reasoning is due to the complex relation semantics in knowledge graphs. Indeed, our experiments suggest that handcrafted priority functions largely hurt the performance of path-based methods (Tab. 6a). In this section, we discuss a neural priority function, which can be end-to-end trained by the reasoning task.

Neural Priority Function To design the neural priority function s uq ( x ) , we draw inspiration from the priority function in the A* algorithm for shortest path problems (Eqn. 4). The priority function has two terms d ( u, x ) and g ( x, v ) , where d ( u, x ) is the current distance from node u to x , and g ( x, v ) estimates the remaining distance from node x to v .

Mother?

a

b

c

d

e

f

6+4

6+6

From a representation learning perspective, we need to learn a representation s uq ( x ) to predict the priority score s uq ( x ) for each node x . Inspired by Eqn. 4, we use the current representation h ( t ) q ( u, x ) to represent d ( t ) ( u, x ) . However, it is challenging to find a representation for g ( t ) ( x, v ) , since we do not know the answer entity v beforehand. Noticing that in the A* algorithm, the target node v can be expressed by the source node plus a displacement (Fig. 4(a)), we reparameterize the answer entity v with the head entity u and the query relation q in A*Net. By replacing g ( t ) ( x, v ) with another function g ( t ) ( u, x, q ) , the representation s uq ( x ) is parameterized as

where g ( · ) is a feed-forward network that outputs a vector representation and [ · , · ] concatenates two representations. Intuitively, the learned representation q captures the semantic of query relation q , which serves the goal for answering query ( u, q, ?) . The function g ([ h ( t ) q ( u, x ) , q ]) compares the current representation h ( t ) q ( u, x ) with the goal q to estimate the remaining representation (Fig. 4(b)). If h ( t ) q ( u, x ) is close to q , the remaining representation will be close to 0, and x is likely to be close to the correct answer. The final priority score is predicted by

where f ( · ) is a feed-forward network and σ is the sigmoid function that maps the output to [0 , 1] .

Learning To learn the neural priority function, we incorporate it as a weight for each message in the A* iteration. For simplicity, let X ( t ) = n ( t -1) uq ( V ) be the nodes we try to propagate through at t -th iteration. We modify Eqn. 9 to be

Eqn. 12 encourages the model to learn larger weights s ( t ) uq ( x ) for nodes that are important for reasoning. In practice, as some nodes may have very large degrees, we further select topL edges from the neighborhood of n ( t -1) uq ( V ) (see App. B). A pseudo code of A*Net is illustrated in Alg. 1. Note the topK and topL functions are not differentiable.

Nevertheless, it is still too challenging to train the neural priority function, since we do not know the ground truth for important paths, and there is no direct supervision for the priority function. Our solution is to share the weights between the priority function and the predictor for the reasoning task. The intuition is that the reasoning task can be viewed as a weak supervision for the priority function. Recall that the goal of s ( t ) uq ( x ) is to determine whether there exists an important path from u to x (Eqn. 8). In the reasoning task, any positive answer entity must be present on at least one important path, while negative answer entities are less likely to be on important paths. Our ablation experiment demonstrates that sharing weights improve the performance of neural priority function (Tab. 6b). Following [38], A*Net is trained to minimize the binary cross entropy loss over triplets

where ( u, q, v ) is a positive sample and { ( u ′ i , q, v ′ i ) } n i =1 are negative samples. Each negative sample ( u i , q, v i ) is generated by corrupting the head or the tail in a positive sample.

Efficient Implementation with Padding-Free Operations Modern neural networks heavily rely on batched execution to unleash the parallel capacity of GPUs. While Alg. 1 is easy to implement for a single sample ( u, q, ?) , it is not trivial to batch A*Net for multiple samples. The challenge is that different samples may have very different sizes for nodes V ( t ) and edges E ( t ) . A common approach is to pad the set of nodes or edges to a predefined constant, which would severely counteract the acceleration brought by A*Net.

Here we introduce padding-free topk operation to avoid the overhead in batched execution. The key idea is to convert batched execution of different small samples into execution of a single large sample, which can be paralleled by existing operations in deep learning frameworks. For example, the batched execution of topk ([[1 , 3] , [2 , 1 , 0]]) can be converted into a multi-key sort problem over

Algorithm 1 A*Net

Input: head entity u , query relation q , #iterations T Output: p ( v | u, q ) for all v ∈ V

1: for v ∈ V do 2: h (0) q ( u, v ) ← ✶ q ( u = v ) 3: end for 4: for t ← 1 to T do 5: X ( t ) ← TopK ( s ( t -1) uq ( x ) | x ∈ V ) 6: E ( t ) ← ⋃ x ∈X ( t ) E ( x ) 7: E ( t ) ← TopL ( s ( t -1) uq ( v ) | ( x, r, v ) ∈ E ( t ) ) 8: V ( t ) ← ⋃ ( x,r,v ) ∈E ( t ) { v } 9: for v ∈ V ( t ) do 10: Compute h ( t ) q ( u, v ) with Eqn. 12 11: Compute priority s ( t ) uq ( v ) with Eqn. 10, 11 12: end for 13: end for 14: ▷ Share weights between s uq ( v ) and the predictor 15: return s ( T ) uq ( v ) as p ( v | u, q ) for all v ∈ V

[[0 , 1] , [0 , 3] , [1 , 2] , [1 , 1] , [1 , 0]] , where the first key is the index of the sample in the batch and the second key is the original input. The multi-key sort is then implemented by composing stable single-key sort operations in deep learning frameworks. See App. C for details.

4 Experiments

We evaluate A*Net on standard transductive and inductive knowledge graph reasoning datasets, including a million-scale one ogbl-wikikg2. We conduct ablation studies to verify our design choices and visualize the important paths learned by the priority function in A*Net.

4.1 Experiment Setup

Datasets & Evaluation We evaluate A*Net on 4 standard knowledge graphs, FB15k-237 [40], WN18RR [16], YAGO3-10 [30] and ogbl-wikikg2 [25]. For the transductive setting, we use the standard splits from their original works [40, 16]. For the inductive setting, we use the splits provided by [39], which contains 4 different versions for each dataset. As for evaluation, we use the standard filtered ranking protocol [6] for knowledge graph reasoning. Each triplet ( u, q, v ) is ranked against all negative triplets ( u, q, v ′ ) or ( u ′ , q, v ) that are not present in the knowledge graph. We measure the performance with mean reciprocal rank (MRR) and HITS at K (H@K). Efficiency is measured by the average number of messages (#message) per step, wall time per epoch and memory cost. To plot the convergence curves for each model, we dump checkpoints during training with a high frequency, and evaluate the checkpoints later on the validation set. See more details in App. D.

Implementation Details Our work is developed based on the open-source codebase of path-based reasoning with Bellman-Ford algorithm 4 . For a fair comparison with existing path-based methods, we follow the implementation of NBFNet [58] and parameterize ⊕ with principal neighborhood aggregation (PNA) [13] or sum aggregation, and parameterize ⊗ with the relation operation from DistMult [49], i.e., vector multiplication. The indicator function (Eqn. 2) ✶ q ( u = v ) = ✶ ( u = v ) q is parameterized with a query embedding q for all datasets except ogbl-wikikg2, where we augment the indicator function with learnable embeddings based on a soft distance from u to v (see App. E for more details). The edge representation (Eqn. 12) w q ( x, r, v ) = W r q + b r is parameterized as a linear function over the query relation q for all datasets except WN18RR, where we use a simple embedding w q ( x, r, v ) = r . We use the same preprocessing steps as in [58], including augmenting each triplet with a flipped triplet, and dropping out query edges during training.

For the neural priority function, we have two hyperparameters: K for the maximum number of nodes and L for the maximum number of edges. To make hyperparameter tuning easier, we define maximum node ratio α = K/ |V| and maximum average degree ratio β = L |V| /K |E| , and tune the ratios for each dataset. The maximum edge ratio is determined by αβ . The other hyperparameters are kept the same as the values in [58]. We train A*Net with 4 Tesla A100 GPUs (40 GB), and select the best model based on validation performance. See App. E for more details.

Baselines We compare A*Net against embedding methods, GNNs and path-based methods. The embedding methods are TransE [6], ComplEx [42], RotatE [38], HAKE [55], RotH [7], PairRE [8], ComplEx+Relation Prediction [12] and ConE [3]. The GNNs are RGCN [36], CompGCN [43] and GraIL [39]. The path-based methods are MINERVA [14], Multi-Hop [29], CURL [52], NeuralLP [50], DRUM [35], NBFNet [58] and RED-GNN [54]. Note that path-finding methods [14, 29, 52] that use reinforcement learning and assume sparse answers can only be evaluated on tail prediction. Training time of all baselines are measured based on their official open-source implementations, except that we use a more recent implementation 5 of TransE and ComplEx.

4.2 Main Results

Tab. 1 shows that A*Net outperforms all embedding methods and GNNs, and is on par with NBFNet on transductive knowledge graph reasoning. We also observe a similar trend of A*Net and NBFNet over path-finding methods on tail prediction (Tab. 2). Since path-finding methods select only one path with reinforcement learning, such results imply the advantage of aggregating multiple paths in A*Net. A*Net also converges faster than all the other methods (Fig. 5). Notably, unlike NBFNet that propagates through all nodes and edges, A*Net only propagates through 10% nodes and 10% edges on both datasets, which suggests that most nodes and edges are not important for path-based reasoning. Tab. 3 shows that A*Net reduces the number of messages by 14.1 × and 42.9 × compared to NBFNet on two datasets respectively. Note that the reduction in time and memory is less than the reduction in the number of messages, since A*Net operates on subgraphs with dynamic sizes and is harder to parallel than NBFNet on GPUs. We leave better parallel implementation as future work.

Tab. 4 shows the performance on ogbl-wikikg2, which has 2.5 million entities and 16 million triplets. While NBFNet faces out-of-memory (OOM) problem even for a batch size of 1, A*Net can perform reasoning by propagating through 0.2% nodes and 0.2% edges at each step. Surprisingly, even with

FB15k-237

0.4

MRR

0.3

0.2

0.1

RotatE

0

1

2

3

4

—ConE

Training Time (hrs)

-CompGCN

WN18RR

—NBFNet

RED-GNN

0.55

A*Net

MRR

0.50

0.45

0

2

4

6

Training Time (hrs)

such sparse propagation, A*Net outperforms embedding methods and achieves a new state-of-the-art result. Moreover, the validation curve in Fig. 1 shows that A*Net converges significantly faster than embedding methods. Since A*Net only learns parameters for relations but not entities, it only uses 6.83 million parameters, which is 36.6 × less than the best embedding method ComplEx+RP.

Tab. 5 shows the performance on inductive knowledge graph reasoning. A*Net is on par with NBFNet and significantly outperforms all the other methods. Note that embedding methods cannot deal with the inductive setting. Other metrics (H@1, H@10) and efficiency results are in App. F.

4.3 Ablation Studies

Priority Function To verify the effectiveness of neural priority function, we compare it against three handcrafted priority functions: personalized PageRank (PPR), Degree and Random. PPR selects nodes with higher PPR scores w.r.t. the query head entity u . Degree selects nodes with larger degrees, while Random selects nodes uniformly. Tab. 6 shows that the neural priority function outperforms all three handcrafted priority functions, suggesting the necessity of learning a neural priority function.

Sharing Weights As discussed in Sec. 3.2, we share the weights between the neural priority function and the reasoning predictor to help train the neural priority function. Tab. 6 compares A*Net trained with and without sharing weights. It can be observed that sharing weights is essential to training a good neural priority function in A*Net.

Trade-off between Performance and Efficiency While A*Net matches the performance of NBFNet in less training time, one may further trade off performance and efficiency in A*Net by adjusting the ratios α and β . Fig. 6 plots curves of performance and speedup ratio w.r.t. different

Bandai

Bandai Namco

video game

media

industry

(Bandai, industry, ?)

α and β . If we can accept a performance similar to embedding methods (e.g., ConE [3]), we can set either α to 1% or β to 10%, resulting in 8.7 × speedup compared to NBFNet.

4.4 Visualization of Learned Important Paths

We can extract the important paths from the neural priority function in A*Net for interpretation. For a given query ( u, q, ?) and a predicted entity v , we can use the node priority s ( t ) uq ( x ) at each step to estimate the importance of a path. Empirically, the importance of a path s q ( P ) is estimated by

where S ( t -1) uq = max x ∈V ( t -1) s ( t -1) uq ( x ) is a normalizer to normalize the priority score for each step t . To extract the important paths with large s q ( P ) , we perform beam search over the priority function s ( t -1) uq ( x ) of each step. Fig. 7 shows the important paths learned by A*Net for a test sample in FB15k-237. Given the query (Bandai, industry, ?) , we can see both paths Bandai subsidiary ← - - - - -Bandai Namco industry - - - - → video game and Bandai industry - - - - → media industry ← - - - -Pony Canyon industry - - - - → video game are consistent with human cognition. More visualization results can be found in App. G.

5 Related Work

Path-based Reasoning Path-based methods use paths between entities for knowledge graph reasoning. Early methods like Path Ranking [28, 19] collect relational paths as symbolic features for classification. Path-RNN [31, 15] and PathCon [45] improve Path Ranking by learning the representations of paths with recurrent neural networks (RNN). However, these works operate on the full set of paths between two entities, which grows exponentially w.r.t. the path length. Typically, these methods can only be applied to paths with at most 3 edges.

To avoid the exhaustive search of paths, many methods learn to sample important paths for reasoning. DeepPath [47] and MINERVA [14] learn an agent to collect meaningful paths on the knowledge graph

through reinforcement learning. These methods are hard to train due to the extremely sparse rewards. Later works improve them by engineering the reward function [29] or the search strategy [37], using multiple agents for positive and negative paths [24] or for coarse- and fine-grained paths [52]. [11] and [33] use a variational formulation to learn a sparse prior for path sampling. Another category of methods utilizes the dynamic programming to search paths in a polynomial time. NeuralLP [50] and DRUM [35] use dynamic programming to learn linear combination of logic rules. All-Paths [41] adopts a Floyd-Warshall-like algorithm to learn path representations between all pairs of entities. Recently, NBFNet [58] and RED-GNN [54] leverage a Bellman-Ford-like algorithm to learn path representations from a single-source entity to all entities. While dynamic programming methods achieve state-of-the-art results among path-based methods, they need to perform message passing on the full knowledge graph. By comparison, our A*Net learns a priority function and only explores a subset of paths, which is more scalable than existing dynamic programming methods.

Efficient Graph Neural Networks Our work is also related to efficient graph neural networks, since both try to improve the scalability of graph neural networks (GNNs). Sampling methods [21, 9, 26, 51] reduce the cost of message passing by computing GNNs with a sampled subset of nodes and edges. Non-parametric GNNs [27, 46, 18, 10] decouple feature propagation from feature transformation, and reduce time complexity by preprocessing feature propagation. However, both sampling methods and non-parametric GNNs are designed for homogeneous graphs, and it is not straightforward to adapt them to knowledge graphs. On knowledge graphs, RS-GCN [17] learns to sample neighborhood with reinforcement learning. DPMPN [48] learns an attention to iteratively select nodes for message passing. SQALER [1] first predicts important path types based on the query, and then applies GNNs on the subgraph extracted by the predicted paths. Our A*Net shares the same goal with these methods, but learns a neural priority function to iteratively select important paths.

6 Discussion and Conclusion

Limitation and Future Work One limitation for A*Net is that we focus on algorithm design rather than system design. As a result, the improvement in time and memory cost is much less than the improvement in the number of messages (Tab. 3 and App. F). In the future, we will co-design the algorithm and the system to further improve the efficiency.

Societal Impact This work proposes a scalable model for path-based reasoning. On the positive side, it reduces the training and test time of reasoning models, which helps control carbon emission. On the negative side, reasoning models might be used in malicious activities, such as discovering sensitive relationship in anonymized data, which could be augmented by a more scalable model.

Conclusion We propose A*Net, a scalable path-based method, to solve knowledge graph reasoning by searching for important paths, which is guided by a neural priority function. Experiments on both transductive and inductive knowledge graphs verify the performance and efficiency of A*Net. Meanwhile, A*Net is the first path-based method that scales to million-scale knowledge graphs.

References

Mattia Atzeni, Jasmina Bogojeska, and Andreas Loukas. Sqaler: Scaling question answering by decoupling multi-hop and logical reasoning. Advances in Neural Information Processing Systems , 34, 2021.

Sören Auer, Christian Bizer, Georgi Kobilarov, Jens Lehmann, Richard Cyganiak, and Zachary Ives. Dbpedia: A nucleus for a web of open data. In The semantic web , pages 722-735. Springer, 2007.

Yushi Bai, Zhitao Ying, Hongyu Ren, and Jure Leskovec. Modeling heterogeneous hierarchies with relation-specific hyperbolic cones. Advances in Neural Information Processing Systems , 34, 2021.

Richard Bellman. On a routing problem. Quarterly of applied mathematics , 16(1):87-90, 1958.

Jonathan Berant, Andrew Chou, Roy Frostig, and Percy Liang. Semantic parsing on freebase from question-answer pairs. In Proceedings of the 2013 conference on empirical methods in natural language processing , pages 1533-1544, 2013.

Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko. Translating embeddings for modeling multi-relational data. Advances in neural information processing systems , 26, 2013.

Ines Chami, Adva Wolf, Da-Cheng Juan, Frederic Sala, Sujith Ravi, and Christopher Ré. Lowdimensional hyperbolic knowledge graph embeddings. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics , pages 6901-6914, 2020.

Linlin Chao, Jianshan He, Taifeng Wang, and Wei Chu. Pairre: Knowledge graph embeddings via paired relation vectors. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 1: Long Papers) , pages 4360-4369, 2021.

Jie Chen, Tengfei Ma, and Cao Xiao. Fastgcn: Fast learning with graph convolutional networks via importance sampling. In International Conference on Learning Representations , 2018.

Ming Chen, Zhewei Wei, Bolin Ding, Yaliang Li, Ye Yuan, Xiaoyong Du, and Ji-Rong Wen. Scalable graph neural networks via bidirectional propagation. Advances in neural information processing systems , 33:14556-14566, 2020.

Wenhu Chen, Wenhan Xiong, Xifeng Yan, and William Yang Wang. Variational knowledge graph reasoning. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers) , pages 1823-1832, 2018.

Yihong Chen, Pasquale Minervini, Sebastian Riedel, and Pontus Stenetorp. Relation prediction as an auxiliary training objective for improving multi-relational graph representations. In 3rd Conference on Automated Knowledge Base Construction , 2021.

Gabriele Corso, Luca Cavalleri, Dominique Beaini, Pietro Liò, and Petar Veliˇ ckovi´ c. Principal neighbourhood aggregation for graph nets. Advances in Neural Information Processing Systems , 33:13260-13271, 2020.

Rajarshi Das, Shehzaad Dhuliawala, Manzil Zaheer, Luke Vilnis, Ishan Durugkar, Akshay Krishnamurthy, Alex Smola, and Andrew McCallum. Go for a walk and arrive at the answer: Reasoning over paths in knowledge bases using reinforcement learning. In International Conference on Learning Representations , 2018.

Rajarshi Das, Arvind Neelakantan, David Belanger, and Andrew McCallum. Chains of reasoning over entities, relations, and text using recurrent neural networks. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 1, Long Papers , pages 132-141, 2017.

Tim Dettmers, Pasquale Minervini, Pontus Stenetorp, and Sebastian Riedel. Convolutional 2d knowledge graph embeddings. In Proceedings of the AAAI conference on artificial intelligence , volume 32, 2018.

Arthur Feeney, Rishabh Gupta, Veronika Thost, Rico Angell, Gayathri Chandu, Yash Adhikari, and Tengfei Ma. Relation matters in sampling: A scalable multi-relational graph neural network for drug-drug interaction prediction. arXiv preprint arXiv:2105.13975 , 2021.

Fabrizio Frasca, Emanuele Rossi, Davide Eynard, Ben Chamberlain, Michael Bronstein, and Federico Monti. Sign: Scalable inception graph neural networks. arXiv preprint arXiv:2004.11198 , 2020.

Matt Gardner and Tom Mitchell. Efficient and expressive knowledge base completion using subgraph feature extraction. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing , pages 1488-1498, 2015.

Ben Goertzel and Cassio Pennachin. Artificial general intelligence , volume 2. Springer, 2007.

Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. Advances in neural information processing systems , 30, 2017.

Peter E Hart, Nils J Nilsson, and Bertram Raphael. A formal basis for the heuristic determination of minimum cost paths. IEEE transactions on Systems Science and Cybernetics , 4(2):100-107, 1968.

Udo Hebisch and Hanns Joachim Weinert. Semirings: algebraic theory and applications in computer science , volume 5. World Scientific, 1998.

Marcel Hildebrandt, Jorge Andres Quintero Serna, Yunpu Ma, Martin Ringsquandl, Mitchell Joblin, and Volker Tresp. Reasoning on knowledge graphs with debate dynamics. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 34, pages 4123-4131, 2020.

Weihua Hu, Matthias Fey, Hongyu Ren, Maho Nakata, Yuxiao Dong, and Jure Leskovec. Ogblsc: A large-scale challenge for machine learning on graphs. arXiv preprint arXiv:2103.09430 , 2021.

Wenbing Huang, Tong Zhang, Yu Rong, and Junzhou Huang. Adaptive sampling towards fast graph representation learning. Advances in neural information processing systems , 31, 2018.

Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. In International Conference on Learning Representations , 2018.

Ni Lao and William W Cohen. Relational retrieval using a combination of path-constrained random walks. Machine learning , 81(1):53-67, 2010.

Xi Victoria Lin, Richard Socher, and Caiming Xiong. Multi-hop knowledge graph reasoning with reward shaping. In EMNLP , 2018.

Farzaneh Mahdisoltani, Joanna Biega, and Fabian Suchanek. Yago3: A knowledge base from multilingual wikipedias. In 7th biennial conference on innovative data systems research . CIDR Conference, 2014.

Arvind Neelakantan, Benjamin Roth, and Andrew McCallum. Compositional vector space models for knowledge base completion. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 1: Long Papers) , pages 156-166, 2015.

Judea Pearl. Probabilistic reasoning in intelligent systems: networks of plausible inference . Morgan kaufmann, 1988.

Meng Qu, Junkun Chen, Louis-Pascal Xhonneux, Yoshua Bengio, and Jian Tang. Rnnlogic: Learning logic rules for reasoning on knowledge graphs. In International Conference on Learning Representations , 2021.

Hongyu Ren, Mikhail Galkin, Michael Cochez, Zhaocheng Zhu, and Jure Leskovec. Neural graph reasoning: Complex logical query answering meets graph databases. arXiv preprint arXiv:2303.14617 , 2023.

Ali Sadeghian, Mohammadreza Armandpour, Patrick Ding, and Daisy Zhe Wang. Drum: End-to-end differentiable rule mining on knowledge graphs. Advances in Neural Information Processing Systems , 32, 2019.

Michael Schlichtkrull, Thomas N Kipf, Peter Bloem, Rianne van den Berg, Ivan Titov, and Max Welling. Modeling relational data with graph convolutional networks. In European semantic web conference , pages 593-607. Springer, 2018.

Yelong Shen, Jianshu Chen, Po-Sen Huang, Yuqing Guo, and Jianfeng Gao. M-walk: Learning to walk over graphs using monte carlo tree search. Advances in Neural Information Processing Systems , 31, 2018.

Zhiqing Sun, Zhi-Hong Deng, Jian-Yun Nie, and Jian Tang. Rotate: Knowledge graph embedding by relational rotation in complex space. In International Conference on Learning Representations , 2019.

Komal Teru, Etienne Denis, and Will Hamilton. Inductive relation prediction by subgraph reasoning. In International Conference on Machine Learning , pages 9448-9457. PMLR, 2020.

Kristina Toutanova and Danqi Chen. Observed versus latent features for knowledge base and text inference. In Proceedings of the 3rd workshop on continuous vector space models and their compositionality , pages 57-66, 2015.

Kristina Toutanova, Xi Victoria Lin, Wen-tau Yih, Hoifung Poon, and Chris Quirk. Compositional learning of embeddings for relation paths in knowledge base and text. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers) , pages 1434-1444, 2016.

Théo Trouillon, Johannes Welbl, Sebastian Riedel, Éric Gaussier, and Guillaume Bouchard. Complex embeddings for simple link prediction. In International Conference on Machine Learning , pages 2071-2080. PMLR, 2016.

Shikhar Vashishth, Soumya Sanyal, Vikram Nitin, and Partha Talukdar. Composition-based multi-relational graph convolutional networks. In International Conference on Learning Representations , 2020.

Denny Vrandeˇ ci´ c and Markus Krötzsch. Wikidata: a free collaborative knowledgebase. Communications of the ACM , 57(10):78-85, 2014.

Hongwei Wang, Hongyu Ren, and Jure Leskovec. Relational message passing for knowledge graph completion. In Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery & Data Mining , pages 1697-1707, 2021.

Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. Simplifying graph convolutional networks. In International conference on machine learning , pages 6861-6871. PMLR, 2019.

Wenhan Xiong, Thien Hoang, and William Yang Wang. Deeppath: A reinforcement learning method for knowledge graph reasoning. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing (EMNLP 2017) , Copenhagen, Denmark, September 2017. ACL.

Xiaoran Xu, Wei Feng, Yunsheng Jiang, Xiaohui Xie, Zhiqing Sun, and Zhi-Hong Deng. Dynamically pruned message passing networks for large-scale knowledge graph reasoning. In International Conference on Learning Representations , 2019.

Bishan Yang, Wen-tau Yih, Xiaodong He, Jianfeng Gao, and Li Deng. Embedding entities and relations for learning and inference in knowledge bases. International Conference on Learning Representations , 2015.

Fan Yang, Zhilin Yang, and William W Cohen. Differentiable learning of logical rules for knowledge base reasoning. In Advances in Neural Information Processing Systems , pages 2316-2325, 2017.

Hanqing Zeng, Hongkuan Zhou, Ajitesh Srivastava, Rajgopal Kannan, and Viktor Prasanna. Graphsaint: Graph sampling based inductive learning method. In International Conference on Learning Representations , 2019.

Denghui Zhang, Zixuan Yuan, Hao Liu, Hui Xiong, et al. Learning to walk with dual agents for knowledge graph reasoning. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 36, pages 5932-5941, 2022.

Fuzheng Zhang, Nicholas Jing Yuan, Defu Lian, Xing Xie, and Wei-Ying Ma. Collaborative knowledge base embedding for recommender systems. In Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining , pages 353-362, 2016.

Yongqi Zhang and Quanming Yao. Knowledge graph reasoning with relational digraph. In Proceedings of the ACM Web Conference 2022 , pages 912-924, 2022.

Zhanqiu Zhang, Jianyu Cai, Yongdong Zhang, and Jie Wang. Learning hierarchy-aware knowledge graph embeddings for link prediction. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 34, pages 3065-3072, 2020.

Da Zheng, Xiang Song, Chao Ma, Zeyuan Tan, Zihao Ye, Jin Dong, Hao Xiong, Zheng Zhang, and George Karypis. Dgl-ke: Training knowledge graph embeddings at scale. In Proceedings of the 43rd International ACM SIGIR Conference on Research and Development in Information Retrieval , pages 739-748, 2020.

Zhaocheng Zhu, Shizhen Xu, Jian Tang, and Meng Qu. Graphvite: A high-performance cpu-gpu hybrid system for node embedding. In The World Wide Web Conference , pages 2494-2504, 2019.

Zhaocheng Zhu, Zuobai Zhang, Louis-Pascal Xhonneux, and Jian Tang. Neural bellman-ford networks: A general graph neural network framework for link prediction. Advances in Neural Information Processing Systems , 34, 2021.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper introduces ANet, a scalable path-based approach for reasoning on extensive knowledge graphs (KGs). In contrast to embedding techniques, path-based methods exhibit inductive capabilities but encounter challenges in terms of scalability due to the exponential growth of paths. ANet addresses this issue by incorporating a priority function, inspired by the A\\* algorithm for shortest-path problems, which enables the selection of crucial nodes and edges during each iteration. This novel approach effectively reduces the time and memory requirements for both training and inference processes.\n\nSTRENGTHS:\nS1: This paper proposes an efficient GNN called A\\*Net for link prediction with good scalability.\n\nS2: A\\*Net shows impressive results on various KGs.\n\nWEAKNESSES:\nW1: Although the method proposed in this article has better scalability, the contributions from theoretical perspectives are incremental compared to NBFNet.\n\nW2: The introduction of the parameter sharing between the priority function and predictor is somewhat unclear, and the reason why the reasoning task can be regarded as weak supervision for the priority function is not well explained.\n\nQUESTIONS:\nQ1: The priority function in A\\*Net is similar to the attention used in RED-GNN except that A\\*Net selects the nodes and edges according to the attention score. In the case where memory allows, how does the performance of A\\* Net change when Top operation is disabled in Algorithm 1 (line 5 & line 7)?\n\nQ2: If some nodes and edges are discarded in the early phase of model training, it may introduce incorrect inductive biases and prevent the model from training effectively. How do you address this issue to avoid such problems or why is this not an issue in A\\*Net?\n\nLIMITATIONS:\nSee **Weaknesses** and **Questions**.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-05"}

comments: SUMMARY:
This paper presents a scalable path-based method for knowledge graph reasoning, which is inspired by the A* algorithm for shortest path problems.

STRENGTHS:
1. The intriguing approach of applying the A$^*$ algorithm's principle to path reasoning in KG is proposed in this paper, along with the introduction of novel methods for crafting the priority function.

2. The paper achieves state-of-the-art results on the large-scale KG reasoning dataset, ogbl-wikikg2.

3. There's a substantial enhancement in efficiency, considering both time and memory usage, as opposed to the top-performing baseline, NBFNet.

WEAKNESSES:
The proposed method performs slightly worse than NBFnet as shown in Table 1, and no results of NBFnet are reported on tail prediction in Table 2.

QUESTIONS:
1. In the context of KG reasoning, a crucial question is, how many steps are typically required for a query? According to the vanilla path reasoning in Equation 1, the number of paths increases exponentially with respect to path length. However, if the path length is typically small, this might not pose a significant problem? Moreover, when dealing with a large-scale KG, the BF algorithm would need to visit $|\mathcal{V}|$ nodes and $|\mathcal{E}|$ edges for each step, which can be quite computationally intensive. Given these considerations, it leads to the question: If the path length is usually small, could vanilla path reasoning be a more efficient choice compared to BF?

2. Another question is, can we simply leverage the idea of beam search into vanilla path reasoning? For example, we keep top-K ranked paths for each step, which may also avoid the exponential growth of the number of paths.

LIMITATIONS:
Yes
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2023-07-05

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe main contribution of this paper is presenting a scalable path-based method A*Net, for link prediction on large-scale knowledge graphs. A*Net is inspired by the A* algorithm for solving shortest path problems, where it learns a priority function to select important nodes and edges at each iteration. This allows for the time and memory reducing for both training and inference. From an efficiency perspective, this could be considered as a path-pruning method to progressively reduce the subgraph based on the learned priority function. The empirical results also demonstrate efficiency improvement.\n\nSTRENGTHS:\n1. The efficiency problem caused by the explosively increasing entities in deeper propagation layers is indeed serious in the recent GNN-based inductive methods. And the proposed method makes sense and technically sound. \n\n2. The experimental results are impressive. The paper demonstrates the practical applications of A*Net in various settings and datasets, with the efficiency improvement compared with several recent baselines. Furthermore, the paper sets a new state-of-the-art on the million-scale dataset ogbl-wikikg2 and converges faster than embedding methods. \n\n3. The paper's organization is well-executed and the content is easily comprehensible.\n\nWEAKNESSES:\n1. The paper's comparison to the A* algorithm seems somewhat overstated. As a derivative work of NBFNet, this paper draws an analogy to another shortest path algorithm, A*. Contrary to the Bellman-Ford algorithm that resolves the shortest path problem from the source to all other points, the A* algorithm typically addresses the shortest path problem from the source to a specific target point. However, in the context of knowledge graph (KG) reasoning, the target point is unknown, rendering the core principle of A*, assessing the estimated remaining cost to the target point, unfeasible. In fact, the A* algorithm's priority rule, involving the distance to the target node, is not pertinent to the priority function in the proposed model. The A* algorithm appears to function primarily as a promotional point, rather than as a guiding principle.\n\n2. Perhaps due to the overemphasis on the A* analogy, the paper's true technical contributions remain unclear. Comparing the core function of NBFNet in Eq. 3 and that of A*Net in Eq. 12, the only discernible difference lies in introducing the priority score, calculated based on the embeddings of the query and the current node. Stripping away the A* algorithm framework, it essentially seems to be a path-pruning technique reliant on an attention mechanism to select the top K nodes and top L edges in each layer for efficiency's sake.\n\n3. The paper lacks insightful contributions regarding important paths beyond a weighted version of the NBENet method. The theoretical appendix focuses solely on integrating path selection into the NBFNet framework, premised on the assumption that a certain function can distinguish important nodes. However, how to ensure that important paths are chosen is not clear. In response to this, the authors propose weight sharing between the priority function and the predictor, asserting that the reasoning task can be seen as a weak supervision for the priority function. However, this appears counterintuitive, given that the priority score is dependent on a specific query. A high predictor score, indicating that the node x answers the query (u, r_1), should not contribute to the priority score of x for a different query (u, r_2).\n\nQUESTIONS:\n1. As addressed in Weaknesses 3, could you elaborate on how weight sharing aids in the selection of important paths?\n\n2. I observe that two handcrafted priority functions, PPR and Degree, are employed in the ablation studies. Given that high connectivity doesn't necessarily denote the importance of paths, what about the effectiveness and efficiency of a random pruning strategy, particularly with respect to the obgl_wikikg2 dataset?\n\n3. In the Visualization section, only the results of the proposed method are displayed without any comparison. Could you clarify what distinct paths the Neural function selects compared to the two handcrafted ones? Furthermore, does the Neural-based path selection align more closely with knowledge semantics?\n\nLIMITATIONS:\nYes. The authors stated the limitation, future work and social impact.", "TITLE": "Official Review", "RECOMMENDATION": 4, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-06"}

comments: SUMMARY:
This paper proposes a scalable path-based knowledge graph reasoning approach. The idea is to extend only important paths from the exponentially growing set of all possible paths. A heuristic priority function is parametrized by a feed-forward network and is trained to predict the priority of nodes to expand. Experiments show that the proposed approach can significantly improve time and memory efficiency and also achieve good results.

STRENGTHS:
- Scalability is an important issue for path-based reasoning approaches. The idea of selecting only important paths is interesting and sounds reasonable
- The proposed approach is effective and supported by extensive experiments. Time and memory efficiency has been significantly improved. Benchmark results are also good.

WEAKNESSES:
My concern is mainly about the design of the priority function Eq (10)

In Eq (10), the first part $h_q^{(t)}(u, x)$ is already conditioned on q, u, and x, so in principle the second part $g([h_q^{(t)}(u, x), q])$ doesn't provide any additional information. Therefore, the priority function is purely based on the current path from the start and contains no information about the goal. In other words, the prediction of the priority function would be the same even if the goal changes. This is different from the design of the A* algorithm and may lose theoretical guarantees. 

It is not appropriate to present the approach in the manner of A* algorithm

QUESTIONS:
Please see Weaknesses

LIMITATIONS:
properly addressed
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 2
DATE: 2023-07-12