{'fraction_non_alphanumeric': 0.029416924966372302, 'fraction_numerical': 0.008947891689572489, 'mean_word_length': 4.596301750940926, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Scaling R-GCN Training with Graph Summarization

Training of Relational Graph Convolutional Networks (R-GCN) is a memory intense task. The amount of gradient information that needs to be stored during training for real-world graphs is often too large for the amount of memory available on most GPUs. In this work, we experiment with the use of graph summarization techniques to compress the graph and hence reduce the amount of memory needed. After training the R-GCN on the graph summary, we transfer the weights back to the original graph and attempt to perform inference on it. We obtain reasonable results on the AIFB, MUTAG and AM datasets. Our experiments show that training on the graph summary can yield a comparable or higher accuracy to training on the original graphs.Furthermore, if we take the time to compute the summary out of the equation, we observe that the smaller graph representations obtained with graph summarization methods reduces the computational overhead. However, further experiments are needed to evaluate additional graph summary models and whether our findings also holds true for very large graphs.


INTRODUCTION
Knowledge Graphs (KG) emerged as an abstraction to represent and exploit complex data, and to ease accessibility [11]. As a result, extensive collections of data stored in KGs are now publicly available, spurring the interest in investigating novel technologies that aim to structure and analyze such data. However, KGs, including well-known ones such as DBpedia and WikiData [1], remain incomplete. There is an evident trade-off between the quantity of data available and its adequate coverage (completeness) [3]. Predicting missing information in KGs, e.g., predicting missing links, is the main focus of statistical relational learning [29]. However, such methods are challenged by large quantities of data and the unknown structure of KGs, harming the scalability of applications [24].
Several techniques have been developed to tackle these larger graphs while still retaining their structure. First, training of GCNs can be scaled by developing a memory-optimized implementation or distributing the computations over multiple GPUs [22]. Second, some techniques try to work with condensed representation of the KG that retains the original structure of the graph. For example, Salha et al. [26] proposed to use a highly dense subset of nodes from the original graph. Deng and his co-authors [10] suggest the creation of a fused graph that embeds the topology of the original graph and in turn recursively coarsens into smaller graphs for a number of iterations. The methods have been shown to improve classification accuracy and accelerate the graph embedding process [10].
In this work, we propose to use graph summarization techniques to create a condensed representation of the KG, i. e., the graph summary. In our approach, we train an R-GCN on the graph summary and, subsequently, transfer the obtained weights to an R-GCN based on the original KG. Finally, we evaluate the later R-GCN and then investigate how its performance behaves when trained further, compared to an R-GCN based on the full KG that was not pre-trained on a summary. From our experiments we observe that training on the graph summary can yield a comparable or higher accuracy to training on the original graph. Furthermore, we show that the smaller graph representations obtained with graph summarization methods reduces the computational overhead if we do not incorporate the time needed for the summarization.

RELATIONAL GRAPH CONVOLUTIONAL NETWORKS
Graph Convolutional Networks (GCNs) have spurred great interest in Machine Learning with graph entities. A GCN takes as input a graph, potentially with input features for the nodes, and outputs embeddings for each of the nodes. GCNs use a message-passing algorithm which means that neighboring information influences the embedding representation of a node. However, a drawback of a GCN is that it treats all relations within a heterogeneous graph the same. Hence, the R-GCN was proposed, which enables the inclusion of relational information into the Graph Neural Network (originally proposed by Schlichtkrull et al. [29] and extensively analyzed by Thanapalasingam et al. [30]).
An R-GCN is defined as a convolution that performs message passing in the context of multi-relational graphs. The updated state of a node after message passing step + 1 of this graph neural network is as follows: This state is a combination of the state of the neighboring nodes after the previous message passing step and the previous state of the node itself. In the formula, we sum over all relation types in and then over all neighbors which have a relation to node ( ). The state of these nodes is projected using relation specific matrices ( ) (the weight matrix for the relation at layer ) before being summed. The R-GCN adds a self-connection when updating the representation of a node, and learns a dedicated weight matrix ( ) 0 to project nodes onto themselves. Finally, the state is set to the value of that sum after applying a non-linear activation function. The state after several message passing steps form a representation for each node in the graph. These representations can be used for node classification or other downstream machine learning tasks.
The R-GCN model suffers from over-parametrisation. Schlichtkrull et al. [29] use basis decomposition to reduce the number of weight matrices. With matrix decomposition, each of the relations has to learn relation coefficients to scale the single projection matrix. Alternatively, a block diagonal decomposition can be used to reduce the parameters [29].

GRAPH SUMMARIZATION
Representing data as a graph is increasingly popular since graphs allow a more efficient and a more flexible implementation of certain applications compared to relational databases [12,16]. Relational databases operate on tabular data models and employ strict data schema [15]. Graph databases use labeled nodes to represent entities such as people or places and labeled edges to represent relationships between entities [16]. The combination of node labels and edge labels can be considered the schema of the graph database [25].
In this paper, we define our (Knowledge) Graph as follows, and note that this definition includes RDF graphs 1 as a special case. Definition 1 (Graph). (definition obtained from [7] page 15). Let be a set of nodes and a set of labels. The set of directed labeled edges is defined as ⊆ {( , , ) | ( , ) ∈ 2 , ∈ }. A Graph is a tuple = ( , , ) where : ⇒ is a node-labeling function.
In the context of RDF web graphs, it is common practice to think of the graph as a set of triples ( , , ). Such triple has a head or source node that has a direct relationship to a destination node , also referred to as target or object node. Figure 1 displays a small example KG. The set of nodes { 1 , 2 , 3 , 4 , 5 } are entity nodes. The set of nodes {" 1", " 2"} are literal nodes, normally used for values such a strings, numbers or dates. An example of triple within this graph is the following: ( 1 , title, "Book1"). Following [7], we define an attribute to be the label of an edge. In this case the attribute relating node 1 and literal node "Book1" is title. Such Knowledge Graphs allow to flexibly add new node labels and edge labels, i. e., adapt to new entities and relationships [11]. This flexibility regarding the data schema means that the inherent structure of the data may be unclear at first or evolve during the lifetime of a graph database. Graph summarization facilitates the identification of meaning and structure in data graphs [14,21]. Thus, graph summaries can be used, among other applications, to discover the data schema of an existing graph database [8]. When we describe a graph summarization techniques, we typically characterize it with three dimensions [7]: (I) size of the graph, (II) size of the graph summary, (III) the impact of the graph's heterogeneity on the graph summary.
When we refer to the size of a graph we generally define it as the number of edges | | that the graph is composed of [7]. A fourth dimension of graph summarization is the role of the literal nodes. Often, summaries are computed taking into consideration literal nodes but their content is abstracted away. As a result, the compression rate increases because many nodes within the graph are ignored when computing the summary. For instance, looking back at Figure 1, the triples connecting to literal nodes "Book1" and "Book2" are stripped away and then the summary is computed.
Intuitively, graph summaries are condensed representations of graphs such that a set of chosen features of the graph summary are equivalent to the features in the original graph [5]. To achieve this, structural graph summaries partition nodes based on equivalent subgraphs. To determine equivalent subgraphs, features such as specific combinations of labels in that subgraph are used. We call this the schema of nodes.
A graph is considered heterogeneous when not consistent regarding its labeling and structure, e. g., there is a huge variety in schema used to describe entities and their relationship [7]. The more heterogeneous a graph, the more complex it becomes to create a concise and precise summary. Concise refers to the size of the summary, whereas precise concerns the preservation of the entity structure. In practice, a reasonable summary is typically smaller than the original graph [28]. Below, we discuss two families of graph summaries: approximate graph summaries and precise graph summaries.

Approximate Graph Summaries
Approximate graph summaries exploit the different features of the data that form the local information of a node. For instance, a node has incoming and outgoing edges with different labels also called attributes [7]. The direction of an edge has semantics within the structure of the graph. A node has a one-to-many rdf:type relations to an object node defining a specific property of a node. The local information of a node described above is combined to produce different partitions of the original graph. The combination of information defines the summarization relation. The partitions, which correspond to summary nodes, are produced based on the summarization relation. Nodes belonging to the same partition are aggregated and mapped accordingly. This section of the paper discusses several approximate graph summary methods such as Attributes Summary, IO Summary and Incoming Attributes summary.
3.1.1 Attributes Summary. The Attributes Summary has been defined in previous literature [6,7] as an approximate graph summary. In the context of a KG, each entity node has zero-tomany relations with different attributes. The set of the attribute per nodes is computed and the entities that have equivalent attribute sets are partitioned together. Each partition is then considered a unique summary node. Each of the original entity nodes is mapped to a partition, hence a summary node, if it has at least one outgoing edge and is not a literal node. It is important to notice the summary method being discussed aggregates a node with few edges into the same partition as another node with many more edges if they have equivalent attribute sets. Therefore, the number of relations a node has is not considered. The nodes that do not have any outgoing edges, often the literal nodes in KGs, are aggregated to the same partition or summary node. The literal nodes information when performing the following summarization technique is abstracted away. Figure 2 shows the Attributes Summary result on the KG fragment presented in Figure 1.
refers to the summary graph. The set of nodes contains as many elements as the power set of attributes in the graph. Therefore, corresponds to the Attribute Summary of G according to the summarization relation ⊆ × defined as follows: This means the nodes are placed in the same partition if the sets containing their attributes are the same. Note that no duplicates triples are added as we store the triples into a set, and by definition a set does not contain duplicate items. Computing this relation and assigning a new label to each partition, we obtain the mapping in Table 1. We can no use this mapping to summarize our running example from Figure 1 into the graph in Figure 2. For example, the nodes 1 and 2 belong to the same partition as they share the same attribute set { } and hence they are summarized into the same node, which received the label 2 .
The summarization relation described above maps nodes without any outgoing edges to an empty summary node, which we give the label ∅. Usually that node represents literal nodes as they do not have any outgoing edges. In our example, the string literals 'Book1' and 'Book2' map to the same empty summary node. title wrote friends Figure 2: Attributes Summary graph with generated mapping from original node to summary node. The green node labeled by the empty set symbol abstracts the content of Literal nodes.  3.1.2 IO Summary. The Input-Output summary is similar to the Attributes Summary. In fact, the structure of Definition 3 is almost identical. However, in this case, for each node in the graph it creates two sets defined as incoming attributes set and outgoing attributes set. All the nodes that have equivalent incoming and outgoing attributes sets are inserted in the same partition.
refers to the summary graph. The set of nodes contains as many elements as the power set of attributes in the graph. Therefore, corresponds to the Incoming Outgoing Attribute Summary of G according to the summarization relation ⊆ × defined as follows: The function and −1 compute the outgoing edges partition and the incoming edges partition respectively. The negative exponent indicates an inverse operation. Therefore, instead of computing the attributes sets of outgoing edges, it computes the attributes sets of incoming edges. A node that has a equivalent incoming and outgoing attributes sets to a node shows that node and belong to the partition under the summarization relation .

Incoming Attributes Summary. The Incoming Attributes
Summary is the inverse operation of the Attributes Summary. The following partitions each node based on the incoming attributes set. Two nodes that have equivalent incoming attributes sets are inserted into the same partition. Definition 4 has a similar structure to the other previously mentioned summarization techniques.
refers to the summary graph. The set of nodes contains as many elements as the power set of attributes in the graph. Therefore, corresponds to the Incoming Attributes Summary of G according to the summarization relation ⊆ × defined as follows: The function −1 takes as input the original node and outputs the corresponding summary node based on the partitions formed on the incoming edges of a node. Therefore, a node with an equivalent incoming edges partition to node shows that nodes and belong to the same summarization relation .

Precise Graph Summaries
Partitioning nodes based solely based on their local subgraph schema structures has certain drawbacks. In contrast to such approximate graph summaries, precise graph summaries compute the schema of nodes considering neighboring nodes over multiple hops [9,18]. Similarly, the notion of aggregating nodes based on local and neighboring information is shared in modern machine learning models that deal with graph entities. The general purpose of a graph summary is to mirror the structure of the original graph whilst being consistently smaller in size. Precise graph summaries are considered a stricter method because the summarization relation is more complex and takes more information from the original graph into account. In order for two nodes to belong to the same partition, neighboring nodes must also share the same schema. A graph summary is said to be precise when indiscernible from the original graph [7]. A summary graph may not have paths that are present in the entity graph but the overall structure of the entity graph is preserved due to graph homomorphism [7]. Additionally, the structure of the original graph is kept in the summary but the inverse may not hold true. Comparing the mapping in Table 1, there is no unique way to always reconstruct the original KG.
Definition 5 (Precise Graph Summary). (definition obtained from [7] page 41). Let = ( , , ) and = ( , , ) be two graphs. The graph S is the summary of the graph G according to a summarization relation ⊆ × . Let = ( 1 , 1 , 2 ) ∈ ∧ .. ∧ ( , , +1 ) ∈ be a path in the summary graph S where ( 1 , .., +1 ) ∈ +1 . Let the set { 1 , .., +1 } be a summary path instance ∈ . A summary is therefore called precise when each instance of a summary path in p forms a path in the original entity graph with regards to the edges in p.
∀ ∈ [1, ] ∃ ( , , +1 ) ∈ Definition 5 states that a graph summary is fully precise if all paths that can be formed in the summary graph can be found in the original graph. The original graph may hold paths that are not present in the graph summary. Looking at the example of graph summary produced in Figure 2, there exist paths which are not present in the original graph, such as the paths ( 5 , 3 , 2 ). Such path can be formed in the summary graph as the nodes { 5 , 3 , 2 } are partitioned by the nodes { 3 , 1 , 2 } which form the previously mentioned path. With the same subset of summary nodes, it is possible to create paths that are contained in the original graph, for instance, the path ( 5 , 4 , 2 ).
3.2.1 Bisimulation. The intuition behind bisimulation, in the context of graphs, is the interpretation of the graph data as transition systems to discover structurally equivalent parts [6,27]. Two nodes' states are bisimilar if their states change following equivalent edge relations [6]. Bisimulation is a binary relation that relates two arbitrary nodes in a KG when itself and its inverse are simulations [7]. For instance, consider two nodes u and v, a simulation relation states that an edge with type departing from and pointing to an arbitrary node implies that there exists an edge with type from pointing to an arbitrary node such that and are simulations. It is useful to realize that two nodes are bisimilar if they share the same outgoing paths. The notion of bisimulation is stricter as it is a symmetric equivalence relation, ensuring that each node can substitute one another.

(k)-forward Bisimulation.
(k)-forward bisimulation is an example of the many graph summarization techniques which aggregates nodes based on neighbors' schema over multiple hops [18,20,31]. It has also been defined as a stratified bisimulation in [6], a summarization relation that is restricted to a maximum path length of k-edges. Other summarization techniques that propose bisimulation over k hops also consider the edge direction [27]. These are referred to as forward, backward and forward/backward [17] bisimulation. In this paper, we use the FLUID framework [4], which allows us to create a forward (k)-bisimulation summary. Figure 3a represents a small fragment of a KG. A forward (k)-bisimulation with chaining parameter = 3 is performed on this small entity graph. The resulting summary graph with alongside the one-toone mapping from original node to summary node is shown in Figure 3b.

METHODS
In this work, we focus on multi-label classification on the types of the nodes. Therefore, the R-GCN uses of a summarized version of the original entity graph and infers the rdf:type relations for each of the original nodes. We expect that the summarized version of the graph retains enough structure of the entity graph, helping to generalize to the complex hierarchy of types in different nodes. It is possible to transfer the parameters of the summarized nodes back to the original nodes by storing links between nodes in the original graph and in the graph summary. This allows us to evaluate the performance of a model only trained on the graph summary and, possibly, to continue training on the original graph. As baseline, we train an R-GCN only on the original graph. All used R-GCN models follow the architecture proposed in [29]. However, the models in our work use binary cross-entropy loss and apply a sigmoid activation function on the output to predict multiple labels.
An issue raised by Bloem et al. [3] is the low number of labeled nodes in the datasets. This is an evident problem when it comes to testing the actual performance. To counter this issue we capture a specific relation that is present in most nodes and use its value as a label. We use the rdf:type relation which indicates the type of the  Figure 3a shows the original KG fragment. Figure 3b shows (k)-bisimulation graph summary produced with a chaining parameter = 3. node (a node can have multiple types) and use these as the classes for the nodes. This is explained in more detail in Section 4.2. The R-GCN models used in this work are implemented using Python 3.9.0 with the PyTorch geometric [13] framework.

Data Pre-processing & Summary Generation
The first step of the experiment is to create a map of original nodes to their labels. There are several ways to obtain these labels. It might be that they are not present in the graph, but rather retrieved from an external source. Alternatively, they are obtained from a set of chosen properties available in the graph [33]. In both cases nodes may belong to a single or multiple classes. However, there are only few datasets equipped with a reasonable number of labeled nodes [3]. Hence, for our experiments we obtain labels by considering the rdf:type relation, and removing these triples from the original graph. Other properties of nodes within the KG are used to train the model.
The graph that was stripped of the rdf:type triples is used as an input for the two summarization frameworks to compute the Attributes Summary (see Section 3.1.1) and the forward (k)bisimulation (see Section 3.2.2) with a chaining parameter = 3. To compute the Attribute Summary, we use a SPARQL query developed by Campinas [7] and a slightly modified version which also gives us the mappings. To compute the forward (k)-bisimulation, we use the FLUID framework [4,5]. We then also generate the mapping from the summary nodes to the original nodes.
Then, we create the summary graph by iterating over the edges in the original graph. For each edge, we apply the mapping function on the source and destination node, and use the outcomes and the relation type to form a new edge for our summarized graph. At this step, we also filter out the literal nodes and remove triples containing the Web Ontology Language attributes as suggested by Campinas [7].

Summary Nodes Labels
A summarization technique may map multiple nodes with different rdf:type values to the same partition or summary node. And hence, we have multiple labels for the same summary node. We create a weighted multi-label for each summary node by taking the relative frequency of each type in the partition (i.e., all nodes mapping to the summary node). Figure 4 shows an example of the labeling of the summary and original nodes. The nodes 1 and 2 are two summary nodes that represents original nodes { 1 , 2 } and { 3 , 4 } respectively. The node 1 has a rdf:type relation and is labeled 2 . Similarly, 3 has two rdf:type relations and is therefore labeled 1 and 4 . From the partitioning of the summary nodes we can obtain the labels for the summary nodes. The node 2 represents nodes { 3 , 4 } and its labeling is 0.5 for 1 because only one node has that relation. The 4 is labeled 1.0 because both nodes point to 4 . The machine learning model that is trained with the summary representation uses these weighted labels. The transfer learning model and benchmark model (our baseline) train on binary values to predict the types of nodes.

Machine Learning Model: R-GCN
To perform the experiments, we set up three different R-GCN models, a model that learns on the graph summary, a second model with parameters transferred from the graph summary model, and finally, a model that follows a normal initialization to act as a baseline. The initialization of the second model is performed by transferring the embedded parameters from the model that learns on the graph summary using the mapping from original nodes to summary nodes.
As mentioned earlier, the model has been slightly modified in order to fit the purpose of the multi-label classification task. A binary cross-entropy loss function [23] is used to compute the loss during training. The assumption is that an element that belongs to one class does not influence the probability of the same element belonging to another class. The following loss function requires target values to be between 0 and 1. The target values of the summary and original nodes are created as described in Section 4.2 The labeling process gives values to the labels that depending on the frequency of that label applying to the original nodes inside the partition. A sigmoid activation function restricts the output of all models between 0 and 1, corresponding to the probabilities of the labels. The output of the model is then rounded to the nearest integer to match the original node labels.
A parameter that needs to be taken into consideration is the number of hidden units between the two R-GCN convolutions. Following the literature [19,29], we set the number of hidden values to 16 for all used R-GCN models. As proposed in [19], we also do not employ a regularizer. The Adam optimizer [23] with a learning rate of 1.0 * 10 −2 and a weight decay of 5.0 * 10 −4 is applied as suggested in [29]. We do not use basis decomposition.
The model that learns on the summary graph is trained first for a total of 51 epochs. The parameters of this model are transferred to the second R-GCN through the mapping produced by the summarization technique. An additional training parameter can be set which consists of freezing the layers of one or more layers so that the weights do not update during training. This is suggested to be done on the model to which the weights have been transferred to run a faster training. If the first convolutional layer of the transfer learning model is frozen, the embedded parameters that were transferred from the graph summary are not updated in the backward pass. The parameters of the R-GCNs are detailed in Appendix A. The labeled instances are split 80% for training and 20% for testing.

DATA SETS
Following existing research works [3,29], we conduct our experiments on the AIFB, MUTAG and AM datasets. Statistics of these datasets can be found in Table 2.

EXPERIMENTAL RESULTS
We are interested in several results. First, we want to know how the transfer model, which gets initialized with the parameters from the summarized model performs. Secondly, we want to know how its performance changes with respect to the epochs if we perform more training on this transfer model. Finally, we have to compare these performances to the R-GCN which was no initialized had nothing to do with the summarized model (i.e., the baseline). In our graphs, we show 2 performance curves. The first one is the transfer learning model. At the zeroth epoch, this shows the performance without any additional training. After that, it shows the performance with additional training. The second curve shows the performance of the standard R-GCN with random initialization in function of the training epochs. In our graphs, we also include the value of the respective loss functions. Figure 5 shows the performance of the transfer learning model trained on the Attributes Summary against the baseline for a single run of the on the AIFB dataset. Table 3 shows the average starting and converging accuracy. The average is calculated by performing (k)-fold cross validation with k set to 5. The red line represents the model to which the embedded parameters of the summary model are transferred to. The green line represents the original model, with weights that are randomly initialized. The transfer learning model (red line) starts with a reasonably high accuracy of 81.7% for the first few epochs. The accuracy of the transfer learning  Table 3: Results of the experiments with (k)-fold cross validation with k set to 5. Note that this cross validation was not performed for the AM dataset due to computational cost; only two runs are reported for each model. model steadily increases up to 91.06% after 50 epochs. In contrast, the accuracy of the original model (green line) starts at a lower accuracy of 57.9% and converges at a lower accuracy of 87.82%.
The results for the transfer learning model trained on the (k)forward bisimulation can be found in Figure 6. Summarily to the transfer learning model trained on the Attribute Summary, the transfer learning model trained on the (k)-forward bisimulation summary consistently outperforms the baseline model over all training epochs. This transfer learning model starts with an accuracy of 77.53% and converges to a final accuracy of 91.30% after 50 training epochs.
The dataset AIFB contains 8,285 entities, of which type information has been stripped. The Attributes Summary reduces the size in total number of edges by 63.7% on the AIFB KG. In this experiment, we need fewer training epochs for the transfer learning model to predict with a reasonably good accuracy compared to the baseline model. Additionally, we observe that the transfer learning model consistently outperforms the baseline model when trained for the same number of epochs.
The MUTAG dataset provided similar insights (see Appendix C for single runs). However, the positive effect of the summarization is not that large. After 20 to 25 epochs, the baseline model catches up with the summarized model. We think this difference has to do with the fact that both summarization techniques provided very concise summaries of the dataset. This means that the model learned on tiny small versions of the original graph. The compression rates were 93.1% and 85.4% for the Attributes Summary and (k)-forward bisimulation, respectively. In addition to this, 113 different labels were found when producing the training and testing nodes in the data preprocessing step, making this an overall much harder task. In previous work, node classification on the MUTAG dataset was done considering as few as 2 classes [30].
Finally, we look at the largest KG, the AM dataset (see Appendix D for single runs). We notice that the transfer models show better results to the baseline models at the start, but that after a while the performance of the baseline catches up to become roughly the same.
The graph summaries which we used in our experiments consider the relations with literal nodes as well (see Section 3). As an ablation, we conducted experiments where we do not take the literal nodes into account when computing the summary. The results for single runs on the AIFB and MUTAG datasets can be found in Appendix E. What we note is that the performance of the transfer learning models becomes less consistent and often fall below the baseline. Hence, considering literal information seems critical for the performance of transfer learning models trained on graph summaries.

CONCLUSION AND FUTURE WORK
We introduced an approach to use graph summaries to efficiently and effectively train R-GCN models on KGs. In our experiments, the R-GCN models trained on the graph summary often outperformed the baseline models and typically started at a much higher initial accuracy before the first training epoch. The only exception is the model trained on the forward (k) bisimulation summary on the MUTAG dataset, which yields at 4% lower accuracy after 50 training epochs than the baseline. In all other cases, the transfer learning model outperforms the baseline. What we identify is that transferring the parameters learned from the graph summary model leads to a jump-start of the learning process. This supports the importance and relevance of graph summarization methods, whose smaller graph representations scale down and reduce the computational overhead involved with novel machine learning models dealing with large KGs. However, due to the complexity of the classification task, the variation in the accuracy remains large. The summarization relation (k)-forward bisimulation and Attributes Summary behaved similarly in the training behavior for the AIFB and AM datasets.
For future work, we plan to extend the experiment with additional tasks. It might be possible to include a baseline study comparing the results with previously reported performances on single-class prediction. Besides, while the graphs we used are common in heterogeneous graph neural networks literature, experiments with larger graphs are necessary.
Another aspect to further experiment with is the hyperparameter k for the (k)-forward bisimulation. In our experiments, the parameter k was fixed to 3. It remains open to investigate a possible relationship between the optimal hyperparameter k in the graph summary and the optimal number of layers in an R-GCN.
In addition to these, the model trained with the graph summary can only learn for the nodes that are mapped. A number of nodes is discarded because such entities are not mapped when producing the graph summary, so their embedding will initially be random. The number of discarded nodes can be reduced by increasing k or by using more complex summarization methods.
Finally, one could also investigate whether these summarization techniques can also be used for other graph neural networks besides R-GCN models, for example for the CompGCN [32].
In this work, we established a framework that uses graph summaries to efficiently and efficiently train R-GCN to predict nodes' labels. The model's performance observed and reported for the AIFB and AM datasets for both summarization methods suggests that summarization can be used to scale training without harming the performance and even increase the performance.  Table 4: Hyper-parameters of the three different R-GCN models B (K)-FORWARD BISIMULATION (AIFB)