# Auction-Based Learning for Question Answering over Knowledge Graphs

^{*}

## Abstract

**:**

## 1. Introduction

- We propose a new method using auction algorithms for question answering in knowledge graphs.
- We show that knowledge graphs can take advantage of the dynamic nature of auction algorithms.
- Our results show that the computational efficiency of the search can be improved by reusing the prices that have been learned from previous queries.
- Lastly, we leverage the entity metadata and path relations to construct an interpretable answer from the resulting path given by auction algorithms.

## 2. Related Work

#### 2.1. Embedding-Based Methods

#### 2.2. Path-Based Methods

#### 2.3. Auction Algorithms

## 3. Auction Algorithms Description

#### 3.1. Auction Path Construction (APC) Algorithm

#### 3.1.1. Background and Terminology

- (a)
- $Downhill:if$${p}_{{e}_{i}}{p}_{{e}_{j}}$
- (b)
- $Level:if$${p}_{{e}_{i}}={p}_{{e}_{j}}$
- (c)
- $Uphill:if$${p}_{{e}_{i}}{p}_{{e}_{j}}$

#### 3.1.2. Formal Definition

- (a)
- $P=\left({e}_{s}\right):$ Set the price ${p}_{{e}_{s}}$ to $max\{{p}_{{e}_{s}},{p}_{succ\left({e}_{s}\right)}+\u03f5\}$, and extend P to $succ\left({e}_{s}\right)$.
- (b)
- $P=({e}_{s},{e}_{1},\dots ,{e}_{k})$ and node ${e}_{k}$ is deadend: Set the price ${p}_{{e}_{k}}$ to ∞ (or a very high number for practical purposes), and contract P to ${e}_{k-1}$.
- (c)
- $P=({e}_{s},{e}_{1},\dots ,{e}_{k})$ and node ${e}_{k}$ is not deadend. Then, the following two cases are considered.
- (i)
- If ${p}_{pred\left({e}_{k}\right)}>{p}_{succ\left({e}_{k}\right)}$, then
**extend**P to $succ\left({e}_{k}\right)$ and set ${p}_{{e}_{k}}$ to any price level that makes the arc $(pred\left({e}_{k}\right),{e}_{k})$ level or downhill and the arc $({e}_{k},succ\left({e}_{k}\right))$ downhill. For example, set$${p}_{{e}_{k}}={p}_{pred\left({e}_{k}\right)}$$This raises the price ${p}_{{e}_{k}}$ to the maximum possible level, making the arc $(pred\left({e}_{k}\right),{e}_{k})$ level. - (ii)
- If ${p}_{pred\left({e}_{k}\right)}\le {p}_{succ\left({e}_{k}\right)}$, then
**contract**P to $pred\left({e}_{k}\right)$ and raise the price of ${e}_{k}$ to the price of $succ\left({e}_{k}\right)$ plus $\u03f5$. This makes the arc $(pred\left({e}_{k}\right),{e}_{k})$ uphill and the arc $({e}_{k},succ\left({e}_{k}\right))$ downhill.

#### 3.1.3. Multiple Destinations or Multiple Origins

#### 3.2. Auction Weighted Path Construction (AWPC) Algorithm

- (a)
- $Downhill:if$${p}_{{e}_{i}}{a}_{ij}+{p}_{{e}_{j}}$ ;
- (b)
- $Level:if$${p}_{{e}_{i}}={a}_{ij}+{p}_{{e}_{j}}$;
- (c)
- $Uphill:if$${p}_{{e}_{i}}{a}_{ij}+{p}_{{e}_{j}}$.

- (a)
- $P=\left({e}_{s}\right):$ Set the price ${p}_{{e}_{s}}$ to $max\{{p}_{{e}_{s}},{a}_{{e}_{s}succ\left({e}_{s}\right)}+{p}_{succ\left({e}_{s}\right)}+\u03f5\}$, and extend P to $succ\left({e}_{s}\right)$.
- (b)
- $P=({e}_{s},{e}_{1},\dots ,{e}_{k})$ and node ${e}_{k}$ is deadend : Set the price ${p}_{{e}_{k}}$ to ∞ (or a very high number for practical purposes), and contract P to ${e}_{k-1}$.
- (c)
- $P=({e}_{s},{e}_{1},\dots ,{e}_{k})$ and node ${e}_{k}$ is not deadend. Then, the following two cases are considered.
- (i)
- If ${p}_{pred\left({e}_{k}\right)}>{a}_{pred\left({e}_{k}\right){e}_{k}}+{a}_{{e}_{k}succ\left({e}_{k}\right)}+{p}_{succ\left({e}_{k}\right)}$, then
**extend**P to $succ\left({e}_{k}\right)$ and set ${p}_{{e}_{k}}$ to any price level that makes the arc $(pred\left({e}_{k}\right),{e}_{k})$ level and the arc $({e}_{k},succ\left({e}_{k}\right))$ downhill. For example, set$${p}_{{e}_{k}}={p}_{pred\left({e}_{k}\right)}-{a}_{pred\left({e}_{k}\right){e}_{k}}$$This raises the price ${p}_{{e}_{k}}$ to the maximum possible level, making the arc $(pred\left({e}_{k}\right),{e}_{k})$ level. - (ii)
- If ${p}_{pred\left({e}_{k}\right)}\le {a}_{pred\left({e}_{k}\right){e}_{k}}+{a}_{{e}_{k}succ\left({e}_{k}\right)}+{p}_{succ\left({e}_{k}\right)}$, then
**contract**P to $pred\left({e}_{k}\right)$ and raise the price of ${e}_{k}$ to ${a}_{{e}_{k}succ\left({e}_{k}\right)}+{p}_{succ\left({e}_{k}\right)}+\u03f5$. This makes the arc $(pred\left({e}_{k}\right),{e}_{k})$ uphill and the arc $({e}_{k},succ\left({e}_{k}\right))$ downhill.

#### Role of the Parameter $\u03f5$

## 4. Question Answering in Knowledge Graphs

#### 4.1. Problem Statement

#### 4.2. Method

**Parsing the Query**: In the first step, the user query is semantically parsed to extract the entities. The entities can be extracted using any state-of-the-art parsing or entity extraction techniques [28] such as natural language processing (NLP)-based named-entity recognition (NER) methods [29]. Different techniques such as rule-based [30], ontology-based methods [31], and learning-based methods [32] can be used for extracting the entities from a query. The choice of the named-entity extraction method for knowledge graphs largely depends on the domain and if the given dataset has a well-defined schema.In this work, we used a dictionary-based look-up method to match the entities [33]. First, the entities are extracted using the spaCy-based named-entity recognition (NER) [34]. Then, using the named-entity linking, we look for the closest matching entity in the knowledge base (KB). Alternatively, a custom lexical matcher can be used [35]. After extraction of the entities, the information from the metadata of the knowledge graph is used to map the entities to the corresponding nodes.For example, as shown in Figure 4a, in a knowledge graph based on a triple dataset, KG20C [36] for the query, “Which paper was published by Amanda at SIGIR conference?”, the entities extracted using spaCy are, (“paper”, “Amanda”, “SIGIR”, “conference”). The closest matching entities in KB are (“Amanda” and “SIGIR”). The metadata in KB has each entity’s attributes, entity ID, name, and type. We fetch the attributes for the candidate entities, “Amanda” and “SIGIR”. Here, the entity ID is the corresponding node number in the graph, (“Amanda”:3877) and (“SIGIR”:4097).We must also determine the origin and destination entities to construct the path. Most knowledge graph question-answering (KGQA) systems use semantic parsing to detect the occurrence and order of entities in the question [37]. In some KGQA systems, the entity extraction models are trained on a question-answer dataset to understand the query pattern [9]. More sophisticated methods use a predefined query template [38]. In this work, for simplicity, we have used the order of occurrence of entities to determine the origin and destination entities. In the case of multiple entities, we consider the first as the origin and the rest as multiple destinations, as shown in the query in Figure 4b. In this paper, we do not elaborate further on each method used in this step, as our work focuses on demonstrating the use of the APC in knowledge graphs.**Path construction using APC (or AWPC)**: In the second step, the triple dataset of a knowledge graph is modeled into a directed graph with nodes and edges. The nodes from step 1 can be denoted as the origin and destination nodes in the graph, and for instance, if the auction path construction algorithm (APC) is used to construct the path between them. The initial prices for all the nodes in E can be chosen arbitrarily or reused from previous searches. If the weighted version of the algorithm (AWPC) is used, then the edges in R should also be given initial edge weights to introduce a bias.The algorithm starts at the origin node. It follows the rules defined in Section 3.1.2 to navigate through the graph structure and update the path and node prices at each iteration. The algorithm terminates and returns to the final path once it reaches the single (or all) destination(s). The resulting path is essentially the set of final nodes with lower prices chosen by the algorithm while auctioning from the origin to the destination node.For the above query example, as shown in Figure 4a, the path given by APC is $[3877,6572,4097]$. This set of nodes in the final path can now be used to provide an explainable answer to the query.**Mapping attributes to build an interpretable answer**: In the final step, we use the attributes I for each entity in E, given as the metadata in knowledge graphs. These attributes can add semantic meaning to the path generated by APC. The edges are mapped to the corresponding relations, and the type and entity names are added from the attributes to construct the final answer.Referring to our example in Figure 4a, for the path, $[3877,6572,4097]$, the attributes for each node and relations for each edge in the path are mapped to construct the final answer as shown in below Figure 5. The prices learned by the algorithm in this search can be used as the starting prices for the following query.

#### 4.2.1. Prices as a “Learning Experience”

#### 4.2.2. Ability of APC to Adapt to an “Evolving KG”

#### 4.2.3. Edge Weights as per “Query Semantics”

## 5. Evaluation

#### 5.1. Dataset

#### 5.2. Experiments and Results

#### 5.2.1. Evaluation Protocol

**Prediction Accuracy**—Did the algorithm predict the answers the same or close to the ground truth?**Adaptability to Evolving Knowledge Graph**—Can the algorithm adapt dynamically when new entities and relations are added to the graph?**Explainable Reasoning Paths**—Does the algorithm give traceable and explainable reasoning paths? Can users make proper inferences from the answers provided by the system?**Computational Efficiency**—How many iterations (or steps) does the algorithm take to provide the final answer? The number of iterations is analogous to the algorithm’s run time complexity and can be used to show computational efficiency.**Support for Multihop Queries**—Can the algorithm answer the queries with multiple hops or longer paths?**Queries with Multiple Destinations**—Can the algorithm answer the questions with two or more parts combined? For example, a query such as, “Which paper author published in this conference and where does he work?” has two destinations.

#### 5.2.2. Experimental Setup

#### 5.2.3. Result Analysis

**Prediction Accuracy**: The resulting paths from each query matched the ground truth. The different node-prices and edge-weights settings given in Table 2 only affected the number of iterations taken by the algorithm to provide the final answer, to be discussed shortly.

**Adaptability to Evolving Knowledge Graph**: To test the algorithm’s adaptability to changing knowledge graphs, we conducted the following experiments.

- We started with a small subgraph of 12 entities from the KG20C dataset and ran around ten queries. The node prices were initially set to “0”. The prices were then reused for the subsequent queries. Similar experiments were conducted by initializing random prices and edge weights settings as described in Table 2.
- In the second simulation, 40 new entities were added to the knowledge graph. The prices of existing nodes were reused, and the newly added nodes were given arbitrary prices. In this step, 20 queries were run on a total of 52 nodes.
- In the third simulation, the remaining entities and relations were added, and 50 queries for each setting (as given in Table 2) were run on the large graph with $16K$ entities. The prices from previous searches were reused for existing nodes. The number of iterations increased slightly for a few queries but eventually decreased after the prices were reused in successive runs.

**Explainable Reasoning Paths**: Explainability refers to the ability of a system to explain the results and the reasoning process to the users, such that they can know the whys and hows of the decision-making process [44].

**Computational Efficiency**: Table 3 shows the number of iterations for a few sample queries from the KG20C dataset with different prices and edge weight (EW) settings, as discussed in experiments 6, 7, 8(a), and 8(b) in Table 2. We can see from the results that the number of iterations reduces significantly by reusing the prices for similar queries. It also shows the effect of bias introduced due to different values of edge weights in the cases where the edge weights were assigned as per the relations extracted from query semantics. The edges with strong matching relations were given “0” initial weights, the medium relations “3”, and the weak relations “6”. The first query with edge weight settings per query semantics had only 76 iterations, which is much fewer than the random weights. The number of iterations dropped to 2 and 3 in the second and the third queries on reusing the prices, respectively, which is a significant computational improvement.

**Support for Multihop Queries**: Most of the queries used in our experiments require multihop reasoning. For example, the query, “In which paper author Fredric cited the paper on Equations for PoS?” needs a multihop inference of the form, (Fredric, $author\_write\_paper$, ?), (?, $paper\_cite\_paper$, Equations for PoS). The APC is able to provide a full traceable path and support the queries with multihop reasoning.

**Queries with Multiple Destinations**: Figure 3b shows the example of a query with multiple destinations. Both the APC and AWPC algorithms support the queries with multiple destinations. They work the same as does a single destination, but a list of all the destinations is maintained and the algorithm continues to run until it has reached all the destinations. This is described in Section 3.1.3.

## 6. Discussion

## 7. Conclusions

## Author Contributions

## Funding

## Data Availability Statement

## Conflicts of Interest

## Abbreviations

KG | knowledge graph |

KGQA | knowledge graph question-answering system |

KB | knowledge base |

NER | named entity recognition |

NLP | natural language processing |

## References

- Kejriwal, M. Domain-Specific Knowledge Graph Construction; Springer: Berlin/Heidelberg, Germany, 2019. [Google Scholar]
- Hogan, A.; Blomqvist, E.; Cochez, M.; d’Amato, C.; Melo, G.D.; Gutierrez, C.; Kirrane, S.; Gayo, J.E.L.; Navigli, R.; Neumaier, S.; et al. Knowledge graphs. ACM Comput. Surv. CSUR
**2021**, 54, 1–37. [Google Scholar] - Chen, Z.; Wang, Y.; Zhao, B.; Cheng, J.; Zhao, X.; Duan, Z. Knowledge graph completion: A review. IEEE Access
**2020**, 8, 192435–192456. [Google Scholar] [CrossRef] - Saxena, A.; Tripathi, A.; Talukdar, P. Improving multi-hop question answering over knowledge graphs using knowledge base embeddings. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, Online, 5–10 July 2020; pp. 4498–4507. [Google Scholar]
- Geng, S.; Fu, Z.; Tan, J.; Ge, Y.; De Melo, G.; Zhang, Y. Path Language Modeling over Knowledge Graphsfor Explainable Recommendation. In Proceedings of the ACM Web Conference 2022, Lyon, France, 25–29 April 2022; pp. 946–955. [Google Scholar]
- Rossi, A.; Barbosa, D.; Firmani, D.; Matinata, A.; Merialdo, P. Knowledge graph embedding for link prediction: A comparative analysis. ACM Trans. Knowl. Discov. Data TKDD
**2021**, 15, 1–49. [Google Scholar] [CrossRef] - Lao, N.; Mitchell, T.; Cohen, W. Random walk inference and learning in a large scale knowledge base. In Proceedings of the 2011 Conference on Empirical Methods in Natural Language Processing, Edinburgh, UK, 27–31 July 2011; pp. 529–539. [Google Scholar]
- Xiong, W.; Hoang, T.; Wang, W.Y. Deeppath: A reinforcement learning method for knowledge graph reasoning. arXiv
**2017**, arXiv:1707.06690. [Google Scholar] - Lan, Y.; He, G.; Jiang, J.; Jiang, J.; Zhao, W.X.; Wen, J.R. Complex knowledge base question answering: A survey. IEEE Trans. Knowl. Data Eng.
**2022**. [Google Scholar] [CrossRef] - Bhowmik, R.; Melo, G.D. Explainable link prediction for emerging entities in knowledge graphs. In Proceedings of the International Semantic Web Conference, Athens, Greece, 2–6 November 2020; Springer: Berlin/Heidelberg, Germany, 2020; pp. 39–55. [Google Scholar]
- Bertsekas, D.P. New Auction Algorithms for Path Planning, Network Transport, and Reinforcement Learning. arXiv
**2022**, arXiv:2207.09588. [Google Scholar] - Nguyen, D.Q. An overview of embedding models of entities and relationships for knowledge base completion. arXiv
**2017**, arXiv:1703.08098. [Google Scholar] - Palmonari, M.; Minervini, P. Knowledge graph embeddings and explainable AI. Knowl. Graphs Explain. Artif. Intell. Found. Appl. Chall.
**2020**, 47, 49. [Google Scholar] - Bao, J.; Duan, N.; Yan, Z.; Zhou, M.; Zhao, T. Constraint-based question answering with knowledge graph. In Proceedings of the COLING 2016, the 26th International Conference on Computational Linguistics: Technical Papers, Osaka, Japan, 11–16 December 2016; pp. 2503–2514. [Google Scholar]
- Ren, H.; Dai, H.; Dai, B.; Chen, X.; Yasunaga, M.; Sun, H.; Schuurmans, D.; Leskovec, J.; Zhou, D. Lego: Latent execution-guided reasoning for multi-hop question answering on knowledge graphs. In Proceedings of the International Conference on Machine Learning, PMLR, Virtual, 18–24 July 2021; pp. 8959–8970. [Google Scholar]
- Das, R.; Dhuliawala, S.; Zaheer, M.; Vilnis, L.; Durugkar, I.; Krishnamurthy, A.; Smola, A.; McCallum, A. Go for a walk and arrive at the answer: Reasoning over paths in knowledge bases using reinforcement learning. arXiv
**2017**, arXiv:1711.05851. [Google Scholar] - Fu, Z.; Xian, Y.; Gao, R.; Zhao, J.; Huang, Q.; Ge, Y.; Xu, S.; Geng, S.; Shah, C.; Zhang, Y.; et al. Fairness-aware explainable recommendation over knowledge graphs. In Proceedings of the 43rd International ACM SIGIR Conference on Research and Development in Information Retrieval, Virtual, 25–30 July 2020; pp. 69–78. [Google Scholar]
- Bertsekas, D.P. A Distributed Algorithm for the Assignment Problem; Lab. for Information and Decision Systems Working Paper; MIT: Cambridge, MA, USA, 1979. [Google Scholar]
- Bertsekas, D.P. Auction algorithms for network flow problems: A tutorial introduction. Comput. Optim. Appl.
**1992**, 1, 7–66. [Google Scholar] [CrossRef] - Bertsekas, D. Network Optimization: Continuous and Discrete Models; Athena Scientific: Nashua, NH, USA, 1998; Volume 8. [Google Scholar]
- Dieci, L.; Walsh, J.D., III. The boundary method for semi-discrete optimal transport partitions and Wasserstein distance computation. J. Comput. Appl. Math.
**2019**, 353, 318–344. [Google Scholar] [CrossRef] - Merigot, Q.; Thibert, B. Optimal transport: Discretization and algorithms. In Handbook of Numerical Analysis; Elsevier: Amsterdam, The Netherlands, 2021; Volume 22, pp. 133–212. [Google Scholar]
- Peyré, G.; Cuturi, M. Computational optimal transport: With applications to data science. Found. Trends Mach. Learn.
**2019**, 11, 355–607. [Google Scholar] [CrossRef] - Lewis, M.; Bhosale, S.; Dettmers, T.; Goyal, N.; Zettlemoyer, L. Base layers: Simplifying training of large, sparse models. In Proceedings of the International Conference on Machine Learning, PMLR, Virtual, 18–24 July 2021; pp. 6265–6274. [Google Scholar]
- Bicciato, A.; Torsello, A. GAMS: Graph Augmentation with Module Swapping. In Proceedings of the ICPRAM, Virtual, 3–5 February 2022; pp. 249–255. [Google Scholar]
- Clark, A.; de Las Casas, D.; Guy, A.; Mensch, A.; Paganini, M.; Hoffmann, J.; Damoc, B.; Hechtman, B.; Cai, T.; Borgeaud, S.; et al. Unified scaling laws for routed language models. In Proceedings of the International Conference on Machine Learning, PMLR, Baltimore, MD, USA, 17–23 July 2022; pp. 4057–4086. [Google Scholar]
- Bertsekas, D.P. An auction algorithm for shortest paths. SIAM J. Optim.
**1991**, 1, 425–447. [Google Scholar] [CrossRef] - Goyal, A.; Gupta, V.; Kumar, M. Recent named entity recognition and classification techniques: A systematic review. Comput. Sci. Rev.
**2018**, 29, 21–43. [Google Scholar] [CrossRef] - Grishman, R.; Sundheim, B.M. Message understanding conference-6: A brief history. In Proceedings of the COLING 1996 Volume 1: The 16th International Conference on Computational Linguistics, Copenhagen, Denmark, 5–9 August 1996. [Google Scholar]
- Chiticariu, L.; Krishnamurthy, R.; Li, Y.; Reiss, F.; Vaithyanathan, S. Domain adaptation of rule-based annotators for named-entity recognition tasks. In Proceedings of the 2010 Conference on Empirical Methods in Natural Language Processing, Online, 9–11 October 2010; pp. 1002–1012. [Google Scholar]
- Karkaletsis, V.; Fragkou, P.; Petasis, G.; Iosif, E. Ontology based information extraction from text. In Knowledge-Driven Multimedia Information Extraction and Ontology Evolution: Bridging the Semantic Gap; Springer: Berlin/Heidelberg, Germany, 2011; pp. 89–109. [Google Scholar]
- Al-Moslmi, T.; Ocaña, M.G.; Opdahl, A.L.; Veres, C. Named entity extraction for knowledge graphs: A literature overview. IEEE Access
**2020**, 8, 32862–32881. [Google Scholar] [CrossRef] - Nadeau, D.; Sekine, S. A survey of named entity recognition and classification. Lingvisticae Investig.
**2007**, 30, 3–26. [Google Scholar] [CrossRef] - Vasiliev, Y. Natural Language Processing with Python and spaCy: A Practical Introduction; No Starch Press: San Francisco, CA, USA, 2020. [Google Scholar]
- Srihari, R.K.; Li, W.; Cornell, T.; Niu, C. Infoxtract: A customizable intermediate level information extraction engine. Nat. Lang. Eng.
**2008**, 14, 33–69. [Google Scholar] [CrossRef] - Tran, H.N.; Takasu, A. Exploring scholarly data by semantic query on knowledge graph embedding space. In International Conference on Theory and Practice of Digital Libraries; Springer: Berlin/Heidelberg, Germany, 2019; pp. 154–162. [Google Scholar]
- Yih, S.W.t.; Chang, M.W.; He, X.; Gao, J. Semantic parsing via staged query graph generation: Question answering with knowledge base. In Proceedings of the Joint Conference of the 53rd Annual Meeting of the ACL and the 7th International Joint Conference on Natural Language Processing of the AFNLP, Beijing, China, 26–31 July 2015. [Google Scholar]
- Bast, H.; Haussmann, E. More accurate question answering on freebase. In Proceedings of the 24th ACM International on Conference on Information and Knowledge Management, Melbourne, Australia, 18–23 October 2015; pp. 1431–1440. [Google Scholar]
- Mahdisoltani, F.; Biega, J.; Suchanek, F. YAGO3: A knowledge base from multilingual wikipedias. In Proceedings of the 7th Biennial Conference on Innovative Data Systems Research, CIDR Conference, Asilomar, CA, USA, 13–16 January 2014. [Google Scholar]
- Sinha, A.; Shen, Z.; Song, Y.; Ma, H.; Eide, D.; Hsu, B.J.; Wang, K. An overview of microsoft academic service (mas) and applications. In Proceedings of the 24th International Conference on World Wide Web, Florence, Italy, 18–22 May 2015; pp. 243–246. [Google Scholar]
- Tran, H.N.; Takasu, A. Multi-Partition Embedding Interaction with Block Term Format for Knowledge Graph Completion. arXiv
**2020**, arXiv:2006.16365. [Google Scholar] - Tran, H.N.; Takasu, A. MEIM: Multi-partition Embedding Interaction beyond Block Term Format for Efficient and Expressive Link Prediction. arXiv
**2022**, arXiv:2209.15597. [Google Scholar] - Suchanek, F.M.; Kasneci, G.; Weikum, G. Yago: A core of semantic knowledge. In Proceedings of the 16th International Conference on World Wide Web, Banff, AB, Canada, 8–12 May 2007; pp. 697–706. [Google Scholar]
- Hoffman, R.R.; Mueller, S.T.; Klein, G.; Litman, J. Metrics for explainable AI: Challenges and prospects. arXiv
**2018**, arXiv:1812.04608. [Google Scholar] - Agrawal, G. Auction Path Construction Algorithms in Knowledge Graphs. 2023. Available online: https://github.com/garima0106/KG-Auction.git (accessed on 12 June 2023).

**Figure 1.**Figure showing the price update and raising the price to the maximum possible level. In case of extension, the algorithm maintains the maximum possible level ${p}_{{e}_{k}}={p}_{pred\left({e}_{k}\right)}$ making the predecessor arc $(pred\left({e}_{k}\right),{e}_{k})$ level. In the case of a contraction, it raises the price of ${e}_{k}$ to the maximum possible level, making the arc $(pred\left({e}_{k}\right),{e}_{k})$ uphill.

**Figure 2.**The figure shows the APC traversal on a five-node graph. The initial prices are arbitrarily chosen as $(0,3,0,0,0)$. The origin node is given as $\left(1\right)$, with three destination nodes $(2,4,5)$. The algorithm chooses to extend or contract and update the price as per the given rules. The prices after the update in each iteration are shown against each node in the figure.

**Figure 3.**The figure shows the AWPC traversal on a four-node graph. The initial prices are arbitrarily chosen as $(0,0,0,0)$ and edge weights as $(1,2,4,2.5)$ (

**a**). The origin node is given as $\left(s\right)$, with the destination node as $\left(t\right)$. The algorithm chooses to extend or contract and update the price per the given rules. The path chosen by AWPC for $\u03f5<3$ is shown in (

**b**).

**Figure 4.**The figure illustrates the step-wise method to answer queries. (

**a**) The single destination query and (

**b**) the query with two parts, i.e., multiple destinations.

**Figure 5.**The figure illustrates the mapping of path nodes to entity attributes and edge relations to build an explainable answer.

Author | Paper | Conference | Domain | Affiliation | Entities | Relations | Edges |
---|---|---|---|---|---|---|---|

8680 | 5047 | 20 | 1923 | 692 | 16,362 | 5 | 55,607 |

Algo | S.No. | Settings | Observations |
---|---|---|---|

APC | 1 | Initial Price as $\u201c0\u201d$ | Algorithm was relatively stable, and the resulting paths matched the ground truth. |

2 | Reusing Prices from (1) | Number of iterations reduced by $60\%$. Resulting paths were the same as those in (1). | |

3 | Random Prices and Stress Testing | Random prices given between 100 and 1000. Higher iterations. Most Paths were the same and gave longer paths for some queries. | |

4 | Reusing Prices from (3) | Relatively stable. Iterations in (4) much fewer than those in (3) but higher or the same as those in (2). | |

AWPC | 5 | Edge Weights as $\u201c0\u201d$ | $\u201c0\u201d$ edge weights results should match the first four settings using APC; validation step. |

6 | Edge Weights as $\u201c1\u201d$ | Same paths; greater or equal number of iterations as in (2). | |

7 | Random Weights | Unstable with random weights between −10 and 10. Iterations increased by almost two times, with not much change in the paths. | |

8(a) | Weights as per “Query Semantics” (S:0,W:1) | Edges with strong match in query given $\u201c0\u201d$ weights and the remaining edges (weak) given “1”; no significant change in iterations. | |

8(b) | (S:0,M:3,W:6) Prices Reused from an Initial Price of “0” | Paths were same or shorter, and iterations were fewer or the same as in (2). |

Query | Price | EW = 1 | EW = [−10, 10] | EW(S:0,W:1) | EW(S:0,M:3,W:6) |
---|---|---|---|---|---|

In which paper did Hang-Li cite paper on “Equations for PoS”? | Initial price = 0 | 353 | 630 | 347 | 76 |

In which paper author Fredric cited the paper on “Equations for PoS”? | Reusing prices | 2 | 32 | 2 | 2 |

Which paper in “Clustering query” cites work on “Equations for PoS”? | Reusing prices | 3 | 13 | 3 | 3 |

Model | Prediction | Multihop Queries | Explainability | Training |
---|---|---|---|---|

Embedding(MEI) | Hits@10 < 70% | Not supported | Candidate entity score | Offline |

APC | Matches ground truth | Supported | Gives full path | Both offline and online |

Criteria | APC | Dijkstra |
---|---|---|

Q1: “If Amanda has worked in cluster analysis domain?” | Path = [3877, 6572, 7780, 1119] | Path = [3877, 6572, 7780, 1119] |

Q2: “If Mehryar Mohri has paper in COLT conference?” | Path = [12,953, 4459, 7868, 4117] suboptimal path | Path = [12,953, 4459, 4117], gives the shortest path |

Explainability | Yes | Yes |

Learn from Past Query | Yes | No |

Computational Efficiency | More efficient for large scale graph | Computationally expensive for large scale |

Adaptability to change | Dynamically evolves | Takes static snapshot of graph |

Model Training | Both online and offline | Offline only |

Evaluation Criteria | APC (and AWPC) |
---|---|

Prediction Accuracy | Resulting paths match the ground truth |

Evolving Knowledge Graph with Emerging Entities | Dynamically adapts to newly added entities |

Explainable Reasoning and Interpretability | Returns traceable paths |

Computational Efficiency | Reduced iterations on reusing node price |

Multihop Queries | Supported |

Queries with Multiple Destinations | Supported |

Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |

© 2023 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Agrawal, G.; Bertsekas, D.; Liu, H.
Auction-Based Learning for Question Answering over Knowledge Graphs. *Information* **2023**, *14*, 336.
https://doi.org/10.3390/info14060336

**AMA Style**

Agrawal G, Bertsekas D, Liu H.
Auction-Based Learning for Question Answering over Knowledge Graphs. *Information*. 2023; 14(6):336.
https://doi.org/10.3390/info14060336

**Chicago/Turabian Style**

Agrawal, Garima, Dimitri Bertsekas, and Huan Liu.
2023. "Auction-Based Learning for Question Answering over Knowledge Graphs" *Information* 14, no. 6: 336.
https://doi.org/10.3390/info14060336