| JenTab | MTab | Mantis V |
| KG Lookup | ElasticSearch on top of KG SPARQL Queries | WikiGraph Generation Ad-hoc API | LamAPI(ElasticSearch, Mongo and Python) |
| Preprocessing | Fix encoding | Y | Y | $\mathrm{N}$ |
| Special characters | Y | N | Y |
| Restore missing spaces | Y | $\mathrm{N}$ | Y |
| Remove HTML tags | $\mathrm{N}$ | Y | $\mathrm{N}$ |
| Remove non-cell-values | $\mathrm{N}$ | Y | $\mathrm{N}$ |
| Datatype | REGEX Type-based cleaning | Cell values identification (literal, entity) SpaCy models for potential types Majority vote to define column type | REGEX for datatypes exceeding a threshold Entity columns that do not exceed the threshold |
| CEA | CREATE | Different query rewriting techniques | Keword search (BM25) Fuzzy search (Levenshtein distance) | LamAPI lookup with IB similarity |
| FILTER | Levenshtein distance (among others) | Filter and hashing (Symetric Delete) Context similarities by row | Levenshtein confidence score for entities Literals XXX |
| SELECT | Levenshtein distance | Highest context similarity | xxxx |
| CTA | CREATE | Types from CEA | Types from CEA | Types from CEA |
| FILTER | Remove the less popular types | - | - |
| SELECT | Maiority vote | Majority vote | Majority vote |
| CPA | CREATE | Cell annotations (CEA) and fuzzy match for data properties | Aggregate all properties from CEA by row | Properties from CEA lookups |
| FILTER | - | - | - |
| SELECT | Majority vote | Majority vote | Majority vote |
+
+## 4. Challenges for a declarative automation of KG Construction
+
+We identify a set of challenges that need to be addressed to declaratively describe solutions for automatic KG construction. These challenges can be divided into two main categories: technical challenges and conceptual challenges.
+
+On the technical side, there is a major difference between the solutions for the automation of KG construction and the execution of declarative KG construction solutions: The solutions for automatic KG construction rely on iterative processes that continuously refine and improves a task, while the different tasks influence each other. To the contrary, the declarative KG construction is a linear process that is executed only once. Not all declarative rules are executed linearly, solutions that restructure [6] or parallelize them [22, 23] are increasingly encountered. Thus, if the solutions for automatic KG construction are declaratively described, their iterative execution needs to be described as well. How do we do that with the mapping languages?
+
+Besides the overall execution process, the iteration patterns are different. The solutions for automatic KG construction are applied to all directions, both per column and per row, and even combined. To the contrary, the declarative solutions are applied only per row, and the mapping languages are designed under this assumption. Should the mapping languages be extended to support more iteration patterns? If so, would the rml:iteration for RML and the relevant constructs in the other mapping languages be sufficient or more adjustments are required?
+
+The solutions for automatic KG construction rely on interrelated tasks which may produce intermediate representations, and their results impact the rest of tasks. Thus, the declarative KG construction solutions need to deal with dynamic and recursive steps (e.g., intermediate representation of the input data sources and mapping rules, multiple function execution, etc.) that can negatively impact the generation process. Hence, declaratively describing is a challenge. Should the mapping languages be further extended then?
+
+On the conceptual side, there are two main differences with respect to the training and target KG. In most real projects that declarative solutions tackle, the input data and sometimes the target ontology are only provided, but there is neither similar data to train the solutions nor existing KGs that can be used to find entities or to predict the relationships. While relying on ontology matching techniques between existing KGs (e.g., DBPedia, Wikidata) and the target ontology or exploiting NLP approaches between ontology and input sources documentation could be a solution for the latter, would it be realistic given that most ontologies are not aligned and not all of them provide documentation?
+
+## 5. Conclusions and Future Work
+
+In this paper, we analyze the KG construction solutions and compare the automatic with the declarative. While the tasks can be aligned with respect to what they achieve, their execution is fundamentally different and a direct alignment is not feasible.
+
+Automatic solutions for KG construction are required to facilitate the adoption of KGs, but there are also merits when the automation tasks are declaratively described, with respect to maintenability, sustainability, and reproducibility. However, directly aligning the automatic solutions with the declarative solutions might be technically and conceptually challenging considering their different execution and iteration patterns. Extending the existing mapping languages would be a solution, but it would also require to address the identified challenges and not only. Would such extensions be feasible and desired or would they lead them beyond their purpose? Although, mapping languages are not the only approach to have declarative descriptions. Declarative descriptions of workflows emerge as well. Would that be a more viable solution? If so, would the automatic and declarative solutions keep on growing in different directions? These are questions that would be nice to reflect and discuss during the workshop.
+
+## References
+
+[1] A. Dimou, M. Vander Sande, P. Colpaert, R. Verborgh, E. Mannens, R. Van de Walle, RML: a generic language for integrated RDF mappings of heterogeneous data, in: Ldow, 2014.
+
+[2] C. Debruyne, D. O'Sullivan, R2RML-F: towards sharing and executing domain logic in R2RML mappings, in: LDOW@ WWW, 2016.
+
+[3] M. Lefrançois, A. Zimmermann, N. Bakerally, A SPARQL extension for generating RDF from heterogeneous formats, in: European Semantic Web Conference, Springer, 2017, pp. 35-50.
+
+[4] E. Daga, L. Asprino, P. Mulholland, A. Gangemi, Facade-X: an opinionated approach to SPARQL anything, Studies on the Semantic Web 53 (2021) 58-73.
+
+[5] E. Iglesias, S. Jozashoori, D. Chaves-Fraga, D. Collarana, M.-E. Vidal, SDM-RDFizer: An RML Interpreter for the Efficient Creation of RDF Knowledge Graphs, in: Proceedings of the 29th ACM International Conference on Information & Knowledge Management, 2020, pp. 3039-3046.
+
+[6] S. Jozashoori, D. Chaves-Fraga, E. Iglesias, M.-E. Vidal, O. Corcho, Funmap: Efficient
+
+execution of functional mappings for knowledge graph creation, in: International Semantic Web Conference, Springer, 2020, pp. 276-293.
+
+[7] L. F. d. Medeiros, F. Priyatna, O. Corcho, MIRROR: Automatic R2RML mapping generation from relational databases, in: International Conference on Web Engineering, Springer, 2015, pp. 326-343.
+
+[8] C. Bizer, A. Seaborne, D2RQ-treating non-RDF databases as virtual RDF graphs, in: Proceedings of the 3rd international semantic web conference (ISWC2004), volume 2004, Springer Hiroshima, 2004.
+
+[9] D. Calvanese, B. Cogrel, S. Komla-Ebri, R. Kontchakov, D. Lanti, M. Rezk, M. Rodriguez-Muro, G. Xiao, Ontop: Answering SPARQL queries over relational databases, Semantic Web 8 (2017) 471-487.
+
+[10] Á. Sicilia, G. Nemirovski, AutoMap4OBDA: Automated generation of R2RML mappings for OBDA, in: European Knowledge Acquisition Workshop, Springer, 2016, pp. 577-592.
+
+[11] E. Jiménez-Ruiz, E. Kharlamov, D. Zheleznyakov, I. Horrocks, C. Pinkel, M. G. Skjæveland, E. Thorstensen, J. Mora, Bootox: Bootstrapping OWL 2 ontologies and R2RML mappings from relational databases, in: International Semantic Web Conference (P&D), 2015.
+
+[12] E. Jiménez-Ruiz, O. Hassanzadeh, V. Efthymiou, J. Chen, K. Srinivas, Semtab 2019: Resources to benchmark tabular data to knowledge graph matching systems, in: European Semantic Web Conference, Springer, 2020, pp. 514-530.
+
+[13] P. Nguyen, I. Yamada, N. Kertkeidkachorn, R. Ichise, H. Takeda, SemTab 2021: Tabular Data Annotation with MTab Tool, SemTab@ ISWC (2021) 92-101.
+
+[14] N. Abdelmageed, S. Schindler, JenTab Meets SemTab 2021's New Challenges, in: SemTab@ ISWC, 2021, pp. 42-53.
+
+[15] V.-P. Huynh, J. Liu, Y. Chabot, F. Deuzé, T. Labbé, P. Monnin, R. Troncy, DAGOBAH: Table and Graph Contexts For Efficient Semantic Annotation Of Tabular Data, in: SemTab@ ISWC, 2021, pp. 19-31.
+
+[16] B. De Meester, T. Seymoens, A. Dimou, R. Verborgh, Implementation-independent function reuse, Future Generation Computer Systems 110 (2020) 946-959.
+
+[17] R. Avogadro, M. Cremaschi, MantisTable V: a novel and efficient approach to Semantic Table Interpretation, SemTab@ ISWC (2021) 79-91.
+
+[18] M. Cremaschi, F. De Paoli, A. Rula, B. Spahiu, A fully automated approach to a complete semantic table interpretation, Future Generation Computer Systems 112 (2020) 478-500.
+
+[19] W. E. Winkler, String comparator metrics and enhanced decision rules in the Fellegi-Sunter model of record linkage (1990).
+
+[20] S. Jozashoori, A. Sakor, E. Iglesias, M.-E. Vidal, EABlock: A Declarative Entity Alignment Block for Knowledge Graph Creation Pipelines, in: Proceedings of the 37th ACM/SIGAPP Symposium On Applied Computing, 2022.
+
+[21] V. I. Levenshtein, et al., Binary codes capable of correcting deletions, insertions, and reversals, in: Soviet physics doklady, volume 10, Soviet Union, 1966, pp. 707-710.
+
+[22] G. Haesendonck, W. Maroy, P. Heyvaert, R. Verborgh, A. Dimou, Parallel RDF generation from heterogeneous big data, in: Proceedings of the International Workshop on Semantic Big Data, 2019, pp. 1-6.
+
+[23] J. Arenas-Guerrero, D. Chaves-Fraga, J. Toledo, M. S. Pérez, O. Corcho, Morph-kgc: Scalable knowledge graph materialization with mapping partitions, Semantic Web (2022).
\ No newline at end of file
diff --git a/papers/KGCW/KGCW 2022/KGCW 2022 Workshop/HlbgMu-HqZq/Initial_manuscript_tex/Initial_manuscript.tex b/papers/KGCW/KGCW 2022/KGCW 2022 Workshop/HlbgMu-HqZq/Initial_manuscript_tex/Initial_manuscript.tex
new file mode 100644
index 0000000000000000000000000000000000000000..bf423c70fc9cb083984d53cc2902d9bec52e3bf8
--- /dev/null
+++ b/papers/KGCW/KGCW 2022/KGCW 2022 Workshop/HlbgMu-HqZq/Initial_manuscript_tex/Initial_manuscript.tex
@@ -0,0 +1,181 @@
+§ DECLARATIVE DESCRIPTION OF KNOWLEDGE GRAPHS CONSTRUCTION AUTOMATION: STATUS & CHALLENGES
+
+David Chaves-Fraga ${}^{1,2}$ , Anastasia Dimou ${}^{1}$
+
+${}^{1}$ KU Leuven, Department of Computer Science, Sint-Katelijne-Waver, Belgium
+
+${}^{2}$ Universidad Politécnica de Madrid, Campus de Montegancedo, Boadilla del Monte, Spain
+
+§ ABSTRACT
+
+Nowadays, Knowledge Graphs (KG) are among the most powerful mechanisms to represent knowledge and integrate data from multiple domains. However, most of the available data sources are still described in heterogeneous data structures, schemes, and formats. The conversion of these sources into the desirable KG requires manual and time-consuming tasks, such as programming translation scripts, defining declarative mapping rules, etc. In this vision paper, we analyze the trends regarding the automation of KG construction but also the use of mapping languages for the same process, and align the two by analyzing their tasks and a few exemplary tools. Our aim is not to have a complete study but to investigate if there is potential in this direction and, if so, to discuss what challenges we need to address to guarantee the maintainability, explainability, and reproducibility of the KG construction.
+
+§ KEYWORDS
+
+Knowledge Graphs, Automation, Explainable AI, Declarative Rules
+
+§ 1. INTRODUCTION
+
+A lot of works on knowledge graph (KG) construction are focused on defining mapping languages to declaratively describe the transformation process, and on optimizing the execution of such declarative rules. The mapping languages rely on either dedicated syntaxes, such as the family of languages around the W3C recommended R2RML ${}^{1}$ (e.g., RML [1] or R2RML-F [2]), or on re-purposing existing specifications, such as query languages like the W3C recommended SPARQL ${}^{2}$ (e.g., SPARQL-Generate [3] or SPARQL-Anything [4]), or constraints languages like ShEx ${}^{3}$ (e.g., ShExML [5,6]).
+
+Despite the plethora of mapping languages and the increasing number of optimizations for the execution of the declarative rules, these rules are still defined through a manual and time-consuming process, affecting negatively their adoption. Different solutions were proposed to automate the definition of mapping rules that describe how a KG should be constructed. On the one hand, MIRROR [7], D2RQ [8] and Ontop [9] follow a similar approach, extracting from the RDB schema a target ontology and the mapping correspondences. On the other hand, AutoMap4OBDA [10] and BootOX [11] consider an input ontology and generate actual R2RML mappings from the RDB. However, these solutions are focused on declarative solutions only for relational databases, while recent solutions investigate non-declarative automation of KG construction.
+
+KGCW'22: International Workshop on Knolwedge Graph Construction, May 30, 2021, Creete, GRE
+
+(C) david.chaves@upm.es (D. Chaves-Fraga); anastasia.dimou@kuleuven.be (A. Dimou)
+
+© 0000-0003-3236-2789 (D. Chaves-Fraga); 0000-0003-2138-7972 (A. Dimou)
+
+(C) ${}_{67}$ (C) C) 2022 Copyright for this paper by its authors. Use permitted under Creative Commons License Attribution 4.0 International (CC BY 4.0).
+
+CEUR Workshop Proceedings (CEUR-WS.org)
+
+${}^{1}$ http://www.w3.org/TR/r2rml/
+
+${}^{2}$ https://www.w3.org/TR/sparql11-overview/
+
+${}^{3}$ https://shex.io/
+
+Beyond relational databases, the recent SemTab challenge ${}^{4}$ present a set of tabular datasets [12] with the aim of matching them automatically to external KGs, such as DBpedia and Wikidata. The proposed solutions $\left\lbrack {{13},{14},{15}}\right\rbrack$ address the problem using different techniques, such as heuristic rules, fuzzy searching over the KGs, or knowledge graph embeddings. Although their final objective is the same (obtain high precision and recall results) and they perform similar procedures, each solution implements its own workflow and addresses each proposed task by SemTab in different ways. Hence, making a fair and fine-grained comparison among the different solutions to understand how they obtain the actual results is not an easy task.
+
+In this vision paper, we align the tasks followed by solutions for the automation of the semantic table annotation with concepts of existing declarative solutions. We indicatively select and analyze a few tools for the automation of KG construction and identify common steps. We discuss if they can be declaratively described relying on existing mapping languages, and what the challenges are to proceed in this direction. We consider the RDF Mapping Language (RML) [1] as a high-level and general representation to describe the schema transformations and its extension, the Function Ontology (FnO) [16] to describe the data transformations.
+
+Our objective is not to present a complete study, but to investigate if there is potential in this direction. By describing the steps followed by different solutions in a more fine-grained and standard manner, we make the steps comparable, and we can better discuss what challenges we need to address to guarantee the maintainability, explainability and reproducibility of the KG construction, as well as to ensure the provenance of each performed task.
+
+§ 2. TASK ALIGNMENT WITH MAPPING LANGUAGES
+
+We analyze the different steps of the SemTab challenge, inspect the relation between the SemTab challenge tasks and align them with concepts from the declarative construction of RDF graphs (Figure 1). To achieve this, we include the relationship between each of the tasks and their potential declarations within a mapping language. We considered the RML mapping language because it is commonly used and the authors are more familiar with, but we are confident that the other mapping languages could express the same concepts. Before we proceed with the alignment, we give a small introduction on the SemTab challenge and RML:
+
+SemTab challenge The SemTab challenge consists of three tasks: (i) cell to KG entity matching (CEA), which matches cells to individuals; (ii) column to KG class matching (CTA), which matches cells to classes; and (iii) column pair to KG property matching (CPA), which captures the relationships between pairs of columns.
+
+RML The RDF mapping language (RML), a superset of the W3C recommended R2RML, expresses schema transformations from heterogeneous data to RDF. An RML mapping contains one or more Triple Maps which on their own turn contain a Subject Map to generate the subjects of the RDF triples, and zero or more Predicate Object Maps with pairs of Predicate and Object Maps to generate the predicates and the objects respectively for each incoming data record. RML was aligned with the Function Ontology (FnO) [16] to describe the data transformations which are required to construct the desired RDF graph, ensuring that the functions are independent from any implementation.
+
+${}^{4}$ https://www.cs.ox.ac.uk/isg/challenges/sem-tab/
+
+ < g r a p h i c s >
+
+Figure 1: Automation tasks alignment within declarative mapping language. Example extracted from SemTab 2021 challenge, where the CEA, CTA and CPA tasks are aligned with a declarative construction of a knowledge graph using the RML mapping language (YARRRML serialisation).
+
+We analyze how the different tasks of the challenge contribute in constructing a part of an RDF triple, and we align these tasks with the corresponding concepts of the RML mapping language that construct the same part of an RDF triple.
+
+Cell-Entity Annotation (CEA): This task identifies the URI of an entity from a cell. In the target RDF graph, this is the subject or the object of the RDF triple. In Fig. 1, the Co10 values are used to obtain the subjects of the triples while the Co13 values generate the objects (both green colored in the RDF extract of Fig. 1). If a declarative approach is considered to generate these triples, for example in RML, the rr: subjectMap property is used (line 5 of RML doc in Fig. 1), which declares how the subjects of the triples are generated and the rr: object Map (line 8 of RML doc in Fig. 1), when the expected objects are in the form of URIs.
+
+Column-Type Annotation (CTA): This task predicts the common class of a set of items given a column from the table. SemTab assumes that a table only generates one kind of entity (i.e. the first column is used for CTA). In Figure 1, we can observe that the URIs retrieved using Co10 are considered for obtaining the corresponding shared concept (i.e., restaurant) (red colored in the RDF extract of Fig. 1). Declaring the class in RML can be done through the shortcut rr: class property within the rr: SubjectMap (line 7 of RML doc in Fig. 1) or using a rr:predicateObjectMap with a rdf:type fixed predicate.
+
+Columns-Property Annotation (CPA): This task aims to predict the property that relates the CTA column (subjects) to the rest of the columns. Fig. 1 shows a CPA task that relates the Co10 with the Co13 through the property architectural style (wdt : P149, yellow colored in the RDF extract). In RML, the predicates of the triples are declared using the rr: predicateMap property (line 8 of RML doc in Fig. 1), and unlike typical mapping rules, where it is usually assumed that predicates are constants (as they are declared in the input ontology), the predicates depend on the data, hence they are dynamically defined.
+
+Based on the aforementioned analysis, we conclude that the tasks performed to automate the KG construction can be aligned with concepts from declarative mapping languages. The CEA task is aligned with the RDF term construction for the subject or the object of the RDF triple, the CTA task assigns the class and the CPA task aligns with the Predicate and Object Map.
+
+§ 3. COMPARING SEMANTIC TABULAR MATCHING SYSTEMS
+
+In this section, we analyze in detail the steps performed by some of the tools proposed for solving the SemTab challenge. The comparative analysis among the three selected engines (summarized in Table 1), is not meant to be exhaustive. We aim to identify if there are common steps and functions that the engines perform to accomplish the challenge's tasks and ultimately if it is possible and desired to declaratively describe them with mapping languages.
+
+§ 3.1. SELECTED SYSTEMS
+
+We indicatively selected the systems that: (i) obtained good results in the SemTab 2021 challenge ${}^{5}$ ; and (ii) have the source code openly available. Therefore, we included in this comparison JenTab [14], MTab [13] and MantisTable V [17]. The use of different terminologies for describing similar tasks (e.g., majority vote in Mantis V is referred as frequency) and the complexity of the proposed workflows, where the results from one of the task influence the others in a iterative way, create difficulties to compare the approaches and reproduce their results.
+
+JenTab ${}^{6}$ participated in SemTab 2020 and 2021, and it was always positioned among the top five solutions for most rounds. It follows a heuristic-based approach proposing the CFS (Create, Filter, Select) approach for all tasks and with different configurations and workflows.
+
+${\mathbf{{MTab}}}^{7}$ participated in all SemTab editions, winning the first prize in 2019 and 2020. Apart from the support of multilingual datasets, MTab implements several approaches for performing the entity search (i.e., CEA): keyword search, fuzzy search, and aggregation search ${}^{8}$ .
+
+MantisTable ${\mathrm{V}}^{9}$ is an extended and improved version of MantisTable [18]. Similarly to JenTab, MantisTable has also participated in SemTab 2020 and 2021 editions. It implements a set of heuristic rules (similar as JenTab) and complex string similarity functions for the entity recognition task (like MTab). Additionally, it provides a general and efficient tool (LamAPI) to fetch the necessary data for all SemTab tasks, independently of the target KG.
+
+${}^{5}$ https://www.cs.ox.ac.uk/isg/challenges/sem-tab/2021
+
+${}^{6}$ https://github.com/fusion-jena/JenTab
+
+${}^{7}$ https://github.com/phucty/mtab_tool
+
+${}^{8}$ https://mtab.app/mtabes/docs
+
+${}^{9}$ https://bitbucket.org/disco_unimib/mantistable-v/
+
+§ 3.2. OBSERVATIONS
+
+The systems we inspected follow the same steps: they perform a preprocessing step, and setup lookup and datatype prediction services. Then the CEA task is performed followed by the CTA and CPA tasks which depend on the CEA task. Given that the systems follow the same steps, we could map the three main tasks (CEA, CPA, CTA) to the Create-Filter-Select (CFS) procedure proposed by JenTab (see Table 1).
+
+We observe similarities in most tasks among the engines. The subtasks performed in the preprocessing step, are very similar in the three engines. The preprocessing tasks include several functions, such as fixing encoding issues, removing HTML tags or special characters, and detecting missing white spaces (see Table 1), and they usually delegate them to third-party libraries (e.g., ftfy ${}^{10}$ ). We observe similar tasks are performed when declarative solutions are used for cleaning and preparing the data. These preprocessing tasks are described with FnO in the case of RML and executed either together with the schema transformations or as a preprocessing task too.
+
+The same occurs for the datatype prediction, where regular expressions are often used to detect if cell values are entities or literals, and what type of literals (string, date, or numbers). In the case of declarative solutions, this datatype inspection task is performed manually. However, adjusting the datatype is possible relying on functions for data transformations.
+
+Most of them also incorporate a lookup step to retrieve the necessary data from the KGs (e.g., using SPARQL queries), including similarity functions or fuzzy search. The search engine for the KG lookups in JenTab and Mantis V is ElasticSearch, although the former implements the Jaro Winkler distance [19] while the later embeds it in a more efficient engine and exploits its query capabilities. Lookups were also incorporated in the case of declarative solutions [20], where lookup services retrieve a URI to identify an entity instead of assigning a new one.
+
+As far as the actual tasks is concerned, each engine performs its own approach for the CEA, CTA, and CPA tasks, although we also find some similarities. The most important ones that are implemented in the three engines are: (i) the Levenshtein distance [21] for filtering candidates, and (ii) the majority vote (called frequency in Mantis V) for selecting the final annotations. We believe that the use of declarative approaches, such as the Function Ontology [16] for describing common functions (e.g., Levenshtein), could make the solutions more comparable. It would also be clearer if they perform the same function, and more explainable, as current solutions for the automation of KG construction act like blackboxes: neither their implementations are open sourced nor the declarative descriptions of what they execute are available. Providing at least declarative descriptions of the performed tasks would enhance the transparency of these solutions.
+
+${}^{10}$ https://pypi.org/project/ftfy/
+
+Table 1
+
+Tasks comparison among different SemTab solutions
+
+max width=
+
+2|c|X JenTab MTab Mantis V
+
+1-5
+2|c|KG Lookup ElasticSearch on top of KG SPARQL Queries WikiGraph Generation Ad-hoc API LamAPI(ElasticSearch, Mongo and Python)
+
+1-5
+5*Preprocessing Fix encoding Y Y $\mathrm{N}$
+
+2-5
+ Special characters Y N Y
+
+2-5
+ Restore missing spaces Y $\mathrm{N}$ Y
+
+2-5
+ Remove HTML tags $\mathrm{N}$ Y $\mathrm{N}$
+
+2-5
+ Remove non-cell-values $\mathrm{N}$ Y $\mathrm{N}$
+
+1-5
+2|c|Datatype REGEX Type-based cleaning Cell values identification (literal, entity) SpaCy models for potential types Majority vote to define column type REGEX for datatypes exceeding a threshold Entity columns that do not exceed the threshold
+
+1-5
+3*CEA CREATE Different query rewriting techniques Keword search (BM25) Fuzzy search (Levenshtein distance) LamAPI lookup with IB similarity
+
+2-5
+ FILTER Levenshtein distance (among others) Filter and hashing (Symetric Delete) Context similarities by row Levenshtein confidence score for entities Literals XXX
+
+2-5
+ SELECT Levenshtein distance Highest context similarity xxxx
+
+1-5
+3*CTA CREATE Types from CEA Types from CEA Types from CEA
+
+2-5
+ FILTER Remove the less popular types - -
+
+2-5
+ SELECT Maiority vote Majority vote Majority vote
+
+1-5
+3*CPA CREATE Cell annotations (CEA) and fuzzy match for data properties Aggregate all properties from CEA by row Properties from CEA lookups
+
+2-5
+ FILTER - - -
+
+2-5
+ SELECT Majority vote Majority vote Majority vote
+
+1-5
+
+§ 4. CHALLENGES FOR A DECLARATIVE AUTOMATION OF KG CONSTRUCTION
+
+We identify a set of challenges that need to be addressed to declaratively describe solutions for automatic KG construction. These challenges can be divided into two main categories: technical challenges and conceptual challenges.
+
+On the technical side, there is a major difference between the solutions for the automation of KG construction and the execution of declarative KG construction solutions: The solutions for automatic KG construction rely on iterative processes that continuously refine and improves a task, while the different tasks influence each other. To the contrary, the declarative KG construction is a linear process that is executed only once. Not all declarative rules are executed linearly, solutions that restructure [6] or parallelize them [22, 23] are increasingly encountered. Thus, if the solutions for automatic KG construction are declaratively described, their iterative execution needs to be described as well. How do we do that with the mapping languages?
+
+Besides the overall execution process, the iteration patterns are different. The solutions for automatic KG construction are applied to all directions, both per column and per row, and even combined. To the contrary, the declarative solutions are applied only per row, and the mapping languages are designed under this assumption. Should the mapping languages be extended to support more iteration patterns? If so, would the rml:iteration for RML and the relevant constructs in the other mapping languages be sufficient or more adjustments are required?
+
+The solutions for automatic KG construction rely on interrelated tasks which may produce intermediate representations, and their results impact the rest of tasks. Thus, the declarative KG construction solutions need to deal with dynamic and recursive steps (e.g., intermediate representation of the input data sources and mapping rules, multiple function execution, etc.) that can negatively impact the generation process. Hence, declaratively describing is a challenge. Should the mapping languages be further extended then?
+
+On the conceptual side, there are two main differences with respect to the training and target KG. In most real projects that declarative solutions tackle, the input data and sometimes the target ontology are only provided, but there is neither similar data to train the solutions nor existing KGs that can be used to find entities or to predict the relationships. While relying on ontology matching techniques between existing KGs (e.g., DBPedia, Wikidata) and the target ontology or exploiting NLP approaches between ontology and input sources documentation could be a solution for the latter, would it be realistic given that most ontologies are not aligned and not all of them provide documentation?
+
+§ 5. CONCLUSIONS AND FUTURE WORK
+
+In this paper, we analyze the KG construction solutions and compare the automatic with the declarative. While the tasks can be aligned with respect to what they achieve, their execution is fundamentally different and a direct alignment is not feasible.
+
+Automatic solutions for KG construction are required to facilitate the adoption of KGs, but there are also merits when the automation tasks are declaratively described, with respect to maintenability, sustainability, and reproducibility. However, directly aligning the automatic solutions with the declarative solutions might be technically and conceptually challenging considering their different execution and iteration patterns. Extending the existing mapping languages would be a solution, but it would also require to address the identified challenges and not only. Would such extensions be feasible and desired or would they lead them beyond their purpose? Although, mapping languages are not the only approach to have declarative descriptions. Declarative descriptions of workflows emerge as well. Would that be a more viable solution? If so, would the automatic and declarative solutions keep on growing in different directions? These are questions that would be nice to reflect and discuss during the workshop.
\ No newline at end of file
diff --git a/papers/KGCW/KGCW 2022/KGCW 2022 Workshop/Hzx73hzWzq/Initial_manuscript_md/Initial_manuscript.md b/papers/KGCW/KGCW 2022/KGCW 2022 Workshop/Hzx73hzWzq/Initial_manuscript_md/Initial_manuscript.md
new file mode 100644
index 0000000000000000000000000000000000000000..70610d729a0e0fbd4ce1ba4ee66d9fb7557df0d7
--- /dev/null
+++ b/papers/KGCW/KGCW 2022/KGCW 2022 Workshop/Hzx73hzWzq/Initial_manuscript_md/Initial_manuscript.md
@@ -0,0 +1,203 @@
+# Supporting Relational Database Joins for Generating Literals in R2RML
+
+Christophe Debruyne ${}^{1}$
+
+${}^{1}$ University of Liege - Montefiore Institute,4000 Liège, Belgium
+
+## Abstract
+
+Since its publication, R2RML has provided us with a powerful tool for generating RDF from relational data, not necessarily manifested as relational databases. R2RML has its limitations, which are being recognized by W3C's Knowledge Graph Construction Community Group. That same group is currently developing a specification that supersedes R2RML in terms of its functionalities and the types of resources it can transform into RDF-primarily hierarchical documents. The community has a good understanding of problems of relational data and documents, even if they might need to be approached differently because of their different formalisms. In this paper, we present a challenge that has not been addressed yet for relational databases-generating literals based on (outer-)joins. We propose a simple extension of the R2RML vocabulary and extend the reference algorithm to support the generation of literals based on (outer-)joins. Furthermore, we implemented a proof-of-concept and demonstrated it using a dataset built for benchmarking joins. While it is not (yet) an extension of RML, this contribution informs us how to include such support and how it allows us to create self-contained mappings rather than relying on less elegant solutions.
+
+## Keywords
+
+R2RML, Knowledge Graph Generation, Outer-joins, Joins
+
+## 1. Introduction
+
+R2RML [1] is a powerful technique for transforming relational data into RDF and was published almost a decade ago. R2RML was conceived for relational databases, but can be applied to relational data. Since then, it inspired many initiatives to generalize this approach for other types of data such as RML [2] and xR2RML [3]. Others looked at extending aspects of (R2)RML not pertaining to the sources being transformed, but to tackle unaddressed challenges and requirements such as RDF Collections [3, 4] and functions [5, 6].
+
+The R2RML Recommendation specified a reference algorithm in which relational joins (natural joins or equi-joins, to be specific) can be used to relate resources. The implementation can be broken into two parts: (1) the generation of triples based on a triples map $t{m}_{1}$ related to a logical source, and (2) the generation of triples relating subjects from $t{m}_{1}$ with those of another triples map $t{m}_{2}$ . While (2) does not use an outer-join, the combination of both (1) and (2) ensures that the data being transformed "behaves" as the result of an outer-join. The problem, however, is that support for such outer-joins is only limited to resources; there is no convenient way to do something similar for literals.
+
+---
+
+Third International Workshop On Knowledge Graph Construction Co-located with the ESWC 2022, 30th May 2022, Crete, Greece
+
+C. c.debruyne@uliege.be (C. Debruyne)
+
+D 0000-0003-4734-3847 (C. Debruyne)
+
+(C) ${}_{12}$ (C) 2022 Copyright for this paper by its authors. Use permitted under Creative Commons License Attribution 4.0 International (CC BY 4.0).
+
+CEUR Workshop Proceedings (CEUR-WS.org)
+
+---
+
+title aka_title id movie id title imdb index kind id production year phonetic code episode_of_id season nr episode nr series years md5sum title imdb index kind id production_year imdb id phonetic_code episode of id season nr episode nr series years md5sum
+
+Figure 1: The tables title and aka_title of the database. A title may be related to one or more aka_titles, and an aka_title may be related to one title.
+
+This paper proposes a simple extension of R2RML for supporting joins for the generation of literals. It furthermore proposes how the reference algorithm should be extended. We demonstrate this extension using a fairly big relational databases developed for bench marking joins [7]. This benchmark provides us also with a realistic case, motivating the need for such an extension. This paper furthermore positions this contribution with other initiatives developed by the Knowledge Graph Generation community with the aim of opening a discussion.
+
+### 2.The Problem
+
+We framed the problem in the previous section. In this section, we will rephrase the problem and discuss several approaches to achieve the desired result that one can observe in practice. To this end, we will be using a running example based on the database developed by [7].
+
+To benchmark the performance of joins, [7] developed a database based on the Internet Movie Database ${}^{1}$ (IMDb). In short, their motivation was that existing synthetic benchmarks may be biased and real and "messy" provided better grounds for comparison. While that aspect is not important for this paper, the database they developed did contain two big tables: title containing information about movies and their titles, and aka_t it le containing variations in titles (either an alternative title, or titles in different languages). Figure 1 depicts the relation between the two tables and their attributes. ${}^{2}$
+
+There are two approaches to solving this problem with R2RML:
+
+Sol1 The first is the creation of two triples maps with one dedicated to the generation of triples for the outer-join. The problem with this approach is that the mapping is not self-contained and that there are two distinct triples maps which need to be maintained. One also needs to document that this construct was necessary to facilitate this outer-join. The advantage is that there are two distinct processes for querying the underlying database and thus less overhead.
+
+---
+
+${}^{1}$ https://www.imdb.com/
+
+${}^{2}$ The files were loaded into a MySQL database, but required some minor pre-processing: a handful of encoding issues in the files and NULL values in aka_table were represented with the number 0 . We also introduced a foreign key constraint that was not present in the SQL schema provided by [7]. The reason being that the foreign key constraint optimizes joins on these two tables. The tables contain 2528312 and 361472 respectively. There are 93 records from aka_table not referring to a record in title and 2322682 records in title have no alternative titles.
+
+---
+
+Sol2 The second, more naïve approach, is the use of one triples map with a (outer-)-join in its logical table. While this makes the triples map self-contained, unlike the approach above, but may require the processor to process many logical rows that generate the same triples.
+
+We may observe, in the wild, cases of the first also being conducted for referencing object maps, especially when the processor used uses the reference algorithm. The problems with respect to self-containedness of triples maps still holds. An R2RML processor may internally "rewrite" referencing object maps as triples maps to optimize the process.
+
+In the next section, we propose a small extension of R2RML to provide support for joins on literal values.
+
+## 3. Proposed solution
+
+In Listing 1, we demonstrate the extension. It introduces the predicate rrf :parentLogicalTable. ${}^{3}$ The domain of that predicate is rr: RefObjectMap and the range is rr: LogicalTable. Our extension requires that a rr: RefObjectMap must have either a rrf:parentLogicalTable or rr:parentTriplesMap. A referencing object map may now also generate literals. Where necessary, we will refer to object maps with a parent-triples map as "regular" referencing object maps.
+
+---
+
+<#title>
+
+ rr:logicalTable [ rr:tableName "title" ] ;
+
+ rr:subjectMap [ rr:template "http://data.example.com/movie/\{id\}" ; rr:class ex:Movie; ] ;
+
+ rr:predicateObjectMap [ rr:predicate ex:title ; rr:objectMap [ rr:column "title" ] ; ] ;
+
+ rr:predicateObjectMap [
+
+ rr:predicate ex:title ;
+
+ rr:objectMap [
+
+ rr:column "title" ;
+
+ rrf:parentLogicalTable [ rr:tableName "aka_title" ] ;
+
+ rr:joinCondition [ rr:child "id" ; rr:parent "movie_id" ] ;
+
+ ] ;
+
+ ] ;
+
+-
+
+---
+
+## Listing 1: Using parent-logical tables for managing joins
+
+The reference algorithm ${}^{4}$ is extended as follows: step 6 will now iterate over all referencing object maps with a rr : parentTriplesMap and we add a 7th step for each referencing object map that uses a parent-logical table. The steps for generating are mostly the same. The two differences are: 1) it may generate any term type, and 2) the column names referred to by the object map are those of the parent. In other words, if both logical tables share a column $\mathrm{X}$ , then a reference to $\mathrm{X}$ would be to that of the parent. This behavior is consistent with that of regular referencing object maps. An implementation of this algorithm is made available. ${}^{5}$
+
+---
+
+${}^{3}$ The namespace rrf refers to the namespace used in [6].
+
+${}^{4}$ https://www.w3.org/TR/r2rml/#generated-rdf
+
+---
+
+## 4. Demonstration
+
+We now present a limited experiment comparing the performance of Sol1, Sol2, and our proposal using the relational database introduced in Section 2. The mappings for Sol1 and Sol2 are in Appendix A. In this experiment, we join using the tables as a whole. As R2RML requires result sets to have unique names for each column, we created a third table aka_title2 where each column received the suffix ' 2 '. We also created a foreign key from aka_title2 to title. We wanted to avoid using subqueries to rename the columns, and these may become materialized and thus have an unfairly negative impact on the outcome.
+
+The experiment was run on a MacBook Pro with a 2.3 GHz Dual-Core Intel Core i5 processor and 16 GB 2133 MHz LPDDR3 RAM. The database was stored in a MySQL 8.0 database in a Docker container. The code for the experiment was written in Java and ran the result of each mapping 11 times, of which the first run was removed to avoid bias from a cold start. The code calls upon the extension of R2RML-F and registered timestamps before and after executing the mapping. We have not registered the time for writing the graph onto the hard disk.
+
+From Figure 2, which shows the average run times in seconds, it is clear that the approach of using two different triples maps (Sol1) is much faster than the two other approaches, which comes as no surprise. The problem, however, is that we have two distinct triples maps and their relationship is not explicit. Placing the outer-join in the logical table (Sol2) has the worst performance. The outer join yields a result set with 155749 more records than the referred table and contains twice the number of attributes. The overhead can be significantly reduced by only selecting the columns of interest, but the three mappings refer to the logical tables as a whole. Unsurprisingly, our solution is less efficient than Sol1 but considerably more efficient than Sol2.
+
+We may conclude from these initial results that the proposed solution is not only a viable solution. It also ensures that the mappings remain self-contained. While performance is crucial in knowledge graph generation, we argue that even the vocabulary is a contribution and that an R2RML processor can rewrite referencing object maps (both types) into distinct triples maps.
+
+## 5. Discussion
+
+In this paper, we extended the concept of rr: RefObjectMap to support joins for literal values. The reference algorithm for R2RML processes these in a separate loop for the generation of relations between subjects of two triples maps. Our approach added a similar step to the generation of literals based on a join. One may ask whether this approach may be adopted for term maps in general. The generation of subjects, predicates, and graphs for relational databases is based on a logical row. Generalizing this approach for such term maps may require a join per row, which is not efficient and is thus best done in the logical table of a triples map.
+
+---
+
+${}^{5}$ https://github.com/chrdebru/r2rml/tree/r2rml-join
+
+---
+
+Sol2 (outer join in TM) 100 105 110 115 120 Proposed solution 80 85 90
+
+Figure 2: Time taken to process three mappings: Sol1-2 triples maps for the outer-join, Sol2- one triples map with the outer-join in the logical table, and out proposed solution.
+
+As we can generate resources with our approach, one can question whether the notion of parent-triples maps is still necessary. The reference algorithm uses both logical tables, even though a processor can only select those used by the subject maps. The question rises: do we refer to (data in) sources, or do we refer to triples maps?
+
+Related to this work is the approach proposed by [8] where they proposed "fields" to manipulate and even combine the source prior to generating RDF. Their work, demonstrated with hierarchical data, aimed to address the problem of references that may yield multiple results and that sources may contain data of mixed formats. They also introduced an abstraction allowing one to retrieve information via a reference that does not depend on the underlying reference formulation. To the best of my knowledge, support for relational databases and the addition of fields from different tables has not yet been published. However, as they declare fields on the logical source, such an approach may boil down to a situation similar to Sol2 mentioned in Section 2.
+
+## 6. Conclusions
+
+We addressed the problem of generating literals from an outer-join, which R2RML does not support. While interesting initiatives are proposed for mostly hierarchical documents, we wanted to address this problem for relational databases by extending R2RML. We proposed a small extension with few implications regarding the R2RML vocabulary. We also extended the reference algorithm and provided an implementation that we have analyzed in an experiment.
+
+From this paper, we can conclude that, for relational databases, our approach is a viable solution. While not as efficient as disjoint triples maps, it may be worth considering not as an approach. It is essential not to consider this vocabulary extension as syntactic sugar, as that would imply it is shorthand for something semantically equivalent. In our approach, the mappings are self-contained, and the relationship between the two logical tables is thus explicit.
+
+We have addressed this problem for relational databases and R2RML. We could envisage that such an approach could be part of RML, which has the ambition to supersede R2RML. How this approach would work for non-relational data is to be studied.
+
+## A. Mappings Used in the Experiment
+
+---
+
+###MAPPING USED FOR SOL1 IN THE EXPERIMENT
+
+<#title_tm>
+
+ rr:logicalTable [ rr:tableName "title" ] ;
+
+ rr:subjectMap [ rr:template "http://data.example.com/movie/\{id\}" ; rr:class ex:Movie; ] ;
+
+ rr:predicateObjectMap [ rr:predicate ex:title ; rr:objectMap [ rr:column "title" ] ; ] .
+
+<#aka_title_tm>
+
+ rr:logicalTable [ rr:tableName "aka_title" ] ;
+
+ rr:subjectMap [ rr:template "http://data.example.com/movie/\{movie_id\}" ; rr:class ex:Movie; ] ;
+
+ rr:predicateObjectMap [ rr:predicate ex:title ; rr:objectMap [ rr:column "title" ] ; ] .
+
+###MAPPING USED FOR SOL2 IN THE EXPERIMENT
+
+<#title_tm>
+
+ rr:logicalTable [
+
+ rr:sqlQuery "SELECT * FROM title t LEFT OUTER JOIN aka_title2 a ON t.id = a.movie_ID2" ] ;
+
+ rr:subjectMap [ rr:template "http://data.example.com/movie/\{id\}" ; rr:class ex:Movie; ] ;
+
+ rr:predicateObjectMap [ rr:predicate ex:title ; rr:objectMap [ rr:column "title" ] ;
+
+ rr:objectMap [ rr:column "title2" ] ;
+
+ ] .
+
+---
+
+## References
+
+[1] S. Das, R. Cyganiak, S. Sundara, R2RML: RDB to RDF Mapping Language, 2012. URL: https://www.w3.org/TR/r2rml/.
+
+[2] A. Dimou, M. V. Sande, P. Colpaert, R. Verborgh, E. Mannens, R. V. de Walle, RML: A Generic Language for Integrated RDF Mappings of Heterogeneous Data, in: C. Bizer, T. Heath, S. Auer, T. Berners-Lee (Eds.), Proceedings of the Workshop on Linked Data on the Web co-located with the 23rd International World Wide Web Conference (WWW 2014), Seoul, Korea, April 8, 2014., volume 1184 of CEUR Workshop Proceedings, CEUR-WS.org, 2014. URL: http://ceur-ws.org/Vol-1184/ldow2014_paper_01.pdf.
+
+[3] F. Michel, L. Djimenou, C. Faron-Zucker, J. Montagnat, Translation of relational and non-relational databases into RDF with xr2rml, in: V. Monfort, K. Krempels, T. A. Majchrzak, Z. Turk (Eds.), WEBIST 2015 - Proceedings of the 11th International Conference on Web Information Systems and Technologies, Lisbon, Portugal, 20-22 May, 2015, SciTePress, 2015, pp. 443-454. URL: https://doi.org/10.5220/0005448304430454.doi:10.5220/0005448304430454.
+
+[4] C. Debruyne, L. McKenna, D. O'Sullivan, Extending R2RML with support for rdf collections and containers to generate MADS-RDF datasets, volume 10450 LNCS, 2017. doi:10.1007/978-3-319-67008-9_42.
+
+[5] B. D. Meester, W. Maroy, A. Dimou, R. Verborgh, E. Mannens, Declarative data transformations for linked data generation: The case of dbpedia, in: E. Blomqvist, D. Maynard, A. Gangemi, R. Hoekstra, P. Hitzler, O. Hartig (Eds.), The Semantic Web - 14th International Conference, ESWC 2017, Portoroz, Slovenia, May 28 - June 1, 2017, Proceedings, Part II, volume 10250 of Lecture Notes in Computer Science, 2017, pp. 33-48. URL: https://doi.org/10.1007/978-3-319-58451-5_3.doi:10.1007/ 978-3-319-58451-5\\_3.
+
+[6] C. Debruyne, D. O'Sullivan, R2RML-F: towards sharing and executing domain logic in R2RML mappings, in: S. Auer, T. Berners-Lee, C. Bizer, T. Heath (Eds.), Proceedings of the Workshop on Linked Data on the Web, LDOW 2016, co-located with 25th International World Wide Web Conference (WWW 2016), volume 1593 of CEUR Workshop Proceedings, CEUR-WS.org, 2016. URL: http://ceur-ws.org/Vol-1593/article-13.pdf.
+
+[7] V. Leis, A. Gubichev, A. Mirchev, P. A. Boncz, A. Kemper, T. Neumann, How good are query optimizers, really?, Proc. VLDB Endow. 9 (2015) 204-215. URL: http://www.vldb.org/pvldb/vol9/p204-leis.pdf.doi:10.14778/2850583.2850594.
+
+[8] T. Delva, D. V. Assche, P. Heyvaert, B. D. Meester, A. Dimou, Integrating nested data into knowledge graphs with RML fields, in: D. Chaves-Fraga, A. Dimou, P. Heyvaert, F. Priyatna, J. F. Sequeda (Eds.), Proceedings of the 2nd International Workshop on Knowledge Graph Construction co-located with 18th Extended Semantic Web Conference (ESWC 2021), Online, June 6, 2021, volume 2873 of CEUR Workshop Proceedings, CEUR-WS.org, 2021. URL: http://ceur-ws.org/Vol-2873/paper9.pdf.
\ No newline at end of file
diff --git a/papers/KGCW/KGCW 2022/KGCW 2022 Workshop/Hzx73hzWzq/Initial_manuscript_tex/Initial_manuscript.tex b/papers/KGCW/KGCW 2022/KGCW 2022 Workshop/Hzx73hzWzq/Initial_manuscript_tex/Initial_manuscript.tex
new file mode 100644
index 0000000000000000000000000000000000000000..225eb43a329b4ec145ccec47eda35c23ee2dbbc8
--- /dev/null
+++ b/papers/KGCW/KGCW 2022/KGCW 2022 Workshop/Hzx73hzWzq/Initial_manuscript_tex/Initial_manuscript.tex
@@ -0,0 +1,161 @@
+§ SUPPORTING RELATIONAL DATABASE JOINS FOR GENERATING LITERALS IN R2RML
+
+Christophe Debruyne ${}^{1}$
+
+${}^{1}$ University of Liege - Montefiore Institute,4000 Liège, Belgium
+
+§ ABSTRACT
+
+Since its publication, R2RML has provided us with a powerful tool for generating RDF from relational data, not necessarily manifested as relational databases. R2RML has its limitations, which are being recognized by W3C's Knowledge Graph Construction Community Group. That same group is currently developing a specification that supersedes R2RML in terms of its functionalities and the types of resources it can transform into RDF-primarily hierarchical documents. The community has a good understanding of problems of relational data and documents, even if they might need to be approached differently because of their different formalisms. In this paper, we present a challenge that has not been addressed yet for relational databases-generating literals based on (outer-)joins. We propose a simple extension of the R2RML vocabulary and extend the reference algorithm to support the generation of literals based on (outer-)joins. Furthermore, we implemented a proof-of-concept and demonstrated it using a dataset built for benchmarking joins. While it is not (yet) an extension of RML, this contribution informs us how to include such support and how it allows us to create self-contained mappings rather than relying on less elegant solutions.
+
+§ KEYWORDS
+
+R2RML, Knowledge Graph Generation, Outer-joins, Joins
+
+§ 1. INTRODUCTION
+
+R2RML [1] is a powerful technique for transforming relational data into RDF and was published almost a decade ago. R2RML was conceived for relational databases, but can be applied to relational data. Since then, it inspired many initiatives to generalize this approach for other types of data such as RML [2] and xR2RML [3]. Others looked at extending aspects of (R2)RML not pertaining to the sources being transformed, but to tackle unaddressed challenges and requirements such as RDF Collections [3, 4] and functions [5, 6].
+
+The R2RML Recommendation specified a reference algorithm in which relational joins (natural joins or equi-joins, to be specific) can be used to relate resources. The implementation can be broken into two parts: (1) the generation of triples based on a triples map $t{m}_{1}$ related to a logical source, and (2) the generation of triples relating subjects from $t{m}_{1}$ with those of another triples map $t{m}_{2}$ . While (2) does not use an outer-join, the combination of both (1) and (2) ensures that the data being transformed "behaves" as the result of an outer-join. The problem, however, is that support for such outer-joins is only limited to resources; there is no convenient way to do something similar for literals.
+
+Third International Workshop On Knowledge Graph Construction Co-located with the ESWC 2022, 30th May 2022, Crete, Greece
+
+C. c.debruyne@uliege.be (C. Debruyne)
+
+D 0000-0003-4734-3847 (C. Debruyne)
+
+(C) ${}_{12}$ (C) 2022 Copyright for this paper by its authors. Use permitted under Creative Commons License Attribution 4.0 International (CC BY 4.0).
+
+CEUR Workshop Proceedings (CEUR-WS.org)
+
+ < g r a p h i c s >
+
+Figure 1: The tables title and aka_title of the database. A title may be related to one or more aka_titles, and an aka_title may be related to one title.
+
+This paper proposes a simple extension of R2RML for supporting joins for the generation of literals. It furthermore proposes how the reference algorithm should be extended. We demonstrate this extension using a fairly big relational databases developed for bench marking joins [7]. This benchmark provides us also with a realistic case, motivating the need for such an extension. This paper furthermore positions this contribution with other initiatives developed by the Knowledge Graph Generation community with the aim of opening a discussion.
+
+§ 2.THE PROBLEM
+
+We framed the problem in the previous section. In this section, we will rephrase the problem and discuss several approaches to achieve the desired result that one can observe in practice. To this end, we will be using a running example based on the database developed by [7].
+
+To benchmark the performance of joins, [7] developed a database based on the Internet Movie Database ${}^{1}$ (IMDb). In short, their motivation was that existing synthetic benchmarks may be biased and real and "messy" provided better grounds for comparison. While that aspect is not important for this paper, the database they developed did contain two big tables: title containing information about movies and their titles, and aka_t it le containing variations in titles (either an alternative title, or titles in different languages). Figure 1 depicts the relation between the two tables and their attributes. ${}^{2}$
+
+There are two approaches to solving this problem with R2RML:
+
+Sol1 The first is the creation of two triples maps with one dedicated to the generation of triples for the outer-join. The problem with this approach is that the mapping is not self-contained and that there are two distinct triples maps which need to be maintained. One also needs to document that this construct was necessary to facilitate this outer-join. The advantage is that there are two distinct processes for querying the underlying database and thus less overhead.
+
+${}^{1}$ https://www.imdb.com/
+
+${}^{2}$ The files were loaded into a MySQL database, but required some minor pre-processing: a handful of encoding issues in the files and NULL values in aka_table were represented with the number 0 . We also introduced a foreign key constraint that was not present in the SQL schema provided by [7]. The reason being that the foreign key constraint optimizes joins on these two tables. The tables contain 2528312 and 361472 respectively. There are 93 records from aka_table not referring to a record in title and 2322682 records in title have no alternative titles.
+
+Sol2 The second, more naïve approach, is the use of one triples map with a (outer-)-join in its logical table. While this makes the triples map self-contained, unlike the approach above, but may require the processor to process many logical rows that generate the same triples.
+
+We may observe, in the wild, cases of the first also being conducted for referencing object maps, especially when the processor used uses the reference algorithm. The problems with respect to self-containedness of triples maps still holds. An R2RML processor may internally "rewrite" referencing object maps as triples maps to optimize the process.
+
+In the next section, we propose a small extension of R2RML to provide support for joins on literal values.
+
+§ 3. PROPOSED SOLUTION
+
+In Listing 1, we demonstrate the extension. It introduces the predicate rrf :parentLogicalTable. ${}^{3}$ The domain of that predicate is rr: RefObjectMap and the range is rr: LogicalTable. Our extension requires that a rr: RefObjectMap must have either a rrf:parentLogicalTable or rr:parentTriplesMap. A referencing object map may now also generate literals. Where necessary, we will refer to object maps with a parent-triples map as "regular" referencing object maps.
+
+<#title>
+
+ rr:logicalTable [ rr:tableName "title" ] ;
+
+ rr:subjectMap [ rr:template "http://data.example.com/movie/{id}" ; rr:class ex:Movie; ] ;
+
+ rr:predicateObjectMap [ rr:predicate ex:title ; rr:objectMap [ rr:column "title" ] ; ] ;
+
+ rr:predicateObjectMap [
+
+ rr:predicate ex:title ;
+
+ rr:objectMap [
+
+ rr:column "title" ;
+
+ rrf:parentLogicalTable [ rr:tableName "aka_title" ] ;
+
+ rr:joinCondition [ rr:child "id" ; rr:parent "movie_id" ] ;
+
+ ] ;
+
+ ] ;
+
+-
+
+§ LISTING 1: USING PARENT-LOGICAL TABLES FOR MANAGING JOINS
+
+The reference algorithm ${}^{4}$ is extended as follows: step 6 will now iterate over all referencing object maps with a rr : parentTriplesMap and we add a 7th step for each referencing object map that uses a parent-logical table. The steps for generating are mostly the same. The two differences are: 1) it may generate any term type, and 2) the column names referred to by the object map are those of the parent. In other words, if both logical tables share a column $\mathrm{X}$ , then a reference to $\mathrm{X}$ would be to that of the parent. This behavior is consistent with that of regular referencing object maps. An implementation of this algorithm is made available. ${}^{5}$
+
+${}^{3}$ The namespace rrf refers to the namespace used in [6].
+
+${}^{4}$ https://www.w3.org/TR/r2rml/#generated-rdf
+
+§ 4. DEMONSTRATION
+
+We now present a limited experiment comparing the performance of Sol1, Sol2, and our proposal using the relational database introduced in Section 2. The mappings for Sol1 and Sol2 are in Appendix A. In this experiment, we join using the tables as a whole. As R2RML requires result sets to have unique names for each column, we created a third table aka_title2 where each column received the suffix ' 2 '. We also created a foreign key from aka_title2 to title. We wanted to avoid using subqueries to rename the columns, and these may become materialized and thus have an unfairly negative impact on the outcome.
+
+The experiment was run on a MacBook Pro with a 2.3 GHz Dual-Core Intel Core i5 processor and 16 GB 2133 MHz LPDDR3 RAM. The database was stored in a MySQL 8.0 database in a Docker container. The code for the experiment was written in Java and ran the result of each mapping 11 times, of which the first run was removed to avoid bias from a cold start. The code calls upon the extension of R2RML-F and registered timestamps before and after executing the mapping. We have not registered the time for writing the graph onto the hard disk.
+
+From Figure 2, which shows the average run times in seconds, it is clear that the approach of using two different triples maps (Sol1) is much faster than the two other approaches, which comes as no surprise. The problem, however, is that we have two distinct triples maps and their relationship is not explicit. Placing the outer-join in the logical table (Sol2) has the worst performance. The outer join yields a result set with 155749 more records than the referred table and contains twice the number of attributes. The overhead can be significantly reduced by only selecting the columns of interest, but the three mappings refer to the logical tables as a whole. Unsurprisingly, our solution is less efficient than Sol1 but considerably more efficient than Sol2.
+
+We may conclude from these initial results that the proposed solution is not only a viable solution. It also ensures that the mappings remain self-contained. While performance is crucial in knowledge graph generation, we argue that even the vocabulary is a contribution and that an R2RML processor can rewrite referencing object maps (both types) into distinct triples maps.
+
+§ 5. DISCUSSION
+
+In this paper, we extended the concept of rr: RefObjectMap to support joins for literal values. The reference algorithm for R2RML processes these in a separate loop for the generation of relations between subjects of two triples maps. Our approach added a similar step to the generation of literals based on a join. One may ask whether this approach may be adopted for term maps in general. The generation of subjects, predicates, and graphs for relational databases is based on a logical row. Generalizing this approach for such term maps may require a join per row, which is not efficient and is thus best done in the logical table of a triples map.
+
+${}^{5}$ https://github.com/chrdebru/r2rml/tree/r2rml-join
+
+ < g r a p h i c s >
+
+Figure 2: Time taken to process three mappings: Sol1-2 triples maps for the outer-join, Sol2- one triples map with the outer-join in the logical table, and out proposed solution.
+
+As we can generate resources with our approach, one can question whether the notion of parent-triples maps is still necessary. The reference algorithm uses both logical tables, even though a processor can only select those used by the subject maps. The question rises: do we refer to (data in) sources, or do we refer to triples maps?
+
+Related to this work is the approach proposed by [8] where they proposed "fields" to manipulate and even combine the source prior to generating RDF. Their work, demonstrated with hierarchical data, aimed to address the problem of references that may yield multiple results and that sources may contain data of mixed formats. They also introduced an abstraction allowing one to retrieve information via a reference that does not depend on the underlying reference formulation. To the best of my knowledge, support for relational databases and the addition of fields from different tables has not yet been published. However, as they declare fields on the logical source, such an approach may boil down to a situation similar to Sol2 mentioned in Section 2.
+
+§ 6. CONCLUSIONS
+
+We addressed the problem of generating literals from an outer-join, which R2RML does not support. While interesting initiatives are proposed for mostly hierarchical documents, we wanted to address this problem for relational databases by extending R2RML. We proposed a small extension with few implications regarding the R2RML vocabulary. We also extended the reference algorithm and provided an implementation that we have analyzed in an experiment.
+
+From this paper, we can conclude that, for relational databases, our approach is a viable solution. While not as efficient as disjoint triples maps, it may be worth considering not as an approach. It is essential not to consider this vocabulary extension as syntactic sugar, as that would imply it is shorthand for something semantically equivalent. In our approach, the mappings are self-contained, and the relationship between the two logical tables is thus explicit.
+
+We have addressed this problem for relational databases and R2RML. We could envisage that such an approach could be part of RML, which has the ambition to supersede R2RML. How this approach would work for non-relational data is to be studied.
+
+§ A. MAPPINGS USED IN THE EXPERIMENT
+
+###MAPPING USED FOR SOL1 IN THE EXPERIMENT
+
+<#title_tm>
+
+ rr:logicalTable [ rr:tableName "title" ] ;
+
+ rr:subjectMap [ rr:template "http://data.example.com/movie/{id}" ; rr:class ex:Movie; ] ;
+
+ rr:predicateObjectMap [ rr:predicate ex:title ; rr:objectMap [ rr:column "title" ] ; ] .
+
+<#aka_title_tm>
+
+ rr:logicalTable [ rr:tableName "aka_title" ] ;
+
+ rr:subjectMap [ rr:template "http://data.example.com/movie/{movie_id}" ; rr:class ex:Movie; ] ;
+
+ rr:predicateObjectMap [ rr:predicate ex:title ; rr:objectMap [ rr:column "title" ] ; ] .
+
+###MAPPING USED FOR SOL2 IN THE EXPERIMENT
+
+<#title_tm>
+
+ rr:logicalTable [
+
+ rr:sqlQuery "SELECT * FROM title t LEFT OUTER JOIN aka_title2 a ON t.id = a.movie_ID2" ] ;
+
+ rr:subjectMap [ rr:template "http://data.example.com/movie/{id}" ; rr:class ex:Movie; ] ;
+
+ rr:predicateObjectMap [ rr:predicate ex:title ; rr:objectMap [ rr:column "title" ] ;
+
+ rr:objectMap [ rr:column "title2" ] ;
+
+ ] .
\ No newline at end of file
diff --git a/papers/KGCW/KGCW 2022/KGCW 2022 Workshop/SFIx1eHodWc/Initial_manuscript_md/Initial_manuscript.md b/papers/KGCW/KGCW 2022/KGCW 2022 Workshop/SFIx1eHodWc/Initial_manuscript_md/Initial_manuscript.md
new file mode 100644
index 0000000000000000000000000000000000000000..30b1d94683c7f875c05291d4a8c9f40986065d60
--- /dev/null
+++ b/papers/KGCW/KGCW 2022/KGCW 2022 Workshop/SFIx1eHodWc/Initial_manuscript_md/Initial_manuscript.md
@@ -0,0 +1,301 @@
+# What is needed in a Knowledge Graph Management Platform? A survey and a proposal
+
+Samira Babalou* 12, Franziska Zander 12, Erik Kleinsteuber 1, Badr El
+
+Haouni ${}^{1}$ , David Schellenberger Costa ${}^{2}$ , Jens Kattge ${}^{2}{}^{2}$ , Birgitta König-Ries-123
+
+${}^{1}$ Heinz-Nixdorf Chair for Distributed Information Systems
+
+Institute for Computer Science, Friedrich Schiller University Jena, Germany
+
+${}^{2}$ German Center for Integrative Biodiversity Research (iDiv), Halle-Jena-Leipzig, Germany
+
+${}^{3}$ Michael-Stifel-Center for Data-Driven and Simulation Science, Jena, Germany
+
+${}^{4}$ Institute of Biology/Geobotany and Botanical Garden, Martin Luther University, Halle, Germany
+
+corresponding author: samira.babalou@uni.jena.de
+
+Abstract. Knowledge Graphs (KGs) play a significant and growing role for semantics-based support of a wide variety of applications. Until recently, creating and maintaining such knowledge graphs was done in a one-off manner requiring significant manual effort and expertise. Over the last few years, the first KG management platforms supporting the lifecycle of KGs from their creation to their maintenance and use have appeared. In this paper, we first survey these platforms. We then take a step further and identify common functionalities across such platforms. We discuss nineteen such functionalities categorized into four groups: creating, extending, using, and maintaining KGs. Based on the findings of this analysis, we present our proposed KG management platform for the biodiversity domain, iKNOW. We focus on the architecture and the KG creation workflow, but also touch on other aspects.
+
+Keywords: Semantic Web . Knowledge Graph . Knowledge Graph Platform . Data Services and Functionality
+
+## 1 Introduction
+
+Increasingly, Knowledge Graphs (KGs) form the semantic data management backbone for a wide variety of applications. A KG [1] consists of nodes connected by edges. It is built from on a set of data sources via different techniques. Besides the instances, KGs can also contain schema information, which can be refined or augmented, e.g., by using a reasoner. Assigning unique identifiers to KG's entities can accelerate the interlinking with other resources on the web. The underlying structure of KGs opens a door for further functionalities such as visualization, supporting keyword search and complex queries via a SPARQL endpoint.
+
+Although KGs have widely gained attention in industry and academia, developing and managing their lifecycle requires a huge effort, expertise, and different functionalities. While, in the beginning, KGs were typically one-off manual efforts, there is a growing awareness that to exploit the capabilities of Knowledge Graph technologies to the maximal extent, support for their creation, access, update, and maintenance is needed. Many of these functionalities are not specific to any given $\mathrm{{KG}}$ but can be provided rather generically. $\mathrm{{KG}}$ platforms aim to do just that.
+
+As our contribution, in this paper, we survey existing KG management platforms and compare them in a general way. We then take a step further and analyze nineteen functionalities in four categories: creating, extending, using, and maintaining KGs. To the best of our knowledge, this is the first survey about KG platforms. Based on the findings of this survey and the needs in our domain, biodiversity research, we have designed our own KG platform. We present this platform, iKNOW, in the second part of the paper.
+
+The rest of the paper is organized as follows. Section 2 surveys existing KG management platforms. The common functionalities of platforms are discussed in Section 3. Our proposal for a KG management platform focussed on biodiversity, iKNOW, is presented in Section 4. The paper is concluded in Section 5.
+
+## 2 Literature Review
+
+In this paper, we define a Knowledge Graph Platform as a web-based platform for creating, managing, and making use of KGs. Such platforms mostly cover the whole lifecycle of KG application and include relevant services or functionalities for interaction and management of KGs.
+
+We contrast these from efforts to build an individual, specific KG. There have been many such efforts in different domains: e.g., Ozymandias [2] in the biodiversity domain, BCKG [3] in the biomedical domain, and I40KG [4] in the industrial domain. These KGs were built one time, and now their associated websites provide the KG access and usage. Such approaches are out of the scope of this paper. Rather, we focus on KG management platforms, which offer a set of operations such as generation and updates on the KG.
+
+In the following subsections, we first present the survey methodology used in this paper, then we briefly summarize the existing KG management platforms and compare them in a general way.
+
+### 2.1 Survey Methodology
+
+In this subsection, we describe our systematic approach to finding publications on KG platforms: We have queried for the keyword "Knowledge Graph Platform" in the Google Scholar search engine ${}^{1}$ . At the time of querying, this resulted in 162 papers (including citation and patents). We used Publish or Perish 8 tool ${}^{2}$ to save the result of the query. The result is available in our GitHub repository 3 Among the list of papers, we selected the relevant papers manually. We aimed to select papers that focus on the KG management platform. Some papers appeared in the result of google scholar because our keyword exists in their texts (e.g., in the literature review section), but those papers mainly do not propose a new KG platform. We did not include such cases. Moreover, we did not consider survey papers and papers written in a language other than English. In our repository, we specified which papers have been selected, and for non-selected ones, we clarified the reason. As a result, we came up with ${11}\mathrm{{KG}}$ platforms, briefly detailed in the following sub-section.
+
+---
+
+${}^{1}$ https://scholar.google.com/ access on 09.02.2022
+
+2 https://harzing.com/blog/2021/10/publish-or-perish-version-8
+
+---
+
+### 2.2 Existing KG Management Platforms
+
+In this section, we give a brief overview of existing platforms:
+
+- BBN (Blue Brain Nexus) [5] is an open-source platform. The KG in this platform can be built from datasets generated from heterogenous sources and formats. BBN has three main components: i) Nexus Delta, a set of services targeting developers for managing data and knowledge graph lifecycle; ii) Nexus Fusion, a web-based user interface enabling users to store, view, query, access, and share (meta)data and manage knowledge graphs; and iii) Nexus Forge, a Python user interface enabling data and knowledge engineers to build knowledge graphs from various data sources and formats using data mappings, transformations, and validations.
+
+- CPS (Corpus Processing Service) [6] is a cloud platform to create and serve Knowledge Graphs over a set of corpus. It uses state-of-the-art natural language understanding models to extract entities and relationships from documents.
+
+- HAPE (Heaven Ape) [7] is a programmable KG platform. The architecture of HAPE is designed in three parts: the client-side, which provides various kinds of services to the users; the server-side, which provides different knowledge management and processing, and the third part, which is KG's knowledge base. The applicability of the platform has been shown over DBpedia data. Moreover, the quality of created KG has been evaluated via metrics introduced in [8]. Although the authors in their published paper claimed that the platform is open to the public, to the best of our knowledge, there is no link to the platform source code or the online web portal.
+
+- Metaphactory [9] is an enterprise platform for building Knowledge Graph management applications. This platform supports different categories of users (end-users, expert users, and application developers), has a customizable UI, and enables the rapid building of use case-specific applications. Metaphactory allows configuring and managing connections to many data repositories. In this platform, data sources are virtually integrated with an ontology-based data access engine, i.e., on-the-fly integration of diverse data sources. The platform is assessed via assessment parameters introduced in [10].
+
+---
+
+3 https://github.com/fusion-jena/iKNOW
+
+---
+
+- Meng et al., [11] proposed a power marketing KG platform. The authors used a Machine Learning (ML) method to extract knowledge from unstructured text. The knowledge instances are stored in relational data. The relationship of knowledge is stored in a graph database.
+
+- MONOLITH [12] is a KG platform combined with Ontology-based Data Management (OBDM) capabilities over relational and non-relational databases to result in one (virtual) data source. The functionalities provided by MONOLITH can be split into two groups: one dedicated to managing OWL ontologies and providing OBDM services, exploiting the mappings between ontology and database; the other to managing KGs and providing services over them. These two groups are linked together, allowing to build the KGs through semantic data access from the results of the ontology queries.
+
+- News Hunter [13] is geared towards supporting journalism by aggregating and semantically integrating news from a variety of sources. It is based on a microservices architecture and consists of a number of independent such services: First, an extensible set of harvesters are aggregated from information from individual sources or existing news. Harvested news items and relevant metadata are deduplicated and stored in a source database. A translator converts items into a canonical language; this allows for cross-language news linking and the application of the broad range of existing NLP (Natural Language Processing) tools. This step, called Lifting in the paper, runs the extracted news items through an NLP pipeline which performs named-entity recognition as well as sentiment and topic analysis. Results of this step are stored in a graph database. ML-based classifiers are used to assign labels to news items thereby annotating them with terms from a common ontology modeling. Via an enricher, the KG can be augmented by information from external sources, e.g., DBpedia Spotlight.
+
+- TCMKG [14] is a KG platform for Traditional Chinese Medicine (TCM) based on the deep learning method. First, an ontology layer represents the knowledge-based diagnosis and treatment process. It includes core entities of the domain with their associated relations. Then, with the help of a named entity recognition (NER) model, TCM entities from unstructured data are extracted.
+
+- UWKGM [15] is a modular web-based platform for KG management. It enables users to integrate different functionalities as RESTful API services into the platform to help different user roles customize the platform as needed. The platform consists of three main components: the backend (API), the frontend (UI), and the system manager (for installation, upgrading, and deployment). The embedded entity suggestion module enables automatic triple extraction and maintains human involvement for quality control.
+
+- YABKO [16] is the successor of HAPE and aims to support the life cycle research on KGs. Researchers can upload their KGs and tools to the YABKO platform that can be free of use for other researchers' experiments. For any requested experiment, YABKO assigns necessary resources (space, time, KGs, tools) to it. After finishing an experiment, the short-term experiment will be dissolved, while the long-term ones can continue to exist on the condition of publishing their results. The core motivation of building YABKO is to help visitors use open-source techniques and resources to perform experiments on KGs and share experiences with other researchers.
+
+- Yang et al., [17] proposed a cloud computing cultural knowledge platform over multiple data sources such as Chinese Wikis, lexical databases, and cultural websites. The platform restricts the knowledge in the field of Chinese public cultural services instead of common sense knowledge. The platform has a set of services for building, updating, and maintaining the KG. It uses rule-based reasoning methods to analyze the existing KG relations to predict the new possible relations.
+
+### 2.3 Comparing Existing KG Management Platforms
+
+In Table 1, we summarize general information about the introduced KG platforms with respect to: their Name, the Year of release (based on the published paper), the used Source Data Type to build KGs, their target applications in industry or Academia, their Open-Source accessibilities, the availability of an Online Demo, a test with a Use Case Study, and, finally, the supported ${KG}$ Construction Method by the platform. Looking at the table, one can observe that:
+
+- most platforms have been introduced in the last three years. This shows that the field is still young and most likely still evolving. This observation is confirmed by our analysis of provided functionality (see below).
+
+- the platforms are very heterogeneous with respect to the number and type of data sources they support.
+
+- for KG construction, basically, all platforms follow an ETL (Extract, Transform, Load) process along with Machine Learning (ML) approaches. They differ in how adaptable this process is and, partially depending on the type of supported data sources, on the concrete steps involved in this process.
+
+- a (to us) surprisingly high percentage of platforms are designed for use within industry (as opposed to academia). This may be one of the reasons why quite many of these platforms are not open source.
+
+- all platforms had a use case study to show the capabilities of the platform by describing a specific KG's usage in a selected application domain.
+
+## 3 Common Functionalities in KG Management Platforms
+
+In this section, we take a closer look at the KG platforms, extract what functionalities they offer and compare them with respect to these functionalities. We consider a functionality for a platform if the functionality is mentioned in the respective papers. Platforms may possess other functionalities not mentioned in the papers. So a missing entry does not necessarily mean a platform does not offer certain functionality. Overall, many of the papers were surprisingly vague about what functionality the platforms offer, so that not always a clear decision was possible. From our analysis, we identified nineteen different functionalities which can be grouped into four categories as follows:
+
+Table 1: Comparing existing KG management platforms concerning their names, the year of release, the type of source data used to build KGs, targeting academia or not, being open-source, availability of an online demo, testing in a use case study, and the KG construction method. ${\checkmark }^{ * }$ means currently not available and - shows not mentioned.
+
+| Decoder | Dot Product | Bilinear | ConcatMLP | HadamardMLP | HadamardMLP w/ Flashlight |
| OGBL-DDI |
| GCN [5] | ${13.8} \pm {1.8}$ | ${16.1} \pm {1.2}$ | ${12.9} \pm {1.4}$ | ${37.1} \pm {5.1}$ | ${37.1} \pm {5.1}$ |
| GraphSAGE [12] | ${36.5} \pm {2.6}$ | ${39.4} \pm {1.7}$ | ${34.2} \pm {1.9}$ | $\mathbf{{53.9} \pm {4.7}}$ | $\mathbf{{53.9} \pm {4.7}}$ |
| Node2Vec [27] | ${11.6} \pm {1.9}$ | ${13.8} \pm {1.6}$ | ${10.8} \pm {1.7}$ | ${23.3} \pm {2.1}$ | ${23.3} \pm {2.1}$ |
| OGBL-COLLAB |
| GCN [5] | ${42.9} \pm {0.7}$ | ${43.2} \pm {0.9}$ | ${42.3} \pm {1.0}$ | ${44.8} \pm {1.1}$ | ${44.8} \pm {1.1}$ |
| GraphSAGE [12] | ${37.3} \pm {0.9}$ | ${41.5} \pm {0.8}$ | ${37.0} \pm {0.7}$ | ${48.1} \pm {0.8}$ | $\mathbf{{48.1} \pm {0.8}}$ |
| Node2Vec [27] | ${27.7} \pm {1.1}$ | ${31.5} \pm {1.0}$ | ${27.2} \pm {0.8}$ | $\mathbf{{48.9} \pm {0.5}}$ | ${48.9} \pm {0.5}$ |
| OGBL-PPA |
| GCN [5] | ${5.1} \pm {0.4}$ | ${5.8} \pm {0.5}$ | ${6.2} \pm {0.6}$ | ${18.7} \pm {1.3}$ | $\mathbf{{18.7} \pm {1.3}}$ |
| GraphSAGE [12] | ${3.2} \pm {0.3}$ | ${6.5} \pm {0.7}$ | ${5.8} \pm {0.4}$ | ${16.6} \pm {2.4}$ | ${16.6} \pm {2.4}$ |
| Node2Vec [27] | ${4.2} \pm {0.5}$ | ${7.8} \pm {0.6}$ | ${8.3} \pm {0.4}$ | $\mathbf{{22.3} \pm {0.8}}$ | $\mathbf{{22.3} \pm {0.8}}$ |
| OGBL-CITATION2 |
| GCN [5] | ${65.3} \pm {0.4}$ | ${69.0} \pm {0.8}$ | ${62.7} \pm {0.3}$ | $\mathbf{{84.7} \pm {0.2}}$ | $\mathbf{{84.7} \pm {0.2}}$ |
| GraphSAGE [12] | ${62.2} \pm {0.7}$ | ${65.4} \pm {0.9}$ | ${60.8} \pm {0.6}$ | $\mathbf{{80.4} \pm {0.1}}$ | ${80.4} \pm {0.1}$ |
| Node2Vec [27] | ${52.7} \pm {0.8}$ | ${54.1} \pm {0.6}$ | ${51.4} \pm {0.5}$ | ${61.4} \pm {0.1}$ | $\mathbf{{61.4} \pm {0.1}}$ |
+
+### 6.2 Hyper-parameter Settings
+
+For all experiments in this section, we report the average and standard deviation over ten runs with different random seeds. The results are reported on the the best model selected using validation data. We set hyper-parameters of the used techniques and considered baseline methods, e.g., the batch size, the number of hidden units, the optimizer, and the learning rate as suggested by their authors. We use the recent MIPS method ScaNN [18] in the implementation of our Flashlight. For the hyper-parameters of our Flashlight, we have found in the experiments that the performance of Flashlight is robust to the change of hyper-parameters in a board range. Therefore, we simply set the number of iterations of our Flashlight as $T = 3$ and the number of retrieved neighbors constant as 200 per iteration by default. We run all experiments on a machine with 80 Intel(R) Xeon(R) E5-2698 v4 @ 2.20GHz CPUs, and a single NVIDIA V100 GPU with 16GB RAM.
+
+### 6.3 Effectiveness of Link Prediction Decoders
+
+We follow the standard benchmark settings of OGB datasets to evaluate the effectiveness of LP with different decoders. The benchmark setting of OGBL-DDI is to predict drug-drug interactions given information on already known drug-drug interactions. The performance is evaluated by Hits@20: each true drug interaction is ranked among a set of approximately 100,000 randomly-sampled negative drug interactions, and count the ratio of positive edges that are ranked at 20-place or above. The task of OGBL-COLLAB is to predict the future author collaboration relationships given the past collaborations. Evaluation metric is Hits50, where each true collaboration is ranked among a set of 100,000 randomly-sampled negative collaborations. The task of OGBL-PPA is to predict new association edges given the training edges. Evaluation metric is Hits@100, where each positive edge is ranked among 3,000,000 randomly-sampled negative edges. The task of OGBL-CITATION2 is predict missing citation given existing citations. The evaluation metric is Mean Reciprocal Rank (MRR), where the reciprocal rank of the true reference among 1,000 sampled negative candidates is calculated for each source nodes, and then the average is taken over all source nodes.
+
+We implement different decoders as introduced in Sec. 2, including the Dot Product, Bilinear, ConcatMLP, and the HadamardMLP decoders, over the LP encoders, including GCN [5], GraphSAGE [12], and Node2Vec [27], to compare the effects of different decoders on the LP effectiveness. We present the results on the OGBL-DDI, OGBL-COLLAB, OGBL-PPA, and OGBL-CITATION2 datasets in Table. 2. We observe that the HadamardMLP decoder outperforms other decoders on all encoders and datasets. Our Flashlight algorithm can effectively retrieve the top scoring neighbors for the HadamardMLP decoder and keep the exact LP probabilities of HadamardMLPs' output, which leads to the same results of the HadamardMLP decoder with and without Flashlight.
+
+Note that the benchmark settings of these datasets sample a small portion of negative edges for the test evaluation, which is not challenging enough to evaluate the scalability of LP decoders on retrieving the top scoring neighbors from massive candidates in practice.
+
+### 6.4 The Flashlight Algorithm Effectively Finds the Top Scoring Neighbors
+
+To evaluate the effectiveness of our Flashlight on retrieving the top scoring neighbors for the HadamardMLP decoder, we propose a more challenging test setting for the OGB LP datasets. Given a source node, we takes its top 100 scoring neighbors of the HadamardMLP decoder as the ground-truth for retrievals. We set the task as retrieving $k$ neighbors for a source node that can match the ground-truth neighbors as much as possible. We formally define the metric as Recall $@k$ , which is the portion of the ground-truth neighbors being in the top $k$ neighbors retrieved by different methods.
+
+We sample 1000 nodes as the source nodes from the OGBL-DDI and OGBL-CITATION2 datasets respectively for evaluation. We evaluate the effectivness of our Flashlight algorithm by checking whether it can find the top scoring neighbors for every source node. We set the number of Flashlight iterations as 10 and the number of retrieved neighbors per iteration as 50 . We present the Recall@ $k$ for $k$ from 1 to 500 averaged over all the source nodes in Fig. 3. The "oracle" curve represents the performance of a optimum searcher, of which the retrieved top $k$ neighbors are exactly the top $k$ scoring neighbors of HadamardMLP.
+
+
+
+Figure 3: Recall $@k$ is the fraction of the 100 top scoring neighbors of HadamardMLP ranked in the top $k$ neighbors retrieved by Flashlight. We report Recall $@k$ averaged over all the source nodes on OGBL-CITATION2 and OGBL-DDI.
+
+When $k = {100}$ , the 100 neighbors retrieved by our Flashlight can cover more than ${80}\%$ ground-truth neighbors. When $k \geq {200}$ , the recall reaches ${100}\%$ . As a comparison, if we randomly sample the candidate neighbors for retrievals, the Recall $@k$ grows linearly with $k$ and is less than $1 \times {10}^{-4}$ for $k = {100}$ on the OGBL-CITATION2 dataset. The curves of Flashlight is close the optimum curve of the "oracle". These results demonstrate the highly effectiveness of our Flashlight on finding the top scoring neighbors.
+
+Given the large OGBL-Citation2 dataset and smaller DDI dataset, our Flashlight exhibits similar Recall $@k$ performance given different numbers $k$ of retrieved neighbors. This implies that our Flashlight can accurately find the top scoring neighbors for both small and large graphs.
+
+### 6.5 Inference Efficiency of Link Prediction with Our Flashlight Algorithm
+
+We use the throughputs to evaluate the inference speed of neighbor retrieval of different methods. The throughput is defined as how many source nodes that a method can serve to retrieve the top 100 scoring neighbors per second. Except for the LP models that follow the encoder and decoder architectures, e.g., GraphSAGE [12], GCN [5], and PLNLP [6], there are some subgraph based LP models, e.g., SUREL [7] and SEAL [58]. The common issue of the subgraph based models is the poor efficiency: they have to crop a seperate subgraph for every node pair to calculate the LP probability on the node pair. In this sense, the node embeddings cannot be shared on the LP calculation for different node pairs. This leads to the much lower inference speed of the subgraph based LP models than the encoder-decoder LP models. We compare the inference effeciency of different methods on the OGBL-CITATION2 dataset in Fig. 4, where we present the inference speed of different methods when achieving the ${100}\%$ recall@100 for the top 100 scoring neighbors.
+
+We observe that our Flashlight significantly accelerate the inference speed of LP models GraphSAGE [12], GCN [5], and PLNLP [6] with the HadamardMLP decoders by more than 100 times. This gap will be even larger for the datasets of larger scales, because the inference with our Flashlight holds the sublinear time complexity while the HadamardMLP decoders holds the linear complexity. Note that the y-axis is in logoratimic scale. The subgraph based methods SUREL [7] and SEAL [58] hold the inference speed of throuputs lower than $1 \times {10}^{-2}$ and $1 \times {10}^{-3}$ respectively, which is not applicable to the practical services that require the low latency of milliseconds.
+
+
+
+Figure 4: The inference speed of different LP methods on the OGBL-CITATION2 dataset. The y-axis (througputs) is in the logarithmic scale.
+
+
+
+Figure 5: The tradeoff between the inference speed (y-axis) and the effectiveness of finding the top scoring neighbors (x-axis) on the OGBL-CITATION2 (left) and OGBL-PPA (right) datasets.
+
+Taking a further step, we comprehensively evaluate the tradeoff between the inference speed and the effectiveness of finding the top scoring neighbors. Taking GraphSAGE as the encoder, we present the tradeoff curves between the throughputs and the Recall@100 on the OGBL-CITATION2 and OGBL-PPI datasets in Fig. 5. In comparison with our Flashlight, we take the HadamardMLP decoder with the Random Sampling as the baseline for comparison. For example, on the OGBL-CITATION2 dataset, when achieving the Recall@100 as more than 80%, the HadamardMLP with our Flashlight can serve more than 200 source nodes per second, while the HadamardMLP with the random sampling can only serve less than 1 node per second. Overall, our Flashlight achieves much better inference speed and effectiveness tradeoff than the HadamardMLP with random sampling.
+
+## 7 Conclusion
+
+Our theoretical and empirical analysis suggests that the HadamardMLP decoders are a better default choice than the Dot Product in terms of LP effectiveness. Because there does not exist a well-developed sublinear complexity top scoring neighbor searching algorithm for HadamardMLP, the HadamardMLP decoders are not scalable and cannot support the fast inference on large graphs. To resolve this issue, we propose the Flashlight algorithm to accelerate the inference of LP models with HadamardMLP decoders. Flashlight progressively operates the well-studied MIPS techniques for a few iterations. We adaptively adjust the query embeddings at every iteration to find more high scoring neighbors. Empirical results show that our Flashlight accelrates the inference of LP models by more than 100 times on the large OGBL-CITATION2 graph. Overall, our work paves the way for the use of strong LP decoders in practical settings by greatly accelerating their inference.
+
+References
+
+[1] Linyuan Lü and Tao Zhou. Link prediction in complex networks: A survey. Physica A: statistical mechanics and its applications, 390(6):1150-1170, 2011. 1
+
+[2] Víctor Martínez, Fernando Berzal, and Juan-Carlos Cubero. A survey of link prediction in complex networks. ACM computing surveys (CSUR), 49(4):1-33, 2016. 1
+
+[3] Lada A Adamic and Eytan Adar. Friends and neighbors on the web. Social networks, 25(3): 211-230, 2003. 1, 6
+
+[4] Yehuda Koren, Robert Bell, and Chris Volinsky. Matrix factorization techniques for recommender systems. Computer, 42(8):30-37, 2009. 1
+
+[5] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016. 1, 2, 3, 6, 7, 8
+
+[6] Zhitao Wang, Yong Zhou, Litao Hong, Yuanhang Zou, and Hanjing Su. Pairwise learning for neural link prediction. arXiv preprint arXiv:2112.02936, 2021. 1, 2, 3, 6, 7, 8, 13
+
+[7] Haoteng Yin, Muhan Zhang, Yanbang Wang, Jianguo Wang, and Pan Li. Algorithm and system co-design for efficient subgraph-based graph representation learning. arXiv preprint arXiv:2202.13538, 2022. 1, 8, 9
+
+[8] Chuxiong Sun and Guoshi Wu. Adaptive graph diffusion networks with hop-wise attention. arXiv preprint arXiv:2012.15024, 2020. 1, 2, 3, 6, 13
+
+[9] Tao Zhou, Linyuan Lü, and Yi-Cheng Zhang. Predicting missing links via local information. The European Physical Journal B, 71(4):623-630, 2009. 1, 6
+
+[10] Steffen Rendle, Walid Krichene, Li Zhang, and John Anderson. Neural collaborative filtering vs. matrix factorization revisited. In Fourteenth ACM conference on recommender systems, pages 240-248, 2020. 1, 2, 3, 4, 6, 13, 14
+
+[11] Rui Liu, Tianyi Wu, and Barzan Mozafari. A bandit approach to maximum inner product search. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 4376-4383, 2019. 1, 6
+
+[12] Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. Advances in neural information processing systems, 30, 2017. 2, 3, 6, 7, 8
+
+[13] Thomas N Kipf and Max Welling. Variational graph auto-encoders. arXiv preprint arXiv:1611.07308,2016. 2, 6
+
+[14] Rex Ying, Ruining He, Kaifeng Chen, Pong Eksombatchai, William L Hamilton, and Jure Leskovec. Graph convolutional neural networks for web-scale recommender systems. In Proceedings of the 24th ACM SIGKDD international conference on knowledge discovery & data mining, pages 974-983, 2018. 2
+
+[15] George Cybenko. Approximation by superpositions of a sigmoidal function. Mathematics of control, signals and systems, 2(4):303-314, 1989. 2
+
+[16] Weihua Hu, Matthias Fey, Hongyu Ren, Maho Nakata, Yuxiao Dong, and Jure Leskovec. Ogb-lsc: A large-scale challenge for machine learning on graphs. arXiv preprint arXiv:2103.09430, 2021.3,7
+
+[17] Xinyan Dai, Xiao Yan, Kelvin KW Ng, Jiu Liu, and James Cheng. Norm-explicit quantization: Improving vector quantization for maximum inner product search. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 51-58, 2020. 4, 6
+
+[18] Ruiqi Guo, Philip Sun, Erik Lindgren, Quan Geng, David Simcha, Felix Chern, and Sanjiv Kumar. Accelerating large-scale inference with anisotropic vector quantization. In International Conference on Machine Learning, pages 3887-3896. PMLR, 2020. 4, 6, 7
+
+[19] Shulong Tan, Zhixin Zhou, Zhaozhuo Xu, and Ping Li. Fast item ranking under neural network based measures. In Proceedings of the 13th International Conference on Web Search and Data Mining, pages 591-599, 2020. 4
+
+[20] Rihan Chen, Bin Liu, Han Zhu, Yaoxuan Wang, Qi Li, Buting Ma, Qingbo Hua, Jun Jiang, Yunlong Xu, Hongbo Deng, et al. Approximate nearest neighbor search under neural similarity metric for large-scale recommendation. arXiv preprint arXiv:2202.10226, 2022. 4
+
+[21] Gobinda G Chowdhury. Introduction to modern information retrieval. Facet publishing, 2010. 6
+
+[22] David Liben-Nowell and Jon Kleinberg. The link prediction problem for social networks. In Proceedings of the twelfth international conference on Information and knowledge management, pages 556-559, 2003.
+
+[23] Glen Jeh and Jennifer Widom. Simrank: a measure of structural-context similarity. In Proceedings of the eighth ACM SIGKDD international conference on Knowledge discovery and data mining, pages 538-543, 2002. 6
+
+[24] Aditya Krishna Menon and Charles Elkan. Link prediction via matrix factorization. In Joint european conference on machine learning and knowledge discovery in databases, pages 437- 452. Springer, 2011. 6
+
+[25] 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, 2014.
+
+[26] Jian Tang, Meng Qu, Mingzhe Wang, Ming Zhang, Jun Yan, and Qiaozhu Mei. Line: Large-scale information network embedding. In Proceedings of the 24th international conference on world wide web, pages 1067-1077, 2015.
+
+[27] 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, 2016. 7
+
+[28] Zhitao Wang, Chengyao Chen, and Wenjie Li. Predictive network representation learning for link prediction. In Proceedings of the 40th international ACM SIGIR conference on research and development in information retrieval, pages 969-972, 2017. 6
+
+[29] Muhan Zhang and Yixin Chen. Weisfeiler-lehman neural machine for link prediction. In Proceedings of the 23rd ACM SIGKDD international conference on knowledge discovery and data mining, pages 575-583, 2017. 6
+
+[30] Muhan Zhang and Yixin Chen. Link prediction based on graph neural networks. Advances in neural information processing systems, 31, 2018. 6
+
+[31] Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In Proceedings of the AAAI conference on artificial intelligence, volume 32, 2018. 6
+
+[32] Edith Cohen and David D Lewis. Approximating matrix multiplication for pattern recognition tasks. Journal of Algorithms, 30(2):211-252, 1999. 6
+
+[33] Hsiang-Fu Yu, Cho-Jui Hsieh, Qi Lei, and Inderjit S Dhillon. A greedy approach for budgeted maximum inner product search. Advances in neural information processing systems, 30, 2017. 6
+
+[34] Qiang Huang, Guihong Ma, Jianlin Feng, Qiong Fang, and Anthony KH Tung. Accurate and fast asymmetric locality-sensitive hashing scheme for maximum inner product search. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1561-1570, 2018. 6
+
+[35] Behnam Neyshabur and Nathan Srebro. On symmetric and asymmetric lshs for inner product search. In International Conference on Machine Learning, pages 1926-1934. PMLR, 2015.
+
+[36] Anshumali Shrivastava and Ping Li. Asymmetric Ish (alsh) for sublinear time maximum inner product search (mips). Advances in neural information processing systems, 27, 2014.
+
+[37] Xiao Yan, Jinfeng Li, Xinyan Dai, Hongzhi Chen, and James Cheng. Norm-ranging lsh for maximum inner product search. Advances in Neural Information Processing Systems, 31, 2018. 6
+
+[38] Jie Liu, Xiao Yan, Xinyan Dai, Zhirong Li, James Cheng, and Ming-Chang Yang. Understanding and improving proximity graph based maximum inner product search. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 139-146, 2020. 6
+
+[39] Stanislav Morozov and Artem Babenko. Non-metric similarity graphs for maximum inner product search. Advances in Neural Information Processing Systems, 31, 2018.
+
+[40] Zhixin Zhou, Shulong Tan, Zhaozhuo Xu, and Ping Li. Möbius transformation for fast inner product search on graph. Advances in Neural Information Processing Systems, 32, 2019. 6
+
+[41] Kazuo Aoyama, Kazumi Saito, Hiroshi Sawada, and Naonori Ueda. Fast approximate similarity search based on degree-reduced neighborhood graphs. In Proceedings of the 17th ACM SIGKDD international conference on Knowledge discovery and data mining, pages 1055-1063, 2011. 6
+
+[42] Akhil Arora, Sakshi Sinha, Piyush Kumar, and Arnab Bhattacharya. Hd-index: Pushing the scalability-accuracy boundary for approximate knn search in high-dimensional spaces. arXiv preprint arXiv:1804.06829, 2018.
+
+[43] Cong Fu, Chao Xiang, Changxu Wang, and Deng Cai. Fast approximate nearest neighbor search with the navigating spreading-out graph. arXiv preprint arXiv:1707.00143, 2017.
+
+[44] Yu A Malkov and Dmitry A Yashunin. Efficient and robust approximate nearest neighbor search using hierarchical navigable small world graphs. IEEE transactions on pattern analysis and machine intelligence, 42(4):824-836, 2018.
+
+[45] Philipp M Riegger. Literature survey on nearest neighbor search and search in graphs. 2010.
+
+[46] Wenhui Zhou, Chunfeng Yuan, Rong Gu, and Yihua Huang. Large scale nearest neighbors search based on neighborhood graph. In 2013 International Conference on Advanced Cloud and Big Data, pages 181-186. IEEE, 2013. 6
+
+[47] Myron Flickner, Harpreet Sawhney, Wayne Niblack, Jonathan Ashley, Qian Huang, Byron Dom, Monika Gorkani, Jim Hafner, Denis Lee, Dragutin Petkovic, et al. Query by image and video content: The qbic system. computer, 28(9):23-32, 1995. 6
+
+[48] Chun Jiang Zhu, Tan Zhu, Haining Li, Jinbo Bi, and Minghu Song. Accelerating large-scale molecular similarity search through exploiting high performance computing. In 2019 IEEE International Conference on Bioinformatics and Biomedicine (BIBM), pages 330-333. IEEE, 2019. 6
+
+[49] Thomas Cover and Peter Hart. Nearest neighbor pattern classification. IEEE transactions on information theory, 13(1):21-27, 1967. 6
+
+[50] Atsutake Kosuge and Takashi Oshima. An object-pose estimation acceleration technique for picking robot applications by using graph-reusing k-nn search. In 2019 First International Conference on Graph Computing (GC), pages 68-74. IEEE, 2019. 6
+
+[51] Qiang Huang, Jianlin Feng, Qiong Fang, Wilfred Ng, and Wei Wang. Query-aware locality-sensitive hashing scheme for $l\_ p$ norm. The VLDB Journal,26(5):683-708,2017. 6
+
+[52] Masajiro Iwasaki. Pruned bi-directed k-nearest neighbor graph for proximity search. In International Conference on Similarity Search and Applications, pages 20-33. Springer, 2016. 6
+
+[53] Yuan Cao, Heng Qi, Wenrui Zhou, Jien Kato, Keqiu Li, Xiulong Liu, and Jie Gui. Binary hashing for approximate nearest neighbor search on big data: A survey. IEEE Access, 6: 2039-2054, 2017. 6
+
+[54] Scott Cost and Steven Salzberg. A weighted nearest neighbor algorithm for learning with symbolic features. Machine learning, 10(1):57-78, 1993. 6
+
+[55] Yitong Meng, Xinyan Dai, Xiao Yan, James Cheng, Weiwen Liu, Jun Guo, Benben Liao, and Guangyong Chen. Pmd: An optimal transportation-based user distance for recommender systems. In European Conference on Information Retrieval, pages 272-280. Springer, 2020. 6
+
+[56] Badrul Sarwar, George Karypis, Joseph Konstan, and John Riedl. Item-based collaborative filtering recommendation algorithms. In Proceedings of the 10th international conference on World Wide Web, pages 285-295, 2001. 6
+
+[57] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. Advances in neural information processing systems, 33:22118-22133, 2020. 6
+
+[58] 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. Advances in Neural Information Processing Systems, 34:9061-9073, 2021. 8, 9
+
+[59] Zeyuan Allen-Zhu, Yuanzhi Li, and Zhao Song. A convergence theory for deep learning via over-parameterization. In International Conference on Machine Learning, pages 242-252. PMLR, 2019. 13
+
+[60] Alexandr Andoni, Rina Panigrahy, Gregory Valiant, and Li Zhang. Learning polynomials with neural networks. In International conference on machine learning, pages 1908-1916. PMLR, 2014.13
+
+## A Learning a Dot Product decoder with a HadamardMLP decoder is Easy
+
+Before we have discussed the limitations of the Dot Product decoder. An interesting questions is whether the HadamardMLP decoder can replace the Dot Product decoder by approximating it. If the MLP decoder can learn a dot product easily, it is safe to use MLP decoder instead of the dot product ones in most cases. There are similar problems actively studied in machine learning. Existing work imply that the difficulty scales polynomial with dimensionality $d$ and $1/\epsilon$ in theory [10,59,60]. This motivates us to investigate the question empirically.
+
+
+
+Figure 6: A MLP decoder can learn a Dot Product decoder well with enough training data. The left and right figures shows the MSE differences (y-axis) per epoch (x-axis) between the outputs of dot product and the MLP decoders given different training sizes with the input embedding dimenionality as $d = {64}$ and $d = {128}$ respectively. The naive output denotes the outputs of zeros.
+
+
+
+Figure 7: Test inverse MSE differences between the outputs of Dot Product and MLP decoders after convergence (y-axis) versus the training set size (x-axis).
+
+We set up a synthetic learning task where given two embeddings ${\mathbf{x}}_{i},{\mathbf{x}}_{j} \in {\mathbb{R}}^{d}$ and a label ${\mathbf{x}}_{i} \cdot {\mathbf{x}}_{j}$ , we want to obtain a MLP function that approximates the ${\mathbf{x}}_{i} \cdot {\mathbf{x}}_{j}$ with the inputs ${\mathbf{x}}_{i},{\mathbf{x}}_{j} \in {\mathbb{R}}^{d}$ . For this experiment, we create the datasets including the embedding matrix as $\mathbf{E} \in {\mathbb{R}}^{{10}^{6} \times d}$ . We draw every row in $\mathbf{E}$ from $\mathcal{N}\left( {0,\mathbf{I}}\right)$ independently. Then, we uniformly sample (without replacement) ${10}^{4}$ and $S$ embedding pair combinations from $\mathbf{E}$ to form the test and training sets (no overlap) respectively.
+
+We train the MLP on the training and evalute it on the test set. For the architecture of the MLP, we keep it simple: we follow the existing work $\left\lbrack {6,8}\right\rbrack$ to set the number of layers as 2 and the number of hidden units as same as the input embeddings: $d$ . For the optimizer, we also folow the existing work $\left\lbrack {6,8}\right\rbrack$ to choose the Adam optimizer. As for evaluation metrics, we compute the MSE (Mean Squared Error) differences between the predicted score of the MLP and the dot product decoders. We measure the MSE of a naive model that predicts always 0 (the average rating). Every experiment is repeated 5 times and we report the mean.
+
+Fig. 6 shows the approximation errors on the MLP per epoch given different number of training pairs and dimensions. The figure suggests that an MLP can easily approximate the dot product with enough training data. Consistent with the theory, the number of samples needed scales polynominally with the increasing dimensions and reduced errors. Ancedotally, we observe the number of needed training samples is about $\mathcal{O}\left( {{d}^{\alpha }/{\epsilon }^{\beta }}\right)$ for $\alpha \approx 2,\beta \ll 1$ (see Fig. 7). In all cases, the MSE errors of the MLP decoder are negligible compared with the naive output.
+
+This experiment shows that an MLP can easily approximate the dot product with enough training data. We hope this can explain, at least partially, why the MLP decoder generally performs better than the dot product.
+
+Our conclusion seems to be distinct to to the existing work [10], which claims that the ConcatMLP is hard to learn a Dot Product. Actually, our conclusion is not conflicted with that in [10]. This ConcatMLP decoder processes the concatenation of the paired embeddings instead of the Hadamard product of the paired embeddings as the HadamardMLP. The HadamardMLP holds the inductive bias similar to the Dot Product, which makes the former easily learns the latter. Actually, we show that a simple two-layer MLP with only two hidden units is equivalent to the Dot Product with specific weights. We assign the first layer weights for two hidden units as1and $- \mathbf{1}$ and the second layer weights as ones. Then, we have its output as:
+
+$$
+{s}_{ij} = {\phi }^{\mathrm{{MLP}}}\left( {{\mathbf{x}}_{\mathbf{i}},{\mathbf{x}}_{j}}\right) = \operatorname{ReLU}\left( {\mathbf{1} \cdot \left( {{\mathbf{x}}_{i} \odot {\mathbf{x}}_{j}}\right) }\right) + \operatorname{ReLU}\left( {-\mathbf{1} \cdot \left( {{\mathbf{x}}_{i} \odot {\mathbf{x}}_{j}}\right) }\right) = \mathbf{1} \cdot \left( {{\mathbf{x}}_{i} \odot {\mathbf{x}}_{j}}\right) = {\mathbf{x}}_{i} \cdot {\mathbf{x}}_{j}, \tag{14}
+$$
+
+which is equivalent to the Dot Product decoder. From this result, we find that any MLP decoder with the careful initialization is equivalent to the Dot Product decoder and thus can learn the Dot Product easily.
\ No newline at end of file
diff --git a/papers/LOG/LOG 2022/LOG 2022 Conference/-H-AKyXZnHn/Initial_manuscript_tex/Initial_manuscript.tex b/papers/LOG/LOG 2022/LOG 2022 Conference/-H-AKyXZnHn/Initial_manuscript_tex/Initial_manuscript.tex
new file mode 100644
index 0000000000000000000000000000000000000000..4b6bc2f2a8e64e7b4fb733703bba9016f729e63e
--- /dev/null
+++ b/papers/LOG/LOG 2022/LOG 2022 Conference/-H-AKyXZnHn/Initial_manuscript_tex/Initial_manuscript.tex
@@ -0,0 +1,327 @@
+Anonymous Author(s)
+
+Anonymous Affiliation
+
+Anonymous Email
+
+§ ABSTRACT
+
+Link prediction (LP) has been recognized as an important task in graph learning with its board practical applications. A typical application of LP is to retrieve the top scoring neighbors for a given source node, such as the friend recommendation. These services desire the high inference scalability to find the top scoring neighbors from many candidate nodes at low latencies. There are two popular decoders that the recent LP models mainly use to compute the edge scores from node embeddings: the HadamardMLP and Dot Product decoders. After theoretical and empirical analysis, we find that the HadamardMLP decoders are generally more effective for LP. However, HadamardMLP lacks the scalability for retrieving top scoring neighbors on large graphs, since to the best of our knowledge, there does not exist an algorithm to retrieve the top scoring neighbors for HadamardMLP decoders in sublinear complexity. To make HadamardMLP scalable, we propose the Flashlight algorithm to accelerate the top scoring neighbor retrievals for HadamardMLP: a sublinear algorithm that progressively applies approximate maximum inner product search (MIPS) techniques with adaptively adjusted query embeddings. Empirical results show that Flashlight improves the inference speed of LP by more than 100 times on the large OGBL-CITATION2 dataset without sacrificing effectiveness. Our work paves the way for large-scale LP applications with the effective HadamardMLP decoders by greatly accelerating their inference.
+
+§ 21 I INTRODUCTION
+
+The goal of link prediction (LP) is to predict the missing links in a graph [1]. LP is drawing increasing attention in the past decade due to its board practical applications [2]. For instance, LP can be used to recommend new friends on social media [3], and recommend attractive items to the costumers on E-commerce sites [4], so as to improve the user experience. During inference, these applications demand the LP methods to retrieve the top scoring neighbors for a source node at low latencies. This is especially challenging on large graphs because the LP methods need to search many candidate nodes to find the top scoring neighbors.
+
+There are two main kinds of architecture followed by the recent LP models. The first uses an encoder, e.g., GCN [5], to obtain the node-level embeddings and uses a decoder, e.g., Dot Product, to get the edge scores between the paired nodes [6]. The second crops a subgraph for every edge and computes the edge score from the subgraph directly [7]. The inference speed of the second is much lower than the first, so we focus on the first kind of models to achieve fast inference on large graphs. In the last years, extensive research focuses on developing more expressive LP encoders [6, 8]. However, much less work pays attention to the essential impacts of the choice of decoders on LP's performance. In this work, we theoretically and empirically analyze two popular LP decoders: Dot Product and HadamardMLP (a MLP following the Hadamard Product), and find that the latter is generally more effective than the former.
+
+In practical applications, we should not only consider the effectiveness of LP, but also inference efficiency. Many LP applications generally require fast retrieval of the top scoring neighbors for low-latency services $\left\lbrack {3,9,{10}}\right\rbrack$ . For a Dot Product decoder, this retrieval can be approximated efficiently at the sublinear time complexity [11]. However, to the best of our knowledge, no such sublinear algorithms exist for the top scoring neighbor retrievals of the HadamardMLP decoders. This means
+
+§ FLASHLIGHT $\MATHCAL{L}$ : SCALABLE LINK PREDICTION WITH EFFECTIVE DECODERS
+
+ < g r a p h i c s >
+
+Figure 1: Two popular LP decoders: The Dot Product (left), equivalent to the element-wise summation following the Hadamard product, and the HadamardMLP decoder (right).
+
+that for every source node, we have to iterate over all the nodes in the graph to compute the scores so as to find the top scoring neighbors for HadamardMLP, which is of linear complexity and cannot scale to large graphs.
+
+To allow LP applications to enjoy the high effectiveness of HadamardMLP decoders while avoiding the poor inference scalability, we propose the scalable top scoring neighbor search algorithm named Flashlight. Our Flashlight progressively calls the well-developed approximate maximum inner product search (MIPS) techniques for a few iterations. At every iteration, we analyze the retrieved neighbors and adaptively adjust the query embedding for Flashlight to find the missed high scoring neighbors. Our Flashlight algorithm holds sublinear time complexity on finding top scoring neighbors for HadamardMLP decoders, allowing for fast and scalable inference. Empirical results show that Flashlight accelerates the inference of LP models by more than 100 times on the large OGBL-CITATION2 dataset without sacrificing the effectiveness. Overall, our work paves the way for the use of effective LP decoders in practical settings by greatly accelerating their inference.
+
+§ 2 REVISITING LINK PREDICTION DECODERS
+
+In this section, we formalize the link prediction (LP) problem and the LP decoders. Typically, many LP models include an encoder that learns the node-level embeddings ${\mathbf{x}}_{i},i \in \mathcal{V}$ , where $\mathcal{V}$ is the set of nodes, and an decoder $\phi : {\mathbb{R}}^{d} \times {\mathbb{R}}^{d} \rightarrow \mathbb{R}$ that combines the node-level embeddings of a pair of nodes: ${\mathbf{x}}_{i},{\mathbf{x}}_{j}$ into a single score: ${s}_{ij}$ . If ${s}_{ij}$ is higher, the link between nodes $i$ and $j$ is more likely to exist. The state-of-the-art models generally use graph neural networks as the encoders [5, 6, 8, 12, 13]. From here on, we mainly focus on the decoder $\phi$ .
+
+§ 2.1 DOT PRODUCT DECODER
+
+The most common decoder of link prediction is the Dot Product $\left\lbrack {6,8,{10}}\right\rbrack$ :
+
+$$
+{s}_{ij} = {\phi }^{\text{ dot }}\left( {{\mathbf{x}}_{i},{\mathbf{x}}_{j}}\right) \mathrel{\text{ := }} {\mathbf{x}}_{i} \cdot {\mathbf{x}}_{j}, \tag{1}
+$$
+
+where $\cdot$ denotes the dot product.
+
+Training a link prediction model with the Dot Product decoder encourages the embeddings of the connected nodes to be close to each other. Intuitively, the score ${s}_{ij}$ can be thought as a measure of the squared Eulidean distance between the node embeddings ${\mathbf{x}}_{i},{\mathbf{x}}_{j}$ , as ${\begin{Vmatrix}{\mathbf{x}}_{i} - {\mathbf{x}}_{j}\end{Vmatrix}}^{2} = {\begin{Vmatrix}{\mathbf{x}}_{i}\end{Vmatrix}}^{2} - 2{\mathbf{x}}_{i} \cdot {\mathbf{x}}_{j} +$ ${\begin{Vmatrix}{\mathbf{x}}_{j}\end{Vmatrix}}^{2}$ , if the $\begin{Vmatrix}{\mathbf{x}}_{j}\end{Vmatrix}$ is constant over the neighbors $j \in \mathcal{N}$ , e.g., after normalization [14]. Because the node embeddings represent the semantic information of nodes, Dot Product assumes the homophily of graph topology, i.e., the semantically similar nodes are more likely to be connected.
+
+§ 2.2 HADAMARDMLP (MLP FOLLOWING HADAMARD PRODUCT) DECODER
+
+Multi layer perceptrons (MLPs) are known to be universal approximators that can approximate any continuous function on a compact set [15]. A MLP layer can be defined as a function $f : {\mathbb{R}}^{{d}_{\text{ in }}} \rightarrow$ ${\mathbb{R}}^{{d}_{\text{ out }}}$ :
+
+$$
+{f}_{\mathbf{W}}\left( \mathbf{x}\right) = \operatorname{ReLU}\left( {\mathbf{W}\mathbf{x}}\right) \tag{2}
+$$
+
+which is parameterized by the learnable weight $\mathbf{W} \in {\mathbb{R}}^{{d}_{\text{ out }} \times {d}_{\text{ in }}}$ (the bias, if exists, can be represented by an additional column in $\mathbf{W}$ and an additional channel in the input $\mathbf{x}$ with the value as 1 ). ReLU is the activation function. In a MLP, several layers of $f$ are stacked, e.g., a 3-layer MLP can be formalized as ${f}_{{\mathbf{W}}_{3}}\left( {{f}_{{\mathbf{W}}_{2}}\left( {{f}_{{\mathbf{W}}_{1}}\left( \mathbf{x}\right) }\right) }\right)$ .
+
+ < g r a p h i c s >
+
+Figure 2: HadamardMLP achieves higher Mean Reciprocal Rank (MRR, higher is better) than other decoders on the OGBL-CITATION2 [16] dataset with the encoder as GraphSAGE [12] and GCN [5]. More empirical results and the detailed settings are in Sec. 6.3.
+
+The state-of-the-art models widely use a MLP following the Hadamard Product between the paired nodes as the decoder (short as the HadamardMLP decoders) [6, 8, 10, 16]:
+
+$$
+{s}_{ij} = {\phi }^{\mathrm{{MLP}}}\left( {{\mathbf{x}}_{i},{\mathbf{x}}_{j}}\right) \mathrel{\text{ := }} \operatorname{MLP}\left( {{\mathbf{x}}_{i} \odot {\mathbf{x}}_{j}}\right) = {\mathbf{w}}_{L}^{T}\left( {{f}_{{\mathbf{W}}_{L - 1}}\left( {\ldots {f}_{{\mathbf{W}}_{1}}\left( {{\mathbf{x}}_{i} \odot {\mathbf{x}}_{j}}\right) \ldots }\right) }\right) , \tag{3}
+$$
+
+where $\odot$ denotes the Hadamard Product. Fig. 1 illustrates these two models the Dot Product and HadamardMLP decoders.
+
+§ 2.3 OTHER LINK PREDICTION DECODERS
+
+In principle, every function that takes two vectors as the input and outputs a scalar can act as the decoder. For example, there are bilinear dot product decoder (short as Bilinear decoder) [6]:
+
+$$
+{s}_{ij} = {\mathbf{h}}_{i}^{T}\mathbf{W}{\mathbf{h}}_{j}, \tag{4}
+$$
+
+where $\mathbf{W}$ is the learnable weight, and the MLPs following the concatenate decoder [6,10] (short as ConcatMLP decoder):
+
+$$
+{s}_{ij} = \operatorname{MLP}\left( {{\mathbf{h}}_{i}\parallel {\mathbf{h}}_{j}}\right) \tag{5}
+$$
+
+, etc. These two decoders are used much less than Dot Product and HadamardMLP in the state-of-the-art LP models possibly due to their lower effectiveness [6, 8, 10, 16].
+
+§ 2.4 HADAMARDMLP IS GENERALLY MORE EFFECTIVE THAN OTHER DECODERS
+
+Dot Product demands the homophily of graph data to effectively infer the link between nodes. In contrast, thanks to the universal approximation capability, MLP can approximate any continuous function, and thus does not demand the homophily of graph data for effective LP. This gap in the expressiveness accounts for the performance difference of these two decoders on many datasets (see Sec. 6.3). We additionally show in Appendix. A that using a HadamardMLP is easy to learn Dot Product, which also partially accounts for the better effectiveness of the HadamardMLP decoders over the Dot Product. Existing work also finds that the effectiveness of Bilinear and ConcatMLP is generally worse than the HardmardMLP or Dot Product decoder [6, 8, 10, 16]. We confirm these findings more rigorously in the empirical results in Fig. 2 and more complete in Sec. 6.3.
+
+§ 3 SCALABILITY OF LINK PREDICTION DECODERS
+
+Most academic studies focus on training runtime when discussing scalability. However, in industrial applications, the inference speed is often more important. The inference of many LP applications needs to retrieve the top scoring neighbors given a source node, e.g., recommending friends to a user for friend recommendation. Given a source node, if there are $n$ nodes in the graph, then the inference time complexity is $\mathcal{O}\left( n\right)$ if the decoder needs to iterate over all the $n$ nodes to compute the edge scores. For large scale applications, $n$ is typically in the range of millions, or even larger. The empirical results show that the inference time of finding the top scoring neighbors for a source node is longer than one second for HadamardMLP on the OGBL-CITATION2 dataset of nearly three million nodes (see Sec. 6.5).
+
+For a Dot Product decoder, the problem of finding the top scoring neighbors can be approximated efficiently. This is a well-studied problem, known as approximate maximum inner product search (MIPS) [17, 18] (see Sec. 5.2 for a comprehensive literature review). MIPS techniques allow Dot Product' inference to be completed in a few milliseconds, even with millions of neighbors. There exists some work that tries to extend MIPS to the ConcatMLP [19, 20]. These methods hold strict assumptions on the models' training and are not directly applicable to the HadamardMLP. To the best of our knowledge, no such sublinear techniques exist for the top scoring neighbor retrieval with the HadamardMLP [10], which is a complex nonlinear function.
+
+To summarize, the HadamardMLP decoder is not scalable for the real time LP services on large graphs, while the Dot Product decoder allows fast retrieval using the well established MIPS techniques.
+
+§ 4 FLASHLIGHT: SCALABLE LINK PREDICTION WITH EFFECTIVE DECODERS
+
+Sec. 2 has shown that the HadamardMLP decoder enjoys higher effectiveness than the Dot Product decoder, which supports the superior performance of HadamardMLP on many LP benchmarks. On the other hand, Sec. 3 has shown that the HadamardMLP is not scalable for real time LP applications on large graphs, while Dot Product supports the fast inference using the well-established MIPS techniques. In this section, we aim to devise fast inference algorithms for HadamardMLP to enable scalable LP with effective decoders.
+
+We try to exploit the advances in the well-developed MIPS techniques to accelerate the inference of HadamardMLP. Specifically, we divide the top scoring retrievals for HadamardMLP predictors into a sequence of MIPS. Our algorithm works in a progressive manner. The query embedding in every search is adaptively adjusted to find the high scoring neighbors missed in the last search.
+
+The challenge of retrieving the neighbors of highest scores for HadamardMLP is rooted in the unawareness of which neurons are activated, since if we know which neurons are activated, the nonlinear HadamardMLP degrades to a linear model. On the $l$ th MLP layer, we define the mask matrix ${\mathbf{M}}_{\mathcal{A},l} \in {\mathbb{R}}^{{d}_{l} \times {d}_{l}}$ to represent the set of activated neurons $\mathcal{A}$ as
+
+$$
+{M}_{ij} = \left\{ \begin{array}{ll} 1, & \text{ if }i = j\text{ and }i \in \mathcal{A} \\ 0, & \text{ otherwise } \end{array}\right. \tag{6}
+$$
+
+With ${\mathbf{M}}_{\mathcal{A},l}$ , we reformulate the HadamardMLP decoder as:
+
+$$
+{s}_{ij} = {\phi }^{\mathrm{{MLP}}}\left( {{\mathbf{x}}_{i},{\mathbf{x}}_{j}}\right) = {\mathbf{w}}_{L}^{T}{\mathbf{M}}_{\mathcal{A},L - 1}{\mathbf{W}}_{L - 1}\ldots {\mathbf{M}}_{\mathcal{A},1}{\mathbf{W}}_{1}\left( {{\mathbf{x}}_{i} \odot {\mathbf{x}}_{j}}\right)
+$$
+
+$$
+= \left( {{\mathbf{W}}_{1}^{T}{\mathbf{M}}_{\mathcal{A},1}\ldots {\mathbf{W}}_{L - 1}^{T}{\mathbf{M}}_{\mathcal{A},L - 1}{\mathbf{w}}_{L} \odot {\mathbf{x}}_{i}}\right) \cdot {\mathbf{x}}_{j} \tag{7}
+$$
+
+Because the vector ${\mathbf{W}}_{1}^{T}{\mathbf{M}}_{\mathcal{A},1}\ldots {\mathbf{W}}_{L - 1}^{T}{\mathbf{M}}_{\mathcal{A},L - 1}^{T}{\mathbf{w}}_{L}$ is determined by the weights of MLP and the activated neurons $\mathcal{A}$ , we term it as ${\operatorname{MLP}}_{\mathcal{A}}\left( \cdot \right)$ :
+
+$$
+{\operatorname{MLP}}_{\mathcal{A}}\left( \cdot \right) \mathrel{\text{ := }} {\mathbf{W}}_{1}^{T}{\mathbf{M}}_{\mathcal{A},1}\ldots {\mathbf{W}}_{L - 1}^{T}{\mathbf{M}}_{\mathcal{A},L - 1}^{T}{\mathbf{w}}_{L} \tag{8}
+$$
+
+Given the source node $i$ , because the score ${s}_{ij}$ is obtained by the dot product between $\left( {{\mathbf{W}}_{1}^{T}{\mathbf{M}}_{\mathcal{A},1}\ldots {\mathbf{W}}_{L - 1}^{T}{\mathbf{M}}_{\mathcal{A},L - 1}^{T}{\mathbf{w}}_{L} \odot {\mathbf{x}}_{i}}\right)$ and the neighbor embedding ${\mathbf{x}}_{j}$ , we term the former vector as the query embedding $\mathbf{q}$ :
+
+$$
+\mathbf{q} \mathrel{\text{ := }} {\mathbf{W}}_{1}^{T}{\mathbf{M}}_{\mathcal{A},1}\ldots {\mathbf{W}}_{L - 1}^{T}{\mathbf{M}}_{\mathcal{A},L - 1}{\mathbf{w}}_{L} \odot {\mathbf{x}}_{i} = {\operatorname{MLP}}_{\mathcal{A}}\left( \cdot \right) \odot {\mathbf{x}}_{i} \tag{9}
+$$
+
+In this way, we can reformulate the output of decoder ${\phi }^{MLP}\left( {{\mathbf{x}}_{i},{\mathbf{x}}_{\mathbf{j}}}\right)$ as
+
+$$
+{s}_{ij} = {\phi }^{\mathrm{{MLP}}}\left( {{\mathbf{x}}_{i},{\mathbf{x}}_{j}}\right) = \mathbf{q} \cdot {\mathbf{x}}_{j}. \tag{10}
+$$
+
+In practice, we can use the $\mathbf{q}$ as the query embedding in MIPS to retrieve the neighbors of highest inner products, which correspond to the highest scores. Here, how to get the activated neurons $\mathcal{A}$ so as to obtain the query embedding $\mathbf{q}$ is an issue. Different node pairs activate different neurons $\mathcal{A}$ . Initially, without knowing which neurons are activated, we first assume all the neurons are activated, i.e., we have the initial query embedding as:
+
+$$
+\mathbf{q}\left\lbrack 1\right\rbrack = \left( {\mathop{\prod }\limits_{{i = 1}}^{{L - 1}}{\mathbf{W}}_{i}^{T}}\right) {\mathbf{w}}_{L} \odot {\mathbf{x}}_{i} \tag{11}
+$$
+
+Algorithm 1 Flashlight $\#$ : progressively "illuminates" the semantic space to retrieve the high scoring neighbors for the LP HadamardMLP decoders.
+
+Input: A trained HadamardMLP decoder ${\phi }^{\text{ MLP }}$ that outputs the logit ${s}_{ij}$ for the input ${\mathbf{x}}_{i} \odot {\mathbf{x}}_{j}$ . The
+
+set of nodes $\mathcal{V}$ . The node embedding set $\mathcal{X} = \left\{ {{\mathbf{x}}_{i} \mid i \in \mathcal{V}}\right\}$ . A source node $i$ . The number of iterations
+
+$T$ . The number of neighbors to retrieve at every iteration: $\mathbf{N} = \left\lbrack {{N}_{1},{N}_{2},\ldots ,{N}_{T}}\right\rbrack$ .
+
+Output: The recommended neighbors $\mathcal{N}$ for the source node $i$ .
+
+ : Initialize the set of retrieved recommended neighbors $\mathcal{N} \leftarrow \varnothing$
+
+ Initialize the set of activated neurons as $\mathcal{A}\left\lbrack 0\right\rbrack$ as all the neurons in MLP.
+
+ for $t \leftarrow 1$ to $T$ do
+
+ Calculate the query embedding $\mathbf{q}\left\lbrack t\right\rbrack \leftarrow {\mathbf{x}}_{i} \odot {\operatorname{MLP}}_{\mathcal{A}\left\lbrack {t - 1}\right\rbrack }\left( \cdot \right)$ .
+
+ $\mathcal{N}\left\lbrack t\right\rbrack \leftarrow {N}_{t}$ neighbors in $\mathcal{X}$ that maximizes the inner product with $\mathbf{q}\left\lbrack t\right\rbrack$ .
+
+ $\mathcal{X} \leftarrow \mathcal{X} \smallsetminus \left\{ {{\mathbf{x}}_{j} \mid j \in \mathcal{N}\left\lbrack t\right\rbrack }\right\} .$
+
+ ${j}^{ \star }\left\lbrack t\right\rbrack = \arg \mathop{\max }\limits_{{j \in \mathcal{N}\left\lbrack t\right\rbrack }}\operatorname{MLP}\left( {{\mathbf{x}}_{i} \odot {\mathbf{x}}_{j}}\right)$
+
+ $\mathcal{A}\left\lbrack t\right\rbrack \leftarrow A\left( {\operatorname{MLP}\left( \cdot \right) ,{\mathbf{x}}_{i} \odot {\mathbf{x}}_{{j}^{ \star }\left\lbrack t\right\rbrack }}\right)$ .
+
+ $\mathcal{N} \leftarrow \mathcal{N} \cup \mathcal{N}\left\lbrack t\right\rbrack$ .
+
+ return $\mathcal{N}$
+
+This initial design can reflect the general trends of increasing the edge scores on LP, without restricting which neurons are activated. We use $\mathbf{q}\left\lbrack 1\right\rbrack$ as the query embedding to retrieve the highest inner product neighbors as $\mathcal{N}\left\lbrack 1\right\rbrack$ in the first iteration. Then, given the retrieved neighbors in the $t$ th iteration as $\mathcal{N}\left\lbrack t\right\rbrack$ , we analyze the $\mathcal{N}\left\lbrack t\right\rbrack$ and adaptively adjust the query embedding $\mathbf{q}\left\lbrack {t + 1}\right\rbrack$ that we use in the next iteration to find more high scoring neighbors. Specifically, we operate the feed-forward to MLP for $\mathcal{N}\left( t\right)$ . We define the function $A\left( {\cdot , \cdot }\right)$ that returns the set of activated neurons for a MLP (the first input) with the input ${\mathbf{x}}_{i} \odot {\mathbf{x}}_{j}$ (the second input). Then we can use it to extract $\mathcal{A}$ as:
+
+$$
+\mathcal{A} = A\left( {\operatorname{MLP}\left( \cdot \right) ,{\mathbf{x}}_{i} \odot {\mathbf{x}}_{j}}\right) . \tag{12}
+$$
+
+Then, we obtain the set of activated neurons of the highest scored neighbor at the $t$ th iteration as:
+
+$$
+\mathcal{A}\left\lbrack t\right\rbrack \leftarrow A\left( {\operatorname{MLP}\left( \cdot \right) ,{\mathbf{x}}_{i} \odot {\mathbf{x}}_{{j}^{ \star }\left\lbrack t\right\rbrack }}\right) \text{ , where }{j}^{ \star }\left\lbrack t\right\rbrack = \arg \mathop{\max }\limits_{{j \in \mathcal{N}\left\lbrack t\right\rbrack }}\operatorname{MLP}\left( {{\mathbf{x}}_{i} \odot {\mathbf{x}}_{j}}\right) . \tag{13}
+$$
+
+This implies that the neighbors activating $\mathcal{A}\left\lbrack t\right\rbrack$ can obtain the high edge scores. Then, if we take $\mathcal{A}\left\lbrack 1\right\rbrack$ as the set of neurons that we activate at the next query, we could find more high scoring neighbors. In this way, we set the neurons that we assume to activate in the next iteration as $\mathcal{A}\left\lbrack t\right\rbrack$ . We repeat the above iterations until enough neighbors are retrieved. The algorithm is summarized in Alg. 1.
+
+We name our algorithm as Flashlight because it works like a flashlight to progressively "illuminates" the semantic space to find the high scoring neighbors. The query embeddings are like the lights sent from the flashlight. And our process of adjusting the query embeddings is just like progressively adjusting the "lights" from the "flashlight" by checking the "objects" found in the last "illumination".
+
+In the experiments, we find that our Flashlight algorithm is effective to find the top scoring neighbors from the massive candidate neighbors. For example, in Fig. 3, our Flashlight is able to find the top 100 scoring neighbors from nearly three million candidates by retrieving only 200 neighbors in the large OGBL-CITATION2 graph dataset for the HadamardMLP decoders.
+
+Complexity Analysis. Using MLP decoders to compute the LP probabilities of all the neighbors holds the complexity as $\mathcal{O}\left( N\right)$ , where $N$ is the number of nodes in the whole graph. Finding the top scoring neighbors from the exact probabilities of all the neighbors also holds the linear complexity $\mathcal{O}\left( N\right)$ . Overall, using MLP decoders to find the top scoring neighbors is of the time complexity $\mathcal{O}\left( N\right)$ . In contrast, our Flashlight progressively calls the MIPS techniques for a constant number of times invariant to the graph data, which leads to the sublinear complexity as same as MIPS. In conclusion, our Flashlight improves the scalability and applicability of HadamardMLP decoders by reducing their inference time complexity from linear to sublinear time.
+
+Table 1: Statistics of datasets.
+
+max width=
+
+Dataset OGBL-DDI OGBL-COLLAB OGBL-PPA OGBL-CITATION2
+
+1-5
+#Nodes 4,267 235,868 576,289 2,927,963
+
+1-5
+$\mathbf{\# {Edges}}$ 1,334,889 1,285,465 30,326,273 30,561,187
+
+1-5
+
+§ 5 RELATED WORK
+
+§ 5.1 LINK PREDICTION MODELS
+
+Existing LP models can be categorized into three families: heuristic feature based [3, 9, 21-23], latent embedding based [12, 24-28], and neural network based ones. The neural network-based link prediction models are mainly developed in recent years, which explore non-linear deep structural features with neural layers. Variational graph auto-encoders [13] predict links by encoding graph with graph convolutional layer [5]. Another two state-of-the-art neural models WLNM [29] and SEAL [30] use graph labeling algorithm to transfer union neighborhood of two nodes (enclosing subgraph) as meaningful matrix and employ convolutional neural layer or a novel graph neural layer DGCNN [31] for encoding. More recently, $\left\lbrack {6,8}\right\rbrack$ summarized the architectures LP models, and formally define the encoders and decoders.
+
+Different from the previous work, we focus on analyzing the effectiveness of different LP decoders and improving the scalability of the effective LP decoders. In practice, we find that the Hadamard decoders exhibit superior effectiveness but poor scalability for inference. Our work significantly accelerates the inference of HadamardMLP decoders to make the effective LP scalable.
+
+§ 5.2 MAXIMUM INNER PRODUCT SEARCH
+
+Finding the top scoring neighbors for the Dot Product decoder at the sublinear time complexity is a well studied research problem, known as the approximate maximum inner product search (MIPS). There are several approaches to MIPS: sampling based [11, 32, 33], LSH-based [34-37], graph based [38-40], and quantization approaches [17, 18]. MIPS is a fundamental building block in various application domains [41-46], such as information retrieval [47, 48], pattern recognition [49, 50], data mining [51, 52], machine learning [53, 54], and recommendation systems [55, 56].
+
+With the explosive growth of datasets' scale and the inevitable curse of dimensionality, MIPS is essential to offer the scalable services. However, the HadamardMLP decoders are nonlinear and there do not exist the well studied sublinear complexity algorithms to find the top scoring neighbors for HadamardMLP [10]. In this work, we utilize the well studied approximate MIPS techniques with the adaptively adjusted query embeddings to find the top scoring neighbors for the MLP decoders in a progressive manner. Our method supports the plug-and-play use during inference and significantly acclerates the LP inference with the effective MLP decoders.
+
+§ 6 EXPERIMENTS
+
+In this section, we first compare the effectiveness of different LP decoders. We find that the HadamardMLP decoders generally perform better than other decoders. Then, we implement our 9 Flashlight algorithm with LP models to show that Flashlight effectively retrieves the top scoring neighbors for the HadamardMLP decoders. As a result, the inference efficiency and scalability of HadamardMLP decoders are improved significantly by our work.
+
+§ 6.1 DATASETS
+
+We evaluate the link prediction on Open Graph Benchmark (OGB) data [57]. We use four OGB datasets with different graph types, including OGBL-DDI, OGBL-COLLAB, OGBL-CITATION2, and OGBL-PPA. OGBL-DDI is a homogeneous, unweighted, undirected graph, representing the drug-drug interaction network. Each node represents a drug. Edges represent interactions between drugs. OGBL-COLLAB is an undirected graph, representing a subset of the collaboration network between authors indexed by MAG. Each node represents an author and edges indicate the collaboration between authors. All nodes come with 128-dimensional features. OGBL-CITATION2 is a directed graph, representing the citation network between a subset of papers extracted from MAG. Each node is a paper with 128-dimensional word2vec features. OGBL-PPA is an undirected, unweighted graph. Nodes represent proteins from 58 different species, and edges indicate biologically meaningful associations between proteins. The statistics of these datasets is presented in Table. 1.
+
+Table 2: The test effectiveness comparison of LP decoders on four OGB datasets (DDI, COLLAB, PPA, and CITATION2) [16]. We report the results of the standard metrics averaged over 10 runs following the existing work $\left\lbrack {6,{16}}\right\rbrack$ . HadamardMLP is more effective than other decoders. Flashlight effectively retrieves the top scoring neighbors for HadamardMLP and keep its exact outputs.
+
+max width=
+
+Decoder Dot Product Bilinear ConcatMLP HadamardMLP HadamardMLP w/ Flashlight
+
+1-6
+6|c|OGBL-DDI
+
+1-6
+GCN [5] ${13.8} \pm {1.8}$ ${16.1} \pm {1.2}$ ${12.9} \pm {1.4}$ ${37.1} \pm {5.1}$ ${37.1} \pm {5.1}$
+
+1-6
+GraphSAGE [12] ${36.5} \pm {2.6}$ ${39.4} \pm {1.7}$ ${34.2} \pm {1.9}$ $\mathbf{{53.9} \pm {4.7}}$ $\mathbf{{53.9} \pm {4.7}}$
+
+1-6
+Node2Vec [27] ${11.6} \pm {1.9}$ ${13.8} \pm {1.6}$ ${10.8} \pm {1.7}$ ${23.3} \pm {2.1}$ ${23.3} \pm {2.1}$
+
+1-6
+6|c|OGBL-COLLAB
+
+1-6
+GCN [5] ${42.9} \pm {0.7}$ ${43.2} \pm {0.9}$ ${42.3} \pm {1.0}$ ${44.8} \pm {1.1}$ ${44.8} \pm {1.1}$
+
+1-6
+GraphSAGE [12] ${37.3} \pm {0.9}$ ${41.5} \pm {0.8}$ ${37.0} \pm {0.7}$ ${48.1} \pm {0.8}$ $\mathbf{{48.1} \pm {0.8}}$
+
+1-6
+Node2Vec [27] ${27.7} \pm {1.1}$ ${31.5} \pm {1.0}$ ${27.2} \pm {0.8}$ $\mathbf{{48.9} \pm {0.5}}$ ${48.9} \pm {0.5}$
+
+1-6
+6|c|OGBL-PPA
+
+1-6
+GCN [5] ${5.1} \pm {0.4}$ ${5.8} \pm {0.5}$ ${6.2} \pm {0.6}$ ${18.7} \pm {1.3}$ $\mathbf{{18.7} \pm {1.3}}$
+
+1-6
+GraphSAGE [12] ${3.2} \pm {0.3}$ ${6.5} \pm {0.7}$ ${5.8} \pm {0.4}$ ${16.6} \pm {2.4}$ ${16.6} \pm {2.4}$
+
+1-6
+Node2Vec [27] ${4.2} \pm {0.5}$ ${7.8} \pm {0.6}$ ${8.3} \pm {0.4}$ $\mathbf{{22.3} \pm {0.8}}$ $\mathbf{{22.3} \pm {0.8}}$
+
+1-6
+6|c|OGBL-CITATION2
+
+1-6
+GCN [5] ${65.3} \pm {0.4}$ ${69.0} \pm {0.8}$ ${62.7} \pm {0.3}$ $\mathbf{{84.7} \pm {0.2}}$ $\mathbf{{84.7} \pm {0.2}}$
+
+1-6
+GraphSAGE [12] ${62.2} \pm {0.7}$ ${65.4} \pm {0.9}$ ${60.8} \pm {0.6}$ $\mathbf{{80.4} \pm {0.1}}$ ${80.4} \pm {0.1}$
+
+1-6
+Node2Vec [27] ${52.7} \pm {0.8}$ ${54.1} \pm {0.6}$ ${51.4} \pm {0.5}$ ${61.4} \pm {0.1}$ $\mathbf{{61.4} \pm {0.1}}$
+
+1-6
+
+§ 6.2 HYPER-PARAMETER SETTINGS
+
+For all experiments in this section, we report the average and standard deviation over ten runs with different random seeds. The results are reported on the the best model selected using validation data. We set hyper-parameters of the used techniques and considered baseline methods, e.g., the batch size, the number of hidden units, the optimizer, and the learning rate as suggested by their authors. We use the recent MIPS method ScaNN [18] in the implementation of our Flashlight. For the hyper-parameters of our Flashlight, we have found in the experiments that the performance of Flashlight is robust to the change of hyper-parameters in a board range. Therefore, we simply set the number of iterations of our Flashlight as $T = 3$ and the number of retrieved neighbors constant as 200 per iteration by default. We run all experiments on a machine with 80 Intel(R) Xeon(R) E5-2698 v4 @ 2.20GHz CPUs, and a single NVIDIA V100 GPU with 16GB RAM.
+
+§ 6.3 EFFECTIVENESS OF LINK PREDICTION DECODERS
+
+We follow the standard benchmark settings of OGB datasets to evaluate the effectiveness of LP with different decoders. The benchmark setting of OGBL-DDI is to predict drug-drug interactions given information on already known drug-drug interactions. The performance is evaluated by Hits@20: each true drug interaction is ranked among a set of approximately 100,000 randomly-sampled negative drug interactions, and count the ratio of positive edges that are ranked at 20-place or above. The task of OGBL-COLLAB is to predict the future author collaboration relationships given the past collaborations. Evaluation metric is Hits50, where each true collaboration is ranked among a set of 100,000 randomly-sampled negative collaborations. The task of OGBL-PPA is to predict new association edges given the training edges. Evaluation metric is Hits@100, where each positive edge is ranked among 3,000,000 randomly-sampled negative edges. The task of OGBL-CITATION2 is predict missing citation given existing citations. The evaluation metric is Mean Reciprocal Rank (MRR), where the reciprocal rank of the true reference among 1,000 sampled negative candidates is calculated for each source nodes, and then the average is taken over all source nodes.
+
+We implement different decoders as introduced in Sec. 2, including the Dot Product, Bilinear, ConcatMLP, and the HadamardMLP decoders, over the LP encoders, including GCN [5], GraphSAGE [12], and Node2Vec [27], to compare the effects of different decoders on the LP effectiveness. We present the results on the OGBL-DDI, OGBL-COLLAB, OGBL-PPA, and OGBL-CITATION2 datasets in Table. 2. We observe that the HadamardMLP decoder outperforms other decoders on all encoders and datasets. Our Flashlight algorithm can effectively retrieve the top scoring neighbors for the HadamardMLP decoder and keep the exact LP probabilities of HadamardMLPs' output, which leads to the same results of the HadamardMLP decoder with and without Flashlight.
+
+Note that the benchmark settings of these datasets sample a small portion of negative edges for the test evaluation, which is not challenging enough to evaluate the scalability of LP decoders on retrieving the top scoring neighbors from massive candidates in practice.
+
+§ 6.4 THE FLASHLIGHT ALGORITHM EFFECTIVELY FINDS THE TOP SCORING NEIGHBORS
+
+To evaluate the effectiveness of our Flashlight on retrieving the top scoring neighbors for the HadamardMLP decoder, we propose a more challenging test setting for the OGB LP datasets. Given a source node, we takes its top 100 scoring neighbors of the HadamardMLP decoder as the ground-truth for retrievals. We set the task as retrieving $k$ neighbors for a source node that can match the ground-truth neighbors as much as possible. We formally define the metric as Recall $@k$ , which is the portion of the ground-truth neighbors being in the top $k$ neighbors retrieved by different methods.
+
+We sample 1000 nodes as the source nodes from the OGBL-DDI and OGBL-CITATION2 datasets respectively for evaluation. We evaluate the effectivness of our Flashlight algorithm by checking whether it can find the top scoring neighbors for every source node. We set the number of Flashlight iterations as 10 and the number of retrieved neighbors per iteration as 50 . We present the Recall@ $k$ for $k$ from 1 to 500 averaged over all the source nodes in Fig. 3. The "oracle" curve represents the performance of a optimum searcher, of which the retrieved top $k$ neighbors are exactly the top $k$ scoring neighbors of HadamardMLP.
+
+ < g r a p h i c s >
+
+Figure 3: Recall $@k$ is the fraction of the 100 top scoring neighbors of HadamardMLP ranked in the top $k$ neighbors retrieved by Flashlight. We report Recall $@k$ averaged over all the source nodes on OGBL-CITATION2 and OGBL-DDI.
+
+When $k = {100}$ , the 100 neighbors retrieved by our Flashlight can cover more than ${80}\%$ ground-truth neighbors. When $k \geq {200}$ , the recall reaches ${100}\%$ . As a comparison, if we randomly sample the candidate neighbors for retrievals, the Recall $@k$ grows linearly with $k$ and is less than $1 \times {10}^{-4}$ for $k = {100}$ on the OGBL-CITATION2 dataset. The curves of Flashlight is close the optimum curve of the "oracle". These results demonstrate the highly effectiveness of our Flashlight on finding the top scoring neighbors.
+
+Given the large OGBL-Citation2 dataset and smaller DDI dataset, our Flashlight exhibits similar Recall $@k$ performance given different numbers $k$ of retrieved neighbors. This implies that our Flashlight can accurately find the top scoring neighbors for both small and large graphs.
+
+§ 6.5 INFERENCE EFFICIENCY OF LINK PREDICTION WITH OUR FLASHLIGHT ALGORITHM
+
+We use the throughputs to evaluate the inference speed of neighbor retrieval of different methods. The throughput is defined as how many source nodes that a method can serve to retrieve the top 100 scoring neighbors per second. Except for the LP models that follow the encoder and decoder architectures, e.g., GraphSAGE [12], GCN [5], and PLNLP [6], there are some subgraph based LP models, e.g., SUREL [7] and SEAL [58]. The common issue of the subgraph based models is the poor efficiency: they have to crop a seperate subgraph for every node pair to calculate the LP probability on the node pair. In this sense, the node embeddings cannot be shared on the LP calculation for different node pairs. This leads to the much lower inference speed of the subgraph based LP models than the encoder-decoder LP models. We compare the inference effeciency of different methods on the OGBL-CITATION2 dataset in Fig. 4, where we present the inference speed of different methods when achieving the ${100}\%$ recall@100 for the top 100 scoring neighbors.
+
+We observe that our Flashlight significantly accelerate the inference speed of LP models GraphSAGE [12], GCN [5], and PLNLP [6] with the HadamardMLP decoders by more than 100 times. This gap will be even larger for the datasets of larger scales, because the inference with our Flashlight holds the sublinear time complexity while the HadamardMLP decoders holds the linear complexity. Note that the y-axis is in logoratimic scale. The subgraph based methods SUREL [7] and SEAL [58] hold the inference speed of throuputs lower than $1 \times {10}^{-2}$ and $1 \times {10}^{-3}$ respectively, which is not applicable to the practical services that require the low latency of milliseconds.
+
+ < g r a p h i c s >
+
+Figure 4: The inference speed of different LP methods on the OGBL-CITATION2 dataset. The y-axis (througputs) is in the logarithmic scale.
+
+ < g r a p h i c s >
+
+Figure 5: The tradeoff between the inference speed (y-axis) and the effectiveness of finding the top scoring neighbors (x-axis) on the OGBL-CITATION2 (left) and OGBL-PPA (right) datasets.
+
+Taking a further step, we comprehensively evaluate the tradeoff between the inference speed and the effectiveness of finding the top scoring neighbors. Taking GraphSAGE as the encoder, we present the tradeoff curves between the throughputs and the Recall@100 on the OGBL-CITATION2 and OGBL-PPI datasets in Fig. 5. In comparison with our Flashlight, we take the HadamardMLP decoder with the Random Sampling as the baseline for comparison. For example, on the OGBL-CITATION2 dataset, when achieving the Recall@100 as more than 80%, the HadamardMLP with our Flashlight can serve more than 200 source nodes per second, while the HadamardMLP with the random sampling can only serve less than 1 node per second. Overall, our Flashlight achieves much better inference speed and effectiveness tradeoff than the HadamardMLP with random sampling.
+
+§ 7 CONCLUSION
+
+Our theoretical and empirical analysis suggests that the HadamardMLP decoders are a better default choice than the Dot Product in terms of LP effectiveness. Because there does not exist a well-developed sublinear complexity top scoring neighbor searching algorithm for HadamardMLP, the HadamardMLP decoders are not scalable and cannot support the fast inference on large graphs. To resolve this issue, we propose the Flashlight algorithm to accelerate the inference of LP models with HadamardMLP decoders. Flashlight progressively operates the well-studied MIPS techniques for a few iterations. We adaptively adjust the query embeddings at every iteration to find more high scoring neighbors. Empirical results show that our Flashlight accelrates the inference of LP models by more than 100 times on the large OGBL-CITATION2 graph. Overall, our work paves the way for the use of strong LP decoders in practical settings by greatly accelerating their inference.
\ No newline at end of file
diff --git a/papers/LOG/LOG 2022/LOG 2022 Conference/-vshFhHpKhX/Initial_manuscript_md/Initial_manuscript.md b/papers/LOG/LOG 2022/LOG 2022 Conference/-vshFhHpKhX/Initial_manuscript_md/Initial_manuscript.md
new file mode 100644
index 0000000000000000000000000000000000000000..0bec05a17c741f9c5023c9b677889369015edb9d
--- /dev/null
+++ b/papers/LOG/LOG 2022/LOG 2022 Conference/-vshFhHpKhX/Initial_manuscript_md/Initial_manuscript.md
@@ -0,0 +1,413 @@
+# Dynamic Network Reconfiguration for Entropy Maximization using Deep Reinforcement Learning
+
+Anonymous Author(s)
+
+Anonymous Affiliation
+
+Anonymous Email
+
+## Abstract
+
+A key problem in network theory is how to reconfigure a graph in order to optimize a quantifiable objective. Given the ubiquity of networked systems, such work has broad practical applications in a variety of situations, ranging from drug and material design to telecommunications. The large decision space of possible reconfigurations, however, makes this problem computationally intensive. In this paper, we cast the problem of network rewiring for optimizing a specified structural property as a Markov Decision Process (MDP), in which a decision-maker is given a budget of modifications that are performed sequentially. We then propose a general approach based on the Deep Q-Network (DQN) algorithm and graph neural networks (GNNs) that can efficiently learn strategies for rewiring networks. We then discuss a cybersecurity case study, i.e., an application to the computer network reconfiguration problem for intrusion protection. In a typical scenario, an attacker might have a (partial) map of the system they plan to penetrate; if the network is effectively "scrambled", they would not be able to navigate it since their prior knowledge would become obsolete. This can be viewed as an entropy maximization problem, in which the goal is to increase the surprise of the network. Indeed, entropy acts as a proxy measurement of the difficulty of navigating the network topology. We demonstrate the general ability of the proposed method to obtain better entropy gains than random rewiring on synthetic and real-world graphs while being computationally inexpensive, as well as being able to generalize to larger graphs than those seen during training. Simulations of attack scenarios confirm the effectiveness of the learned rewiring strategies.
+
+## 24 1 Introduction
+
+A key problem in network theory is how to rewire a graph in order to optimize a given quantifiable objective. Addressing this problem might have applications in several domains, given the fact several systems of practical interest can be represented as graphs $\left\lbrack {{23},{24},{29},{49},{50}}\right\rbrack$ . A large body of literature studies how to construct and design networks in order to optimize some quantifiable goal, such as robustness in supply chain and wireless sensor networks [40, 53] or ADME properties of molecules $\left\lbrack {{19},{39}}\right\rbrack$ . Given the intractable number of distinct configurations of even relatively small networks, optimizing these structural and topological properties is generally a non-trivial task that has been approached from various angles in graph theory $\left\lbrack {{15},{18}}\right\rbrack$ and also studied from heuristic perspectives $\left\lbrack {{21},{35}}\right\rbrack$ . Exact solutions are too computationally expensive to obtain and heuristic methods are generally sub-optimal and do not generalize well to unseen instances.
+
+The adoption of graph neural networks (GNNs) [41] and deep reinforcement learning (RL) [36] techniques have lead to promising approaches to the problem of optimizing graph processes or structure $\left\lbrack {{14},{16},{30}}\right\rbrack$ . A fundamental structural modification is rewiring, in which edges (e.g., links in a computer network) are reconfigured such that the topology is changed while their total number remains constant. The problem of rewiring to optimize a structural property has not been studied in the literature.
+
+In this paper, we present a solution to the network rewiring problem for optimizing a specified structural property. We formulate this task as a Markov Decision Process (MDP), in which a decision-maker is given a budget of rewiring operations that are performed sequentially. We then propose an approach based on the Deep Q-Network (DQN) algorithm and GNNs that can efficiently learn strategies for rewiring networks. We evaluate the method by means of a realistic cybersecurity case study. In particular, we assume a scenario in which an attacker has entered a computer network and aims to reach a particular node of interest. We also assume that the attacker has partial knowledge of the underlying graph topology, which is used to reach a given target inside the network. The goal is to learn a rewiring process for modifying the structure of the graph so as to disrupt the capability of the attacker to reach its target, all the while keeping the network operational. This can be seen as an example of moving target defense (MTD) [8]. We frame the solution as an entropy maximization problem, in which the goal is to increase the surprise of the network in order to disrupt the navigation of the attacker inside it. Indeed, entropy acts as proxy measurement of the difficulty of this task, with an increase in entropy corresponding to an increase its difficulty. In particular, we consider two measures of network entropy - namely Shannon entropy and Maximal Entropy Random Walk (MERW), and we compare their effectiveness.
+
+More specifically, the contributions of this paper can be summarized as follows:
+
+- We formulate the problem of graph rewiring so as to maximize a global structural property as an MDP, in which a central decision-maker is given a certain budget of rewiring operations that are performed sequentially. We formulate an approach that combines GNN architectures and the DQN algorithm to learn an optimal set of rewiring actions by trial-and-error;
+
+- We present an extensive case study of the proposed approach in the context of defense against network intrusion by an attacker. We show that our method is able to obtain better gains in entropy than random rewiring, while scaling to larger networks than a local greedy search, and generalizing to larger out-of-distribution graphs in some cases. Furthermore, we demonstrate the effectiveness of this approach by simulating the movement of an attacker in the network, finding that indeed the applied modifications increase the difficulty for the attacker to reach its targets in both synthetic and real-world graph topologies.
+
+## 2 Related work
+
+RL for graph reconfiguration. Recently, an increasing amount of research has been conducted on the use of reinforcement learning in graph reconfiguration. In particular, in [14] a solution based on reinforcement learning for modifying graphs with the aim of attacking both node and graph classification is presented. In addition, the authors briefly introduce a defense method using adversarial training and edge removal, which decreases their proposed classifier attack rate slightly by $1\%$ . This defense strategy is however only effective on the attack strategy it is trained on and does not generalize. Instead, the authors of [34] use a reinforcement learning approach to learn an attack strategy for neural network classifiers of graph topologies based on edge rewiring, and show that they are able to achieve misclassification with changes that are less noticeable compared to edge and vertex removal and addition. Our paper focuses on a different problem that does not involve classification tasks, but the maximization of a given network objective function. In [16] reinforcement learning techniques are applied to the problem of optimizing the robustness of a graph by means of graph construction; the authors show that their proposed method is able to outperform existing techniques and generalize to different graphs. In the present work, we optimize a global structural property through rewiring instead of constructing a graph through edge addition.
+
+Graph robustness and attacks. A related research area is the optimization of graph robustness [37], which denotes the capacity of a graph to withstand targeted attacks and random failures. [42] demonstrates how small changes in complex networks such as an electricity system or the Internet can improve their robustness against malicious attacks. [6] investigates several heuristic reconfiguration techniques that aim to improve graph robustness without substantially modifying the network structure, and find that preferential rewiring is superior to random rewiring. The authors of [11] extend this study to a framework that can accommodate multiple rewiring strategies and objectives. Several works have used information-based complexity metrics in the context of network defense or attack strategies: [27] proposes a network security metric to assess network vulnerability by measuring the Kolmogorov complexity of effective attack paths. The underlying reasoning is that the more complex attack paths have to be in order to harm a network, the less vulnerable a network is to external attacks. Furthermore, [25] investigates the vulnerability of complex networks, finding that attacks based on edge and vertex removal are substantially more effective when the network properties are recomputed after each attack.
+
+
+
+Figure 1: Illustrative example of the MDP timesteps comprising a single rewiring operation. The agent observes an initial state ${S}_{0} = \left( {{G}_{0},\varnothing ,\varnothing }\right)$ (first panel), from which it then selects a base node ${v}_{1} = \{ 1\}$ that will be rewired (second panel). Given the new state that contains the initial graph and the selected base node, the agent selects a target node ${v}_{2} = \{ 5\}$ to which an edge will be added (third panel). Finally, a third node ${v}_{3} = \{ 0\}$ is selected from the neighborhood of ${v}_{1} = \{ 1\}$ and the corresponding edge is removed (last panel). After a sequence of $b$ rewiring operations, the agent will receive a reward proportional to the improvement in the objective function $\mathcal{F}$ .
+
+Cybersecurity and network defense. In the last decade and in recent years in particular, a drastic surge in cyberattacks on governmental and industrial organizations has exposed the imminent vulnerability of global society to cyberthreats [43]. The targeted digital systems are generally structured as a network in which entities in the system communicate and share resources among each other. Typically, attackers seek to gain unauthorized access to the underlying network through an entry point and search for highly valuable nodes in order to infect these digital systems with malicious software such as viruses, ransomware and spyware [3], enabling them to extract sensitive information or control the functioning of the network [26]. Moving target defense (MTD) is a cybersecurity defense technique by which a network and the underlying software are dynamically changed to counteract attack strategies [4, 8, 9, 44, 51] Most existing MTD techniques involve NP-hard problems, and approximate or heuristic solutions are often impractical [8]. We note that while most studies are applied to specific software architectures, which prevent them from being applied effectively to large scale deployments, in this work we focus on modeling this problem from an abstract, infrastructure-agnostic perspective.
+
+## 3 Graph rewiring as an MDP
+
+### 3.1 Problem statement
+
+We define a graph (network) as $G = \left( {\mathcal{V},\mathcal{E}}\right)$ , where $\mathcal{V} = \left\{ {{v}_{1},\ldots ,{v}_{n}}\right\}$ is the set of $n = \left| \mathcal{V}\right|$ vertices (nodes) and $\mathcal{E} = \left\{ {{e}_{1},\ldots ,{e}_{m}}\right\}$ is the set of $m = \left| \mathcal{E}\right|$ edges (links). A rewiring operation $\gamma \left( {G,{v}_{i},{v}_{j},{v}_{k}}\right)$ transforms the graph $G$ by adding the non-edge $\left( {{v}_{i},{v}_{j}}\right)$ and removing the existing edge $\left( {{v}_{i},{v}_{k}}\right)$ ; we denote the set of all such operations by $\Gamma$ . Given a budget $b \propto m$ of rewiring operations, and a global objective function $\mathcal{F}\left( G\right)$ to be maximized, the goal is to find the set of unique rewiring operations out of ${\Gamma }^{b}$ such that the resulting graph ${G}^{\prime }$ maximizes $\mathcal{F}\left( {G}^{\prime }\right)$ .
+
+Since the size of the set of possible rewirings grows rapidly with the graph size, we cast this problem as a sequential decision-making process, which is detailed below.
+
+### 3.2 MDP framework
+
+We let every rewiring operation consist of three sub-steps: 1) base node selection; 2) node selection for edge addition; and 3) node selection for edge removal. We precede the edge removal step by edge addition to suppress potential disconnections of the graph. The rewiring procedure is illustrated in Figure 1. For reducing the size of the decision space, we model each sub-step of the rewiring operation as a separate timestep in the MDP itself. Its elements are defined as:
+
+State. The state ${S}_{t}$ is the tuple ${S}_{t} = \left( {{G}_{t},{a}_{1},{a}_{2}}\right)$ , containing the graph ${G}_{t} = \left( {\mathcal{V},{\mathcal{E}}_{t}}\right)$ , the chosen base node ${a}_{1}$ , and the chosen addition node ${a}_{2}$ . The base node and addition node may be null $\left( \varnothing \right)$ depending on the rewiring operation sub-step.
+
+Actions. We specify three distinct action spaces ${\mathcal{A}}_{\widehat{t}}\left( {S}_{t}\right)$ , where $\widehat{t} \mathrel{\text{:=}} \left( \begin{array}{ll} t & \text{ mod }3 \end{array}\right)$ denotes the sub-step within a rewiring operation. Letting the degree of node $v$ be ${k}_{v}$ , they are defined as:
+
+$$
+{\mathcal{A}}_{0}\left( {{S}_{t} = \left( {\left( {\mathcal{V},{\mathcal{E}}_{t}}\right) ,\varnothing ,\varnothing }\right) }\right) = \left\{ {v \in \mathcal{V}\left| {0 < {k}_{v} < }\right| \mathcal{V} \mid - 1}\right\} , \tag{1}
+$$
+
+$$
+{\mathcal{A}}_{1}\left( {{S}_{t} = \left( {\left( {\mathcal{V},{\mathcal{E}}_{t}}\right) ,{a}_{1},\varnothing }\right) }\right) = \left\{ {v \in \mathcal{V} \mid \left( {{a}_{1}, v}\right) \notin {\mathcal{E}}_{t}}\right\} , \tag{2}
+$$
+
+$$
+{\mathcal{A}}_{2}\left( {{S}_{t} = \left( {\left( {\mathcal{V},{\mathcal{E}}_{t}}\right) ,{a}_{1},{a}_{2}}\right) }\right) = \left\{ {v \in \mathcal{V} \mid \left( {{a}_{1}, v}\right) \in {\mathcal{E}}_{t} \smallsetminus \left( {{a}_{1},{a}_{2}}\right) }\right\} . \tag{3}
+$$
+
+Transitions. Transitions are deterministic; the model $P\left( {{S}_{t} = {s}^{\prime } \mid {S}_{t - 1} = s,{A}_{t - 1} = {a}_{t - 1}}\right)$ transitions to state ${S}^{\prime }$ with probability 1, where:
+
+$$
+{S}^{\prime } = \left\{ \begin{array}{lll} \left( {\left( {\mathcal{V},{\mathcal{\xi }}_{t - 1}}\right) ,{a}_{1},\varnothing }\right) , & \text{ if }3 \mid t + 2 & \text{ mark base node } \\ \left( {\left( {\mathcal{V},{\mathcal{\xi }}_{t - 1} \cup \left( {{a}_{1},{a}_{2}}\right) }\right) ,{a}_{1},{a}_{2}}\right) , & \text{ if }3 \mid t & \text{ mark addition node }\& \text{ add edge } \\ \left( {\left( {\mathcal{V},{\mathcal{\xi }}_{t - 1} \smallsetminus \left( {{a}_{1},{a}_{3}}\right) }\right) ,\varnothing ,\varnothing }\right) , & \text{ if }3 \mid t + 1 & \text{ remove edge }\& \text{ reset marked nodes } \end{array}\right.
+$$
+
+(4)
+
+Rewards. The reward signal ${R}_{t}$ is proportional to the difference in the value of the objective function $\mathcal{F}$ before and after the graph reconfiguration. Furthermore, a key operational constraint in the domain we consider is that the network remains connected after the rewiring operations. Instead of running connectivity algorithms at every time-step to determine if a potential removed edge disconnects the graph, we encourage maintaining connectivity by giving a penalty $\bar{r} < 0$ at the end of the episode if the graph becomes disconnected. All rewards and penalties are provided at the final timestep $T$ , and no intermediate rewards are given. This enables the flexibility to discover long-term strategies that maximize the total cumulative reward of a sequence of reconfigurations rather than a single-step rewiring operation, even if the graph is disconnected during intermediate steps. Concretely, given an initial graph ${G}_{0} = \left( {\mathcal{V},{\mathcal{E}}_{0}}\right)$ , we define the reward function at timestep $t$ as:
+
+$$
+{R}_{t} = \left\{ \begin{array}{ll} {c}_{\mathcal{F}} \cdot \left( {\mathcal{F}\left( {G}_{t}\right) - \mathcal{F}\left( {G}_{0}\right) }\right) & \text{ if }t = T \land c\left( G\right) = 1, \\ \bar{r} & \text{ if }t = T \land c\left( G\right) \geq 2, \\ 0 & \text{ otherwise,} \end{array}\right. \tag{5}
+$$
+
+where $c\left( G\right)$ denotes the number of connected components of $G$ , and $\bar{r} < 0$ is the disconnection penalty. As the different objective functions may act on different scales, we use a reward scaling ${c}_{\mathcal{F}}$ , which we empirically establish for every objective function $\mathcal{F}$ .
+
+## 4 Reinforcement learning representation and parametrization
+
+In this section, we extend the graph representation and value function approximation parametrizations proposed in past work $\left\lbrack {{14},{16}}\right\rbrack$ for the problem of graph rewiring.
+
+### 4.1 Graph representation
+
+As the state and action spaces in network reconfiguration quickly become intractable for a sequence of rewiring operations, we require a graph representation that generalizes over similar states and actions. To this end, we use a GNN architecture that is based on a mean field inference method [46]. More specifically, we use a variant of the structure2vec [13] embedding method to represent every node ${v}_{i} \in \mathcal{V}$ in a graph $G = \left( {\mathcal{V},\mathcal{E}}\right)$ by an embedding vector ${\mu }_{i}$ . This embedding vector is constructed in an iterative process by linearly transforming feature vectors ${x}_{i}$ with a set of weights $\left\{ {{\theta }^{\left( 1\right) },{\theta }^{\left( 2\right) }}\right\}$ , aggregating the ${x}_{i}$ with the feature vectors of neighboring nodes ${v}_{j} \in {\mathcal{N}}_{i}$ , then applying the nonlinear Rectified Linear Unit (ReLU) activation function. Hence, at every step $l \in \left( {1,2,\ldots , L}\right)$ , embedding vectors are updated according to:
+
+$$
+{\mu }_{i}^{\left( l + 1\right) } = \operatorname{ReLU}\left( {{\theta }^{\left( 1\right) }{x}_{i} + {\theta }^{\left( 2\right) }\mathop{\sum }\limits_{{j \in {\mathcal{N}}_{i}}}{\mu }_{j}^{\left( l\right) }}\right) , \tag{6}
+$$
+
+where all embedding vectors are initialized as ${\mu }_{i}^{\left( 0\right) } = \mathbf{0}$ . After $L$ iterations of feature aggregation, we obtain the node embedding vectors ${\mu }_{i} \equiv {\mu }_{i}^{\left( L\right) }$ . By summing the embedding vectors of nodes in a graph $G$ , we obtain its permutation-invariant embedding: $\mu \left( G\right) = \mathop{\sum }\limits_{{i \in \mathcal{V}}}{\mu }_{i}$ . These invariant graph embeddings represent part of the state that the RL agent observes. Aside from permutation invariance, such embeddings allow learned models to be applied to graphs of different sizes, potentially larger than those seen during training.
+
+### 4.2 Value function approximation
+
+Due to the intractable size of the state-action space in graph reconfiguration tasks, we make use of neural networks to learn approximations of the state-action values $Q\left( {s, a}\right)$ [47]. More specifically, as the action spaces defined in Equation (1) are discrete, we use the DQN algorithm [36] to update the state-action values as follows:
+
+$$
+Q\left( {s, a}\right) \leftarrow Q\left( {s, a}\right) + \alpha \left\lbrack {r + \gamma \mathop{\max }\limits_{{{a}^{\prime } \in \mathcal{A}}}Q\left( {{s}^{\prime },{a}^{\prime }}\right) - Q\left( {s, a}\right) }\right\rbrack . \tag{7}
+$$
+
+The DQN algorithm uses an experience replay buffer [33] from which it samples previously observed transitions $\left( {s, a, r,{s}^{\prime }}\right)$ , and periodically synchronizes a target network with the parameters of the Q-network. The target network is used in the computation of the learning target for estimating the Q-value of the best action in the next timestep, making the learning more stable as the parameters are - kept fixed between updates. We use three separate MLP parametrizations of the Q-function, each corresponding to one of the three sub-steps of the rewiring procedure:
+
+$$
+{Q}_{1}\left( {{S}_{t} = \left( {{G}_{t},\varnothing ,\varnothing }\right) ,{A}_{t}}\right) = {\theta }^{\left( 3\right) }\operatorname{ReLU}\left( {{\theta }^{\left( 4\right) }\left\lbrack {{\mu }_{{A}_{t}} \oplus \mu \left( {G}_{t}\right) }\right\rbrack }\right) , \tag{8a}
+$$
+
+$$
+{Q}_{2}\left( {{S}_{t} = \left( {{G}_{t},{a}_{1},\varnothing }\right) ,{A}_{t}}\right) = {\theta }^{\left( 5\right) }\operatorname{ReLU}\left( {{\theta }^{\left( 6\right) }\left\lbrack {{\mu }_{{a}_{1}} \oplus {\mu }_{{A}_{t}} \oplus \mu \left( {G}_{t}\right) }\right\rbrack }\right) , \tag{8b}
+$$
+
+$$
+{Q}_{3}\left( {{S}_{t} = \left( {{G}_{t},{a}_{1},{a}_{2}}\right) ,{A}_{t}}\right) = {\theta }^{\left( 7\right) }\operatorname{ReLU}\left( {{\theta }^{\left( 8\right) }\left\lbrack {{\mu }_{{a}_{1}} \oplus {\mu }_{{a}_{2}} \oplus {\mu }_{{A}_{t}} \oplus \mu \left( {G}_{t}\right) }\right\rbrack }\right) , \tag{8c}
+$$
+
+where $\oplus$ denotes concatenation. We highlight that, since the underlying structure2vec parameters shown in Equation (6) are shared, the combined set of the learnable parameters in our model is $\Theta = {\left\{ {\theta }^{\left( i\right) }\right\} }_{i = 1}^{8}$ . During validation and test time, we derive a greedy policy from the above learned Q-functions as $\arg \mathop{\max }\limits_{{a \in {\mathcal{A}}_{t}}}Q\left( {s, a}\right)$ . During training, however, we use a linearly decaying $\epsilon$ -greedy behavioral policy. We refer the reader to Appendix B for a detailed description of our implementation.
+
+## 5 Case study: network reconfiguration for intrusion defense
+
+In this section, we detail the specifics of our intrusion defense application scenario. We first present the definition of the objective functions we leverage, which act as proxy metrics for the difficulty of navigating the graph. Secondly, we detail the procedure we use for simulating attacker behavior during an intrusion, which will allow us to compare the pre- and post-rewiring costs of traversal.
+
+### 5.1 Objective functions for network obfuscation
+
+Our goal is to reconfigure the network so as to deter an attacker with partial knowledge of the network topology. Equivalently, we seek to modify the network so as to increase the surprise of the network and render this prior knowledge obsolete, while keep the network operational. A natural formalization of surprise is the concept of entropy, which measures the quantity of information encoded in a graph or, equivalently, its complexity.
+
+As measures of entropy, we investigate two graph quantities that are invariant to permutations in representation: the Shannon entropy of the degree distribution [2] and the Maximum Entropy Random Walk (MERW) [7] calculated from the spectrum of the adjacency matrix. The former captures the idea that graphs with heterogeneous degrees are less predictable than regular graphs, while the latter is related to random walks on the network. Whereas generic random walks generally do not
+
+
+
+Figure 2: Illustrative example of the evaluation process for a network reconfiguration. (i) The graph is rewired by our approach, removing and adding the highlighted edges respectively. (ii) The leftmost nodes in the graph become unreachable by the attacker from the entry point marked E, and hence a path to them must be rediscovered by exploring the graph. (iii) To reach the nodes, the attacker pays a cost of 1 and 2 respectively for "unlocking" the previously unseen links along the highlighted paths. The total cost induced by the rewiring strategy is ${\mathcal{C}}_{\mathrm{{RW}}}^{\text{tot }} = 3$ .
+
+maximize entropy [17], MERW uses a specific choice of transition probabilities that ensures every trajectory of fixed length is equiprobable, resulting in a maximal global entropy in the limit of infinite trajectory length. Although the local transition probabilities depend on the global structure of the graph, the generating process is local [7]. More formally, the two objective functions are formulated as follows: the Shannon entropy is defined as ${\mathcal{F}}_{\text{Shannon }}\left( G\right) = - \mathop{\sum }\limits_{{k = 1}}^{{n - 1}}q\left( k\right) {\log }_{2}q\left( k\right)$ , where $q\left( k\right)$ is the degree distribution; MERW is defined as ${\mathcal{F}}_{\text{MERW }}\left( G\right) = \ln \lambda$ , where $\lambda$ is the largest eigenvalue of the adjacency matrix. In terms of time complexity, computing the Shannon entropy scales as $\mathcal{O}\left( n\right)$ . The calculation of MERW has instead an $\mathcal{O}\left( {n}^{3}\right)$ complexity due to the eigendecomposition required to compute the spectrum of the adjacency matrix.
+
+It is worth noting that, in preliminary experiments, we have additionally investigated objective functions related to the Kolmogorov complexity. Also known as algorithmic complexity, this measure does not suffer from distributional dependencies [32]. As the Kolmogorov complexity is theoretically incomputable [10], we used graph compression algorithms such as bzip-2 [12] and Block Decomposition Methods [52] to approximate the Kolmogorov complexity. However, as these approximations depend on the representation of the graph such as the adjacency matrix, one has to consider many permutations of the graph representation. Compressing the representation for a sufficient number of permutations becomes infeasible even for small graphs. While the MERW objective function is also derived from the adjacency matrix through its largest eigenvalue, it does not suffer from this artifact as the spectrum of the adjacency matrix is invariant to permutations.
+
+### 5.2 Simulating and evaluating attacker behavior
+
+Given an initial connected and undirected graph ${G}_{0} = \left( {\mathcal{V},{\mathcal{E}}_{0}}\right)$ , we model the attacker as having entered the network through an arbitrary node $u \in \mathcal{V}$ , and having built a local map ${\mathcal{M}}_{0}^{u} = \left( {{\mathcal{V}}^{u},{\mathcal{E}}_{0}^{u}}\right)$ around this entry point, where ${\mathcal{V}}^{v} \subset \mathcal{V}$ is the set of nodes and ${\mathcal{E}}_{0}^{u} \subset {\mathcal{E}}_{0}$ is the set of edges in the map. The rewiring procedure transforms the initial graph ${G}_{0} = \left( {\mathcal{V},{\mathcal{E}}_{0}}\right)$ to the graph ${G}_{ * } = \left( {\mathcal{V},{\mathcal{E}}_{ * }}\right)$ , yielding the new local map ${\mathcal{M}}_{ * }^{u} = \left( {{\mathcal{V}}^{u},{\mathcal{E}}_{ * }^{u}}\right)$ that is unknown to the attacker. Our goal is to evaluate the effectiveness of the reconfiguration by measuring how "stale" the prior information of the attacker has become in comparison to the new map: if the attacker struggles to find its targets in the updated topology, the rewiring has succeeded.
+
+Let $\overline{{\mathcal{V}}^{u}}$ denote the set of nodes in the new local map ${\mathcal{M}}_{ * }^{u}$ that are unreachable through at least one trajectory composed of original edges ${E}_{0}^{u}$ in the old map. For each newly unreachable node ${v}_{i}$ , we measure the cost ${\mathcal{C}}_{\mathrm{{RW}}}\left( {v}_{i}\right)$ of finding it with a forward random walk, in which the random walker only returns to the previous node if the current node has no other outgoing links. Every time the random walker encounters a link that is (i) not included in ${E}_{0}^{u}$ and (ii) not yet encountered during the random walk, the cost increases by one. This simulates the cost of having to explore the new graph topology due to the reconfigurations that were introduced. Finally, we let ${\mathcal{C}}_{\mathrm{{RW}}}^{\text{tot }} = \mathop{\sum }\limits_{{{v}_{i} \in {\mathcal{V}}^{u}}}{\mathcal{C}}_{\mathrm{{RW}}}\left( {v}_{i}\right)$ denote the sum of the costs for all newly unreachable nodes, which is our metric for the effectiveness of a rewiring strategy. An illustrative example of a forward random walk and cost evaluation is shown in Figure 2, and a formal description is presented in Algorithm 1 in Appendix B to aid reproducibility.
+
+## 6 Experiments
+
+### 6.1 Experimental setup
+
+Training and evaluation procedure. Our agent is trained on synthetic graphs of size $n = {30}$ that are generated using the graph models listed below. The given budget is ${15}\%$ of the total edges $m$ that are present in the initial graph. When performing the attacker simulations, the initial local map contains the subgraph induced by all nodes that are 2 hops away from the entry point, which is sampled without replacement from the node set. Training occurs separately for each graph model and objective $\mathcal{F}$ on a set of graphs ${\mathcal{G}}_{\text{train }}$ of size $\left| {\mathcal{G}}_{\text{train }}\right| = 6 \cdot {10}^{2}$ . Every 10 training steps, we measure the performance on a disjoint validation set ${\mathcal{G}}_{\text{validation }}$ of size $\left| {\mathcal{G}}_{\text{validation }}\right| = 2 \cdot {10}^{2}$ . We perform reconfiguration operations on a test set ${\mathcal{G}}_{\text{test }}$ of size $\left| {\mathcal{G}}_{\text{test }}\right| = {10}^{2}$ . To account for stochasticity, we train our models with 10 different seeds and present mean and confidence intervals accordingly. Further details about the experimental procedure (e.g., hyperparameter optimization) can be found in Appendix B.
+
+Synthetic graphs. We evaluate the approaches on graphs generated by the following models:
+
+Barabási-Albert (BA): A preferential attachment model where nodes joining the network are linked to $M$ nodes [5]. We consider values of ${M}_{ba} = 2$ and ${M}_{ba} = 1$ (abbreviated BA-2 and BA-1).
+
+Watts-Strogatz (WS): A model that starts with a ring lattice of nodes with degree $k$ . Each edge is rewired to a random node with probability $p$ , yielding characteristically small shortest path lengths [48]. We use $k = 4$ and $p = {0.1}$ .
+
+Erdős-Rényi (ER): A random graph model in which the existence of each edge is governed by a uniform probability $p$ [20]. We use $p = {0.15}$ .
+
+Real-world graphs. We also consider the real-world Unified Host and Network (UHN) dataset [45], which is a subset of network and host events from an enterprise network. We transform this dataset into a graph by identifying the bidirectional links between hosts appearing in these records, obtaining a graph with $n = {461}$ nodes and $m = {790}$ edges. Further information about this processing can be found in Appendix B.
+
+Baselines. We compare the approach against two baselines: Random, which acts in the same MDP as the agent but chooses actions uniformly, and Greedy, which is a shallow one-step search over all rewirings from a given configuration. The latter picks the rewiring that gives the largest improvement in $\mathcal{F}$ . As this search scales very poorly with graph size and budget, we only evaluate it on graphs of size 30 that are used to train the DQN as a comparison point for validating the learned strategies.
+
+### 6.2 Entropy maximization results
+
+We first consider the results for the maximization of the entropy-based objectives. The gains in entropy obtained by the methods on the held-out test set are shown in Table 1 , while training curves are presented in Appendix A. The results demonstrate that the approach discovers better reconfiguration strategies than random rewiring in all cases, and even the greedy search in one setting. Furthermore, we evaluate the out-of-distribution generalization properties of the learned models along two dimensions: varying the graph size $n \in \left\lbrack {{10},{300}}\right\rbrack$ and the budget $b$ as a percentage of existing edges $\in \{ 5,{10},{15},{20},{25}\}$ . The results for this experiment (from which Greedy is excluded due to poor scalability) are shown in Figure 3. We find that, with the exception of the (BA, ${\mathcal{F}}_{\text{Shannon }}$ ) combination, the learned models generalize well to graphs substantially larger in size as well as varying rewiring budgets.
+
+Table 1: Entropy gains on test graphs with $n = {30}$ .
+
+ | Dataset | $\left| \mathcal{D}\right|$ | $\left| \bar{\mathcal{V}}\right|$ | $\left| \overline{\mathcal{E}}\right|$ | SL | A* | ${h}_{euc}$ | BFS | SAIL | BFWS | PHIL |
| Citation Networks | Cora (Sen et al. [49]) | 1 | 2,708 | 5,429 | 2.201 | 2.067 | 1.000 | 4.001 | 0.669 | 1.378 | 0.475 |
| PubMed (Sen et al. [49])) | 1 | 19,717 | 44,338 | 2.157 | 2.983 | 1.000 | 3.853 | 1.196 | 1.000 | 0.745 |
| CiteSeer (Sen et al. [49])) | 1 | 3,327 | 4,732 | 1.636 | 1.487 | 1.000 | 2.190 | 1.062 | 0.951 | 0.599 |
| Coauthor (cs) (Schur et al. [50]) | 1 | 18,333 | 81,894 | 1.571 | 1.069 | 1.000 | 2.820 | 1.941 | 1.026 | 0.835 |
| Coauthor (physics) (Schur et al. [50]) | 1 | 34,493 | 247,962 | 4.076 | 1.081 | 1.000 | 4.523 | - | 1.012 | 0.964 |
| Biological Networks | OGBG-Molhiv (Hu et al. [48]) | 41,127 | 25.5 | 27.5 | 1.086 | 1.065 | 1.000 | 1.267 | 1.104 | 1.146 | 1.016 |
| PPI (Zitnik et al. [51]) | 24 | 2,372.67 | 34,113.16 | 0.772 | 0.831 | 1,000 | 5.618 | 1.746 | 3.941 | 0.658 |
| Proteins (Full) (Morris et al. [52]) | 1.113 | 39.06 | 72.82 | 0.995 | 0.997 | 1.000 | 2.645 | 0.891 | 0.966 | 0.831 |
| Enzymes (Morris et al. [52]) | 600 | 32.63 | 62.14 | 1.073 | 1.007 | 1.000 | 1.358 | 1.036 | 0.992 | 0.757 |
| ASTs | OGBG-Code2 (Hu et al. [48]) | 452,741 | 125.2 | 124.2 | 1.196 | 1.013 | 1.000 | 1.267 | 1.029 | 0.817 | 1.219 |
| Road Networks | OSMnx - Modena (Boeing [53]) | 1 | 29.324 | 38,309 | 2.904 | 3.085 | 1.000 | 3.493 | 1.182 | 0.997 | 0.489 |
| OSMnx - New York (Boeing [53]) | 1 | 54.128 | 89.618 | 39.424 | 36.529 | 1.000 | 63.352 | 1.583 | 1.013 | 0.962 |
+
+Table 2: Comparison of PHIL with baseline approaches on 4 groups of datasets: citation networks, biological networks, abstract syntax trees, and road networks. "-" denotes being out of a 4-day's training time limit. We can observe that, on average across all datasets, PHIL outperforms the best baseline per dataset by 13.4%. Discounting the OGBG datasets, this number becomes 19.5%.
+
+Similarly as in Section 5.1, our MLP has four layers of width 128 with LeakyReLU activations and we use a DeeperGCN [47] graph convolution with softmax aggregation. The utilized node and edge features are the provided features in each dataset, except for a few minor modifications which are discussed in Appendix A & Appendix C. We train an MLP of depth 5 and width 256 using supervised learning (SL) for our learning-based baseline method.
+
+Discussion. The results presented in Table 2 suggest that PHIL can learn superior search heuristics compared with baseline methods, outperforming top baselines per dataset in terms of visited nodes during a search by ${13.4}\%$ on average. Two datasets where PHIL fell short compared to other baselines are the OGBG-Molhiv and OGBG-Code2 datasets. The OGBG-Code2 dataset adopts a project split [54] and OGBG-Mohliv adopts a scaffold split [55], both of which ensure that graphs of different structure are present in the training & test sets. Although PHIL improved upon uninformed search (BFS) in the OGB datasets, structural graph consistency is explicitly discouraged in the above-mentioned OGBG splits. Without the OGBG datasets, PHIL improves on the top baselines per dataset by ${19.5}\%$ on average, and upon the Euclidean node feature heuristic $\left( {h}_{\text{euc }}\right)$ by ${20.4}\%$ . Note that we trained PHIL up to $N = {60}$ iterations, which means that it only encountered a small subset of the pathfinding problems in the single graph setting, which means that PHIL had to generalize to learn useful heuristics. Even in Cora, the $\left| \mathcal{D}\right| = 1$ dataset with least number of nodes, PHIL observed roughly 6,000 node distances during training, which is less than ${0.2}\%$ of total distances in the Cora graph.
+
+### 5.3 Planning for drone flight
+
+In our final experiment, we use PHIL to plan collision-free paths in a practical drone flight use case within an indoor environment. We built our environment using the CoppeliaSim simulator [56], and the Ivy framework [57]. Figure 6 presents the environment which we refer to as room adversarial in Table 3. For more detail about each environment, please refer to the supplementary material. We discretize the environments into 3D grid graphs of size ${50} \times {50} \times {25}$ , and randomly remove 5 sub-graphs of size $5 \times$ $5 \times 5$ both during training and testing, this way simulating real-life planning scenarios with random obstacles. The hyperparameter configuration and the specific architecture we utilize are equivalent to Section 5.1, but with $n = 4$ . Likewise, the node features are 3D grid coordinates, and the baselines include supervised learning (SL), ${h}_{euc},{\mathrm{\;A}}^{ * }$ , and BFS, similarly as in Sections 5.1, 5.2. In Table 3 we report the ratio of expanded nodes with respect to ${h}_{euc}$ .
+
+
+
+Figure 6: This figure illustrates the room adversarial environment with an example planning problem (red) and the expanded graph by PHIL (blue).
+
+311 Video demo. We provide a video demonstration of PHIL running in room adversarial: https: //cutt.ly/eniu5ax.
+
+| Symbol | Description |
| $\mathcal{G}$ | Graph |
| V | Vertex set |
| $\varepsilon$ | Edge set |
| ${\mathcal{E}}_{ij}$ | Edge set of node pair(i, j) |
| $N$ | Number of nodes |
| $D$ | Dimension size |
| ${\mathcal{I}}_{T}$ | Time interval |
| $T$ | Time length |
| $B$ | Number of bins |
| ${\beta }_{i}$ | Bias term of node $i$ |
| X | Initial position matrix |
| ${\mathbf{v}}^{\left( b\right) }$ | Velocity matrix for bin $b$ |
| ${\mathbf{r}}_{i}\left( t\right)$ | Position of node $i$ at time $t$ |
| ${\lambda }_{ij}\left( t\right)$ | Intensity of node pair(i, j)at time $t$ |
| ${e}_{ij}$ | An event time of node pair(i, j) |
| $\sum$ | Covariance matrix |
| $\lambda$ | Scaling factor of the covariance |
| ${\sigma }_{\sum }$ | Noise variance |
| ${\sigma }_{\mathrm{B}}$ | Lengthscale variable of RBF kernel |
| ② | Kronecker product |
| I | Identity matrix |
| B | Bin interaction matrix |
| C | Node interaction matrix |
| D | Dimension interaction matrix |
| $\mathbf{R}$ | Capacitance matrix |
| $K$ | Latent dimension of $\mathbf{C}$ |
+
diff --git a/papers/LOG/LOG 2022/LOG 2022 Conference/48WaBYh_zbP/Initial_manuscript_tex/Initial_manuscript.tex b/papers/LOG/LOG 2022/LOG 2022 Conference/48WaBYh_zbP/Initial_manuscript_tex/Initial_manuscript.tex
new file mode 100644
index 0000000000000000000000000000000000000000..f9b8b644aee2c21a6b58822f696df2ed8de46d1c
--- /dev/null
+++ b/papers/LOG/LOG 2022/LOG 2022 Conference/48WaBYh_zbP/Initial_manuscript_tex/Initial_manuscript.tex
@@ -0,0 +1,258 @@
+§ PIECEWISE-VELOCITY MODEL FOR LEARNING CONTINUOUS-TIME DYNAMIC NODE REPRESENTATIONS
+
+Anonymous Author(s)
+
+Anonymous Affiliation
+
+Anonymous Email
+
+§ ABSTRACT
+
+Networks have become indispensable and ubiquitous structures in many fields to model the interactions among different entities, such as friendship in social networks or protein interactions in biological graphs. A major challenge is to understand the structure and dynamics of these systems. Although networks evolve through time, most existing graph representation learning methods target only static networks. Whereas approaches have been developed for the modeling of dynamic networks, there is a lack of efficient continuous time dynamic graph representation learning methods that can provide accurate network characterization and visualization in low dimensions while explicitly accounting for prominent network characteristics such as homophily and transitivity. In this paper, we propose the Precewise-VElocity Model (PIVEM) for the representation of continuous-time dynamic networks. It learns dynamic embeddings in which the temporal evolution of nodes is approximated by piecewise linear interpolations based on a latent distance model with piecewise constant node-specific velocities. The model allows for analytically tractable expressions of the associated Poisson process likelihood with scalable inference invariant to the number of events. We further impose a scalable Kronecker structured Gaussian Process prior to the dynamics accounting for community structure, temporal smoothness, and disentangled (uncorrelated) latent embedding dimensions optimally learned to characterize the network dynamics. We show that PIVEM can successfully represent network structure and dynamics in ultra-low two and three-dimensional embedding spaces. We further extensively evaluate the performance of the approach on various networks of different types and sizes and find that it outperforms existing relevant state-of-art methods in downstream tasks such as link prediction. In summary, PIVEM enables easily interpretable dynamic network visualizations and characterizations that can further improve our understanding of the intrinsic dynamics of time-evolving networks.
+
+§ 28 1 INTRODUCTION
+
+With technological advancements in data storage and production systems, we have witnessed the massive growth of graph (or network) data in recent years, with many prominent examples, including social, technological, and biological networks from diverse disciplines [1]. They propose an exquisite way to store and represent the interactions among data points and machine learning techniques on graphs have thus gained considerable attention to extract meaningful information from these complex systems and perform various predictive tasks. In this regard, Graph Representation Learning (GRL) techniques have become a cornerstone in the field through their exceptional performance in many downstream tasks such as node classification and edge prediction. Unlike the classical techniques relying on the extraction and design of handcrafted feature vectors peculiar to given networks, GRL approaches aim to design algorithms that can automatically learn features optimally preserving various characteristics of networks in their induced latent space.
+
+Many networks evolve through time and are liable to modifications in structure with newly arriving nodes or emerging connections, the GRL methods have primarily addressed static networks, in other words, a snapshot of the networks at a specific time. However, recent years have seen increasing efforts toward modeling dynamic complex networks, see also [2] for a review. Whereas most approaches have concentrated their attention on discrete-time temporal networks, which have built upon a collection of time-stamped networks (c.f. [3-11]) modeling of networks in continuous time has also been studied (c.f. [12-15]). These approaches have been based on latent class [3, 4, 12-14] and latent feature modeling approaches [5-11, 15] including advanced dynamic graph neural network representations [16, 17].
+
+Although these procedures have enabled to characterize evolving networks useful for downstream tasks such as link prediction and node classification, existing dynamic latent feature models are either in discrete time or do not explicitly account for network homophily and transitivity in terms of their latent representations. Whereas latent class models typically provide interpretable representations at the level of groups, latent feature models in general rely on high-dimensional latent representations that are not easily amenable to visualization and interpretation. A further complication of most existing dynamic modeling approaches is their scaling typically growing in complexity by the numbers of observed events and number of network dyads.
+
+This work addresses the embedding problem of nodes in a continuous-time latent space and seeks to accurately model network interaction patterns using low dimensional scalable representations explicitly accounting for network homopholy and transitivity. The main contributions of the paper can be summarized as follows:
+
+ * We propose a novel scalable GRL method, the Precewise-VElocity Model (PIVEM), to flexibly learn continuous-time dynamic node representations.
+
+ * We present a framework balancing the trade-off between the smoothness of node trajectories in the latent space and model capacity accounting for the temporal evolution.
+
+ * We show that the PIVEM can embed nodes accurately in very low dimensional spaces, i.e., $D = 2$ , such that it serves as a dynamic network visualization tool facilitating human insights into networks' complex, evolving structures.
+
+ * The performance of the introduced approach is extensively evaluated in various downstream tasks, such as network reconstruction and link prediction. We show that it outperforms wellknown baseline methods on a wide range of datasets. Besides, we propose an efficient model optimization strategy enabling the PIVEM to scale to large networks.
+
+Source code and other materials. The datasets, implementation of the method in Python, and all the generated animations can be found at the address: https://tinyurl.com/pivem.
+
+§ 2 RELATED WORK
+
+The work on dynamic modeling of complex networks has spurred substantial attention in recent years and covers approaches for the modeling of dynamic structures at the level of groups (i.e., latent class models) and dynamic representation learning approaches based on latent feature models including graph neural networks (GNNs). Whereas most attention has been given to discrete time dynamic networks a substantial body of work has also covered continuous time modeling as outlined below.
+
+§ 2.1 DYNAMIC LATENT CLASS MODELS
+
+Initial efforts for modeling continuously evolving networks has combined latent class models defined by the stochastic block models [18, 19] with Hawkes processes [20, 21]. In the work of [12], co-dependent (through time) Hawkes processes were combined with the Infinite Relational Model [22] (Hawkes IRM), yielding a non-parametric Bayesian approach capable of expressing reciprocity between inferred groups of actors. A drawback of such a model is the computational cost of the imposed Markov-chain Monte-Carlo optimization, as well as, its limitation on modelling only reciprocation effects. Scalability issues were addressed in [13] via the Block Hawkes Model (BHM), which utilizes variational inference and simplifies the Hawkes IRM model by associating only the inferred block structure pairs with a univariate point process. Recently, the BHM model was extended to decoupling interactions between different pairs of nodes belonging to the same block pair, through the use of independent univariate Hawkes processes, defining the Community Hawkes Independent Pairs model [14]. Whereas the above works have been based on continuous time modeling of dynamic networks the dynamic-IRM (dIRM) of [3] focused on the modeling of discrete time networks by inducing a infinite Hidden Markov Model (IHMM) to account for transitions over time of nodes between communities. In [4] a dynamic hierarchical block model was proposed based on the modeling of change points admitting dynamic node relocation within a Gibbs fragmentation tree. Despite the various advantages of such models, networks are constrained to be regarded and analyzed at a block level which in many cases is restrictive.
+
+§ 2.2 DYNAMIC LATENT FEATURE MODELS
+
+Prominent works around node-level representations of continuous-time networks have originally considered feature propagation within the discrete time network topology [23] or extended the random-walk frameworks of [6] and [7] to the temporal case yielding the Continuous-Time Dynamic Network Embeddings model (CTDNE), outperforming the aforementioned original approaches in multiple temporal settings. CTDNE provides a single temporal-aware node embedding, meaning that network and node evolution are unable to be visualized and explored. A more flexible approach was designed in [24] (DyRep) where temporal node embeddings are learned under a so-called latent mediation process, combining an association process describing the dynamics of the network with a communication process describing the dynamics on the network. The DyRep model uses deep recurrent architectures to parameterize the intensity function of the point process, and thus the embedding space suffers from lack of explainability. Graph neural networks (GNNs) can be extended to the analysis of continuous networks via the Temporal Graph Network (TGN) [17] where the classical encoder-decoder architecture is coupled with a memory cell.
+
+In the context of latent feature dynamic network models Gaussian Processes (GP) has been used to characterize the smoothness of the temporal dynamics. This includes the discrete time dynamic network model considered in [8] in which latent factors where endowed a GP prior based on radial basis function kernels imposing temporal smoothness within the latent representation. The approach was extended in [9] to impose stochastic differential equations for the evolution of latent factors. In [15] GPs were used for the modeling of continuous time dynamic networks based on Poisson and Hawkes processes respectively including exogenous as well as endogenous features specified by a radial basis function prior.
+
+Latent Distance Models (LDM) as proposed in [25] have recently been shown to outperform prominent GRL methods utilizing very-low dimensions in the static case [26, 27]. LDMs for temporal networks have been mostly studied in the discrete case [10], considering mainly diffusion dynamics in order to make predictions, as firstly studied in [28] and extended with popularity and activity effects [11]. While all these models express homophily (a tendency where similar nodes are more likely to connect to each other than dissimilar ones) and transitivity ("a friend of a friend is a friend") in the dynamic case, they fail to account for continuous dynamics.
+
+Our work is inspired by these previous approaches for the modeling of dynamic complex networks. Specifically, we make use of the latent distance model formulation to account for homophily and transitivity, the Poisson Process for the characterization of continuous time dynamics, and a Gaussian Process prior based on the radial-basis-function kernel to account for temporal smoothness within the latent representation. Inspired by latent class models we further impose a structured low-rank representation of nodes based on soft-assigning nodes to communities exhibiting similar temporal dynamics. Notably, we exploit how LDMs as opposed to GNN approaches in general can provide easy interpretable yet accurate network representations in ultra low $D = 2$ dimensional spaces facilitating accurate dynamic network visualization and interpretation.
+
+§ 3 PROPOSED APPROACH
+
+Our main objective is to represent every node of a given network, $\mathcal{G} = \left( {\mathcal{V},\mathcal{E}}\right)$ , into a low-dimensional metric space, $\left( {\mathrm{X},{d}_{\mathrm{X}}}\right)$ , in which the pairwise node proximities will be characterized by their distances in a continuous-time latent space (Objective 3.1). Since we address the continuous-time dynamic networks, the interactions among nodes through time can vary, with new links appearing or disappearing at any time. More precisely, we will presently consider undirected continuous-time networks:
+
+Definition 3.1. A continuous-time dynamic undirected graph on a time interval ${\mathcal{I}}_{T} \mathrel{\text{ := }} \left\lbrack {0,T}\right\rbrack$ is an ordered pair $\mathcal{G} = \left( {\mathcal{V},\mathcal{E}}\right)$ where $\mathcal{V} = \{ 1,\ldots ,N\}$ is a set of nodes and $\mathcal{E} \subseteq \left\{ {\{ i,j,t\} \in {\mathcal{V}}^{2} \times {\mathcal{I}}_{T} \mid 1 \leq }\right.$ $i < j \leq N\}$ is a set of events or edges.
+
+We will use the symbol, $N$ , to denote the number of nodes in the vertex set and ${\mathcal{E}}_{ij}\left\lbrack {{t}_{l},{t}_{u}}\right\rbrack \subseteq \mathcal{E}$ to indicate the set of edges between nodes $i$ and $j$ occurring on the interval $\left\lbrack {{t}_{l},{t}_{u}}\right\rbrack \subseteq {\mathcal{I}}_{T}$
+
+But we note that the approach readily extends to directed and bipartite dynamic networks.
+
+§ 3.1 NONHOMOGENEOUS POISSON POINT PROCESSES
+
+The Poisson Point Processes (PPP)s are one of the natural choices widely used to model the number of random events occurring in time or the locations in a spatial space. PPPs are parameterized by a quantity known as the rate or the intensity indicating the average density of the points in the underlying space of the Poisson process. If the intensity depends on the time or location, the point process is called Nonhomogeneous PPP (Defn. 3.2), and it is typically adapted for applications in which the event points are not uniformly distributed [29].
+
+Definition 3.2. [Nonhomogeneous PPP] A counting process $\{ M\left( t\right) ,t \geq 0\}$ is called a nonhomogeneous Poisson process with intensity function $\lambda \left( t\right) ,t \geq 0$ if (i) $M\left( 0\right) = 0$ ,(ii) $M\left( t\right)$ has independent increments: i.e., $\left( {M\left( {t}_{1}\right) - M\left( {t}_{0}\right) }\right) ,\ldots ,\left( {M\left( {t}_{B}\right) - M\left( {t}_{B - 1}\right) }\right)$ are independent random variables for each $0 \leq {t}_{0} < \cdots < {t}_{B}$ , and (iii) $M\left( {t}_{u}\right) - M\left( {t}_{l}\right)$ is Poisson distributed with mean ${\int }_{{t}_{l}}^{{t}_{u}}\lambda \left( t\right) {dt}$ .
+
+In this paper, we consider continuous-time dynamic networks such that the events (or links/edges) among nodes can occur at any point in time. As we will examine in the following sections, these interactions do not necessarily exhibit any recurring characteristics; instead, they vary over time in many real networks. In this regard, we assume that the number of links, $M\left\lbrack {{t}_{l},{t}_{u}}\right\rbrack$ , between a pair of node $\left( {i,j}\right) \in {\mathcal{V}}^{2}$ follows a nonhomogeneous Poisson point process (NHPP) with intensity function ${\lambda }_{ij}\left( t\right)$ on the time interval $\left\lbrack {{t}_{l},{t}_{u}}\right)$ , and for a given network $\mathcal{G} = \left( {\mathcal{V},\mathcal{E}}\right)$ , the log-likelihood function can be written by
+
+$$
+\mathcal{L}\left( \Omega \right) \mathrel{\text{ := }} \log p\left( {\mathcal{G} \mid \Omega }\right) = \frac{1}{2}\mathop{\sum }\limits_{{\left( {i,j}\right) \in {\mathcal{V}}^{2}}}\left( {\mathop{\sum }\limits_{{{e}_{ij} \in {\mathcal{E}}_{ij}}}\log {\lambda }_{ij}\left( {e}_{ij}\right) - {\int }_{0}^{T}{\lambda }_{ij}\left( t\right) {dt}}\right) \tag{1}
+$$
+
+where ${\mathcal{E}}_{i,j} \subseteq \mathcal{E}\left\lbrack {0,T}\right\rbrack$ is the set of links of node pair $\left( {i,j}\right) \in {\mathcal{V}}^{2}$ on the timeline ${\mathcal{I}}_{T} \mathrel{\text{ := }} \left\lbrack {0,T}\right\rbrack$ , and $\Omega = {\left\{ {\lambda }_{ij}\right\} }_{1 \leq i < j \leq N}$ indicates the set of intensity functions.
+
+§ 3.2 PROBLEM FORMULATION
+
+Without loss of generality, it can be assumed that the timeline starts from 0 and is bounded by $T \in {\mathbb{R}}^{ + }$ . Since the interactions among nodes can occur at any time point on ${\mathcal{I}}_{T} = \left\lbrack {0,T}\right\rbrack$ , we would like to identify an accurate continuous-time node representation $\{ r\left( {i,t}\right) {\} }_{\left( {i,t}\right) \in \mathcal{V} \times {\mathcal{I}}_{T}}$ defined using a low-dimensional latent space ${\mathbb{R}}^{D}\left( {D \ll N}\right)$ where $\mathbf{r} : \mathcal{V} \times {\mathcal{I}}_{T} \rightarrow {\mathbb{R}}^{D}$ is a map indicating the embedding or representation of node $i \in \mathcal{V}$ at time point $t \in {\mathcal{I}}_{T}$ . We define our objective more formally as follows:
+
+Objective 3.1. Let $\mathcal{G} = \left( {\mathcal{V},\mathcal{E}}\right)$ be a continuous-time dynamic network and ${\lambda }^{ * } : {\mathcal{V}}^{2} \times {\mathcal{I}}_{T} \rightarrow \mathbb{R}$ be an unknown intensity function of a nonhomogeneous Poisson point process. For a given metric space $\left( {\mathrm{X},{d}_{\mathrm{X}}}\right)$ , our purpose it to learn a function or representation $\mathbf{r} : \mathcal{V} \times {\mathcal{I}}_{T} \rightarrow \mathrm{X}$ satisfying
+
+$$
+\frac{1}{\left( {t}_{u} - {t}_{l}\right) }{\int }_{{t}_{l}}^{{t}_{u}}{d}_{\mathrm{X}}\left( {\mathbf{r}\left( {i,t}\right) ,\mathbf{r}\left( {j,t}\right) }\right) {dt} \approx \frac{1}{\left( {t}_{u} - {t}_{l}\right) }{\int }_{{t}_{l}}^{{t}_{u}}{\mathbf{\lambda }}^{ * }\left( {i,j,t}\right) {dt} \tag{2}
+$$
+
+for all $\left( {i,j}\right) \in {\mathcal{V}}^{2}$ pairs, and for every interval $\left\lbrack {{t}_{l},{t}_{u}}\right\rbrack \subseteq {\mathcal{I}}_{T}$ .
+
+In this work, we consider the Euclidean metric on a $D$ -dimensional real vector space, $\mathrm{X} \mathrel{\text{ := }} {\mathbb{R}}^{D}$ and the embedding of node $i \in \mathcal{V}$ at time $t \in {\mathcal{I}}_{T}$ will be denoted by ${\mathbf{r}}_{i}\left( t\right) \in {\mathbb{R}}^{D}$ .
+
+§ 3.3 PIVEM: PIECEWISE-VELOCITY MODEL FOR LEARNING CONTINUOUS-TIME EMBEDDINGS
+
+We learn continuous-time node representations by employing the canonical exponential link-function defining the intensity function as
+
+$$
+{\lambda }_{ij}\left( t\right) \mathrel{\text{ := }} \exp \left( {{\beta }_{i} + {\beta }_{j} - {\begin{Vmatrix}{\mathbf{r}}_{i}\left( t\right) - {\mathbf{r}}_{j}\left( t\right) \end{Vmatrix}}^{2}}\right) \tag{3}
+$$
+
+where ${\mathbf{r}}_{i}\left( t\right) \in {\mathbb{R}}^{D}$ and ${\beta }_{i} \in \mathbb{R}$ denote the embedding vector at time $t$ and the bias term of node $i \in \mathcal{V}$ , respectively. For given bias terms, it can be seen by Lemma 3.1, that the definition of the intensity function provides a guarantee for our goal given in Equation (2), and a pair of nodes having a high number of interactions can be positioned close in the latent space. Although we utilize the squared Euclidean distance in Equation (3), which is not a metric, but we impose it as a distance [27, 30].
+
+Lemma 3.1. For given fixed bias terms ${\left\{ {\beta }_{i}\right\} }_{i \in \mathcal{V}}$ , the node embeddings, ${\left\{ {\mathbf{r}}_{i}\left( t\right) \right\} }_{i \in \mathcal{V}}$ , learned by optimizing the objective function given in Equation (1) satisfy
+
+$$
+\left| {\frac{1}{\left( {t}_{u} - {t}_{l}\right) }{\int }_{{t}_{l}}^{{t}_{u}}\begin{Vmatrix}{{\mathbf{r}}_{i}\left( t\right) - {\mathbf{r}}_{j}\left( t\right) }\end{Vmatrix}{dt}}\right| \leq \sqrt{\left( {{\beta }_{i} + {\beta }_{j}}\right) - \log \left( {{p}_{ij}\frac{{m}_{ij}}{\left( {t}_{u} - {t}_{l}\right) }}\right) }\;\text{ for all }\left( {i,j}\right) \in {\mathcal{V}}^{2}
+$$
+
+where ${p}_{ij}$ is the probability of having more than ${m}_{ij}$ links between $i$ and $j$ on the interval $\left\lbrack {{t}_{l},{t}_{u}}\right)$ .
+
+§ PROOF. PLEASE SEE THE APPENDIX FOR THE PROOF.
+
+Notably, constraining the approximation of the unknown intensity function by a metric space imposes the homophily property (i.e., similar nodes in the graph are placed close to each other in embedding space). When we have a pair of nodes exhibiting high interactions, they must have average intensity, so the term, ${p}_{ij}\left( {{m}_{ij}/\left( {{t}_{u} - {t}_{l}}\right) }\right.$ , in Lemma 3.1 converges to 1, and the average distance between the nodes is bounded by the sum of their bias terms. It can also be seen that the transitivity property holds up to some extend (i.e., if node $i$ is similar to $j$ and $j$ similar to $k$ , then $i$ should also be similar to $k$ ) since we can bound the squared Euclidean distance [27,31].
+
+Importantly, for a dynamic embedding, we would like to have embeddings of a pair of nodes close enough to each other when they have high interactions during a particular time interval and far away from each other if they have less or no links. Note that the bias terms ${\left\{ {\beta }_{i}\right\} }_{i \in \mathcal{V}}$ are responsible for the node-specific effects such as degree heterogeneity [31, 32], and they provide additional flexibility to the model by acting as scaling factor for the corresponding nodes so that, for instance, a hub node might have a high number of interactions simultaneously without getting close to the others in the latent space.
+
+Since our primary purpose is to learn continuous node representations in a latent space, we define the representation of node $i \in \mathcal{V}$ at time $t$ based on a linear model by ${\mathbf{r}}_{i}\left( t\right) \mathrel{\text{ := }} {\mathbf{x}}_{i}^{\left( 0\right) } + {\mathbf{v}}_{i}t$ . Here, ${\mathbf{x}}_{i}^{\left( 0\right) }$ can be considered as the initial position and ${\mathbf{v}}_{i}$ the velocity of the corresponding node. However, the linear model provides a minimal capacity for tracking the nodes and modeling their representations. Therefore, we reinterpret the given timeline ${\mathcal{I}}_{T} \mathrel{\text{ := }} \left\lbrack {0,T}\right\rbrack$ by dividing it into $B$ equally-sized bins, $\left\lbrack {{t}_{b - 1},{t}_{b}}\right) ,\left( {1 \leq b \leq B}\right)$ such that $\left\lbrack {0,T}\right\rbrack = \left\lbrack {0,{t}_{1}}\right) \cup \cdots \cup \left\lbrack {{t}_{B - 1},{t}_{B}}\right\rbrack$ where ${t}_{0} \mathrel{\text{ := }} 0$ and ${t}_{B} \mathrel{\text{ := }} T$ . By applying the linear model for each subinterval, we obtain a piecewise linear approximation of general intensity functions strengthening the models' capacity. As a result, we can write the position of node $i$ at time $t \in {\mathcal{I}}_{T}$ as follows:
+
+$$
+{\mathbf{r}}_{i}\left( t\right) \mathrel{\text{ := }} {\mathbf{x}}_{i}^{\left( 0\right) } + {\Delta }_{B}{\mathbf{v}}_{i}^{\left( 1\right) } + {\Delta }_{B}{\mathbf{v}}_{i}^{\left( 2\right) } + \cdots + \left( {t{\;\operatorname{mod}\;\left( {\Delta }_{B}\right) }}\right) {\mathbf{v}}_{i}^{\left( \left\lfloor t/{\Delta }_{B}\right\rfloor + 1\right) } \tag{4}
+$$
+
+where ${\Delta }_{B}$ indicates the bin widths, $T/B$ , and ${\;\operatorname{mod}\;\left( \cdot \right) }$ is the modulo operation used to compute the remaining time. Note that the piece-wise interpretation of the timeline allows us to track better the path of the nodes in the embedding space, and it can be seen by Theorem 3.2 that we can obtain more accurate trails by augmenting the number of bins.
+
+Theorem 3.2. Let $\mathbf{f}\left( t\right) : \left\lbrack {0,T}\right\rbrack \rightarrow {\mathbb{R}}^{D}$ be a continuous embedding of a node. For any given $\epsilon > 0$ , there exists a continuous, piecewise-linear node embedding, $\mathbf{r}\left( t\right)$ , satisfying $\parallel \mathbf{f}\left( t\right) - \mathbf{r}\left( t\right) {\parallel }_{2} < \epsilon$ for all $t \in \left\lbrack {0,T}\right\rbrack$ where $\mathbf{r}\left( t\right) \mathrel{\text{ := }} {\mathbf{r}}^{\left( b\right) }\left( t\right)$ for all $\left( {b - 1}\right) {\Delta }_{B} \leq t < b{\Delta }_{B},\mathbf{r}\left( t\right) \mathrel{\text{ := }} {\mathbf{r}}^{\left( B\right) }\left( t\right)$ for $t = T$ and ${\Delta }_{B} = T/B$ for some $B \in {\mathbb{N}}^{ + }$ .
+
+§ PROOF. PLEASE SEE THE APPENDIX FOR THE PROOF.
+
+Prior probability. In order to control the smoothness of the motion in the latent space, we employ a Gaussian Process (GP) [33] prior over the initial position ${\mathbf{x}}^{\left( 0\right) } \in {\mathbb{R}}^{N \times D}$ and velocity vectors $\mathbf{v} \in {\mathbb{R}}^{B \times N \times D}$ . Hence, we suppose that $\operatorname{vect}\left( {\mathbf{x}}^{\left( \mathbf{0}\right) }\right) \oplus \operatorname{vect}\left( \mathbf{v}\right) \sim \mathcal{N}\left( {\mathbf{0},\mathbf{\sum }}\right)$ where $\mathbf{\sum } \mathrel{\text{ := }} {\lambda }^{2}\left( {{\sigma }_{\sum }^{2}\mathbf{I} + \mathbf{K}}\right)$ is the covariance matrix with a scaling factor $\lambda \in \mathbb{R}$ . We utilize, ${\sigma }_{\sum \in \mathbb{R}}$ , to denote the noise of the covariance, and $\operatorname{vect}\left( \mathbf{z}\right)$ is the vectorization operator stacking the columns to form a single vector. To reduce the number of parameters of the prior and enable scalable inference, we define $\mathbf{K}$ as a Kronecker product of three matrices $\mathbf{K} \mathrel{\text{ := }} \mathbf{B} \otimes \mathbf{C} \otimes \mathbf{D}$ respectively accounting for temporal-, node-, and dimension specific covariance structures. Specifically, we define $\mathbf{B} \mathrel{\text{ := }} \left\lbrack {c}_{{\mathbf{x}}^{0}}\right\rbrack \oplus {\left\lbrack \exp {\left( -{\left( {c}_{b} - {\widetilde{c}}_{\widetilde{b}}\right) }^{2}/2{\sigma }_{\mathbf{B}}^{2}\right) }_{1 \leq b,\widetilde{b} \leq B}\right\rbrack }_{1 \leq b,\widetilde{b} \leq B}$ is a $\left( {B + 1}\right) \times \left( {B + 1}\right)$ matrix intending to capture the smoothness of velocities across time-bins where ${c}_{b} = \frac{{t}_{b - 1} + {t}_{b}}{2}$ is the center of the corresponding
+
+bin, and the matrix is constructed by combining the radial basis function kernel (RBF) with a scalar term ${c}_{{\mathbf{x}}^{0}}$ corresponding to the initial position being decoupled from the structure of the velocities. The node specific matrix, $\mathbf{C} \in {\mathbb{R}}^{N \times N}$ , is constructed as a product of a low-rank matrix $\mathbf{C} \mathrel{\text{ := }} {\mathbf{{QQ}}}^{\top }$ where the row sums of $\mathbf{Q} \in {\mathbb{R}}^{N \times k}$ equals to $1\left( {k \ll N}\right)$ , and it aims to extract covariation patterns of the motion of the nodes. Finally, we simply set the dimensionality matrix to the identity: $\mathbf{D} \mathrel{\text{ := }} \mathbf{I} \in {\mathbb{R}}^{D \times D}$ in order to have uncorrelated dimensions.
+
+To sum up, we can express our objective relying on the piecewise velocities with the prior as follows:
+
+$$
+\widehat{\Omega } = \underset{\Omega }{\arg \max }\frac{1}{2}\mathop{\sum }\limits_{{\left( {i,j}\right) \in {\mathcal{V}}^{2}}}\left( {\mathop{\sum }\limits_{{{e}_{ij} \in {\mathcal{E}}_{ij}}}\log {\lambda }_{ij}\left( {e}_{ij}\right) - {\int }_{0}^{T}{\lambda }_{ij}\left( t\right) {dt}}\right) + \log \mathcal{N}\left( {\left\lbrack \begin{matrix} {\mathbf{x}}^{\left( 0\right) } \\ \mathbf{v} \end{matrix}\right\rbrack ;\mathbf{0},\mathbf{\sum }}\right) \tag{5}
+$$
+
+where $\Omega = \left\{ {\mathbf{\beta },{\mathbf{x}}^{\left( 0\right) },\mathbf{v},{\sigma }_{\sum },{\sigma }_{\mathbf{B}},{c}_{{\mathbf{x}}^{0}},\mathbf{Q}}\right\}$ is the set of hyper-parameters, and ${\lambda }_{ij}\left( t\right)$ is the intensity function as defined in Equation (3) based on the node embeddings, ${\mathbf{r}}_{i}\left( t\right) \in {\mathbb{R}}^{D}$ .
+
+§ 3.4 OPTIMIZATION
+
+Our objective given in Equation (5) is not a convex function, so the learning strategy that we follow is of great significance in order to escape from the local minima and for the quality of the representations. We start by randomly initializing the model’s hyper-parameters from $\left\lbrack {-1,1}\right\rbrack$ except for the velocity tensor, which is set to 0 at the beginning. We adapt the sequential learning strategy in learning these parameters. In other words, we first optimize the initial position and bias terms together, $\left\{ {{\mathbf{x}}^{\left( 0\right) },\mathbf{\beta }}\right\}$ , for a given number of epochs; then, we include the velocity tensor, $\{ \mathbf{v}\}$ , in the optimization process and repeat the training for the same number of epochs. Finally, we add the prior parameters and learn all model hyper-parameters together. We have employed Adam optimizer [34] with learning rate 0.1 .
+
+Computational issues and complexity. Note that we need to evaluate the log-intensity term in Equation (5) for each $\left( {i,j}\right) \in {\mathcal{V}}^{2}$ and event time ${e}_{ij} \in {\mathcal{E}}_{ij}$ . Therefore, the computational cost required for the whole network is bounded by $\mathcal{O}\left( {{\left| \mathcal{V}\right| }^{2}\left| \mathcal{E}\right| }\right)$ . However, we can alleviate the computational cost by pre-computing certain coefficients at the beginning of the optimization process so that the complexity can be reduced to $\mathcal{O}\left( {{\left| \mathcal{V}\right| }^{2}B}\right)$ . We also have an explicit formula for the computation of the integral term since we utilize the squared Euclidean distance so that it can be computed in at most $\mathcal{O}\left( {\left| \mathcal{V}\right| }^{2}\right)$ operations. Instead of optimizing the whole network at once, we apply a batching strategy over the set of nodes in order to reduce the memory requirements. As a result, we sample $\mathcal{S}$ nodes for each epoch. Hence, the overall complexity for the log-likelihood function is $\mathcal{O}\left( {{\mathcal{S}}^{2}B\mathcal{I}}\right)$ where $\mathcal{I}$ is the number of epochs and $\mathcal{S} \ll \left| \mathcal{V}\right|$ . Similarly, the prior can be computed in at most $\mathcal{O}\left( {{B}^{3}{D}^{3}{K}^{2}\mathcal{S}}\right)$ operations by using various algebraic properties such as Woodbury matrix identity and Matrix Determinant lemma [35]. To sum up, the complexity of the proposed approach is $\mathcal{O}\left( {B{\mathcal{S}}^{2}\mathcal{I} + {B}^{3}{D}^{3}{K}^{2}\mathcal{S}\mathcal{I}}\right)$ (Please see the appendix for the derivations and other details).
+
+§ 4 EXPERIMENTS
+
+In this section, we extensively evaluate the performance of the proposed PIecewise-VElocity Model with respect to the well-known baselines in challenging tasks over various datasets of sizes and types. We consider all networks as undirected, and the event times of links are scaled to the interval $\left\lbrack {0,1}\right\rbrack$ for the consistency of experiments. We use the finest granularity level of the given input timestamps, such as seconds and milliseconds. We provide a brief summary of the networks below, but more details and various statistics are reported in Table 4 in the appendix. For all the methods, we learn node embeddings in two-dimensional space $\left( {D = 2}\right)$ since one of the objectives of this work is to produce dynamic node embeddings facilitating human insights into a complex network.
+
+Experimental Setup. We first split the networks into two sets, such that the events occurring in the last 10% of the timeline are taken out for the prediction. Then, we randomly choose 10% of the node pairs among all possible dyads in the network for the graph completion task, and we ensure that each node in the residual network contains at least one event keeping the number of nodes fixed. If a pair of nodes only contains events in the prediction set and if these nodes do not have any other links during the training time, they are removed from the networks.
+
+For conducting the experiments, we generate the labeled dataset of links as follows: For the positive samples, we construct small intervals of length $2 \times {10}^{-3}$ for each event time (i.e., $\left\lbrack {e - {10}^{-3},e + {10}^{3}}\right\rbrack$ where $e$ is an event time). We randomly sample an equal number of time points and corresponding node pairs to form negative instances. If a sampled event time is not located inside the interval of a positive sample, we follow the same strategy to build an interval for it, and it is considered a negative instance. Otherwise, we sample another time point and a dyad. Note that some networks might contain a very high number of links, which leads to computational problems for these networks. Therefore, we subsample ${10}^{4}$ positive and negative instances if they contain more than this.
+
+Table 1: The performance evaluation for the network reconstruction experiment over various datasets.
+
+max width=
+
+2*X 2|c|Synthetic(π) 2|c|Synthetic $\left( \mu \right)$ 2|c|College 2|c|Contacts 2|c|Email 2|c|Forum 2|c|Hypertext
+
+2-15
+ ROC PR ROC PR ROC PR ROC PR ROC PR ROC PR ROC PR
+
+1-15
+LDM .563 .539 .669 .642 .951 .944 .860 .835 .954 .948 .909 .897 .818 .797
+
+1-15
+NODE2VEC .519 .507 .503 .509 .711 .655 .812 .756 .853 .828 .677 .619 .696 .648
+
+1-15
+CTDNE .518 .522 .499 .505 .689 .656 .599 .584 .630 .645 .643 .608 .540 .545
+
+1-15
+PIVEM .762 .713 .905 .869 .948 .948 .938 .938 .978 .977 .907 .902 .830 .823
+
+1-15
+
+Synthetic datasets. We generate two artificial networks in order to evaluate the behavior of the models in controlled experimental settings. (i) Synthetic $\left( \pi \right)$ is sampled from the prior distribution stated in Subsection 3.2. The hyper-parameters, $\mathbf{\beta },K$ and $B$ are set to0,20and 100, respectively. (ii) Synthetic $\left( \mu \right)$ is constructed based on the temporal block structures. The timeline is divided into 10 sub-intervals, and the nodes are randomly split into 20 groups for each interval. The links within each group are sampled from the Poisson distribution with the constant intensity of 5 .
+
+Real Networks. The (iii) Hypertext network [36] was built on the radio badge records showing the interactions of the conference attendees for 2.5 days, and each event time indicates 20 seconds of active contact. Similarly, (iv) the Contacts network [37] was generated concerning the interactions of the individuals in an office environment. (v) Forum [38] is comprised of the activity data of university students on an online social forum system. (vi) CollegeMsg [39] indicates the private messages among the students on an online social platform. Finally, (vii) Eu-Email [40] was constructed based on the exchanged e-mail information among the members of European research institutions.
+
+Baselines. We compare the performance of our method with three baselines. We include LDM with Poisson rate and node-specific biases [31, 41] since it is a static method having the closest formulation to ours. A very well-known GRL method, NODE2VEC (or N2V) [7] relies on the explicit generation of the random walks, and learns node embeddings by relying on the node proximities within random walks. In our experiments, we tune the model’s parameters(p, q)from $\{ {0.25},{0.5},1,2,4\}$ . Since it has the ability to run over the weighted networks, we also constructed a weighted graph based on the number of links through time and reported the best score of both versions of the networks. CTDNE [42] is a dynamic node embedding approach performing temporal random walks over the network. But it is unable to produce instantaneous node representations and produces embeddings only for a given time. Therefore, we have utilized the last time of the training set to obtain the representations. We provide the other details about the parameter settings of the baseline methods in the appendix.
+
+For our method, we set the parameter $K = {25}$ , and bins count $B = {100}$ to have enough capacity to track node interactions. For the regularization term $\left( \lambda \right)$ of the prior, we first mask ${20}\%$ of the dyads in the optimization of Equation (5). Furthermore, we train the model by starting with $\lambda = {10}^{6}$ , and then we reduce it to one-tenth after each 100 epoch. The same procedure is repeated until $\lambda = {10}^{-6}$ , and we choose the $\lambda$ value minimizing the log-likelihood of the masked pairs. The final embeddings are then obtained by performing this annealing strategy without any mask until this $\lambda$ value. We repeat this procedure 5 times, and we consider the best-performing method in learning the embeddings. The relative standard deviation of the experiments is always less than 0.5, and Figure 1a shows an illustrative example for tuning $\lambda$ over the Synthetic $\left( \pi \right)$ dataset with 5 random runs.
+
+For the performance comparison of the methods, we provide the Area Under Curve (AUC) scores for the Receiver Operating Characteristic (ROC) and Precision-Recall (PR) curves [43]. We compute the intensity of a given instance for LDM and PIVEM for the similarity measure of the node pair. Since NODE2VEC and CTDNE rely on the SkipGram architecture [44], we use cosine similarity for them.
+
+Network Reconstruction. Our goal is to see how accurately a model can capture the interaction patterns among nodes and generate embeddings exhibiting their temporal relationships in a latent space. In this regard, we train the models on the residual network and generate sample sets as described previously. The performance of the models is reported in Table 1. Comparing the performance of PIVEM against the baselines, we observe favorable results across all networks, highlighting the importance and ability of PIVEM to account for and detect structure in a continuous time manner.
+
+Table 2: The performance evaluation for the network completion experiment over various datasets.
+
+max width=
+
+2*X 2|c|Synthetic(π) 2|c|Synthetic $\left( \mu \right)$ 2|c|College 2|c|Contacts 2|c|Email 2|c|Forum 2|c|Hypertext
+
+2-15
+ ROC PR ROC PR ROC PR ROC PR ROC PR ROC PR ROC PR
+
+1-15
+LDM .535 .529 .646 .631 .931 .926 .836 .799 .948 .942 .863 .858 .761 .738
+
+1-15
+NODE2VEC .519 .511 .747 .677 .685 .637 .787 .744 .818 .777 .635 .592 .596 .588
+
+1-15
+CTDNE .522 .527 .499 .503 .647 .599 .658 .656 .571 .593 .617 .592 .464 .485
+
+1-15
+PIVEM .750 .696 .874 .851 .935 .934 .873 .864 .951 .953 .879 .875 .770 .712
+
+1-15
+
+Table 3: The performance evaluation for the link prediction experiment over various datasets.
+
+max width=
+
+2*X 2|c|Synthetic(π) 2|c|Synthetic $\left( \mu \right)$ 2|c|College 2|c|Contacts 2|c|Email 2|c|Forum 2|c|Hypertext
+
+2-15
+ ROC PR ROC PR ROC PR ROC PR ROC PR ROC PR ROC PR
+
+1-15
+LDM .562 .539 .498 .642 .951 .944 .860 .835 .954 .948 .909 .897 .819 .797
+
+1-15
+NODE2VEC .518 .506 .498 .502 .705 .676 .783 .716 .825 .807 .635 .605 .748 .739
+
+1-15
+CTDNE .514 .526 .457 .481 .666 .643 .632 .623 .629 .629 .621 .599 .508 .532
+
+1-15
+PIVEM .716 .689 .474 .485 .891 .887 .876 .884 .964 .964 .894 .895 .756 .767
+
+1-15
+
+Network Completion. The network completion experiment is a relatively more challenging task than the reconstruction. Since we hide 10% of the network, the dyads containing events are also viewed as non-link pairs, and the temporal models should place these nodes in distant locations of the embedding space. However, it might be possible to predict these events accurately if the network links have temporal triangle patterns through certain time intervals. In Table 2, we report the AUC-ROC and PR-AUC scores for the network completion experiment. Once more, PIVEM outperforms the baselines (in most cases significantly). We again discovered evidence supporting the necessity for modeling and tracking temporal networks with time-evolving embedding representations.
+
+Future Prediction. Finally, we examine the performance of the models in the future prediction task. Here, the models are asked to forecast the ${10}\%$ future of the timeline. For PIVEM, the similarity between nodes is obtained by calculating the intensity function for the timeline of the training set (i.e., from 0 to 0.9 ), and we keep our previously described strategies for the baselines since they generate the embeddings only for the last training time. Table 3 presents the performances of the models. It is noteworthy that while PIVEM outperforms the baselines significantly on the Synthetic $\left( \pi \right)$ network, it does not show promising results on Synthetic $\left( \mu \right)$ . Since the first network is compatible with our model, it successfully learns the dominant link pattern of the network. However, the second network conflicts with our model: it forms a completely different structure for every 0.1 second. For the real datasets, we observe mostly on-par results, especially with LDM. Some real networks contain link patterns that become "static" with respect to the future prediction task.
+
+We have previously described how we set the prior coefficient, $\lambda$ , and now we will examine the influence of the other hyperparameters over the $\operatorname{Synthetic}\left( \pi \right)$ dataset for network reconstruction.
+
+Influence of dimension size(D). We report the AUC-ROC and AUC-PR scores in Figure 1b. When we increase the dimension size, we observe a constant increase in performance. It is not a surprising
+
+ < g r a p h i c s >
+
+ < g r a p h i c s >
+
+Figure 2: Comparisons of the ground truth and learned representations in two-dimensional space.
+
+result because we also increase the model's capacity depending on the dimension. However, the two-dimensional space still provides comparable performances in the experiments, facilitating human insights into networks' complex, evolving structures.
+
+Influence of bin count(B). Figure $1\mathrm{c}$ demonstrates the effect of the number of bins for the network reconstruction task. We generated the Synthetic $\left( \pi \right)$ network from for 100 bins, so it can be seen that the performance stabilizes around ${2}^{6}$ , which points out that PIVEM reaches enough capability to model the interactions among nodes.
+
+Latent Embedding Animation. Although many GRL methods show high performance in the downstream tasks, in general, they require high dimensional spaces, so a postprocessing step later has to be applied in order to visualize the node representations in a small dimensional space. However, such processes cause distortions in the embeddings, which can lead a practitioner to end up with inaccurate arguments about the data.
+
+As we have seen in the experimental evaluations, our proposed approach successfully learns embed-dings in the two-dimensional space, and it also produces continuous-time representations. Therefore, it offers the ability to animate how the network evolves through time and can play a crucial role in grasping the underlying characteristics of the networks. As an illustrative example, Figure 2 compares the ground truth representations of Synthetic $\left( \pi \right)$ with the learned ones. The synthetic network consists of small communities of 5 nodes, and each color indicates these groups. Although the problem does not have unique solutions, it can be seen that our model successfully seizes the clustering patterns in the network. We refer the reader to supplementary materials for the full animation.
+
+§ 5 CONCLUSION AND LIMITATIONS
+
+In this paper, we have proposed a novel continuous-time dynamic network embedding approach, namely, Piecewise Velocity Model (PIVEM). Its performance has been examined in various experiments, such as network reconstruction and completion tasks over various networks with respect to the very well-known baselines. We demonstrated that it could accurately embed the nodes into a two-dimensional space. Therefore, it can be directly utilized to animate the learned node embeddings, and it can be beneficial in extracting the networks' underlying characteristics, foreseeing how they will evolve through time. We showed that the model could scale up to large networks.
+
+Although our model successfully learns continuous-time representations, it is unable to capture temporal patterns in the network in terms of the GP structure. Therefore, we are planning to employ different kernels instead of RBF, such as periodic kernels in the prior. The optimization strategies of the proposed method might be improved to escape from local minima. As a possible future direction, the algorithm can also be adapted for other graph types, such as directed and multi-layer networks.
\ No newline at end of file
diff --git a/papers/LOG/LOG 2022/LOG 2022 Conference/4FlyRlNSUh/Initial_manuscript_md/Initial_manuscript.md b/papers/LOG/LOG 2022/LOG 2022 Conference/4FlyRlNSUh/Initial_manuscript_md/Initial_manuscript.md
new file mode 100644
index 0000000000000000000000000000000000000000..0847d30ea3fe3eea56d84c09bbd5f09769f452e8
--- /dev/null
+++ b/papers/LOG/LOG 2022/LOG 2022 Conference/4FlyRlNSUh/Initial_manuscript_md/Initial_manuscript.md
@@ -0,0 +1,564 @@
+# On the Expressiveness and Generalization of Hypergraph Neural Networks
+
+Anonymous Author(s)
+
+Anonymous Affiliation
+
+Anonymous Email
+
+## Abstract
+
+This extended abstract describes a framework for analyzing the expressiveness, learning, and (structural) generalization of hypergraph neural networks (Hyper-GNNs). Specifically, we focus on how HyperGNNs can learn from finite datasets and generalize structurally to graph reasoning problems of arbitrary input sizes. Our first contribution is a fine-grained analysis of the expressiveness of Hyper-GNNs, that is, the set of functions that they can realize. Our result is a hierarchy of problems they can solve, defined in terms of various hyperparameters such as depths and edge arities. Next, we analyze the learning properties of these neural networks, especially focusing on how they can be trained on a finite set of small graphs and generalize to larger graphs, which we term structural generalization. Our theoretical results are further supported by the empirical results.
+
+## 1 Introduction
+
+Reasoning over graph-structured data is an important task in many applications, including molecule analysis, social network modeling, and knowledge graph reasoning [1-3]. While we have seen great success of various relational neural networks, such as Graph Neural Networks [GNNs; 4] and Neural Logical Machines [NLM; 5] in a variety of applications [6-8], we do not yet have a full understanding of how different design parameters, such as the depth of the neural network, affects the expressiveness of these models, or how effectively these models generalize from limited data.
+
+This paper analyzes the expressiveness and generalization of relational neural networks applied to hypergraphs, which are graphs with edges connecting more than two nodes. We have formally shown the "if and only if" conditions for the expressive power with respect to the edge arity. That is, $k$ -ary hyper-graph neural networks are sufficient and necessary for realizing FOC- $k$ , a fragment of first-order logic which involves at most $k$ variables. This is a helpful result because now we can determine whether a specific hypergraph neural network can solve a problem by understanding what form of logic formula can represent the solution to this problem. Next, we formally described the relationship between expressiveness and non-constant-depth networks. We state a conjecture about the "depth hierarchy," and connect the potential proof of this conjecture to the distributed computing literature. Our results highlight that: Even when the inputs and outputs of models have only unary and binary relations, allowing intermediate hyperedge representations increases the expressiveness.
+
+Furthermore, we prove, under certain realistic assumptions, it is possible to train a hypergraph neural networks on a finite set of small graphs, and it will generalize to arbitrarily large graphs. This ability is the result of the weight-sharing nature of hypergraph neural networks. We hope our work can serve as a foundation for designing hypergraph neural networks: to solve a specific problem, what arity do you need? What depth do you need? Will my model have structural generalization (i.e., to larger graphs)? Our theoretical results on learning are further supported by experiments, for empirical demonstration of the theorems.
+
+## 2 Hypergraph Reasoning Problems and Hypergraph Neural Networks
+
+A hypergraph representation $G$ is a tuple(V, X), where $V$ is a set of entities (nodes), and $X$ is a set of hypergraph representation functions. Specifically, $X = \left\{ {{X}_{0},{X}_{1},{X}_{2},\cdots ,{X}_{k}}\right\}$ , where ${X}_{j} : \left( {{v}_{1},{v}_{2},\cdots ,{v}_{j}}\right) \rightarrow \mathcal{S}$ is a function mapping every tuple of $j$ nodes to a value. We call $j$ the arity of the hyperedge and $k$ is the max arity of input hyperedges.m The range $\mathcal{S}$ can be any set of discrete labels that describes relation type, or a scalar number (e.g., the length of an edge), or a vector. In general, we will use the arity 0 representation function ${X}_{0}\left( \varnothing \right) \rightarrow \mathcal{S}$ to represent any global properties of the graph as a whole.
+
+A graph reasoning function $f$ is a mapping from a hypergraph representation $G = \left( {V, X}\right)$ to another hyperedge representation function $Y$ on $V$ . As concrete examples, asking whether a graph is fully connected is a graph classification problem, where the output $Y = \left\{ {Y}_{0}\right\}$ and ${Y}_{0}\left( \varnothing \right) \rightarrow {\mathcal{S}}^{\prime } = \{ 0,1\}$ is a global label; finding the set of disconnected subgraphs of size $k$ is a $k$ -ary hyperedge classification problem, where the output $Y = \left\{ {Y}_{k}\right\}$ is a label for each $k$ -ary hyperedges.
+
+There are two main motivations and constructions of a neural network applied to graph reasoning problems: message-passing-based and first-order-logic-inspired. Both approaches construct the computation graph layer by layer. The input to the entire neural network consists of the input features of nodes and hyperedges, while the output of the neural network is the per-node or per-edge prediction of desired properties, depending on the training task.
+
+In a nutshell, within each layer, message-passing-based hypergraph neural networks, Higher-Order GNNs [9], perform message passing between each hyperedge and its neighbours. Specifically, we say the j-th neighbour set of a hyperedge $u = \left( {{x}_{1},{x}_{2},\cdots ,{x}_{i}}\right)$ of arity $i$ is ${N}_{j}\left( u\right) =$ $\left\{ \left( {{x}_{1},{x}_{2},\cdots ,{x}_{j - 1}, r,{x}_{j + 1},\cdots ,{x}_{i}}\right) \right\}$ , where $r \in V$ . Then, the all neighbours of node $u$ is the union of all ${N}_{j}$ ’s, where $j = 1,2,\cdots , i$ .
+
+On the other hand, first-order-logic-inspired hypergraph neural networks consider building neural networks that can emulate first logic formulas. Neural Logic Machines [NLM; 5] are defined in terms of a set of input hyperedges; each hyperedge of arity $k$ is represented by a vector of (possibly real) values obtained by applying all of the k -ary predicates in the domain to the tuple of vertices it connects. Each layer in an NLM learns to apply a linear transformation with nonlinear activation and quantification operators (analogous to the for all $\forall$ and exists $\exists$ quantifiers in first-order logic), on these values. It is easy to prove, by construction, that given a sufficient number of layers and maximum arity, NLMs can learn to realize any first-order-logic formula. For readers who are not familiar with HO-GNNs [9] and NLMs [5], we include a mathematical summary of their computation graph in Appendix B. Our analysis starts from the following theorem.
+
+Theorem 2.1. HO-GNNs [9] are equivalent to NLMs in terms of expressiveness. Specifically, a B-ary HO-GNN is equivalent to an NLM applied to $B + 1$ -ary hyperedges. Proofs are in Appendix B.3.
+
+Given Theorem 2.1, we can focus our analysis on just one single type of hypergraph neural network. Specifically, we will focus on Neural Logic Machines [NLM; 5] because its architecture naturally aligns with first-order logic formula structures, which will aid some of our analysis. An NLM is characterized by hyperparameters $D$ (depth), and $B$ maximum arity. We are going to assume that $B$ is a constant, but $D$ can be dependent on the size of the input graph. We will use $\operatorname{NLM}\left\lbrack {D, B}\right\rbrack$ to denote an NLM family with depth $D$ and max arity $B$ . Other parameters such as the width of neural networks affects the precise details of what functions can be realized, as it does in a regular neural network, but does not affect the analyses in this extended abstract. Furthermore, we will be focusing on neural networks with bounded precision, and briefly discuss how our results generalize to unbounded precision cases.
+
+## 3 Expressiveness of Relational Neural Networks
+
+We start from a formal definition of hypergraph neural network expressiveness.
+
+Definition 3.1 (Expressiveness). We say a model family ${\mathcal{M}}_{1}$ is at least expressive as ${\mathcal{M}}_{2}$ , written as ${\mathcal{M}}_{1} \succcurlyeq {\mathcal{M}}_{2}$ , if for all ${M}_{2} \in {\mathcal{M}}_{2}$ , there exists ${M}_{1} \in {\mathcal{M}}_{1}$ such that ${M}_{1}$ can realize ${M}_{2}$ . A model family ${\mathcal{M}}_{1}$ is more expressive than ${\mathcal{M}}_{2}$ , written as ${\mathcal{M}}_{1} \succ {\mathcal{M}}_{2}$ , if ${\mathcal{M}}_{1} \succcurlyeq {\mathcal{M}}_{2}$ and $\exists {M}_{1} \in {\mathcal{M}}_{1}$ , $\forall {M}_{2} \in {\mathcal{M}}_{2},{M}_{2}$ can not realize ${M}_{1}$ .
+
+Arity Hierarchy We first aim to quantify how the maximum arity $B$ of the network’s representation affects its expressiveness and find that, in short, even if the inputs and outputs of neural networks are of low arity, the higher the maximum arity for intermediate layers, the more expressive the NLM is.
+
+Theorem 3.1 (Arity Hierarchy). For any maximum arity $B$ , there exists a depth ${D}^{ * }$ such that: $\forall D \geq {D}^{ * },\operatorname{NLM}\left\lbrack {D, B + 1}\right\rbrack$ is more expressive than $\operatorname{NLM}\left\lbrack {D, B}\right\rbrack$ . This theorem applies to both fixed-precision and unbounded-precision networks.
+
+Proof sketch: Our proof slightly extends the proof of Morris et al. [9]. First, the set of graphs distinguishable by $\operatorname{NLM}\left\lbrack {D, B}\right\rbrack$ is bounded by graphs distinguishable by a $D$ -round order- $B$ Weisfeiler-Leman test [10]. If models in NLM $\left\lbrack {D, B}\right\rbrack$ cannot generate different outputs for two distinct
+
+hypergraphs ${G}_{1}$ and ${G}_{2}$ , but there exists $M \in \operatorname{NLM}\left\lbrack {D, B + 1}\right\rbrack$ that can generate different outputs for ${G}_{1}$ and ${G}_{2}$ , then we can construct a graph classification function $f$ that $\operatorname{NLM}\left\lbrack {D, B + 1}\right\rbrack$ (with some fixed precision) can realize but $\operatorname{NLM}\left\lbrack {D, B}\right\rbrack$ (even with unbounded precision) cannot.* The full proof is described in Appendix C.1.
+
+It is also important to quantify the minimum arity for realizing certain graph reasoning functions.
+
+Theorem 3.2 (FOL realization bounds). Let ${\mathrm{{FOC}}}_{B}$ denote a fragment of first order logic with at most $B$ variables, extended with counting quantifiers of the form ${\exists }^{ \geq n}\phi$ , which state that there are at least $n$ nodes satisfying formula $\phi$ [11].
+
+- (Upper Bound) Any function $f$ in ${\mathrm{{FOC}}}_{B}$ can be realized by $\mathrm{{NLM}}\left\lbrack {D, B}\right\rbrack$ for some $D$ .
+
+- (Lower Bound) There exists a function $f \in {\mathrm{{FOC}}}_{B}$ such that for all $D, f$ cannot be realized by $\operatorname{NLM}\left\lbrack {D, B - 1}\right\rbrack$ .
+
+Proof: The upper bound part of the claim has been proved by Barceló et al. [12] for $B = 2$ . The results generalize easily to arbitrary $B$ because the counting quantifiers can be realized by sum aggregation. The lower bound part can be proved by applying Section 5 of [11], in which they show that ${\mathrm{{FOC}}}_{B}$ is equivalent to a(B - 1)-dimensional WL test in distinguishing non-isomorphic graphs. Given that $\mathrm{{NLM}}\left\lbrack {D, B - 1}\right\rbrack$ is equivalent to the(B - 2)-dimensional WL test of graph isomorphism, there must be an ${\mathrm{{FOL}}}_{B}$ formula that distinguishes two non-isomorphic graphs that $\operatorname{NLM}\left\lbrack {D, B - 1}\right\rbrack$ cannot. Hence, ${\mathrm{{FOL}}}_{B}$ cannot be realized by $\mathrm{{NLM}}\left\lbrack {\cdot , B - 1}\right\rbrack$ .
+
+Depth Hierarchy We now study the dependence of the expressiveness of NLMs on depth $D$ . Neural networks are generally defined to have a fixed depth, but allowing them to have a depth that is dependent on the number of nodes $n = \left| V\right|$ in the graph can substantially increase their expressive power. In the following, we define a depth hierarchy by analogy to the time hierarchy in computational complexity theory [13], and we extend our notation to let $\operatorname{NLM}\left\lbrack {O\left( {f\left( n\right) }\right) , B}\right\rbrack$ denote the class of adaptive-depth NLMs in which the growth-rate of depth $D$ is bounded by $O\left( {f\left( n\right) }\right)$ .
+
+Conjecture 3.3 (Depth hierarchy). For any maximum arity $B$ , for any two functions $f$ and $g$ , if $g\left( n\right) = o\left( {f\left( n\right) /\log n}\right)$ , that is, $f$ grows logarithmically more quickly than $g$ , then fixed-precision $\operatorname{NLM}\left\lbrack {O\left( {f\left( n\right) }\right) , B}\right\rbrack$ is more expressive than fixed-precision $\operatorname{NLM}\left\lbrack {O\left( {g\left( n\right) }\right) , B}\right\rbrack$ .
+
+There is a closely related result for the congested clique model in distributed computing, where [14] proved that $\operatorname{CLIQUE}\left( {g\left( n\right) }\right) \varsubsetneq \operatorname{CLIQUE}\left( {f\left( n\right) }\right)$ if $g\left( n\right) = o\left( {f\left( n\right) }\right)$ . This result does not have the $\log n$ gap because the congested clique model allows $\log n$ bits to transmit between nodes at each iteration, while fixed-precision NLM allows only a constant number of bits. The reason why the result on congested clique can not be applied to fixed-precision NLMs is that congested clique assumes unbounded precision representation for each individual node.
+
+However, Conjecture 3.3 is not true for NLMs with unbounded precision, because there is an upper bound depth $O\left( {n}^{B - 1}\right)$ for a model’s expressiveness power. ${}^{ \dagger }$ That is, an unbounded-precision NLM can not achieve stronger expressiveness by increasing its depth beyond $O\left( {n}^{B - 1}\right)$ .
+
+It is important to point out that, to realize a specific graph reasoning function, NLMs with different maximum arity $B$ may require different depth $D$ . Fürer [15] provides a general construction for problems that higher-dimensional NLMs can solve in asymptotically smaller depth than lower-dimensional NLMs. In the following we give a concrete example for computing $S - T$ Connectivity- $k$ , which asks whether there is a path of nodes from $S$ and $T$ in a graph, with length $\leq k$ .
+
+Theorem 3.4 (S-T Connectivity- $k$ with Different Max Arity). For any function $f\left( k\right)$ , if $f\left( k\right) = o\left( k\right)$ , $\operatorname{NLM}\left\lbrack {O\left( {f\left( k\right) }\right) ,2}\right\rbrack$ cannot realize S-T Connectivity- $k$ . That is, S-T Connectivity- $k$ requires depth at least $O\left( k\right)$ for a relational neural network with an maximum arity of $B = 2$ . However, S-T Connectivity- $k$ can be realized by $\operatorname{NLM}\left\lbrack {O\left( {\log k}\right) ,3}\right\rbrack$ .
+
+Proof sketch. For any integer $k$ , we can construct a graph with two chains of length $k$ , so that if we mark two of the four ends as $S$ or $T$ , any $\operatorname{NLM}\left\lbrack {k - 1,2}\right\rbrack$ cannot tell whether $S$ and $T$ are on the same chain. The full proof is described in Appendix C.3.
+
+There are many important graph reasoning tasks that do not have known depth lower bounds, including all-pair connectivity and shortest distance [16, 17]. In Appendix C.3, we discuss the concrete complexity bounds for a series of graph reasoning problems.
+
+---
+
+${}^{ * }$ Note that the arity hierarchy is applied to fixed-precision and unbounded-precision separately. For example, $\operatorname{NLM}\left\lbrack {D, B}\right\rbrack$ with unbounded precision is incomparable with $\operatorname{NLM}\left\lbrack {D, B + 1}\right\rbrack$ with fixed precision.
+
+${}^{ \dagger }$ See appendix C. 2 for a formal statement and the proof.
+
+---
+
+## 4 Learning and Generalization in Relational Neural Networks
+
+Given our understanding of what functions can be realized by NLMs, we move on to the problems of learning them: Can we effectively learn a NLMs to solve a desired task given a sufficient number of input-output examples? In this paper, we show that applying enumerative training with examples up to some fixed graph size can ensure that the trained neural network will generalize to all graphs larger than those appearing in the training set.
+
+A critical determinant of the generalization ability for NLMs is the aggregation function they use. Specifically, Xu et al. [18] have shown that using sum as the aggregation function provides maximum expressiveness for graph neural networks. However, sum aggregation cannot be implemented in fixed-precision models with an arbitrary number of nodes, because as the graph size $n$ increases, the range of the sum aggregation also increases.
+
+Definition 4.1 (Fixed-precision aggregation function). An aggregation function is fixed precision if it maps from any finite set of inputs with values drawn from finite domains to a fixed finite set of possible output values; that is, the cardinality of the range of the function cannot grow with the number of elements in the input set. Two useful fixed-precision aggregation functions are max, which computes the dimension-wise maximum over the set of input values, and fixed-precision mean, which approximates the dimension-wise mean to a fixed decimal place.
+
+In order to focus on structural generalization in this section, we consider an enumerative training paradigm. When the input hypergraph representation domain $\mathcal{S}$ is a finite set, we can enumerate the set ${\mathcal{G}}_{ < N}$ of all possible input hypergraph representations of size bounded by $N$ . We first enumerate all graph sizes $n \leq N$ ; for each $n$ , we enumerate all possible values assigned to the hyperedges in the input. Given training size $N$ , we enumerate all inputs in ${\mathcal{G}}_{ \leq N}$ , associate with each one the corresponding ground-truth output representation, and train the model with these input-output pairs.
+
+This has much stronger data requirements than the standard sampling-based training mechanisms in machine learning. In practice, this can be approximated well when the input domain $\mathcal{S}$ is small and the input data distribution is approximately uniformly distributed. The enumerative learning setting is studied by the language identification in the limit community [19], in which it is called complete presentation. This is an interesting learning setting because even if the domain for each individual hyperedge representation is finite, as the graph size can go arbitrarily large, the number of possible inputs is enumerable but unbounded.
+
+Theorem 4.1 (Fixed-precision generalization under complete presentation). For any hypergraph reasoning function $f$ , if it can be realized by a fixed-precision relational neural network model $\mathcal{M}$ , then there exists an integer $N$ , such that if we train the model with complete presentation on all input hypergraph representations with size smaller than $N,{\mathcal{G}}_{ \leq N}$ , then for all $M \in \mathcal{M}$ ,
+
+$$
+\mathop{\sum }\limits_{{G \in {\mathcal{G}}_{ < N}}}1\left\lbrack {M\left( G\right) \neq f\left( G\right) }\right\rbrack = 0 \Rightarrow \forall G \in {\mathcal{G}}_{\infty } : M\left( G\right) = f\left( G\right) .
+$$
+
+That is, as long as $M$ fits all training examples, it will generalize to all possible hypergraphs in ${\mathcal{G}}_{\infty }$ .
+
+Proof. The key observation is that for any fixed vector representation length $W$ , there are only a finite number of distinctive models in a fixed-precision NLM family, independent of the graph size $n$ . Let ${W}_{b}$ be the number of bits in each intermediate representation of a fixed-precision NLM. There are at most ${\left( {2}^{{W}_{b}}\right) }^{{2}^{{W}_{b}}}$ different mappings from inputs to outputs. Hence, if $N$ is sufficiently large to enumerate all input hypergraphs, we can always identify the correct model in the hypothesis space.
+
+Our results are related to the algorithmic alignment approach [20, 21]. In contrast to their Probably Approximately Correct Learning (PAC-Learning) bounds for sample efficiency, our expressiveness results directly quantifies whether a hypergraph neural network can be trained to realize a specific function. Our generalization theorem applies to more generally than their result on Max-Degree function learning due to the assumption of fixed precision.
+
+## 5 Conclusion
+
+In this extended abstract, we have shown the substantial increase of expressive power due to higher-arity relations and increasing depth, and have characterized very powerful structural generalization from training on small graphs to performance on larger ones. We further discuss the relationship between these results and existing results in Appendix A. All theoretical results are further supported by the empirical results, discussed in Appendix D. Although many questions remain open about the overall generalization capacity of these models in continuous and noisy domains, we believe this work has shed some light on their utility and potential for application in a variety of problems.
+
+References
+
+[1] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In ${ICML},{2017.1}$
+
+[2] Michael Schlichtkrull, Thomas N Kipf, Peter Bloem, Rianne Van Den Berg, Ivan Titov, and Max Welling. Modeling relational data with graph convolutional networks. In ESWC, 2018.
+
+[3] Qi Liu, Maximilian Nickel, and Douwe Kiela. Hyperbolic graph neural networks. IEEE Transactions on Knowledge and Data Engineering, 2017. 1
+
+[4] Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE transactions on neural networks, 20(1):61-80, 2008. 1
+
+[5] Honghua Dong, Jiayuan Mao, Tian Lin, Chong Wang, Lihong Li, and Denny Zhou. Neural logic machines. In ${ICLR},{2019.1},2,7,8,{16}$
+
+[6] Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261, 2018. 1
+
+[7] Christian Merkwirth and Thomas Lengauer. Automatic generation of complementary descriptors with molecular graph networks. Journal of chemical information and modeling, 45(5):1159- 1168, 2005.
+
+[8] Petar Veličković, Rex Ying, Matilde Padovano, Raia Hadsell, and Charles Blundell. Neural execution of graph algorithms. In ${ICLR},{2020.1}$
+
+[9] Christopher Morris, Martin Ritzert, Matthias Fey, William L Hamilton, Jan Eric Lenssen, Gaurav Rattan, and Martin Grohe. Weisfeiler and leman go neural: Higher-order graph neural networks. In ${AAAI},{2019.2},7,{12}$
+
+[10] AA Leman and B Weisfeiler. A reduction of a graph to a canonical form and an algebra arising during this reduction. Nauchno-Technicheskaya Informatsiya, 2(9):12-16, 1968. 2
+
+[11] Jin-Yi Cai, Martin Fürer, and Neil Immerman. An optimal lower bound on the number of variables for graph identification. Combinatorica, 12(4):389-410, 1992. 3, 12, 13
+
+[12] Pablo Barceló, Egor V Kostylev, Mikael Monet, Jorge Pérez, Juan Reutter, and Juan Pablo Silva. The logical expressiveness of graph neural networks. In ICLR, 2020. 3, 7, 13
+
+[13] Juris Hartmanis and Richard E Stearns. On the computational complexity of algorithms. Transactions of the American Mathematical Society, 117:285-306, 1965. 3
+
+[14] Janne H Korhonen and Jukka Suomela. Towards a complexity theory for the congested clique. In ${SPAA},{2018.3}$
+
+[15] Martin Fürer. Weisfeiler-lehman refinement requires at least a linear number of iterations. In ICALP, 2001. 3
+
+[16] Mauricio Karchmer and Avi Wigderson. Monotone circuits for connectivity require super-logarithmic depth. SIAM J. Discrete Math., 3(2):255-265, 1990. 3, 7
+
+[17] Shreyas Pai and Sriram V Pemmaraju. Connectivity lower bounds in broadcast congested clique. In ${PODC},{2019.3}$
+
+[18] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In ICLR, 2019. 4, 7
+
+[19] E Mark Gold. Language identification in the limit. Inf. Control., 10(5):447-474, 1967. 4
+
+[20] Keyulu Xu, Jingling Li, Mozhi Zhang, Simon S Du, Ken-ichi Kawarabayashi, and Stefanie Jegelka. What can neural networks reason about? In ICLR, 2020. 4, 7
+
+[21] Keyulu Xu, Mozhi Zhang, Jingling Li, Simon S Du, Ken-ichi Kawarabayashi, and Stefanie Jegelka. How neural networks extrapolate: From feedforward to graph neural networks. In ICLR, 2021. 4, 7
+
+[22] Yuan Li, Alexander Razborov, and Benjamin Rossman. On the ac^0 complexity of subgraph isomorphism. SIAM J. Comput., 46(3):936-971, 2017. 7
+
+[23] Benjamin Rossman. Average-case complexity of detecting cliques. PhD thesis, Massachusetts Institute of Technology, 2010. 7
+
+[24] Andreas Loukas. What graph neural networks cannot learn: depth vs width. In International Conference on Learning Representations, 2020. 7
+
+[25] Mostafa Dehghani, Stephan Gouws, Oriol Vinyals, Jakob Uszkoreit, and Lukasz Kaiser. Universal transformers. In ${ICLR},{2019.7}$
+
+[26] Yifan Feng, Haoxuan You, Zizhao Zhang, Rongrong Ji, and Yue Gao. Hypergraph neural networks. In ${AAAI},{2019.11}$
+
+[27] Naganand Yadati, Madhav Nimishakavi, Prateek Yadav, Vikram Nitin, Anand Louis, and Partha Talukdar. Hypergcn: A new method of training graph convolutional networks on hypergraphs. In NeurIPS, 2019.
+
+[28] Song Bai, Feihu Zhang, and Philip HS Torr. Hypergraph convolution and hypergraph attention. Pattern Recognition, 110:107637, 2021. 11
+
+[29] Kaize Ding, Jianling Wang, Jundong Li, Dingcheng Li, and Huan Liu. Be more with less: Hypergraph attention networks for inductive text classification. In EMNLP, 2020. 11
+
+[30] Jing Huang and Jie Yang. Unignn: a unified framework for graph and hypergraph neural networks. In IJCAI, 2021. 11
+
+[31] Sandra Kiefer and Pascal Schweitzer. Upper bounds on the quantifier depth for graph differentiation in first order logic. In LICS, 2016. 12
+
+[32] Efim A Dinic. Algorithm for solution of a problem of maximum flow in networks with power estimation. In Soviet Math. Doklady, volume 11, pages 1277-1280, 1970. 15
+
+272
+
+## Appendix
+
+The appendix is organized as the following. In Appendix A, we discuss the related work. In Appendix B, we provide a formalization of two types of hypergraph neural networks discussed in the main paper, and proved their equivalence. In Appendix C, we prove the theorems for the arity hierarchy and provide concrete examples for expressiveness analyses. Finally, in Appendix D, we include additional experiment results to empirically illustrate the application of theorems discussed in the paper.
+
+## A Related Work
+
+Solving problems on graphs of arbitrary size is studied in many fields. NLMs can be viewed as circuit families with constrained architecture. In distributed computation, the congested clique model can be viewed as 2-arity NLMs, where nodes have identities as extra information. Common graph problems including sub-structure detection $\left\lbrack {{22},{23}}\right\rbrack$ and connectivity $\left\lbrack {16}\right\rbrack$ are studied for lower bounds in terms of depth, width and communication. This has been connected to GNNs for deriving expressiveness bounds [24].
+
+Studies have been conducted on the expressiveness of GNNs and their variants. [18] provide an illuminating characterization of GNN expressiveness in terms of the WL graph isomorphism test. [12] reviewed GNNs from the logical perspective and rigorously refined their logical expressiveness with respect to fragments of first-order logic. [5] proposed Neural Logical Machines (NLMs) to reason about higher-order relations, and showed that increasing order inreases expressiveness. It is also possible to gain expressiveness using unbounded computation time, as shown by the work of Dehghani et al. [25] on dynamic halting in transformers.
+
+It is interesting that GNNs may generalize to larger graphs. Xu et al. [20, 21] have studied the notion of algorithmic alignment to quantify such structural generalization. Dong et al. [5] provided empirical results showing that NLMs generalize to much larger graphs on certain tasks. In Xu et al. [20], they analyzed and compared the sample complexity of Graph Neural Networks. This is different from our notion of expressiveness for realizing functions. In Xu et al. [21], they showed emperically on some problems (e.g., Max-Degree, Shortest Path, and n-body problem) that algorithm alignment helps GNNs to extrapolate, and theoretically proved the improvement by algorithm alignment on the Max-Degree problem. In this extended abstract, instead of focusing on computing specific graph problems, we analyzed how GNNs can extrapolate to larger graphs in a general case, based on the assumption of fixed precision computation.
+
+## B Hypergraph Neural Networks
+
+We now introduce two important hypergraph neural network implementations that can be trained to solve graph reasoning problems: Higher-order Graph Neural Networks [HO-GNN; 9] and Neural Logic Machines [NLM; 5]. The are equivalent to each other in terms of expressiveness. Showing this equivalence allows us to focus the rest of the paper on analyzing a single model type, with the understanding that the conclusions generalize to a broader class of hypergraph neural networks.
+
+### B.1 Higher-order Graph Neural Networks
+
+Higher-order Graph Neural Networks [HO-GNNs; 9] are Graph Neural Networks (GNNs) that apply to hypergraphs. A GNN is usually defined based on two message passing operations.
+
+- Edge update: the feature of each edge is updated by features of its ends.
+
+- Note update: the feature of each node is updated by features of all edges adjacent to it.
+
+However, computing only node-wise and edge-wise features does not handle higher-order relations, such as triangles in the graph. In order to obtain more expressive power, GNNs have be extend to hypergraphs of higher arity [9]. Specifically, HO-GNNs on $B$ -ary hypergraph maintains features for all $B$ -tuple of nodes, and the neighborhood is extended to $B$ -tuples accordingly: the feature of tuple $\left( {{v}_{1},{v}_{2},\cdots ,{v}_{B}}\right)$ is updated by the $\left| V\right|$ element multiset (contain $\left| V\right|$ elements for each $u \in V$ ) of $B$ -tuples of features
+
+$$
+\left( {{H}_{i}\left\lbrack {u,{v}_{2},\cdots ,{v}_{B}}\right\rbrack ,{H}_{i - 1}\left\lbrack {{v}_{1}, u,{v}_{2},\cdots ,{v}_{B}}\right\rbrack ,\cdots {H}_{i - 1}\left\lbrack {{v}_{1},\cdots ,{v}_{B - 1}, u}\right\rbrack }\right) \tag{B.1}
+$$
+
+
+
+Figure 1: The overall architecture of our Neural Logic Machines (NLMs). It follows the computation graph of NLM [5] and can be applied to hypergraphs.
+
+where ${H}_{i - 1}\left\lbrack \mathbf{v}\right\rbrack$ is the feature of tuple $\mathbf{v}$ from the previous iteration.
+
+We now introduce the formal definition of the high-dimensional message passing. We denote $v$ as a $B$ -tuple of nodes $\left( {{v}_{1},{v}_{2},\cdots ,{v}_{B}}\right)$ , and generalize the neighborhood to a higher dimension by defining the neighborhood of $\mathbf{v}$ as all node tuples that differ from $\mathbf{v}$ at one position.
+
+$$
+\operatorname{Neighbors}\left( {\mathbf{v}, u}\right) = \left( {\left( {u,{v}_{2},\cdots ,{v}_{B}}\right) ,\left( {{v}_{1}, u,{v}_{3},\cdots ,{v}_{B}}\right) ,\cdots ,\left( {{v}_{1},\cdots ,{v}_{B - 1}, u}\right) }\right) \tag{B.2}
+$$
+
+$$
+N\left( \mathbf{v}\right) = \{ \text{ Neighbors }\left( {\mathbf{v}, u}\right) \mid u \in V\} \tag{B.3}
+$$
+
+Then message passing scheme naturally generalizes to high-dimensional features using the high-dimensional neighborhood.
+
+$$
+{\operatorname{Received}}_{i}\left\lbrack \mathbf{v}\right\rbrack = \mathop{\sum }\limits_{u}\left( {{\mathrm{{NN}}}_{1}\left( {{H}_{i - 1}\left\lbrack \mathbf{v}\right\rbrack ;{\operatorname{CONCAT}}_{{\mathbf{v}}^{\prime } \in \text{ neighbors }\left( {\mathbf{v}, u}\right) }{H}_{i - 1}\left\lbrack {\mathbf{v}}^{\prime }\right\rbrack }\right) }\right) \tag{B.4}
+$$
+
+### B.2 Neural Logic Machines
+
+A NLM is a multi-layer neural network that operates on hypergraph representations, in which the hypergraph representation functions are represented as tensors. The input is a hypergraph representation(V, X). There are then several computational layers, each of which produces a hypergraph representation with nodes $V$ and a new set of representation functions. Specifically, a $B$ -ary NLM produces hypergraph representation functions with arities from 0 up to a maximum hyperedge arity of $B$ . We let ${T}_{i, j}$ denote the tensor representation for the output at layer $i$ and arity $j$ . Each entry in the tensor is a mapping from a set of node indices $\left( {{v}_{1},{v}_{2},\cdots ,{v}_{j}}\right)$ to a vector in a latent space ${\mathbb{R}}^{W}$ . Thus, ${T}_{i, j}$ is a tensor of $j + 1$ dimensions, with the first $j$ dimensions corresponding to $j$ -tuple of nodes, and the last feature dimension. For convenience, we write ${h}_{0, \cdot }$ for the input hypergraph representation and ${h}_{D, \cdot }$ for the output of the NLM.
+
+Fig. 1a shows the overall architecture of NLMs. It has $D \times B$ computation blocks, namely relational reasoning layers (RRLs). Each block ${\mathrm{{RRL}}}_{i, j}$ , illustrated in Fig. 1b, takes the output from neighboring arities in the previous layer, ${T}_{i - 1, j - 1},{T}_{i - 1, j}$ and ${T}_{i - 1, j + 1}$ , and produces ${T}_{i, j}$ . Below we show the computation of each primitive operation in an RRL.
+
+The expand operation takes tensor ${T}_{i - 1, j - 1}$ (arity $j - 1$ ) and produces a new tensor ${T}_{i - 1, j - 1}^{E}$ of arity $j$ . The reduce operation takes tensor ${T}_{i - 1, j + 1}$ (arity $j + 1$ ) and produces a new tensor ${T}_{i - 1, j + 1}^{R}$ of arity $j + 1$ . Mathematically,
+
+$$
+{T}_{i - 1, j - 1}^{E}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{j}}\right\rbrack = {T}_{i - 1, j - 1}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{j - 1}}\right\rbrack ;
+$$
+
+$$
+{T}_{i - 1, j + 1}^{R}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{j}}\right\rbrack = {\operatorname{Agg}}_{{v}_{j + 1}}\left\{ {{T}_{i - 1, j + 1}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{j},{v}_{j + 1}}\right\rbrack }\right\} .
+$$
+
+Here, Agg is called the aggregation function of a NLM. For example, a sum aggregation function takes the summation along the dimension $j + 1$ of the tensor, and a max aggregation function takes the max along that dimension.
+
+The concat (concatenate) operation $\oplus$ is applied at the "vector representation" dimension. The permute operation generates a new tensor of the same arity, but it fuses the representations of hyperedges that share the same set of entities but in different order, such as $\left( {{v}_{1},{v}_{2}}\right)$ and $\left( {{v}_{2},{v}_{1}}\right)$ . Mathematically, for tensor $X$ of arity $j$ , if $Y =$ permute(X)then
+
+$$
+Y\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{j}}\right\rbrack = \mathop{\operatorname{Concat}}\limits_{{\sigma \in {S}_{j}}}\left\{ {X\left\lbrack {{v}_{{\sigma }_{1}},{v}_{{\sigma }_{2}},\cdots ,{v}_{{\sigma }_{j}}}\right\rbrack }\right\} ,
+$$
+
+where $\sigma \in {S}_{j}$ iterates over all permuations of $\{ 1,2,\cdots j\} .{\mathrm{{NN}}}_{j}$ is a multi-layer perceptron (MLP) applied to each entry in the tensor produced after permutation, with nonlinearity $\sigma$ (e.g., ReLU).
+
+It is important to note that we intentionally name the MLPs ${\mathrm{{NN}}}_{j}$ instead of ${\mathrm{{NN}}}_{i, j}$ . In generalized relational neural networks, for a given arity $j$ , all MLPs across all layers $i$ are shared. It is straightforward to see that this "weight-shared" model can realize a "non-weight-shared" NLM that uses different weights for MLPs at different layers when the number of layers is a constant. With a sufficiently large length of the representation vector, we can simulate the computation of applying different transformations by constructing block matrix weights. (A more formal proof is in Appendix B) The advantage of this weight sharing is that the network can be easily extended to a "recurrent" model. For example, we can apply the NLM for a number of layers that is a function of $n$ , where $n$ is the the number of nodes in the input graph. Thus, we will use the term layers and iterations interchangeably.
+
+Handling high-arity features and using deeper models usually increase the computational cost. In appendix B.5, we show that the time and space complexity of NLM $\left\lbrack {D, B}\right\rbrack$ is $O\left( {D{n}^{B}}\right)$ .
+
+Note that even when hyperparameters such as the maximum arity and the number of iterations are fixed, a NLM is still a model family $\mathcal{M}$ : the weights for MLPs will be trained on some data. Furthermore, each model $M \in \mathcal{M}$ is a NLM with a specific set of MLP weights.
+
+### B.3 Expressiveness Equivalence of Relational Neural Networks
+
+Since we are going to study both constant-depth and adaptive-depth graph neural networks, we first prove the following lemma (for general multi-layer neural networks), which helps us simplify the analysis.
+
+Lemma B.1. A neural network with representation width $W$ that has $D$ different layers ${\mathrm{{NN}}}_{1},\cdots ,{\mathrm{{NN}}}_{D}$ can be realized by a neural network that applies a single layer ${\mathrm{{NN}}}^{\prime }$ for $D$ iterations with width $\left( {D + 1}\right) \left( {W + 1}\right)$ .
+
+Proof. The representation for ${\mathrm{{NN}}}^{\prime }$ can be partitioned into $D + 1$ segments each of length $W + 1$ . Each segment consist of a "flag" element and a $W$ -element representation, which are all 0 initially, except for the first segment, where the flag is set to 1 , and the representation is the input.
+
+${\mathrm{{NN}}}^{\prime }$ has the weights for all ${\mathrm{{NN}}}_{1},\cdots ,{\mathrm{{NN}}}_{D}$ , where weights ${\mathrm{{NN}}}_{i}$ are used to compute the representation in segment $i + 1$ from the representation in segment $i$ . Additionally, at each iteration, segment $i + 1$ can only be computed if the flag in segment $i$ is 1, in which case the flag of segment $i + 1$ is set to 1 . Clearly, after $D$ iterations, the output of ${\mathrm{{NN}}}_{k}$ should be the representation in segment $D + 1$ .
+
+Due to Lemma B.1, we consider the neural networks that recurrently apply the same layer because a) they are as expressive as those using layers of different weights, b) it is easier to analyze a single neural network layer than $D$ layers, and c) they naturally generalize to neural networks that runs for adaptive number of iterations (e.g. GNNs that run $O\left( {\log n}\right)$ iterations where $n$ is the size of the input graph).
+
+We first describe a framework for quantifying if two hypergraph neural network models are equally expressive on regression tasks (which is more general than classification problems). The framework view the expressiveness from the perspective of computation. Specifically, we will prove the expressiveness equivalence between models by showing that their computation can be aligned.
+
+In complexity, we usually show a problem is at least as hard as the other one by showing a reduction from the other problem to the problem. Similarly, on the expressiveness of NLMs, we can construct reduction from model family $\mathcal{A}$ to model family $\mathcal{B}$ to show that $\mathcal{B}$ can realize all computation that $\mathcal{A}$ does, or even more. Formally, we have the following definition.
+
+Definition B.1 (Expressiveness reduction). For two model families $\mathcal{A}$ and $\mathcal{B}$ , we say $\mathcal{A}$ can be reduced to $\mathcal{B}$ if and only if there is a function $r : \mathcal{A} \rightarrow \mathcal{B}$ such that for each model instance $A \in \mathcal{A}$ , $r\left( A\right) \in \mathcal{B}$ and $A$ have the same outputs on all inputs. In this case, we say $\mathcal{B}$ is at least as expressive as $\mathcal{A}$ .
+
+Definition B. 2 (Expressiveness equivalence). For two model families $\mathcal{A}$ and $\mathcal{B}$ , if $\mathcal{A}$ and $\mathcal{B}$ can be reduced to each other, then $\mathcal{A}$ and $\mathcal{B}$ are equally expressive. Note that this definition of expressiveness equivalence generalizes to both classification and regression tasks.
+
+Equivalence between HO-GNNs and NLMs. We will prove the equivalence between HO-GNNs and NLMs by making reductions in both directions.
+
+Lemma B.2. A $B$ -ary HO-GNN with depth $D$ can be realized by a NLM with maximum arity $B + 1$ and depth ${2D}$ .
+
+Proof. We prove lemma B. 2 by showing that one layer of GNNs on $B$ -ary hypergraphs can be realized by two NLM with maximum arity $B + 1$ .
+
+Firstly, a GNN layer maintain features of $B$ -tuples, which are stored in correspondingly in an NLM layer at dimension $B$ . Then we will realize the message passing scheme using the NLM features of dimension $B$ and $B + 1$ in two steps.
+
+Recall the message passing scheme generalized to high dimensions (to distinguish, we use $H$ for HO-GNN features and $T$ for NLM features.)
+
+$$
+{\operatorname{Received}}_{i}\left( \mathbf{v}\right) = \mathop{\sum }\limits_{u}\left( {{\mathrm{{NN}}}_{1}\left( {{H}_{i - 1, B}\left\lbrack \mathbf{v}\right\rbrack ;{\operatorname{CONCAT}}_{{\mathbf{v}}^{\prime } \in \text{ neighbors }\left( {\mathbf{v}, u}\right) }{H}_{i - 1}\left\lbrack {\mathbf{v}}^{\prime }\right\rbrack }\right) }\right) \tag{B.5}
+$$
+
+At the first step, the Expand operation first raise the dimension to $B + 1$ by expanding a non-related variable $u$ to the end, and the Permute operation can then swap $u$ with each of the elements (or no swap). Particularly, ${T}_{i, B}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{B}}\right\rbrack$ will be expand to
+
+$$
+{T}_{i + 1, B + 1}\left\lbrack {u,{v}_{2},{v}_{3},\cdots ,{v}_{B},{v}_{1}}\right\rbrack ,{T}_{i + 1, B + 1}\left\lbrack {{v}_{1}, u,{v}_{3},\cdots ,{v}_{B},{v}_{2}}\right\rbrack ,\cdots ,
+$$
+
+$$
+{T}_{i + 1, B + 1}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{B - 1}, u,{v}_{B}}\right\rbrack \text{, and}{T}_{i + 1, B + 1}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{B - 1},{v}_{B}, u}\right\rbrack
+$$
+
+Hence, ${T}_{i + 1, B + 1}\left\lbrack {{v}_{1},{v}_{2},{v}_{3},\cdots ,{v}_{B}, u}\right\rbrack$ receives the features from
+
+$$
+{T}_{i, B}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{B}}\right\rbrack ,{T}_{i, B}\left\lbrack {u,{v}_{2},{v}_{3},\cdots ,{v}_{B}}\right\rbrack ,{T}_{i, B}\left\lbrack {{v}_{1}, u,{v}_{3},\cdots ,{v}_{B}}\right\rbrack ,\cdots ,{T}_{i, B}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{B - 1}, u}\right\rbrack
+$$
+
+These features matches the input of ${\mathrm{{NN}}}_{1}$ in equation B. 5, and in this layer ${\mathrm{{NN}}}_{1}$ can be applied to compute things inside the summation.
+
+Then at the second step, the last element is reduced to get what tuple $v$ should receive, so $v$ can be updated. Since each HO-GNN layer can be realized by such two NLM layers, each $B$ -ary HO-GNN with depth $D$ can be realized by a NLM of maximum arity $\left( {B + 1}\right)$ and depth ${2D}$ .
+
+To complete the proof we need to find a reduction from NLMs of maximum arity $B + 1$ to $B$ -ary HO-GNNs. The key observation here is that the features of $\left( {B + 1}\right)$ -tuples in NLMs can only be expanded from sub-tuples, and the expansion and reduction involving $\left( {B + 1}\right)$ -tuples can be simulated by the message passing process.
+
+Lemma B.3. The features of $\left( {B + 1}\right)$ -tuples feature ${T}_{i, B + 1}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{B + 1}}\right\rbrack$ can be computed from the following tuples
+
+$$
+\left( {{T}_{i, B}\left\lbrack {{v}_{2},{v}_{3},\cdots ,{v}_{B + 1}}\right\rbrack ,{T}_{i, B}\left\lbrack {{v}_{1},{v}_{3},\cdots ,{v}_{B + 1}}\right\rbrack ,\cdots ,{T}_{i, B}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{B}}\right\rbrack }\right) .
+$$
+
+Proof. Lemma B. 3 is true because $\left( {B + 1}\right)$ -dimensional representations can either be computed from themselves at the previous iteration, or expanded from $B$ -dimensional representations. Since representations at all previous iterations $j < i$ can be contained in ${T}_{i, B}$ , it is sufficient to compute ${T}_{i, B + 1}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{B + 1}}\right\rbrack$ from all its $B$ -ary sub-tuples. Then let's construct the HO-GNN for given NLM to show the existence of the reduction.
+
+Lemma B.4. A NLM of maximum arity $B + 1$ and depth $D$ can be realized by a $B$ -ary HO-GNN with no more than $D$ iterations.
+
+Proof. We can realize the Expand and Reduce operation with only the $B$ -dimensional features using the broadcast message passing scheme. Note that Expand and Reduce between $B$ -dimensional features and $\left( {B + 1}\right)$ -dimensional features in the NLM is a special case where claim B.3 is applied.
+
+Let’s start with Expand and Reduce operations between features of dimension $B$ or lower. For the $b$ -dimensional feature in the NLM, we keep ${n}^{\underline{b}}{n}^{B - b \ddagger }$ copies of it and store them the representation of every $B$ -tuple who has a sub-tuple ${}^{§}$ that is a permutation of the $b$ -tuple. That is, for each $B$ -tuple in the $B$ -ary HO-GNN, for its every sub-tuple of length $b$ , we store $b$ ! representations corresponding to every permutation of the $b$ -tuple in the NLM. Keeping representation for all sub-tuple permutations make it possible to realize the Permute operation. Also, it is easy to notice that Expand operation is realized already, as all features with dimension lower than $B$ are naturally expanded to $B$ dimension by filling in all possible combinations of the rest elements. Finally, the Reduce operation can be realized using a broadcast casting message passing on certain position of the tuple.
+
+Now let's move to the special case - the Expand and Reduce operation between features of dimensions $B$ and $B + 1$ . Claim B. 3 suggests how the $\left( {B + 1}\right)$ -dimensional features are stored in $B$ -dimensional representations in GNNs, and we now show how the Reduce can be realized by message passing.
+
+We first bring in claim B. 3 to the HO-GNN message passing, where we have ${\operatorname{Received}}_{i}\left\lbrack \mathbf{v}\right\rbrack$ to be
+
+$$
+\sum \left( {{\mathrm{{NN}}}_{1}\left( {{T}_{i - 1, B}\left\lbrack {{v}_{2},{v}_{3},\cdots ,{v}_{B}, u}\right\rbrack ,{T}_{i - 1, B}\left\lbrack {{v}_{1},{v}_{3},\cdots ,{v}_{B}, u}\right\rbrack ,\cdots ,{T}_{\left( {i - 1}\right) , B}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{B}}\right\rbrack }\right) }\right)
+$$
+
+Note that the last term ${T}_{i - 1, B}\left\lbrack {{v}_{1},{v}_{2},\cdots ,{v}_{B}}\right\rbrack$ is contained in ${H}_{i - 1}\left( v\right)$ in equation B.5, and other terms are contained in ${H}_{i - 1}\left( {v}^{\prime }\right)$ for ${v}^{\prime } \in$ neighbors(v, u). Hence, equation B. 5 is sufficient to simulate the Reduce operation.
+
+Theorem B.5. $B$ -ary HO-GNNs are equally expressive as NLMs with maximum arity $B + 1$ .
+
+Proof. This is a direct conclusion by combining Lemma B. 2 and Lemma B.4.
+
+### B.4 Expressiveness of hypergraph convolution and attention
+
+There exist other variants of hypergraph neural networks. In particular, hypergraph convolution[26- 28], attention[29] and message passing[30] focus on updating node features instead of tuple features through hyperedges . These approaches can be viewed as instances of hypergraph neural networks, and they have smaller time complexity because they do not model all high-arity tuples. However, they are less expressive than the standard hypergraph neural networks with equal max arity.
+
+These approaches can be formulated to two steps at each iteration. At the first step, each hyperedge is updated by the features of nodes it connects.
+
+$$
+{h}_{i, e} = {\mathrm{{AGG}}}_{v \in e}{f}_{i - 1, v} \tag{B.6}
+$$
+
+At the second step, each node is updated by the features of hyperedges connecting it.
+
+$$
+{f}_{i, v} = {\mathrm{{AGG}}}_{v \in e}{h}_{i, e} \tag{B.7}
+$$
+
+where ${f}_{i, v}$ is the feature of node $v$ at iteration $i$ , and ${h}_{i, v}$ is the aggregated message passing through hyperedge $e$ at iteration $i + 1$ .
+
+It is not hard to see that B. 6 can be realized by $B$ iterations of NLM layers with Expand operations where $B$ is the max arity of hyperedges. This can be done by expanding each node feature to every high arity features that contain the node, and aggregate them at the tuple corresponding to each hyperedge. Then, B. 7 can also be realized by $B$ iterations of NLM layers with Reduce operations, as the tuple feature will finally be reduced to a single node contained in the tuple.
+
+---
+
+${}^{ \ddagger }{n}^{\underline{k}} = n \times \left( {n - 1}\right) \times \cdots \times \left( {n - k + 1}\right) .$
+
+${}^{§}$ The sub-tuple does not have to be consecutive, but instead can be a any subset of the tuple that keeps the element order.
+
+---
+
+This approach has lower complexity compared to the GNNs we study applied on hyperedges, because it only requires communication between nodes and hyperedges connecting to them, which takes $O\left( {\left| V\right| \cdot \left| E\right| }\right)$ time at each iteration. Compared to them, NLMs takes $O\left( {\left| V\right| }^{B}\right)$ time because NLMs keep features of every tuple with max arity $B$ , and allow communication from tuples to tuples instead of between tuples and single nodes. An example is provided below that this approach can not solve while NLMs can.
+
+Consider a graph with 6 nodes and 6 edges forming two triangles(1,2,3)and(4,5,6). Because of the symmetry, the representation of each node should be identical throughout hypergraph message passing rounds. Hence, it is impossible for these models to conclude that(1,2,3)is a triangle but (4,2,3)is not, based only on the node representations, because they are identical. In contrast, NLMs with max arity 3 can solve them (as standard triangle detection problem in Table 1).
+
+### B.5 The Time and Space Complexity of NLMs
+
+Handling high-arity features and using deeper models usually increase the computational cost in terms of time and space. As an instance that use the architecture of RelNN, NLMs with depth $D$ and max arity $B$ takes $O\left( {D{n}^{B}}\right)$ time when applying to graphs with size $n$ . This is because both Expand and Reduce operation have linear time complexity with respect to the input size (which is $O\left( {n}^{B}\right)$ at each iteration). If we need to record the computational history (which is typically the case when training the network using back propagation), the space complexity is the same as the time complexity.
+
+GNNs applied to(B - 1)-ary hyperedges and depth $D$ are equally expressive as RelNNs with depth $O\left( D\right)$ and max arity $B$ . Though up to(B - 1)-ary features are kept in their architecture, the broadcast message passing scheme scale up the complexity by a factor of $O\left( n\right)$ , so they also have time and space complexity $O\left( {D{n}^{B}}\right)$ . Here the length of feature tensors $W$ is treated as a constant.
+
+## C Arity and Depth Hierarchy: Proofs and Analysis
+
+### C.1 Proof of Theorem 3.1: Arity Hierarchy.
+
+[9] have connected high-dimensional GNNs with high-dimensional WL tests. Specifically, they showed that the $B$ -ary HO-GNNs are equally expressive as $B$ -dimensional WL test on graph isomorphism test problem. In Theorem B. 5 we proved that $B$ -ary HO-GNNs are equivalent to NLM of maximum arity $B + 1$ in terms of expressiveness. Hence, NLM of maximum arity $B + 1$ can distinguish if two non-isomorphic graphs if and only if $B$ -dimensional WL test can distinguish them.
+
+However, Cai et al. [11] provided an construction that can generate a pair of non-isomorphic graphs for every $B$ , which can not be distinguished by(B - 1)-dimensional WL test but can be distinguished by $B$ -dimensional WL test. Let ${G}_{B}^{1}$ and ${G}_{B}^{2}$ be such a pair of graph.
+
+Since NLM of maximum arity $B + 1$ is equally expressive as $B$ -ary HO-GNNs, there must be such a NLM that classify ${G}_{B}^{1}$ and ${G}_{B}^{2}$ into different label. However, such NLM can not be realized by any NLM of maximum arity $B$ because they are proven to have identical outputs on ${G}_{B}^{1}$ and ${G}_{B}^{2}$ .
+
+In the other direction, NLMs of maximum arity $B + 1$ can directly realize NLMs of maximum arity $B$ , which completes the proof.
+
+### C.2 Upper Depth Bound for Unbounded-Precision NLM.
+
+The idea for proving an upper bound on depth is to connect NLMs to WL-test, and use the $O\left( {n}^{B}\right)$ upper bound on number of iterations for $B$ -dimensional test [31], and FOC formula is the key connection.
+
+For any fixed $n, B$ -dimensional WL test divide all graphs of size $n,{\mathcal{G}}_{ = n}$ , into a set of equivalence classes $\left\{ {{\mathcal{C}}_{1},{\mathcal{C}}_{2},\cdots ,{\mathcal{C}}_{m}}\right\}$ , where two graphs belong to the same class if they can not be distinguished by the WL test. We have shown that NLMs of maximum arity $\left( {B + 1}\right)$ must have the same input for all graphs in the same equivalence class. Thus, any NLM of maximum arity $B + 1$ can be view as a labeling over ${\mathcal{C}}_{1},\cdots ,{\mathcal{C}}_{m}$ .
+
+Stated by Cai et al. [11], $B$ -dimensional WL test are as powerful as ${\mathrm{{FOC}}}_{B + 1}$ in differentiating graphs graphs. Combined with the $O\left( {n}^{B}\right)$ upper bound of WL test iterations, for each ${\mathcal{C}}_{i}$ , there must be an ${\mathrm{{FOC}}}_{B + 1}$ formula of quantifier depth $O\left( {n}^{B}\right)$ that exactly recognize ${\mathcal{C}}_{i}$ over ${\mathcal{G}}_{ = n}$ .
+
+Finally, with unbounded precision, for any $f\left( n\right)$ , NLM of maximum arity $B + 1$ and depth $f\left( n\right)$ can compute all ${\mathrm{{FOC}}}_{B + 1}$ formulas with quantifier depth $f\left( n\right)$ . Note that there are finite number of such formula because the supscript of counting quantifiers is bounded by $n$ .
+
+For any graph in some class ${\mathcal{C}}_{i}$ , the class can be determined by evaluating these FOC formulas, and then the label is determined. Therefore, any NLM of maximum arity $B + 1$ can be realized by a NLM of maximum arity $B + 1$ and depth $O\left( {n}^{B}\right)$ .
+
+### C.3 Graph Problems
+
+| $B = 4$ | 4-Clique Detection NLM $\left\lbrack {O\left( 1\right) ,4}\right\rbrack$ | 4-Clique Count NLM $\left\lbrack {O\left( 1\right) ,4}\right\rbrack$ |
| $B = 3$ | Triangle Detection NLM $\left\lbrack {O\left( 1\right) ,3}\right\rbrack$ Bipartiteness NLM[O( $\log n$ ), 3]* All-Pair Connectivity NLM[O( $\log n$ ),3] ${}^{ \star }$ All-Pair Connectivity- $k$ NLM ${\left\lbrack O\left( \log k\right) ,3\right\rbrack }^{ \star }$ | All-Pair Distance NLM ${\left\lbrack O\left( \log n\right) ,3\right\rbrack }^{ \star }$ |
| $B = 2$ | ${\mathrm{{FOC}}}_{2}$ Realization NLM $\left\lbrack {\cdot ,2}\right\rbrack \left\lbrack {12}\right\rbrack$ 3/4-Link Detection NLM[O(1), 2] S-T Connectivity NLM $\left\lbrack {O\left( n\right) ,2}\right\rbrack$ S-T Connectivity- $k$ NLM $\left\lbrack {O\left( k\right) ,2}\right\rbrack$ | S-T Distance NLM $\left\lbrack {O\left( n\right) ,2}\right\rbrack$ Max Degree NLM $\left\lbrack {O\left( 1\right) ,2}\right\rbrack$ Max Flow NLM ${\left\lbrack O\left( {n}^{3}\right) ,2\right\rbrack }^{ \star }$ |
| $B = 1$ | Node Color Majority: NLM[O(1), 1] | Count Red Nodes: NLM $\left\lbrack {O\left( 1\right) ,1}\right\rbrack$ |
| Classification Tasks | Regression Tasks |
+
+Table 1: The minimum depth and arity of NLMs for solving graph classification and regression tasks. The * symbol indicates that these are conjectured lower bounds.
+
+We list a number of examples for graph classification and regression tasks, and we provide the definitions and the current best known NLMs for learning these tasks from data. For some of the problems, we will also show why they can not be solved by a simpler problems, or indicate them as open problems.
+
+Node Color Majority. Each node is assigned a color $c \in \mathcal{C}$ where $\mathcal{C}$ is a finite set of all colors. The model needs to predict which color the most nodes have.
+
+Using a single layer with sum aggregation, the model can count the number of nodes of color $c$ for each $c \in \mathcal{C}$ on its global representation.
+
+Count Red Nodes. Each node is assigned a color of red or blue. The model needs to count the number of red nodes.
+
+Similarly, using a single layer with sum aggregation, the model can count the number of red nodes on its global representation.
+
+3-Link Detection. Given an unweighted, undirected graph, the model needs to detect whether there is a triple of nodes(a, b, c)such that $a \neq c$ and(a, b)and(b, c)are edges.
+
+This is equivalent to check whether there exists a node with degree at least 2 . We can use a Reduction operation with sum aggregation to compute the degree for each node, and then use a Reduction operation with max aggregation to check whether the maximum degree of nodes is greater than or equal to 2 .
+
+Note that this can not be done with 1 layer, because the edge information is necessary for the problem, and they require at least 2 layers to be passed to the global representation.
+
+4-Link Detection. Given an unweighted undirected graph, the model needs to detect whether there is a 4-tuple of nodes(a, b, c, d)such that $a \neq c, b \neq d$ and $\left( {a, b}\right) ,\left( {b, c}\right) ,\left( {c, d}\right)$ are edges (note that a triangle is also a 4-link).
+
+This problem is equivalent to check whether there is an edge between two nodes with degrees $\geq 2$ . We can first reduce the edge information to compute the degree for each node, and then expand it back to 2-dimensional representations, so we can check for each edge if the degrees of its ends are $\geq 2$ . Then the results are reduced to the global representation with existential quantifier (realized by max aggregation) in 2 layers.
+
+Triangle Detection. Given a unweighted undirected graph, the model is asked to determine whether there is a triangle in the graph i.e. a tuple(a, b, c)so that $\left( {a, b}\right) ,\left( {b, c}\right) ,\left( {c, a}\right)$ are all edges.
+
+This problem can be solved by NLM [4,3]: we first expand the edge to 3-dimensional representations, and determine for each 3-tuple if they form a triangle. The results of 3-tuples require 3 layers to be passed to the global representation.
+
+We can prove that Triangle Detection indeed requires breadth at least 3 . Let $k$ -regular graphs be graphs where each node has degree $k$ . Consider two $k$ -regular graphs both with $n$ nodes, so that exactly one of them contains a triangle ${}^{1}$ . However, NLMs of breadth 2 has been proven not to be stronger than WL test on distinguish graphs, and thus can not distinguish these two graphs (WL test can not distinguish any two $k$ -regular graphs with equal size).
+
+4-Clique Detection and Counting. Given an undirected graph, check existence of, or count the number of tuples(a, b, c, d)so that there are edges between every pair of nodes in the tuple.
+
+This problem can be easily solved by a NLM with breadth 4 that first expand the edge information to the 4-dimensional representations, and for each tuple determine whether its is a 4-clique. Then the information of all 4-tuples are reduced 4 times to the global representation (sum aggregation can be used for counting those).
+
+Though we did not find explicit counter-example construction on detecting 4-cliques with NLMs of breadth 3 , we suggest that this problem can not be solved with NLMs with 3 or lower breadth.
+
+Connectivity. The connectivity problems are defined on unweighted undirected graphs. S-T connectivity problems provides two nodes $S$ and $T$ (labeled with specific colors), and the model needs to predict if they are connected by some edges. All pair connectivity problem require the model to answer for every pair of nodes. Connectivity- $k$ problems have an additional requirement that the distance between the pair of nodes can not exceed $k$ .
+
+S-T connectivity- $k$ can be solved by a NLM of breadth 2 with $k$ iterations. Assume $S$ is colored with color $c$ , at every iteration, every node with color $c$ will spread the color to its neighbors. Then, after $k$ iterations, it is sufficient to check whether $T$ has the color $c$ .
+
+With NLMs of breadth 3, we can use $O\left( {\log k}\right)$ matrix multiplications to solve connectivity- $k$ between every pair of nodes. Since the matrix multiplication can naturally be realized by NLMs of breadth 3 with two layers. All-pair connectivity problems can all be solved with $O\left( {\log k}\right)$ layers.
+
+Theorem C.1(S-T connectivity- $k$ with NLM). S-T connectivity- $k$ can not be solved by a NLM of maximum arity within $o\left( k\right)$ iterations.
+
+Proof. We construct two graphs each has ${2k}$ nodes ${u}_{1},\cdots ,{u}_{k},{v}_{1},\cdots ,{v}_{k}$ . In both graph, there are edges $\left( {{u}_{i},{u}_{i + 1}}\right)$ and $\left( {{v}_{i},{v}_{i + 1}}\right)$ for $1 \leq i \leq k - 1$ i.e. there are two links of length $k$ . We then set $S = {u}_{1}, T = {u}_{n}$ and $S = {u}_{1}, T = {v}_{n}$ the the two graphs.
+
+We will analysis GNNs as NLMs are proved to be equivalent to them by scaling the depth by a constant factor. Now consider the node refinement process where each node $x$ is refined by the multiset of labels of $x$ ’s neighbots and the multiiset of labels of $x$ ’s non-neighbors.
+
+Let ${C}_{j}^{\left( i\right) }\left( x\right)$ be the label of $x$ in graph $j$ after $i$ iterations, at the beginning, WLOG, we have
+
+$$
+{C}_{1}^{\left( 0\right) }\left( {u}_{1}\right) = 1,{C}_{1}^{\left( 0\right) }\left( {u}_{n}\right) = 2{C}_{1}^{\left( 0\right) }\left( {u}_{1}\right) = 1,{C}_{1}^{\left( 0\right) }\left( {v}_{n}\right) = 2
+$$
+
+and all other nodes are labeled as 0 .
+
+Then we can prove by induction: after $i \leq \frac{k}{2} - 1$ iterations, for $1 \leq t \leq i + 1$ we have
+
+$$
+{C}_{1}^{\left( {u}_{t}\right) } = {C}_{2}^{\left( i\right) }\left( {u}_{t}\right) ,{C}_{1}^{\left( {v}_{t}\right) } = {C}_{2}^{\left( i\right) }\left( {v}_{t}\right)
+$$
+
+598
+
+$$
+{C}_{1}^{\left( {u}_{k - t + 1}\right) } = {C}_{2}^{\left( i\right) }\left( {v}_{k - t + 1}\right) ,{C}_{1}^{\left( {v}_{k - t + 1}\right) } = {C}_{2}^{\left( i\right) }\left( {u}_{k - t + 1}\right)
+$$
+
+---
+
+${}^{1}$ Such construction is common. One example is $k = 2, n = 6$ , and the graph may consist of two separated triangles or one hexagon
+
+---
+
+and for $i + 2 \leq t \leq k - i - 1$ we have
+
+$$
+{C}_{1}^{\left( {u}_{t}\right) } = {C}_{2}^{\left( i\right) }\left( {u}_{t}\right) ,{C}_{1}^{\left( {v}_{t}\right) } = {C}_{2}^{\left( i\right) }\left( {v}_{t}\right)
+$$
+
+This is true because before $\frac{k}{2}$ iterations are run, the multiset of all node labels are identical for the two graphs (say ${S}^{\left( i\right) }$ ). Hence each node $x$ is actually refined by its neighbors and ${S}^{\left( i\right) }$ where ${S}^{\left( i\right) }$ is the same for all nodes. Hence, before running $\frac{k}{2}$ iterations when the message between $S$ and $T$ finally meets in the first graph, GNN can not distinguish the two graphs, and thus can not solve the connectivity with distance $k - 1$ .
+
+Max Degree. The max degree problem gives a graph and ask the model to output the maximum degree of its nodes.
+
+Like we mentioned in 3-link detection, one layer for computing the degree for each node, and another layer for taking the max operation over nodes should be sufficient.
+
+Max Flow. The Max Flow problem gives a directional graph with capacities on edges, and indicate two nodes $S$ and $T$ . The models is then asked to compute the amount of max-flow from $S$ to $T$ .
+
+Notice that the Breadth First Search (BFS) component in Dinic's algorithm[32] can be implemented on NLMs as they does not require node identities (all new-visited nodes can augment to their non-visited neighbors in parallel). Since the BFS runs for $O\left( n\right)$ iteration, and the Dinic’s algorithm runs BFS $O\left( {n}^{2}\right)$ times, the max-flow can be solved by NLMs with in $O\left( {n}^{3}\right)$ iterations.
+
+Distance. Given a graph with weighted edges, compute the length of the shortest between specified node pair (S-T Distance) or all node pairs (All-pair Distance).
+
+Similar to Connectivity problems, but Distance problems now additionally record the minimum distance from $S$ (for S-T) or between every node pairs (for All-pair), which can be updated using min operator (using Min-plus matrix multiplication for All-pair case).
+
+## D Experiments
+
+We now study how our theoretical results on model expressiveness and learning apply to relational neural networks trained with gradient descent on practically meaningful problems. We begin by describing two synthetic benchmarks: graph substructure detection and relational reasoning.
+
+In the graph substructure detection dataset, there are several tasks of predicting whether there input graph containd a sub-graph with specific structure. The tasks are: 3-link (length-3 path), 4-link, triangle, and 4-clique. These are important graph properties with many potential applications.
+
+The relational reasoning dataset is composed of two family-relationship prediction tasks and two connectivity-prediction tasks. They are all binary edge classification tasks. In the family-relationship prediction task, the input contains the mother and father relationships, and the task is to predict the grandparent and uncle relationships between all pairs of entities. In the connectivity-prediction tasks, the input is the edges in an undirected graph and the task is to predict, for all pairs of nodes, whether they are connected with a path of length $\leq 4$ (connectivity-4) and whether they are connected with a path of arbitrary length (connectivity). The data generation for all datasets is included in Appendix D.
+
+### D.1 Experiment Setup
+
+For all problems, we have 800 training samples, 100 validation samples, and 300 test samples for each different $n$ we are testing the models on.
+
+We then provide the details on how we synthesize the data. For most of the problems, we generate the graph by randomly selecting from all potential edges i.e. the Erdős-Rényi model. We sample the number of edges around $n,{2n}, n\log n$ and ${n}^{2}/2$ . For all problems, with ${50}\%$ probability the graph will first be divided into2,3,4or 5 parts with equal number of components, where we use the first generated component to fill the edges for rest of the components. Some random edges are added afterwards. This make the data contain more isomorphic sub-graphs, which we found challenging empirically.
+
+Substructure Detection. To generate a graph that does not contain a certain substructure, we randomly add edges when reaching a maximal graph not containing the substructure or reaching the
+
+| Model | Enzymes | $\mathbf{{Mutag}}$ | Proteins | PTC |
| $\mathbf{{MLP}}$ | 41.10>26.18 ${}^{ \circ }$ | ${87.61} > {84.61}^{ \circ }$ | 75.43~75.01 | ${64.59} > {62.79}^{ \circ }$ |
| GCN | ${54.48} > {48.60}^{ \circ }$ | ${89.61} > {85.42}^{ \circ }$ | 75.67>74.50 ${}^{ \circ }$ | 65.76~65.21 |
| $\mathbf{{GAT}}$ | 54.88~54.95 | 90.00>86.14 ${}^{ \circ }$ | 73.44>70.51 ${}^{ \circ }$ | 66.29~66.29 |
| GIN | ${{54.77} > {53.44}}^{ * }$ | 89.56~88.33 | ${73.32}^{ \circ }{72.05}^{ \circ }$ | 61.44~60.21 |
| Chebnet | 61.88~62.23 | 91.44>88.33 ${}^{ \circ }$ | 74.30>66.94 ${}^{ \circ }$ | 64.79~63.87 |
| GNNML3 | ${61.42} < {62.79}^{ \circ }$ | ${92.50} > {91.47}^{ * }$ | 75.54>62.32 ${}^{ \circ }$ | ${64.26} < {66.10}^{ \circ }$ |
| * $p < {0.01}$ ,$p < {0.0001}$ |
+
+Table 2: Mean $\pm$ stddev of the best IGEL-augmented graph classification model and reported results on $k$ -hop, GSN, and ESAN from $\left\lbrack {{19},{20},{23}}\right\rbrack$ . Best performing baselines underlined.
+
+| Model | + IGEL | Star | Triangle | Tailed Tri. | 4-Cycle | $\mathbf{{Custom}}$ |
| Linear | No | ${1.60}\mathrm{E} - {01}$ | ${3.41}\mathrm{E} - {01}$ | ${2.82}\mathrm{E} - {01}$ | ${2.03}\mathrm{E} - {01}$ | ${5.11}\mathrm{E} - {01}$ |
| $\mathbf{{Yes}}$ | ${4.23}\mathrm{E} - {03}$ | 4.38E-03 | ${1.85}\mathrm{E} - {02}$ | ${1.36}\mathrm{E} - {01}$ | ${5.25}\mathrm{E} - {02}$ |
| MLP | No | ${2.66}\mathrm{E} - {06}$ | ${2.56}\mathrm{E} - {01}$ | ${1.60}\mathrm{E} - {01}$ | ${1.18}\mathrm{E} - {01}$ | ${4.54}\mathrm{E} - {01}$ |
| $\mathbf{{Yes}}$ | ${8.31}\mathrm{E} - {05}$ | ${5.69}\mathrm{E} - {05}$ | 5.57E-05 | ${7.64}\mathrm{E} - {02}$ | ${2.34}\mathrm{E} - {04}$ |
| GCN | No | 4.72E-04 | ${2.42}\mathrm{E} - {01}$ | ${1.35}\mathrm{E} - {01}$ | ${1.11}\mathrm{E} - {01}$ | ${1.54}\mathrm{E} - {03}$ |
| $\mathbf{{Yes}}$ | ${8.26}\mathrm{E} - {04}$ | ${1.25}\mathrm{E} - {03}$ | 4.15E-03 | 7.32E-02 | 1.17E-03 |
| $\mathbf{{GAT}}$ | No | ${4.15}\mathrm{E} - {04}$ | ${2.35}\mathrm{E} - {01}$ | ${1.28}\mathrm{E} - {01}$ | ${1.11}\mathrm{E} - {01}$ | ${2.85}\mathrm{E} - {03}$ |
| Yes | 4.52E-04 | 6.22E-04 | 7.77E-04 | 7.33E-02 | ${6.66}\mathrm{E} - {04}$ |
| GIN | No | ${3.17}\mathrm{E} - {04}$ | ${2.26}\mathrm{E} - {01}$ | ${1.22}\mathrm{E} - {01}$ | ${1.11}\mathrm{E} - {01}$ | ${2.69}\mathrm{E} - {03}$ |
| $\mathbf{{Yes}}$ | ${6.09}\mathrm{E} - {04}$ | ${1.03}\mathrm{E} - {03}$ | 2.72E-03 | ${6.98}\mathrm{E} - {02}$ | ${2.18}\mathrm{E} - {03}$ |
| Chebnet | No | ${5.79}\mathrm{E} - {04}$ | ${1.71}\mathrm{E} - {01}$ | ${1.12}\mathrm{E} - {01}$ | ${8.95}\mathrm{E} - {02}$ | ${2.06}\mathrm{E} - {03}$ |
| $\mathbf{{Yes}}$ | ${3.81}\mathrm{E} - {03}$ | ${7.88}\mathrm{E} - {04}$ | ${2.10}\mathrm{E} - {03}$ | 7.90E-02 | ${2.05}\mathrm{E} - {03}$ |
| GNNML3 | No | ${8.90}\mathrm{E} - {05}$ | ${2.36}\mathrm{E} - {04}$ | ${2.91}\mathrm{E} - {04}$ | ${6.82}\mathrm{E} - {04}$ | ${9.86}\mathrm{E} - {04}$ |
| Yes | ${9.29}\mathrm{E} - {04}$ | ${2.19}\mathrm{E} - {04}$ | ${4.23}\mathrm{E} - {04}$ | ${6.98}\mathrm{E} - {04}$ | 4.17E-04 |
+
+Notably, the Linear baseline plus IGEL outperforms MP-GNNs without IGEL for star, triangle, tailed triangle and custom 1-WL graphlets. By introducing IGEL on the MLP baseline, it outperforms all other models including GNNML3 on the triangle, tailed-triangle and custom 1-WL graphlets.
+
+Since Linear and MLP baselines do not use message passing, we believe raw IGEL encodings may be sufficient to identify certain graph structures even with simple linear models. For all graphlets except 4-cycles, introducing IGEL yields performance similar to GNNML3 at lower pre-processing and model training/inference costs, as IGEL obviates the need for costly eigen-decomposition and can be used in simple models only performing graph-level readouts without message passing.
+
+---
+
+${}^{1}$ Simple 8 vertices graphs from: http://users.cecs.anu.edu.au/~bdm/data/graphs.html
+
+${}^{2}$ SRG(25,12,5,6)graphs from: http://users.cecs.anu.edu.au/~bdm/data/graphs.html
+
+${}^{3}$ 3-stars, triangles, tailed triangles and 4-cycles, plus a custom 1-WL graphlet proposed in [26]
+
+${}^{4}$ Counts are stddev-normalized so that MSE values are comparable across graphlet types, following [26].
+
+---
\ No newline at end of file
diff --git a/papers/LOG/LOG 2022/LOG 2022 Conference/5Zxh3fQ8F-h/Initial_manuscript_tex/Initial_manuscript.tex b/papers/LOG/LOG 2022/LOG 2022 Conference/5Zxh3fQ8F-h/Initial_manuscript_tex/Initial_manuscript.tex
new file mode 100644
index 0000000000000000000000000000000000000000..108073b2fd50a55600dd0333e17d042e387f690b
--- /dev/null
+++ b/papers/LOG/LOG 2022/LOG 2022 Conference/5Zxh3fQ8F-h/Initial_manuscript_tex/Initial_manuscript.tex
@@ -0,0 +1,184 @@
+§ BEYOND 1-WL WITH LOCAL EGO-NETWORK ENCODINGS
+
+Anonymous Author(s)
+
+Anonymous Affiliation
+
+Anonymous Email
+
+§ ABSTRACT
+
+Identifying similar network structures is key to capture graph isomorphisms and learn representations that exploit structural information encoded in graph data. This work shows that ego-networks can produce a structural encoding scheme for arbitrary graphs with greater expressivity than the Weisfeiler-Lehman (1-WL) test. We introduce IGEL, a preprocessing step to produce features that augment node representations by encoding ego-networks into sparse vectors that enrich Message Passing (MP) Graph Neural Networks (GNNs) beyond 1-WL expressivity. We describe formally the relation between IGEL and 1-WL, and characterize its expressive power and limitations. Experiments show that IGEL matches the empirical expressivity of state-of-the-art methods on isomorphism detection while improving performance on seven GNN architectures.
+
+§ 13 1 INTRODUCTION
+
+Novel approaches for learning on graphs have appeared in recent years within the machine learning community [1]. Notably, the introduction of Graph Convolutional Networks [2, 3] led to a broad body of research aiming to efficiently capture network interactions, leveraging spectral information [4], scaling beyond seen nodes [5], or generalizing attention to Graph Neural Networks (GNNs) [6]. Underlying this family of GNN models is the Message Passing (MP) mechanism [7]. In MP-GNNs, a node is represented by iteratively aggregating feature 'messages' from its neighbours based on edge connectivity, with successful applications on several domains [7-11]. However, recently it has been shown that message passing limits the representational power of GNNs, which are bound by the Weisfeiler-Lehman (1-WL) test [12]. As such, MP-GNNs cannot reach the expressivity of $k$ -dimensional WL generalizations [13,14] ( $k$ -WL) or analogous MATLANG [15,16] languages. Casting MP-GNN representations in these terms [17] has driven recent research towards expressivity.
+
+To improve expressivity, recent approaches extend message-passing, leveraging topological information from cell complexes [18], extending the message-passing mechanism with sub-graph information [19-22], propagating messages through $k$ network hops [23], introducing relative positioning information for network vertices [24], or using higher order $k$ -vertex tuples to reach $k$ -WL expressivity [14]. In an other direction, methods such as Provably Powerful Graph Networks (PPGN) [25] are guaranteed to be as expressive as the 3-WL test at cubic time and quadratic memory costs. More recently, GNNML3 [26] introduced a network architecture with equal memory and time costs to MP-GNNs, but experimentally capable of 3-WL expressivity that introduces spectral information through a preprocessing step with cubic worst-case time complexity.
+
+The aforementioned approaches improve expressivity by extending MP-GNNs architectures, often evaluating on standarized benchmarks [27-29]. However, identifying the optimal approach on novel domains remains unclear and requires costly architecture search. In this work, we present IGEL, an Inductive Graph Encoding of Local information allowing MP-GNN and Deep Neural Network (DNN) models to go beyond 1-WL expressivity without modifying model architectures. IGEL is closely related to the Weisfeiler-Lehman isomorphism test, and produces inductive representations of vertex structures that can be introduced into MP-GNN models. IGEL reframes capturing 1-WL information irrespective of model architecture as a pre-processing step that simply extends node attributes.
+
+§ 2 IGEL: EGO-NETWORKS AS SPARSE INDUCTIVE REPRESENTATIONS.
+
+Given a graph $G = \left( {V,E}\right)$ , we define $n = \left| V\right|$ and $m = \left| E\right| ,{d}_{G}\left( v\right)$ is the degree of a node $v$ in $G$ and ${d}_{\max }$ is the maximum degree. For $u,v \in V,{l}_{G}\left( {u,v}\right)$ is their shortest distance, and $\operatorname{diam}\left( G\right) = \max \left( {{l}_{G}\left( {u,v}\right) \mid u,v \in V}\right)$ is the diameter of $G.{\mathcal{N}}_{G}^{\alpha }\left( v\right)$ is the set of neighbours of $v$ in $G$ up to distance $\alpha$ (Equation 1), and ${\mathcal{E}}_{v}^{\alpha }$ is the $\alpha$ -depth ego-network centered on $v$ (Equation 2):
+
+$$
+{\mathcal{N}}_{G}^{\alpha }\left( v\right) = \left\{ {u \mid u \in V \land {l}_{G}\left( {u,v}\right) \leq \alpha }\right\} ,
+$$
+
+Let $\{ | \cdot \rangle \}$ denote a lexicographically-ordered multi-set. Algorithm 1 shows the 1-WL test, where hash a 1-WL iteration. The output of 1-WL is ${\mathbb{N}}^{n}$ -mapping each node to a color, bounded by $n$ distinct operate on $k$ -tuples of vertices, such that colors are assigned to $k$ -vertex tuples. If two graphs ${G}_{1},{G}_{2}$ are not distinguishable by the $k$ -WL test (that is, their coloring histograms match), they are $k$ -WL equivalent-denoted ${G}_{1}{ \equiv }_{k - \mathrm{{WL}}}{G}_{2}$ . Due to the hashing step,1-WL does not preserve distance information in the encoding, and perturbations (e.g. different color in a neighbour) produce different node-level representations. IGEL addresses both limitations, improving expressivity in the process.
+
+§ 2.1 THE IGEL ALGORITHM
+
+Intuitively, IGEL encodes a vertex $v$ with the multi-set of ordered degree sequences at each distance $\alpha$ steps with two modifications. First, the hashing step is removed and replaced by computing the union of multi-sets across steps $\left( \cup \right)$ ; second, the iteration number is explicitly introduced in the representation-with the output multi-set ${e}_{v}^{\alpha }$ shown in Algorithm 2.
+
+In order to be used as vertex features, the multi-set can be represented as a sparse vector ${\operatorname{IGEL}}_{\text{ vec }}^{\alpha }\left( v\right)$ , where the $i$ -th index contains the frequency of path-length and degree pairs $\left( {\lambda ,\delta }\right)$ . Degrees greater than ${d}_{\max }$ are capped to ${d}_{\max }$ , and vector indices are output by bijective function $f : \left( {\mathbb{N},\mathbb{N}}\right) \mapsto \mathbb{N}$ -shown in Figure 1:
+
+${\operatorname{IGEL}}_{\text{ vec }}^{\alpha }{\left( v\right) }_{i} = \left| \left\{ {\left( {\lambda ,\delta }\right) \in {e}_{v}^{\alpha }\text{ s.t. }f\left( {\lambda ,\delta }\right) = i}\right\} \right| .$
+
+${G}_{1} = \left( {{V}_{1},{E}_{1}}\right)$ and ${G}_{2} = \left( {{V}_{1},{E}_{1}}\right)$ are IGEL-equivalent for $\alpha$ if the sorted multi-set containing node representations is the same for ${G}_{1}$ and ${G}_{2}$ :
+
+${G}_{1}{ \equiv }_{\text{ IGEL }}^{\alpha }{G}_{2} \Leftrightarrow$
+
+$\left\{ \left\{ {{e}_{{v}_{1}}^{\alpha } : \forall {v}_{1} \in {V}_{1}}\right\} \right\} = \left\{ \left\{ {{e}_{{v}_{2}}^{\alpha } : \forall {v}_{2} \in {V}_{2}}\right\} \right\} .$(1)
+
+$$
+{\mathcal{E}}_{v}^{\alpha } = \left( {{V}^{\prime },{E}^{\prime }}\right) \subseteq G\text{ , s.t. }u \in {\mathcal{N}}_{G}^{\alpha }\left( v\right) \Leftrightarrow u \in {V}^{\prime },\left( {u,v}\right) \in {E}^{\prime } \subseteq E \Leftrightarrow u,v \in {V}^{\prime }\text{ . } \tag{2}
+$$
+
+maps a multi-set to an equivalence class shared by all nodes with matching multi-set encodings after colors if each node is uniquely colored. $k$ -higher order variants of the WL test (denoted $k$ -WL) tests within ${\mathcal{E}}_{v}^{\alpha }$ . As such, IGEL is a variant of the 1-WL algorithm shown in Algorithm 1, executed for
+
+ < g r a p h i c s >
+
+Figure 1: IGEL encoding of the green vertex. Dashed region denotes ${\mathcal{E}}_{v}^{\alpha }\left( {\alpha = 2}\right)$ . The green vertex is at distance 0, blue vertices at 1 and red vertices at 2. Labels show degrees in ${\mathcal{E}}_{v}^{\alpha }$ . The frequency of $\left( {\lambda ,\delta }\right)$ tuples forming ${\operatorname{IGEL}}_{\text{ vec }}^{\alpha }\left( v\right)$ is: $\{ \left( {0,2}\right) : 1,\left( {1,2}\right) : 1,\left( {1,4}\right) : 1,\left( {2,3}\right) : 2,\left( {2,4}\right) : 1\}$ .
+
+Algorithm 1 1-WL (Color refinement).
+
+Input: $G = \left( {V,E}\right)$
+
+ 1: ${c}_{v}^{0} \mathrel{\text{ := }} \operatorname{hash}\left( \left\{ \left\{ {{d}_{G}\left( v\right) }\right\} \right\} \right) \forall v \in V$
+
+ do
+
+ ${c}_{v}^{i + 1} \mathrel{\text{ := }} \operatorname{hash}\left( \left\{ \left\{ {{c}_{u}^{i} : \mathop{\forall }\limits_{{u \neq v}}u \in {\mathcal{N}}_{G}^{1}\left( v\right) }\right\} \right\} \right)$
+
+ while ${c}_{v}^{i} \neq {c}_{v}^{i - 1}$
+
+Output: ${c}_{v}^{i} : V \mapsto \mathbb{N}$
+
+Algorithm 2 IGEL Encoding.
+
+Input: $G = \left( {V,E}\right) ,\alpha : \mathbb{N}$
+
+ ${e}_{v}^{0} \mathrel{\text{ := }} \left\{ {\{ \left( {0,{d}_{G}\left( v\right) }\right) \} }\right\} \forall v \in V$
+
+ for $i \mathrel{\text{ := }} 1;i + = 1$ until $i = \alpha$ do
+
+ ${e}_{v}^{i} \mathrel{\text{ := }} \bigcup \left( {{e}_{v}^{i - 1},}\right.$
+
+ $\{ (i,{d}_{{\mathcal{E}}_{C}^{\alpha }(v)}(u))$
+
+ $\left. \left. {\forall u \in {\mathcal{N}}_{G}^{\alpha }\left( v\right) \mid {l}_{G}\left( {u,v}\right) = i}\right\} \right)$
+
+ end for
+
+ Dutput: ${e}_{v}^{\alpha } : V \mapsto \{ \{ \left( {\mathbb{N},\mathbb{N}}\right) \} \}$
+
+Space complexity. IGEL’s worst case space complexity is $\mathcal{O}\left( {\alpha \cdot n \cdot {d}_{\max }}\right)$ , conservatively assuming that every node will require ${d}_{\max }$ parameters at every $\alpha$ depth from the center of the ego-network.
+
+Time complexity. For IGEL, each vertex has ${d}_{\max }$ neighbours where the $\alpha$ iterations imply traversing through geometrically larger ego-networks with ${\left( {d}_{\max }\right) }^{\alpha }$ vertices, upper bounded by $m$ . Thus IGEL’s time complexity follows $\mathcal{O}\left( {n \cdot \min \left( {m,{\left( {d}_{\max }\right) }^{\alpha }}\right) }\right)$ , with $\mathcal{O}\left( {n \cdot m}\right)$ when $\alpha \geq \operatorname{diam}\left( G\right)$ .
+
+§ 3 THEORETICAL AND EXPERIMENTAL FINDINGS
+
+First, we analyze IGEL's expressive power with respect to 1-WL and recent improvements. Second, we measure the impact of IGEL as an additional input to enrich existing MP-GNN architectures.
+
+§ 3.1 EXPRESSIVITY: WHICH GRAPHS ARE IGEL-DISTINGUISHABLE?
+
+In this section, we discuss the increased expressivity of IGEL with respect to 1-WL, and identify expressivity upper-bounds for graphs that are indistinguishable under MATLANG and the 3-WL test.
+
+ * Relationship to 1-WL. IGEL is capable of distinguishing graphs that are indistinguishable by the 1-WL test-e.g., $d$ -regular graphs. A graph is $d$ -regular graph if all nodes have degree $d.d$ - regular graphs with equal cardinality are indistinguishable by 1-WL. Specifically, for any pair of $d$ - regular graphs ${G}_{1}$ and ${G}_{2}$ such that $\left| {V}_{1}\right| = \left| {V}_{2}\right|$ , ${G}_{1}{ \equiv }_{1 - \mathrm{{WL}}}{G}_{2}$ (see Appendix A for details).
+
+ < g r a p h i c s >
+
+Figure 2: IGEL encodings for two Cospectral 4- regular graphs from [30]. IGEL distinguishes 4 kinds of structures within the graphs (associated with every node as a, b, c, and d). The two graphs can be distinguished since the encoded structures and their frequencies do not match.
+
+However, there exist $d$ -regular graphs that can be distinguished by IGEL, as shown in Figure 2. Since the graph is $d$ -regular, tracing Algorithm 1 shows that the 1-WL test assigns the same color to all nodes and stabilizes after one iteration. In contrast, IGEL with $\alpha = 1$ identifies 4 kinds of structures with different frequencies between the graphs-thus being able to distinguish them.
+
+ * Expressivity upper bounds. We identify an upper expressivity bound for IGEL, where the method fails to distinguish graphs e.g. Strongly Regular Graphs (Definition 1) with equal parameters (Theorem 1, see Appendix B for details): Definition 1. An-vertex $d$ -regular graph is strongly regular-denoted $\operatorname{SRG}\left( {n,d,\beta ,\gamma }\right)$ -if adjacent vertices have $\beta$ vertices in common, and non-adjacent vertices have $\gamma$ vertices in common.
+
+Theorem 1. IGEL cannot distinguish SRGs when $n,d$ , and $\beta$ are the same, and between any value of $\gamma$ (same or otherwise). IGEL when $\alpha = 1$ can only distinguish SRGs with different values of $n,d$ , and $\beta$ , while IGEL when $\alpha = 2$ can only distinguish SRGs with different values of $n$ and $d$ .
+
+Our findings show that IGEL is a powerful representation, capable of distinguishing 1-WL equivalent graphs such as Figure 2-which as cospectral graphs, are known to be expressable in strictly more powerful MATLANG sub-languages than 1-WL [16]. Additionally, the upper bound on Strongly Regular Graphs is a hard ceiling on expressivity since SRGs are known to be indistinguishable by 3-WL [31]. IGEL shares the experimental upper-bound of expressivity of recent methods such as GNNML3 [26]. Furthermore, IGEL can provably reach comparable expressivity on SRGs with respect to sub-graph methods implemented within MP-GNN architectures (see Appendix B, subsection B.2), such as Nested GNNs [21] and GNN-AK [22], which are known to be not less powerful than 3-WL, and the ESAN framework when leveraging ego-networks with root-node flags as a subgraph sampling policy (EGO+) [19], which is as powerful as the 3-WL.
+
+§ 3.2 EXPERIMENTAL EVALUATION
+
+We evaluate ${\operatorname{IGEL}}_{\text{ vec }}^{\alpha }\left( v\right)$ as a method of producing architecture-agnostic vertex features on five tasks: graph classification, isomorphism detection, graphlet counting, link prediction, and node classification.
+
+Experimental Setup. We reproduce results from [26], introducing IGEL as features on graph classification, isomorphism and graphlet counting, comparing the performance of adding/removing IGEL on six GNN architectures. We also evaluate IGEL on link prediction against transductive baselines, and on node classification as an additional feature used in MLPs without message-passing
+
+Notation. The following formatting denotes significant (as per paired t-tests) positive, negative, and insignificant differences after introducing IGEL, with the best results per task / dataset underlined.
+
+Table 1: Per-model graph classification accuracy met rics on TU data sets. Each cell shows the average accuracy of the model and data set in that row and column, with IGEL (left) and without IGEL (right).
+
+max width=
+
+Model Enzymes $\mathbf{{Mutag}}$ Proteins PTC
+
+1-5
+$\mathbf{{MLP}}$ 41.10>26.18 ${}^{ \circ }$ ${87.61} > {84.61}^{ \circ }$ 75.437̃5.01 ${64.59} > {62.79}^{ \circ }$
+
+1-5
+GCN ${54.48} > {48.60}^{ \circ }$ ${89.61} > {85.42}^{ \circ }$ 75.67>74.50 ${}^{ \circ }$ 65.766̃5.21
+
+1-5
+$\mathbf{{GAT}}$ 54.885̃4.95 90.00>86.14 ${}^{ \circ }$ 73.44>70.51 ${}^{ \circ }$ 66.296̃6.29
+
+1-5
+GIN ${{54.77} > {53.44}}^{ * }$ 89.568̃8.33 ${73.32}^{ \circ }{72.05}^{ \circ }$ 61.446̃0.21
+
+1-5
+Chebnet 61.886̃2.23 91.44>88.33 ${}^{ \circ }$ 74.30>66.94 ${}^{ \circ }$ 64.796̃3.87
+
+1-5
+GNNML3 ${61.42} < {62.79}^{ \circ }$ ${92.50} > {91.47}^{ * }$ 75.54>62.32 ${}^{ \circ }$ ${64.26} < {66.10}^{ \circ }$
+
+1-5
+5|c|* $p < {0.01}$ , $p < {0.0001}$
+
+1-5
+
+Table 2: Mean $\pm$ stddev of the best IGEL-augmented graph classification model and reported results on $k$ -hop, GSN, and ESAN from $\left\lbrack {{19},{20},{23}}\right\rbrack$ . Best performing baselines underlined.
+
+max width=
+
+Model Mutag Proteins PTC
+
+1-4
+IGEL (best) ${92.5} \pm {1.2}$ ${75.7} \pm {0.3}$ ${66.3} \pm {1.3}$
+
+1-4
+$k$ -hop [23] ${}^{ \dagger }$ ${87.9} \pm {1.2}^{\diamond }$ ${75.3} \pm {0.4}$ -
+
+1-4
+GSN [20] ${}^{ \dagger }$ ${92.2} \pm {7.5}$ ${76.6} \pm {5.0}$ ${68.2} \pm {7.2}$
+
+1-4
+ESAN [19] ${}^{ \dagger }$ ${91.1} \pm {7.0}$ ${76.7} \pm {4.1}$ ${69.2} \pm {6.5}$
+
+1-4
+
+$\dagger$ : Results as reported by $\left\lbrack {{19},{20},{23}}\right\rbrack$ .
+
+— Graph Classification. Table 1 shows graph classification results on the TU molecule data sets [28]. We evaluate differences in mean accuracy between 10 runs with (left) / without (right) IGEL. We do not tune network hyper-parameters and establish statistical significance through paired t-tests, with $p < {0.01}$ (*) and $p < {0.0001}$ (*). Our results show that IGEL in the Mutag and Proteins data sets improves the performance of all MP-GNN models. On the Enzymes and PTC data sets, results are mixed: for all models other than GNNML3, IGEL either significantly improves accuracy (on MLPNet, GCN, and GIN on Enzymes), or does not have a negative impact on performance.
+
+In Table 2, we compare the best IGEL results from Table 1 with reported results for expressive baselines: $k$ -hop GNNs [23], GSNs [20], and ESAN [19]. All results are comparable to IGEL except Mutag, where IGEL significantly outperforms $k$ -hop with $p < {0.0001}$ . When comparing IGEL and best performing baselines for every data set, no differences are statistically significant $\left( {p > {0.01}}\right)$ .
+
+ * Isomorphism Detection & Graphlet Counting. Adding IGEL to the six models in Table 1 on the EXP [32] graph isomorphism task produces significant improvements: all GNN models distinguish all non-isomorphic yet 1-WL equivalent EXP graph pairs with IGEL vs. 50% accuracy without IGEL (i.e. random guessing). Likewise, IGEL significantly improves GNN performance on the RandomGraph data set [33] counting triangles, tailed triangles and the custom 1-WL graphlets proposed by [26] (see detailed results on Appendix C).
+
+ * Link Prediction & Node Classification. We test IGEL on edge / node level tasks to assess its use as a baseline in non-GNN settings. On a transductive link prediction task, we train DeepWalk [34] style embeddings of IGEL encodings rather than node identities on the Facebook and CA-AstroPh graphs [35]. IGEL-derived embeddings outperform transductive baselines modelling link prediction as an edge-level binary classification task, measuring 0.976 vs. 0.968 (Facebook) and 0.984 vs. 0.937 (CA-AstroPh) AUC comparing IGEL vs. node2vec [36]. On multi-label node classification on PPI [5], we train an MLP (e.g. no message passing) with node features and IGEL encodings. Our MLP shows better micro-F1 (0.850) when $\alpha = 1$ than MP-GNN architectures such as GraphSAGE (0.768, as reported in [6]), but underperforms compared to a 3-layer GAT (0.973 micro-F1 from [6]).
+
+ * Experimental Summary. Introducing IGEL yields comparable performance to state-of-the-art methods without architectural modifications-including when compared to strong baseline models focused on WL expressivity such as GNNML3, $k$ -hop, GSN or ESAN. Furthermore, IGEL achieves this at a lower computational cost, in comparison for instance with GNNML3, which requires a $\mathcal{O}\left( {n}^{3}\right)$ eigen-decomposition step to introduce spectral channels. Finally, IGEL can also be used in transductive settings (link prediction) as well as node-level tasks (node classification) and outperform strong transductive baselines or enhance models without message-passing, such as MLPs. As such, we believe IGEL is an attractive baseline with a clear relationship to the 1-WL test that can be used to improve MP-GNN expressivity without the need of costly architecture search.
+
+§ 4 CONCLUSIONS
+
+We presented IGEL, a novel vertex representation algorithm on unattributed graphs allowing MP-GNN architectures to go beyond 1-WL expressivity. We showed that IGEL is related and more expressive than the 1-WL test, and formally proved an expressivity upper bound on certain families of Strongly Regular Graphs. Finally, our experimental results indicate that introducing IGEL in existing MP-GNN architectures yield comparable performance to state-of-the-art methods, without architectural modifications and at lower computational costs than other approaches.
\ No newline at end of file
diff --git a/papers/LOG/LOG 2022/LOG 2022 Conference/60avttW0Mv/Initial_manuscript_md/Initial_manuscript.md b/papers/LOG/LOG 2022/LOG 2022 Conference/60avttW0Mv/Initial_manuscript_md/Initial_manuscript.md
new file mode 100644
index 0000000000000000000000000000000000000000..cce1bbf76ceaeee6414e1722b10a74726b322091
--- /dev/null
+++ b/papers/LOG/LOG 2022/LOG 2022 Conference/60avttW0Mv/Initial_manuscript_md/Initial_manuscript.md
@@ -0,0 +1,307 @@
+# Continuous Neural Algorithmic Planners
+
+Anonymous Author(s)
+
+Anonymous Affiliation
+
+Anonymous Email
+
+## Abstract
+
+Neural algorithmic reasoning studies the problem of learning classical algorithms with neural networks, especially with a focus on graph architectures. A recent proposal, XLVIN, reaps the benefits of using a graph neural network that simulates value iteration algorithm in deep reinforcement learning agents. It allows model-free planning without access to privileged information of the environment, which is usually unavailable. However, XLVIN only supports discrete action spaces, and is hence nontrivially applicable to most tasks of real-world interest. We expand XLVIN to continuous action spaces by discretization, and evaluate several selective expansion policies to deal with the large planning graphs. Our proposal, CNAP, demonstrates how neural algorithmic reasoning can make a measurable impact in higher-dimensional continuous control settings, such as MuJoCo, bringing gains in low-data settings and outperforming model-free baselines.
+
+## 14 1 Introduction
+
+Neural networks are capable of learning directly from high-dimensional unstructured input data, tackling the input constraints that limit classical algorithms from solving more complex problems. However, neural networks often require large amounts of data to train and suffer from poor generalization and interpretability. On the other hand, algorithms intrinsically generalize and provide mathematical provability with performance guarantees. The complementary relationship motivates the topic of neural algorithmic reasoning to study the problem of learning classical algorithms with neural networks [1].
+
+Recent works focus on utilizing Graph Neural Networks (GNNs) [2-4] for algorithmic reasoning tasks due to the close algorithmic alignment that was proven to bring better sample efficiency and generalization ability $\left\lbrack {5,6}\right\rbrack$ . Besides shortest-path and spanning-tree algorithms, there have been a number of successful applications by aligning GNNs with classical algorithms, covering a range of problems such as bipartite matching [7], min-cut problem [8], and Travelling Salesman Problem [9].
+
+We look at the application of using a GNN that simulates the value iteration algorithm [10] in deep reinforcement learning agents. Value iteration [11] is a dynamic programming algorithm that guarantees to solve a reinforcement learning problem but is traditionally inhibited by its requirement of tabulated inputs. Earlier works [12-16] introduced value iteration as an inductive bias to facilitate the agents to perform implicit planning, without the need of explicitly invoking a planning algorithm, but were found to suffer from an algorithmic bottleneck [17]. Conversely, eXecuted Latent Value Iteration Net (XLVIN) [17] was proposed to leverage a value-iteration-behaving GNN [10] by adopting the neural algorithmic framework [1]. XLVIN is able to learn under a low-data regime, tackling the algorithmic bottleneck suffered by other implicit planners.
+
+One particular difficulty of implicit planners is handling a continuous action space. XLVIN uses a transition model to build a planning graph, over which the pre-trained GNN can execute value iteration in a latent space. So far, it only applies to environments with small and discrete action spaces. The limitation is that the construction of the planning graph requires an enumeration of all possible actions - starting from the current state and expanding for a number of hops equal to the planning horizon. The graph size quickly explodes as the dimensionality of the action space increases. Moreover, a continuous action space results in an infinite pool of action choices, making the construction of a planning graph infeasible.
+
+Nevertheless, continuous control is of significant importance, as most simulation or robotics control tasks [18] have continuous action spaces by design. High complexity also naturally arises as the problem moves towards more powerful real-world domains. To extend such an agent powered by neural algorithmic reasoning to complex continuous control problems, we propose Continuous Neural Algorithmic Planner (CNAP). It generalizes XLVIN to continuous action spaces by discretizing them through binning. Moreover, CNAP handles the large planning graph by following a sampling policy that carefully selects actions during the neighbor expansion stage. Choosing which actions to sample is critical as the graph built determines where the GNN would simulate value iteration computation, and ultimately influences the planning performance.
+
+In addition, the discreteness of the graph neural network simulating the value iteration update rule contrasts with the continuous action space, corresponding to continuous edges between states. CNAP also presents a novel setup for neural algorithmic reasoning, where the downstream task does not fully align with the algorithm studied. This opens a new path for the direction, going beyond the current standard of precise application of learned classical graph algorithms.
+
+We confirm the feasibility of CNAP on a continuous relaxation of a classical low-dimensional control task, where we can still fully expand all of the binned actions after discretization. Then, we apply CNAP to general MuJoCo [19] environments with complex continuous dynamics, where expanding the planning graph by taking all actions is impossible. By expanding the application scope from simple discrete control to complex continuous control, we show that such an intelligent agent with algorithmic reasoning power can be applied to tasks with more real-world interests.
+
+## 2 Background
+
+### 2.1 Markov Decision Process (MDP)
+
+A reinforcement learning problem can be formally described using the MDP framework. At each time step $t \in \{ 0,1,\ldots , T\}$ , the agent performs an action ${a}_{t} \in \mathcal{A}$ given the current state ${s}_{t} \in \mathcal{S}$ . This spawns a transition into a new state ${s}_{t + 1} \in \mathcal{S}$ according to the transition probability $p\left( {{s}_{t + 1} \mid {s}_{t},{a}_{t}}\right)$ , and produces a reward ${r}_{t} = r\left( {{s}_{t},{a}_{t}}\right)$ . A policy $\pi \left( {{a}_{t} \mid {s}_{t}}\right)$ guides an agent by specifying the probability of choosing an action ${a}_{t}$ given a state ${s}_{t}$ . The trajectory $\tau$ is the sequence of actions and states the agents took $\left( {{s}_{0},{a}_{0},\ldots ,{s}_{T},{a}_{T}}\right)$ . We define the infinite horizon discounted return as $R\left( \tau \right) = \mathop{\sum }\limits_{{t = 0}}^{\infty }{\gamma }^{t}{r}_{t}$ , where $\gamma \in \left\lbrack {0,1}\right\rbrack$ is the discount factor. The goal of an agent is to maximize the overall return by finding the optimal policy ${\pi }^{ * } = {\operatorname{argmax}}_{\pi }{\mathbb{E}}_{\tau \sim \pi }\left\lbrack {R\left( \tau \right) }\right\rbrack$ . We can measure the desirability of a state $s$ using the state-value function ${V}^{ * }\left( s\right) = {\mathbb{E}}_{\tau \sim {\pi }^{ * }}\left\lbrack {R\left( \tau \right) \mid {s}_{t} = s}\right\rbrack$ .
+
+### 2.2 Value Iteration
+
+Value iteration is a dynamic programming algorithm that computes the optimal policy and its value function given a tabulated MDP that perfectly describes the environment. It randomly initializes ${V}^{ * }\left( s\right)$ and iteratively updates the value function of each state $s$ using the Bellman optimality equation [11]:
+
+$$
+{V}_{i + 1}^{ * }\left( s\right) = \mathop{\max }\limits_{{a \in \mathcal{A}}}\left\{ {r\left( {s, a}\right) + \gamma \mathop{\sum }\limits_{{{s}^{\prime } \in \mathcal{S}}}p\left( {{s}^{\prime } \mid s, a}\right) {V}_{t}^{ * }\left( {s}^{\prime }\right) }\right\} \tag{1}
+$$
+
+and we can extract the optimal policy using:
+
+$$
+{\pi }^{ * }\left( s\right) = \mathop{\operatorname{argmax}}\limits_{{a \in \mathcal{A}}}\left\{ {r\left( {s, a}\right) + \gamma \mathop{\sum }\limits_{{{s}^{\prime } \in \mathcal{S}}}p\left( {{s}^{\prime } \mid s, a}\right) {V}^{ * }\left( {s}^{\prime }\right) }\right\} \tag{2}
+$$
+
+### 2.3 Message-Passing GNN
+
+Graph Neural Networks (GNNs) generalize traditional deep learning techniques onto graph-structured data [20][21]. A message-passing GNN [3] iteratively updates its node feature ${\overrightarrow{h}}_{s}$ by aggregating messages from its neighboring nodes. At each timestep $t$ , a message can be computed between each connected pair of nodes via a message function $M\left( {{\overrightarrow{h}}_{s}^{t},{\overrightarrow{h}}_{{s}^{\prime }}^{t},{\overrightarrow{e}}_{{s}^{\prime } \rightarrow s}}\right)$ , where ${\overrightarrow{e}}_{{s}^{\prime } \rightarrow s}$ is the edge feature. A node receives messages from all its connected neighbors $\mathcal{N}\left( s\right)$ and aggregates them via a permutation-invariant operator $\oplus$ that produces the same output regardless of the spatial permutation of the inputs. The aggregated message ${\overrightarrow{m}}_{s}^{t}$ of a node $s$ can be formulated as:
+
+$$
+{\overrightarrow{m}}_{s}^{t} = {\bigoplus }_{{s}^{\prime } \in \mathcal{N}\left( s\right) }M\left( {{\overrightarrow{h}}_{s}^{t},{\overrightarrow{h}}_{{s}^{\prime }}^{t},{\overrightarrow{e}}_{{s}^{\prime } \rightarrow s}}\right) \tag{3}
+$$
+
+The node feature ${\overrightarrow{h}}_{s}^{t}$ is then transformed via an update function $U$ :
+
+$$
+{\overrightarrow{h}}_{s}^{t + 1} = U\left( {{\overrightarrow{h}}_{s}^{t},{\overrightarrow{m}}_{s}^{t}}\right) \tag{4}
+$$
+
+### 2.4 Neural Algorithmic Reasoning
+
+A dynamic programming (DP) algorithm breaks down the problem into smaller sub-problems, and recursively computes the optimal solutions. DP algorithm has a general form:
+
+$$
+\text{Answer}\left\lbrack k\right\rbrack \left\lbrack i\right\rbrack = \text{DP-Update}\left( {\{ \text{Answer}\left\lbrack {k - 1}\right\rbrack \left\lbrack j\right\rbrack \} , j = 1\ldots n}\right) \tag{5}
+$$
+
+The alignment between GNN and DP can be seen from mapping nodes representation ${\overrightarrow{h}}_{s}$ to Answer $\left\lbrack k\right\rbrack \left\lbrack i\right\rbrack$ , and the aggregation step of GNN to DP-Update.
+
+An algorithmic alignment framework was proposed by [5], where they proved that GNNs could simulate dynamic programming algorithms efficiently with good sample complexity. Furthermore, [6] showed that imitating the individual steps and intermediate outputs of graph algorithms using GNNs can generalize well into out-of-distribution data.
+
+## 3 Related Work
+
+### 3.1 Continuous action space
+
+A common technique for dealing with continuous control problems is to discretize the action space, converting them into discrete control problems. However, discretization leads to an explosion in action space. [22] proposed to use a policy with factorized distribution across action dimensions, and proved it effective on high-dimensional complex tasks with on-policy optimization algorithms. Moreover, we can sample a subset of actions during node expansion when constructing a planning graph. Sampled MuZero [23] extended MuZero [24] with a sample-based policy based on parameter reuse for policy iteration algorithms. Instead, our work constructs a graph for a neural algorithmic reasoner to execute value iteration algorithm, where the actions sampled would directly participate in the Bellman optimality equation (1).
+
+### 3.2 Large-scale graphs
+
+Sampling modules [25] are introduced into GNN architectures to deal with large-scale graphs as a result of neighbor explosion from stacking multiple layers. The unrolling process to construct a planning graph requires node-level sampling. Previous work GraphSAGE [26] introduces a fixed size of node expansion procedure into GCN [2]. This is followed by PinSage [27], which uses a random-walk-based GCN to perform importance-based sampling. However, our work looks at sampling under an implicit planning context, where the importance of each node in sampling is more difficult to understand due to the lack of an exact description of the environment dynamics. Furthermore, sampling in a multi-dimensional action space also requires more careful thinking in the decision-making process.
+
+## 4 Architecture
+
+Our architecture uses XLVIN as a starting point, which we introduce first. This is followed by a discussion of the challenges that arise from extending neural algorithmic implicit planners to the continuous action space and the approaches we proposed to address them.
+
+### 4.1 XLVIN modules
+
+Given the observation space $\mathbf{S}$ and the action space $\mathcal{A}$ , we let the dimension of state embeddings in the latent space be $k$ . The XLVIN architecture can be broken down into four modules:
+
+
+
+Figure 1: XLVIN modules
+
+Encoder $\left( {z : S \rightarrow {\mathbb{R}}^{k}}\right)$ : A 3-layer MLP which encodes the raw observation from the environment $s \in \mathbf{S}$ , to a state embedding ${\overrightarrow{h}}_{s} = z\left( s\right)$ in the latent space.
+
+Transition $\left( {T : {\mathbb{R}}^{k} \times \mathcal{A} \rightarrow {\mathbb{R}}^{k}}\right)$ : A 3-layer MLP with layer norm taken before the last layer that takes two inputs: the state embedding of an observation $z\left( s\right) \in {\mathbb{R}}^{k}$ , and an action $a \in \mathcal{A}$ . It predicts the next state embedding $z\left( {s}^{\prime }\right) \in \mathbb{R}$ , where ${s}^{\prime }$ is the next state transitioned into when the agent performed an action $a$ under current state $s$ .
+
+Executor $\left( {X : {\mathbb{R}}^{k} \times {\mathbb{R}}^{\left| \mathcal{A}\right| \times k} \rightarrow {\mathbb{R}}^{k}}\right)$ : A message-passing GNN pre-trained to simulate each individual step of the value iteration algorithm following the set-up in [10]. Given the current state embedding ${\overrightarrow{h}}_{s}$ , a graph is constructed by enumerating all possible actions $a \in \mathcal{A}$ as edges to expand, and then using the Transition module to predict the next state embeddings as neighbors $\mathcal{N}\left( {\bar{h}}_{s}\right)$ . Finally, the Executor output is an updated state embedding ${\mathcal{X}}_{s} = X\left( {{\overrightarrow{h}}_{s},\mathcal{N}\left( {\overrightarrow{h}}_{s}\right) }\right)$ .
+
+Policy and Value $\left( {P : {\mathbb{R}}^{k} \times {\mathbb{R}}^{k} \rightarrow {\left\lbrack 0,1\right\rbrack }^{\left| \mathcal{A}\right| }\text{and}V : {\mathbb{R}}^{k} \times {\mathbb{R}}^{k} \rightarrow \mathbb{R}}\right)$ : The Policy module is a linear layer that takes the outputs from the Encoder and Executor, i.e. the state embedding ${\overrightarrow{h}}_{s}$ and the updated state embedding ${\overrightarrow{\mathcal{X}}}_{s}$ , and produces a categorical distribution corresponding to the estimated policy, $P\left( {{\overrightarrow{h}}_{s},{\overrightarrow{\mathcal{X}}}_{s}}\right)$ . The Tail module is also a linear layer that takes the same inputs and produces the estimated state-value function, $V\left( {{\overrightarrow{h}}_{s},{\overrightarrow{\mathcal{X}}}_{s}}\right)$ .
+
+The training procedure follows the XLVIN paper [17], and Proximal Policy Optimization (PPO) [28] is used to train the model, apart from the Executor. We use the PPO implementation and hyperparameters by [29]. The Executor is pre-trained as shown in [10] and directly plugged in.
+
+### 4.2 Discretization of the continuous action space
+
+Assume the continuous action space $\mathcal{A}$ has $D$ dimensions. Given the number of action bins $N,\mathcal{A}$ is discretized into evenly spaced discrete action bins. That is, in each dimension $i \in \{ 1,\ldots , D\}$ , ${\mathcal{A}}_{i} = \left\lbrack {{v}_{1},{v}_{2}}\right\rbrack$ is converted to $\left\{ {{a}_{i}^{1},{a}_{i}^{2},\ldots ,{a}_{i}^{N}}\right\}$ where ${a}_{i}^{k} = \left\lbrack {{v}_{1} + \left( {\left( {{v}_{2} - {v}_{1}}\right) /N}\right) \cdot k,{v}_{1} + \left( \left( {{v}_{2} - }\right. \right. }\right.$ $\left. {\left. {v}_{1}\right) /N}\right) \cdot \left( {k + 1}\right) )$ , and the upper bound is taken inclusively when $k = N$ . For each action bin ${a}_{i}^{k}$ , the median value is chosen as the action to take.
+
+Challenge: The discretization of a multi-dimensional continuous action space leads to a combinatorial explosion in action space size. The explosion results in two bottlenecks in the architecture: (i) the Policy module that produces the action probabilities and (ii) the construction of the GNN graph, which requires an enumeration of all possible actions. Below, we address the two bottlenecks respectively.
+
+### 4.3 Factorized joint policy
+
+Assume each action $\overrightarrow{a} \in \mathcal{A}$ has $D$ dimensions, and each dimension has $N$ discrete action bins. A naive policy ${\pi }^{ * } = p\left( {\overrightarrow{a} \mid s}\right)$ produces a categorical distribution with ${N}^{D}$ possible actions. To tackle this challenge, we follow a factorized joint policy proposed in [22]:
+
+$$
+{\pi }^{ * }\left( {\overrightarrow{a} \mid s}\right) = \mathop{\prod }\limits_{{i = 1}}^{D}{\pi }_{i}^{ * }\left( {{a}_{i} \mid s}\right) \tag{6}
+$$
+
+
+
+Figure 2: (a) Factorized joint policy on an action space with dimension of two. (b) Sampling methods when constructing the graph in Executor.
+
+As illustrated in Figure 2(a), a factorized joint policy $P\left( {{\overrightarrow{h}}_{s},{\overrightarrow{\mathcal{X}}}_{s}}\right)$ is a linear layer with an output dimension of $N * D$ . It approximates $D$ policies simultaneously. Each policy ${\pi }_{i}^{ * }\left( {{a}_{i} \mid s}\right)$ indicates the probability of choosing an action ${a}_{i} \in {\mathcal{A}}_{i}$ in the ${i}^{\text{th }}$ dimension, where $\left| {\mathcal{A}}_{i}\right| = N$ . This deals with the exponential explosion of action bins due to discretization, and the increase is now linear. Note there is a trade-off in the choice of $N$ , as a larger number of action bins retains more information from the continuous action space, but it also implies larger graphs and hence computation costs. We provide an ablation study in evaluation on the impact of this choice.
+
+### 4.4 Neighbor sampling methods
+
+As shown in Figure 2(b), the second bottleneck occurs when constructing a graph to execute the pre-trained GNN. It treats each state as a node, then enumerates all possible actions ${\overrightarrow{a}}_{i} \in \left| \mathcal{A}\right|$ to connect neighbors via approximating $\overrightarrow{h}\left( s\right) \overset{{\overrightarrow{a}}_{i}}{ \rightarrow }\overrightarrow{h}\left( {s}_{i}^{\prime }\right)$ . Therefore, each node has degree $\left| \mathcal{A}\right|$ , and graph size grows even faster as it expands deeper. To tackle this challenge, instead of using all possible actions, we propose to use a neighbor sampling method to choose a subset of actions to expand. The important question is which actions to select. The pre-trained GNN uses the graph constructed to simulate value iteration behavior and predict the state-value function. Hence, it is critical that we can include the action that produces a good approximation of the state-value function in our sampling.
+
+Below, we propose four possible methods to sample $K$ actions from $\mathcal{A}$ , where $K \ll \left| \mathcal{A}\right|$ is a fixed number, under the context of value-iteration-based planning.
+
+#### 4.4.1 Gaussian methods
+
+Gaussian distribution is a common baseline policy distribution for continuous action spaces, and it is straightforward to interpret. Furthermore, it discourages extreme actions while encouraging neutral ones with some level of continuity, which suits the requirement of many planning problems. We propose two variants of sampling policy based on Gaussian distribution.
+
+(1) Manual-Gaussian: A Gaussian distribution is used to randomly sample action values in each dimension ${a}_{i} \in {\mathcal{A}}_{i}$ , which are stacked together as a final action vector $\overrightarrow{a} = {\left\lbrack {a}_{0},\ldots ,{a}_{D - 1}\right\rbrack }^{T} \in \mathcal{A}$ . We repeat for $K$ times to sample a subset of $K$ action vectors. We set the mean $\mu = N/2$ and standard deviation $\sigma = N/4$ , where $N$ is the number of discrete action bins. These two parameters are chosen to spread a reasonable distribution over $\left\lbrack {0, N - 1}\right\rbrack$ . Outliers and non-integers are rounded to the nearest whole number within the range of $\left\lbrack {0, N - 1}\right\rbrack$ .
+
+(2) Learned-Gaussian: The two parameters manually chosen in the previous method pose a constraint on placing the median action in each dimension as the most likely. Here instead, two fully-connected linear layers are used to separately estimate the mean $\mu$ and standard deviation $\sigma$ . They take the state embedding ${\overrightarrow{h}}_{s}$ from Encoder and output parameter estimations for each dimension. We use the reparameterization trick [30] to make the sampling differentiable.
+
+#### 4.4.2 Parameter reuse
+
+Gaussian methods still restrain a fixed distribution on the sampling distribution, which may not necessarily fit. Previous work [23] studied a similar action sampling problem. They reasoned that since the actions selected by the policy are expected to be more valuable, we can directly use the policy for sampling.
+
+(3) Reuse-Policy: We can reuse Policy layer $P\left( {{\overrightarrow{h}}_{s},{\overrightarrow{\mathcal{X}}}_{s}}\right)$ to sample the actions when we expand the graph in Executor. This is equivalent to using the policy distribution ${\pi }^{ * } = p\left( {\overrightarrow{a} \mid s}\right)$ as the neighbor sampling distribution. However, the second input ${\overrightarrow{\mathcal{X}}}_{s}$ for Policy layer comes from Executor, which is not available at the time of constructing the graph. It is filled up by setting ${\overrightarrow{\mathcal{X}}}_{s} = \overrightarrow{0}$ as placeholders.
+
+#### 4.4.3 Learn to expand
+
+Lastly, we can also use a separate layer to learn the neighbor sampling distribution.
+
+(4) Learned-Sampling: This uses a fully-connected linear layer that consumes ${\overrightarrow{h}}_{s}$ and produces an output dimension of $\left| {N \cdot D}\right|$ . It is expected to learn the optimal neighbor sampling distribution in a factorized joint manner, same as Figure 2(a). The outputs are logits for $D$ categorical distributions, where we used Gumbel-Softmax [31] for differentiable sampling actions in each dimension, together producing $\overrightarrow{a} = {\left\lbrack {a}_{1},\ldots ,{a}_{D}\right\rbrack }^{T}$ .
+
+## 5 Results
+
+### 5.1 Classic Control
+
+To evaluate the performance of CNAP agents, we first ran the experiments on a relatively simple MountainCarContinuous-v0 environment from OpenAI Gym Classic Control suite [32], where the action space was one-dimensional. The training of the agent used PPO under 20 rollouts with 5 training episodes each, so the training consumed 100 episodes in total.
+
+We compared two variants of CNAP agents: "CNAP-B" had its Executor pre-trained on a type of binary graph that aimed to simulate the bi-directional control of the car, and "CNAP-R" had its Executor pre-trained on random synthetic Erdős-Rényi graphs. In Table 1, we compared both CNAP agents against a "PPO Baseline" agent that consisted of only the Encoder and Policy/Tail modules. Both the CNAP agents outperformed the baseline agent for this environment, indicating the success of extending XLVIN onto continuous settings via binning.
+
+Table 1: Mean rewards for MountainCarContinuous-v0 using PPO Baseline and two variants of CNAP agents. All three agents ran on 10 action bins, and were trained on 100 episodes in total. Both CNAP agents executed one step of value iteration. The reward was averaged over 100 episodes and 10 seeds.
+
+| Encoder Layer | Output Shape | Param. | Decoder Layer | Output Shape | Param. |
| Input | (•, 3,267) | 0 | Fully Connected | $\left( {\bullet ,{2}^{5},\;{15}}\right)$ | 5280 |
| ChebConv | $\left( {\bullet ,{2}^{4},{267}}\right)$ | 304 | Unpooling | $\left( {\bullet ,{2}^{5},\;{78}}\right)$ | 0 |
| Pooling | $\left( {\bullet ,{2}^{4},\;{78}}\right)$ | 0 | ChebConv | $\left( {\bullet ,{2}^{5},\;{78}}\right)$ | 6176 |
| ChebConv | $\left( {\bullet ,{2}^{5},\;{78}}\right)$ | 3104 | Unpooling | $\left( {\bullet ,{2}^{4},{267}}\right)$ | 0 |
| Pooling | $\left( {\bullet ,{2}^{5},\;{15}}\right)$ | 0 | ChebConv | $( \bullet ,{2}^{4},{267})$ | 3088 |
| Fully Connected | $\left( {\bullet ,{10}}\right)$ | 4810 | ChebConv | $\left( {\bullet ,\;3,{267}}\right)$ | 291 |
+
+## Ablation Study
+
+We perform an ablation study to justify some of the design and parameter choices in our spectral CoSMA architecture. In Table 4, we report the P2S errors on the FAUST dataset and the elephant from the GALLOP dataset after 50 epochs of training. The accuracy degrades for at least one of the two datasets when we reduce the degree $K$ of the Chebyshev polynomials, reduce the size of the hidden representation ${hr}$ , reduce the number of output channels of the convolutional layers, or change the Chebyshev Graph Convolution to the Graph Convolution from [10], who use only first-order Chebyshev polynomials. For the latter change, the networks are trained for 100 epochs.
+
+We also list the P2S errors for a training without using the surface-aware training loss but instead, the patch-wise mean squared error and a hidden representation of size ${hr} = 8$ as in [2]. These networks are trained for 150 epochs as the main experiments.
+
+Table 4: Ablation study of our parameter choices based on P2S errors $\left( {\times {10}^{-2}}\right)$ for 2 training runs.
+
+| $\mathbf{{No}.}$ | Notations | Definitions |
| 1. | ${Z}_{u}^{\left( k\right) }$ | A dictionary (with values ${Z}_{u, a}^{\left( k\right) }$ , of size ${M}_{k}$ ) denoting the $k$ -hop neighborhood representation for node $u$ . |
| 2. | ${Z}_{u, a}^{\left( k\right) }$ | A vector (of length $F$ for $k \geq 1$ ) in the values of ${Z}_{u}^{\left( k\right) }$ representing node $v$ as a $k$ -hop neighbor of $u$ . |
| 3. | ${s}_{u}^{\left( k\right) }$ | An auxiliary array to record the node IDs who are currently recorded as the keys of ${Z}_{u}^{\left( k\right) }$ . |
| 4. | ${\mathrm{{DE}}}_{u}^{t}\left( a\right)$ | The distance encoding of node $a$ based on the keys of N-caches of node $u$ at time $t$ (Eq. (1)). |
| 5. | hash(a) | The hash function mapping a node ID $a$ to the position of ${Z}_{u, a}^{\left( k\right) }$ in the $k$ -hop N-cache of any node $u$ . |
+
+
+
+Figure 2: Neighborhood representations and Joining Neighborhood Features & Representations to make predictions. Left: Neighborhood representations of a node. Node $u$ interacts with $v$ at ${t}_{3}$ in the example in Fig. 1. The 0-hop (self) representation and 1-hop representations will be updated based on ${Z}_{v}^{\left( 0\right) }$ . The 2-hop representations will be updated by inserting ${Z}_{v}^{\left( 1\right) }.{Z}_{u}^{\left( k\right) }$ ’s are maintained in N-caches. Right: In the example of Fig. 1, to predict the link $\left( {u, v,{t}_{3}}\right)$ , the neighborhood representations of node $u$ and node $v$ will be joined: The structural feature DE is constructed according to Eq. (1); The representations are sum-pooled according to Eq. (2). Then, an attention layer (Eq. (3)) is adopted to make the final prediction.
+
+One remark is that for the input timestamps ${t}_{i}$ , we adopt Fourier features to encode them before filling them into RNNs, i.e., with learnable parameter ${\omega }_{i}$ ’s, $1 \leq i \leq d$ , T-encoding $\left( t\right) =$ $\left\lbrack {\cos \left( {{\omega }_{1}t}\right) ,\sin \left( {{\omega }_{1}t}\right) ,\ldots ,\cos \left( {{\omega }_{d}t}\right) ,\sin \left( {{\omega }_{d}t}\right) }\right\rbrack$ , which has been proved to be useful for temporal network representation learning [4, 20, 29, 34, 48, 49].
+
+The large-hop $\left( { > 1}\right)$ neighborhood representation ${Z}_{u}^{\left( k\right) }$ is also a dictionary. Similarly, the keys of ${Z}_{u}^{\left( k\right) }$ correspond to the nodes who lie in the $k$ -hop neighborhood of $u$ . The update of ${Z}_{u}^{\left( k\right) }$ is as follows: If $u$ interacts with $v, v$ ’s(k - 1)-hop neighborhood by definition becomes a part of $k$ -hop neighborhood of $u$ after the interaction. Given this observation, ${Z}_{u}^{\left( k\right) }$ can also be updated by using ${Z}_{v}^{\left( k - 1\right) }$ . However, we avoid using a RNN for the large-hop update to reduce complexity. Instead, we directly insert ${Z}_{v}^{\left( k - 1\right) }$ into ${Z}_{u}^{\left( k\right) }$ , i.e., setting ${Z}_{u, a}^{\left( k\right) } \leftarrow {Z}_{v, a}^{\left( k - 1\right) }$ for all $a \in \operatorname{key}\left\lbrack {Z}_{v}^{\left( k - 1\right) }\right\rbrack$ . If ${Z}_{u, a}^{\left( k\right) }$ has already existed before the insertion, we simply replace it.
+
+Next, we will introduce the implementation of the above representations via N-caches. Readers who only care about the learning models can skip this part and directly go to Sec. 4.2. The maintenance of N-caches (aka. neighborhood representations) as the network evolves is summarized in Alg. 1.
+
+Scalable Implementation. Neighborhood representations cannot be directly implemented via python dictionary to achieve scalable maintenance. Instead, we adopt the following three design techniques: (a) Setting size limit; (b) Parallelizing hash-maps; (c) Addressing collisions.
+
+Algorithm 1: N-caches construction and update $\left( {\mathcal{V},\mathcal{E},\alpha }\right)$
+
+---
+
+for $k$ from 0 to 2 (consider only two hops) do
+
+ for $u$ in $\mathcal{V}$ , in parallel, do
+
+ Initialize fixed-size dictionaries ${Z}_{u}^{\left( k\right) }$ in GPU with key spaces ${s}_{u}^{\left( k\right) }$ and value spaces;
+
+I for(u, v, t, e)in each mini-batch(u, v, t, e)of $\mathcal{E}$ , in parallel, do
+
+ ${Z}_{u}^{\left( 0\right) } \leftarrow \mathbf{{RNN}}\left( {{Z}_{u}^{\left( 0\right) },\left\lbrack {{Z}_{v}^{\left( 0\right) }, t, e}\right\rbrack }\right) //$ update 0-hop self-representation
+
+ ${Z}_{\text{prev }} \leftarrow {Z}_{u, v}^{\left( 1\right) }$ if ${s}_{u}^{\left( 1\right) }\left\lbrack {\operatorname{hash}\left( v\right) }\right\rbrack$ equals $v$ , else 0 // check if ${Z}_{u, v}^{\left( 1\right) }$ is recorded in ${Z}_{u}^{\left( 1\right) }$ or not;
+
+ if ${s}_{u}^{\left( 1\right) }\left\lbrack {\operatorname{hash}\left( v\right) }\right\rbrack$ equals ( $v$ or ${EMPTY}$ ) or rand $\left( {0,1}\right) < \alpha$ then
+
+ ${s}_{u}^{\left( 1\right) }\left\lbrack {\text{hash}\left( v\right) }\right\rbrack \leftarrow v,{Z}_{u, v}^{\left( 1\right) } \leftarrow \mathbf{{RNN}}\left( {{Z}_{\text{prev }},\left\lbrack {{Z}_{v}^{\left( 0\right) }, t, e}\right\rbrack }\right) ;//$ update 1-hop nbr. representation
+
+ for $w$ in ${s}_{v}^{\left( 1\right) }$ , in parallel, do
+
+ if ${s}_{u}^{\left( 2\right) }\left\lbrack {\operatorname{hash}\left( w\right) }\right\rbrack$ equals ( $w$ or ${EMPTY}$ ) or rand $\left( {0,1}\right) < \alpha$ then
+
+ ${s}_{u}^{\left( 2\right) }\left\lbrack {\operatorname{hash}\left( w\right) }\right\rbrack \leftarrow w,{Z}_{u, w}^{\left( 2\right) } \leftarrow {Z}_{v, w}^{\left( 1\right) };//$ update 2-hop nbr. representations
+
+ repeat lines 5-11 with(v, u, t, e)
+
+---
+
+(a) Limiting size: In a real-world network, the size of neighborhood of a node typically follows a long-tailed distribution [50, 51]. So, it is irregular and memory inefficient to record the entire neighborhood. Instead, we set an upper limit ${M}_{k}$ to the size of each-hop representation ${Z}_{u}^{\left( k\right) }$ , which means ${Z}_{u}^{\left( k\right) }$ may record only a subset of nodes in the $k$ -hop neighborhood of node $u$ . This idea is inspired by previous works that have shown structural features constructed based on a down-sampled neighborhood is sufficient to provide good performance [34, 52]. To further decrease the memory overhead, we only set each representation ${Z}_{u, a}^{\left( k\right) }, k \geq 1$ as a vector of small dimension $F$ . Overall, the memory overhead of the $\mathrm{N}$ -cache per node is $O\left( {\mathop{\sum }\limits_{{k = 1}}^{K}{M}_{k} \times F}\right)$ . In our experiments, we consider at most $K = 2$ hops, and set the numbers of tracked neighbors ${M}_{1},{M}_{2} \in \left\lbrack {2,{40}}\right\rbrack$ and the size of each representation $F \in \left\lbrack {2,8}\right\rbrack$ , which already gives very good performance. Based on the above design, the overall memory overhead is just about hundreds per node, which is comparable to the commonly-used memory cost of tracking a big single-vector representation for each node.
+
+(b) The hash-map: As NAT needs to frequently access N-caches, a fast implementation of using node IDs to search within N-caches in parallel is needed. To enable the parallel search, we design GPU dictionaries to implement N-caches. Specifically, for every node $u$ , we pre-allocate $O\left( {{M}_{k} \times F}\right)$ space in GPU-RAM to record the values in ${Z}_{u}^{\left( k\right) }$ . A hash function is adopted to access the values in ${Z}_{u}^{\left( k\right) }$ . For some node $a$ , we compute $\operatorname{hash}\left( a\right) \equiv \left( {q * a}\right) \left( {\;\operatorname{mod}\;{M}_{k}}\right)$ for a fixed large prime number $q$ to decide the row-index in ${Z}_{u}^{\left( k\right) }$ that records ${Z}_{u, a}^{\left( k\right) }$ . Such a simple hashing allows NAT accessing multiple neighborhood representations in N-caches in parallel.
+
+However, as the size ${M}_{k}$ of each $\mathrm{N}$ -cache is small, in particular smaller than the corresponding neighborhood, the hash-map may encounter collisions. To detect such collisions, we also pre-allocate $O\left( {M}_{k}\right)$ space in each $\mathrm{N}$ -cache ${Z}_{u}^{\left( k\right) }$ for an array ${s}_{u}^{\left( k\right) }$ to record the IDs of the nodes who are the most recent ones recorded in ${Z}_{u}^{\left( k\right) }$ . Specifically, we use ${s}_{u}^{\left( k\right) }\left\lbrack {\operatorname{hash}\left( a\right) }\right\rbrack$ to check whether node $a$ is a key of ${Z}_{u}^{\left( k\right) }$ . If ${s}_{u}^{\left( k\right) }\left\lbrack {\operatorname{hash}\left( a\right) }\right\rbrack$ is $a,{Z}_{u, a}^{\left( k\right) }$ is recorded at the position hash(a)of ${Z}_{u}^{\left( k\right) }$ . If ${s}_{u}^{\left( k\right) }\left\lbrack {\operatorname{hash}\left( a\right) }\right\rbrack$ is neither $a$ nor EMPTY, the position hash(a)of ${Z}_{u}^{\left( k\right) }$ records the representation of another node.
+
+(c) Addressing collisions: If encountering a collision when NAT works on an evolving network, NAT addresses that collision in a random manner. Specifically, suppose we are to write ${Z}_{u, a}^{\left( k\right) }$ into ${Z}_{u}^{\left( k\right) }$ . If another node $b$ satisfies $\operatorname{hash}\left( a\right) = \operatorname{hash}\left( b\right) = p$ and ${Z}_{u, b}^{\left( k\right) }$ has occupied the position $p$ of ${Z}_{u}^{\left( k\right) }$ , then, we replace ${Z}_{u, b}^{\left( k\right) }$ by ${Z}_{u, a}^{\left( k\right) }$ (and ${s}_{u}^{\left( k\right) }\left\lbrack {\operatorname{hash}\left( a\right) }\right\rbrack \leftarrow a$ simultaneously) with probability $\alpha$ . Here, $\alpha \in (0,1\rbrack$ is a hyperparameter. Although the above random replacement strategy sounds heuristic, it is essentially equivalent to random-sampling nodes from the neighborhood without replacement (random dropping $\leftrightarrow$ random sampling). Note that random-sampling neighbors is a common strategy used to scale up GNNs for static networks [53-55], so here we essentially apply an idea of similar spirit to temporal networks. We find a small size ${M}_{k}\left( { \leq {40}}\right)$ can give a good empirical performance while keeping the model scalable, and NAT is relatively robust to a wide range of $\alpha$ .
+
+### 4.2 Joint Neighborhood Structural Features and Neural-network-based Encoding
+
+As illustrated in the toy example in Fig. 1, structural features from the joint neighborhood are critical to reveal how temporal networks evolve. Previous methods in static networks adopt distance encoding (DE) (or called labeling tricks more broadly) to formulate these features [18, 19]. Recently, this idea has got generalized to temporal networks [34]. However, the model CAWN in [34] uses online random-walk sampling, which cannot be parallelized on GPUs and is thus extremely slow. Our design of N-caches allows addressing such a problem. Fig. 2 Right illustrates the procedure.
+
+NAT generates joint neighborhood structural features as follows. Suppose our prediction is made for a temporal link(u, v, t). For every node $a$ in the joint neighborhood of $u$ and $v$ decided by their N-caches at timestamp $t$ , i.e., $a \in \left\lbrack {{ \cup }_{k = 0}^{K}\operatorname{key}\left( {Z}_{u}^{\left( k\right) }\right) }\right\rbrack \cup \left\lbrack {{ \cup }_{{k}^{\prime } = 0}^{K}\operatorname{key}\left( {Z}_{v}^{\left( {k}^{\prime }\right) }\right) }\right\rbrack$ , we associate it with a DE
+
+${\mathrm{{DE}}}_{uv}^{t}\left( a\right) = {\mathrm{{DE}}}_{u}^{t}\left( a\right) \oplus {\mathrm{{DE}}}_{v}^{t}\left( a\right)$ , where ${\mathrm{{DE}}}_{w}^{t}\left( a\right) = \left\lbrack {\chi \left\lbrack {a \in {Z}_{w}^{\left( 0\right) }}\right\rbrack ,\ldots ,\chi \left\lbrack {a \in {Z}_{w}^{\left( K\right) }}\right\rbrack }\right\rbrack , w \in \{ u, v\}$(1)
+
+Here, $\chi \left\lbrack {a \in {Z}_{w}^{\left( i\right) }}\right\rbrack$ is 1 if $a$ is among the keys of N-cache ${Z}_{w}^{\left( i\right) }$ or 0 otherwise. $\oplus$ denotes vector concatenation. As for the example to predict $\left( {u, v,{t}_{3}}\right)$ in Fig. 1, the DEs of four nodes $u, a, v, b$ are as shown in Fig. 2 Right. Note that ${\mathrm{{DE}}}_{uv}^{{t}_{3}}\left( a\right) = \left\lbrack {0,1,0}\right\rbrack \oplus \left\lbrack {0,1,0}\right\rbrack$ because $a$ appears in the keys of both ${Z}_{u}^{\left( 1\right) }$ and ${Z}_{v}^{\left( 1\right) }$ , which further implies $a$ as a common neighbor of $u$ and $v$ .
+
+Simultaneously, NAT also aggregates neighborhood representations for every node $a$ in the common neighborhood of $u$ and $v$ . Specifically, for node $a$ , we aggregate the representations via a sum pool
+
+$$
+{Q}_{uv}^{t}\left( a\right) = \mathop{\sum }\limits_{{k = 0}}^{K}\mathop{\sum }\limits_{{w \in \{ u, v\} }}{Z}_{w, a}^{\left( k\right) } \times \chi \left\lbrack {a \in {Z}_{w}^{\left( k\right) }}\right\rbrack . \tag{2}
+$$
+
+Here, if $a$ is not in the neighborhood ${Z}_{w}^{\left( k\right) },\chi \left\lbrack {a \in {Z}_{w}^{\left( k\right) }}\right\rbrack = 0$ and thus ${Z}_{w, a}^{\left( k\right) }$ does not participate in the aggregation. Both DE (Eq (1)) and representation aggregation (Eq (2)) can be done for multiple node pairs in parallel on GPUs. We detail the parallel steps in Appendix A. After joining DE and neighborhood representations, for each link(u, v, t)to be predicted, NAT has a collection of representations ${\Omega }_{u, v}^{t} = \left\{ {{\mathrm{{DE}}}_{uv}^{t}\left( a\right) \oplus {Q}_{uv}^{t}\left( a\right) \mid a \in {\mathcal{N}}_{u, v}^{t}}\right\}$ .
+
+Ultimately, we propose to use attention to aggregate the collected representations in ${\Omega }_{u, v}^{t}$ to make the final prediction for the link(u, v, t). Let MLP denote a multi-layer perceptron and we adopt
+
+$$
+\text{logit} = \operatorname{MLP}\left( {\mathop{\sum }\limits_{{h \in {\Omega }_{u, v}^{t}}}{\alpha }_{h}\operatorname{MLP}\left( h\right) }\right) \text{, where}\left\{ {\alpha }_{h}\right\} = \operatorname{softmax}\left( \left\{ {{w}^{T}\operatorname{MLP}\left( h\right) \mid h \in {\Omega }_{u, v}^{t}}\right\} \right) \text{,} \tag{3}
+$$
+
+where $w$ is a learnable vector parameter and the logit can be plugged in the cross-entropy loss for training or compared with a threshold to make the final prediction.
+
+## 5 Experiments
+
+In this section, we evaluate the performance and the scalability of NAT against a variety of baselines on real-world temporal networks. We further conduct ablation study on relevant modules and hyperparameter analysis. Unless specified for comparison, the hyperparameters of NAT (such as ${M}_{1},{M}_{2}, F,\alpha$ ) are detailed in Appendix C and Table 7 (in the Appendix).
+
+### 5.1 Experimental setup
+
+Datasets. We use seven real-world datasets that are available to the public, whose statistics are listed in Table 1. Further details of these datasets can be found in Appendix B. We preprocess all datasets by following previous literatures. We transform the node and edge features of Wikipedia and Reddit to 172-dim feature vectors. For other datasets, those features will be zeros since they are non-attributed. We split the datasets into training, validation and testing data according to the ratio of 70/15/15. For inductive test, we sample the unique nodes in validation and testing data with probability 0.1 and remove them and their associated edges from the networks during the model training. We detail the procedure of inductive evaluation for NAT in Appendix C.1.
+
+Baselines. We run experiments against 6 strong baselines that give the SOTA approaches for modeling temporal networks. Out of the 6 baselines, CAWN [34], TGAT [29] and TGN [20] need to sample neighbors from the historical events, while JODIE [28], DyRep [27], keep track of dynamic node representations to avoid sampling. CAWN is the only model that constructs neighborhood structural features. As we are interested in both prediction performance and model scalability, we include an efficient implementation of TGN sourced from Pytorch Geometric (TGN-pg), a library built upon PyTorch including different variants of GNNs [56]. TGN is slower than TGN-pg because TGN in [20] does not process a batch fully in parallel while TGN-pg does. Additional details about the baselines can be found in appendix $\mathrm{C}$ .
+
+| Task | Method | Wikipedia | Reddit | Social E. $1\mathrm{\;m}$ . | Social E. | Enron | UCI | Ubuntu | Wiki-talk |
| Inductive | CAWN | ${98.52} \pm {0.04}$ | ${98.19} \pm {0.03}$ | ${80.09} \pm {1.89}$ | ${50.00} \pm {0.00}{}^{ * }$ | ${93.28} \pm {0.01}$ | ${80.37} \pm {0.65}$ | ${50.00} \pm {0.00}^{ * }$ | ${50.00} \pm {0.00}^{ * }$ |
| JODIE | ${95.58} \pm {0.37}$ | ${95.96} \pm {0.29}$ | ${80.61} \pm {1.55}$ | ${81.13} \pm {0.52}$ | ${81.69} \pm {2.21}$ | ${86.13} \pm {0.34}$ | ${56.68} \pm {0.49}$ | ${65.89} \pm {4.72}$ |
| DyRep | ${94.72} \pm {0.14}$ | ${97.04} \pm {0.29}$ | ${81.54} \pm {1.81}$ | ${52.68} \pm {0.11}$ | ${77.44} \pm {2.28}$ | ${68.38} \pm {1.30}$ | ${53.25} \pm {0.03}$ | ${51.87} \pm {0.93}$ |
| TGN | ${98.01} \pm {0.06}$ | ${97.76} \pm {0.05}$ | ${86.00} \pm {0.70}$ | ${67.01} \pm {10.3}$ | ${75.72} \pm {2.55}$ | ${83.21} \pm {1.16}$ | ${62.14} \pm {3.17}$ | ${56.73} \pm {2.88}$ |
| TGN-pg | ${94.91} \pm {0.35}$ | ${94.34} \pm {3.22}$ | ${63.44} \pm {3.54}$ | ${88.10} \pm {4.81}$ | ${69.55} \pm {1.62}$ | ${86.36} \pm {3.60}$ | ${79.44} \pm {0.85}$ | ${85.35} \pm {2.96}$ |
| TGAT | ${97.25} \pm {0.18}$ | ${96.69} \pm {0.11}$ | ${54.66} \pm {0.66}$ | ${50.00} \pm {0.00}$ | ${57.09} \pm {0.89}$ | ${70.47} \pm {0.59}$ | ${54.73} \pm 4.{.94}$ | ${71.04} \pm {3.59}$ |
| NAT | $\mathbf{{98.55} \pm {0.09}}$ | $\mathbf{{98.56} \pm {0.21}}$ | $\mathbf{{91.82} \pm {1.91}}$ | $\mathbf{{95.16} \pm {0.66}}$ | ${94.94} \pm {1.15}$ | $\mathbf{{92.46} \pm {0.93}}$ | $\mathbf{{90.35} \pm {0.20}}$ | $\mathbf{{93.81} \pm {1.16}}$ |
| Transductive | CAWN | ${98.62} \pm {0.05}$ | ${98.66} \pm {0.09}$ | ${79.59} \pm {0.21}$ | ${50.00} \pm {0.00}{}^{ * }$ | ${91.46} \pm {0.35}$ | ${82.84} \pm {0.16}$ | ${50.00} \pm {0.00}^{ * }$ | ${50.00} \pm {0.00}^{ * }$ |
| JODIE | ${96.15} \pm {0.36}$ | ${97.29} \pm {0.05}$ | ${77.02} \pm {1.11}$ | ${69.30} \pm {0.21}$ | ${83.42} \pm {2.63}$ | ${91.09} \pm {0.69}$ | ${60.29} \pm {2.66}$ | ${75.00} \pm {4.90}$ |
| DyRep | ${95.81} \pm {0.15}$ | ${98.00} \pm {0.19}$ | ${76.96} \pm {4.05}$ | ${51.14} \pm {0.24}$ | ${78.04} \pm {2.08}$ | ${72.25} \pm {1.81}$ | ${52.22} \pm {0.02}$ | ${62.07} \pm {0.06}$ |
| TGN | ${98.57} \pm {0.05}$ | ${98.70} \pm {0.03}$ | ${88.72} \pm {0.65}$ | ${69.39} \pm {10.50}$ | ${80.87} \pm {4.37}$ | ${89.53} \pm {1.49}$ | ${53.80} \pm {2.23}$ | ${66.01} \pm {4.79}$ |
| TGN-pg | ${97.26} \pm {0.10}$ | ${98.62} \pm {0.07}$ | ${66.39} \pm {6.90}$ | ${64.03} \pm {8.97}$ | ${80.85} \pm {2.70}$ | ${91.47} \pm {0.29}$ | ${90.56} \pm {0.44}$ | ${94.16} \pm {0.09}$ |
| TGAT | ${96.65} \pm {0.06}$ | ${98.19} \pm {0.08}$ | ${58.10} \pm {0.47}$ | ${50.00} \pm {0.00}$ | ${61.25} \pm {0.99}$ | ${77.88} \pm {0.31}$ | ${55.46} \pm {5.47}$ | ${78.43} \pm {2.15}$ |
| NAT | $\mathbf{{98.68} \pm {0.04}}$ | $\mathbf{{99.10} \pm {0.09}}$ | $\mathbf{{90.20} \pm {0.20}}$ | ${94.43} \pm {1.67}$ | $\mathbf{{92.42} \pm {0.09}}$ | $\mathbf{{93.92} \pm {0.15}}$ | $\mathbf{{93.50} \pm {0.34}}$ | ${95.82} \pm {0.31}$ |
+
+Table 2: Performance in average precision (AP) (mean in percentage $\pm {95}\%$ confidence level). Bold font and underline highlight the best performance and the second best performance on average. *The under-performance of CAWN on Social E., Ubuntu and Wiki-talk may be caused by a recent code change due to a bug [57].
+
+Regarding hyperparameters, if a dataset has been tested by a baseline, we use the set of hyperparame-ters that are provided in the corresponding paper. Otherwise, we tune the parameters such that similar components have sizes in the same scale. For example, matching the number of neighbors sampled and the embedding sizes. We also fix the training and inference batch sizes so that the comparison of training and inference time can be fair between different models. For training, since CAWN uses 32 as the default while others use 200 , we decide on using 100 that is between the two. For validation and testing, we use batch size 32 over all baselines. We also apply the early stopping strategy for all models to record the number of epochs to converge and the total model running time to converge. We also set a time limit of 10 hours for training. once that time is reached, we will use the best epoch so far for evaluation. More detailed hyperparameters are provided in Appendix C.
+
+Hardware. We run all experiments using the same device that is equipped with eight Intel Core i7-4770HQ CPU @ 2.20GHz with 15.5 GiB RAM and one GPU (GeForce GTX 1080 Ti).
+
+Evaluation Metrics. For prediction performance, we evaluation all models with Average Precision (AP) and Area Under the ROC curve (AUC). In the main text, the prediction performance in all tables is evaluated in AP. The AUC results are given in the appendix. All results are summarized based on 5 time independent experiments. For computing performance, the metrics include (a) average training and inference time (in seconds) per epoch, denoted as Train and Test respectively, (b) averaged total time (in seconds) of a model run, including training of all epochs, and testing, denoted as Total, (c) the averaged number of epochs for convergence, denoted as Epoch, (d) the maximum GPU memory and RAM occupancy percentage monitored throughout the entire processes, denoted as GPU and $\mathbf{{RAM}}$ , respectively. We ensure that there are no other applications running during our evaluations.
+
+### 5.2 Results and Discussion
+
+Overall, our method achieves SOTA performance on all 7 datasets. The modeling capacity of NAT exceeds all of the baselines and the time complexities of training and inference are either lower or comparable to the fastest baselines. Let us provide the detailed analysis next.
+
+Prediction Performance. We give the result of AP in Table 2 and AUC in Appendix Table 6.
+
+| Task | Method | Wikipedia | Reddit | Social E. $1\mathrm{\;m}$ . | Social E. | Enron | UCI | Ubuntu | Wiki-talk |
| Inductive | CAWN | ${98.16} \pm {0.06}$ | ${97.97} \pm {0.01}$ | ${78.36} \pm {2.94}$ | ${50.00} \pm {0.00}$ | ${94.29} \pm {0.15}$ | ${79.35} \pm {0.48}$ | ${50.00} \pm {0.00}$ | ${50.00} \pm {0.00}$ |
| JODIE | ${95.16} \pm {0.42}$ | ${96.31} \pm {0.16}$ | ${85.16} \pm {1.24}$ | ${86.14} \pm {0.67}$ | ${82.56} \pm {1.88}$ | ${85.02} \pm {0.38}$ | ${52.41} \pm {5.80}$ | ${65.94} \pm {4.26}$ |
| DyRep | ${93.97} \pm {0.18}$ | ${96.86} \pm {0.29}$ | ${84.38} \pm {1.69}$ | ${49.84} \pm {0.35}$ | ${76.69} \pm {2.64}$ | ${67.36} \pm {1.47}$ | ${53.22} \pm {0.03}$ | ${50.37} \pm {0.42}$ |
| TGN | ${97.84} \pm {0.06}$ | ${97.63} \pm {0.09}$ | ${88.43} \pm {0.38}$ | ${70.86} \pm {10.30}$ | ${75.28} \pm {1.81}$ | ${81.65} \pm {1.44}$ | ${62.98} \pm {3.36}$ | ${59.24} \pm {2.34}$ |
| TGN-pg | ${94.96} \pm {0.33}$ | ${94.53} \pm {3.04}$ | ${63.17} \pm {4.69}$ | ${90.24} \pm {3.72}$ | ${67.99} \pm {1.78}$ | ${86.02} \pm {3.34}$ | ${74.85} \pm {1.44}$ | ${83.25} \pm {2.96}$ |
| TGAT | ${97.25} \pm {0.18}$ | ${96.37} \pm {0.10}$ | ${51.23} \pm {0.69}$ | ${50.0} \pm {0.00}$ | ${55.86} \pm {1.01}$ | ${70.83} \pm {0.58}$ | ${55.73} \pm {6.47}$ | ${74.50} \pm {3.71}$ |
| NAT | $\mathbf{{98.27} \pm {0.12}}$ | $\mathbf{{98.56} \pm {0.21}}$ | $\mathbf{{92.62} \pm {1.66}}$ | $\mathbf{{96.13} \pm {0.46}}$ | ${95.25} \pm {1.37}$ | $\mathbf{{90.18} \pm {1.30}}$ | $\mathbf{{87.72} \pm {0.28}}$ | $\mathbf{{92.73} \pm {1.35}}$ |
| Transductive | CAWN | ${98.39} \pm {0.08}$ | ${98.64} \pm {0.04}$ | ${79.59} \pm {0.32}$ | ${50.00} \pm {0.00}$ | ${92.32} \pm {0.26}$ | ${81.76} \pm {0.18}$ | ${50.00} \pm {0.00}$ | ${50.00} \pm {0.00}$ |
| JODIE | ${96.05} \pm {0.39}$ | ${97.63} \pm {0.05}$ | ${82.36} \pm {0.87}$ | ${76.87} \pm {0.32}$ | ${85.28} \pm {2.25}$ | ${91.69} \pm {0.40}$ | ${52.61} \pm {2.50}$ | ${73.32} \pm {4.37}$ |
| DyRep | ${95.34} \pm {0.18}$ | ${97.93} \pm {0.20}$ | ${80.58} \pm {3.55}$ | ${50.05} \pm {3.64}$ | ${79.28} \pm {1.84}$ | ${72.62} \pm {2.01}$ | ${52.38} \pm {0.02}$ | ${69.89} \pm {2.67}$ |
| TGN | ${98.42} \pm {0.05}$ | ${98.65} \pm {0.03}$ | ${90.37} \pm {0.40}$ | ${73.08} \pm {9.74}$ | ${82.08} \pm {4.36}$ | ${89.54} \pm {1.58}$ | ${54.13} \pm {2.52}$ | ${76.07} \pm {5.28}$ |
| TGN-pg | ${97.06} \pm {0.09}$ | ${98.58} \pm {0.08}$ | ${66.89} \pm {7.90}$ | ${66.14} \pm {10.7}$ | ${81.23} \pm {2.80}$ | ${91.16} \pm {0.30}$ | ${89.59} \pm {0.42}$ | ${93.69} \pm {0.06}$ |
| TGAT | ${96.65} \pm {0.06}$ | ${98.07} \pm {0.08}$ | ${56.98} \pm {0.53}$ | ${50.00} \pm {0.00}$ | ${62.08} \pm {1.08}$ | ${79.85} \pm {0.24}$ | ${57.23} \pm {6.55}$ | ${81.82} \pm {1.87}$ |
| NAT | ${98.51} \pm {0.05}$ | ${99.01} \pm {0.11}$ | $\mathbf{{91.77} \pm {0.19}}$ | $\mathbf{{93.63} \pm {0.36}}$ | $\mathbf{{93.08} \pm {0.18}}$ | $\mathbf{{92.08} \pm {0.18}}$ | $\mathbf{{92.62} \pm {0.10}}$ | $\mathbf{{95.33} \pm {0.26}}$ |
+
+Table 6: Performance in AUC (mean in percentage $\pm {95}\%$ confidence level.) bold font and underline highlight the best performance on average and the second best performance on average. Timeout means the time of training for one epoch is more than one hour.
+
+