Explainability for node level predictions generated by a graph neural network

Abstract

According to an aspect, there is provided a computer-implemented method for generating an explainability output for node-level predictions generated by a Graph Neural Network (GNN) on an input graph. The input graph comprises a plurality of nodes and a plurality of edges. The method comprises dividing (901) the plurality of nodes into a plurality of clusters. Dividing into clusters comprises breaking edges between nodes in a cluster and any nodes outside the cluster. The method also comprises, for each batch of a plurality of batches of nodes, using (907) an explainability method to generate, in parallel, importance scores of incoming neighbour nodes for the nodes in a batch. A batch comprises at most one node from each of the plurality of clusters.

Description

[0001] Explai nability for node level predictions generated by a Graph Neural Network

[0002] Technical Field

[0003] This disclosure relates to a method and apparatus for parallelising the generation of an explainability output for node level predictions generated by a Graph Neural Network (GNN).

[0004] Background

[0005] Deep Learning models have shown an impressive performance over the last few years, exhibiting great results in domains such as text, computer vision, and audio processing, among others (see, for example, “Explaining and harnessing adversarial examples” by Goodfellow, I. J., Shlens, J., & Szegedy, C. (2014) [Reference 1]). For fields such as molecular biology and telecommunications, a new branch of Deep Learning has emerged, namely Geometric Deep Learning (GDL). GDL generalised deep learning architectures in a non-Euclidean space by incorporating a geometric prior, i.e., information about structure space and symmetry of the input variables. A set of architectures called Graph Neural Networks (GNNs) are used in this domain, for example as described in “Neural message passing for quantum chemistry” by Gilmer, J., Schoenholz, S. S., Riley, P. F., Vinyals, O., & Dahl, G. E. (2017, July), in International conference on machine learning (pp. 1263-1272) [Reference 2], and “Explainability in graph neural networks: A taxonomic survey” by Yuan, H., Yu, H., Gui, S., & Ji, S. (2022), IEEE transactions on pattern analysis and machine intelligence, 45(5), 5782-5799 [Reference 3],

[0006] However, GNNs suffer from the same problem as any other Deep Learning architecture, namely that they are not explainable. Several studies have tried to solve this, including as described in Reference [3], There are different problems to explore in this field, but one of them, which is addressed in “Evaluating Neighbor Explainability for Graph Neural Networks” by Llorente, O., Vaderna, P., Laki, S., Kotroczo, R., Csoma, R., & Szalai-Gindl, J. M. (2023) [Reference 4], explains how important each neighbour is for the model when making a node-level prediction.

[0007] However, with these types of models there is another complexity, as inputs are no longer independent of each other, since GNNs consider the neighbours when making a prediction (i.e., spatial relationships among the nodes and edges in a geometric graph). This has a major impact in two types of techniques, which tend to be the most effective and popular ones [Reference 4], namely gradient and occlusion techniques. On the one hand, in gradient-based techniques, as described in [Reference 4], the gradient of a node may come from different neighbours. As the explainability for a given node is calculated from the gradients received from the nodes where the given node is a neighbour, then these received gradients will combine and it will be impossible to know the explainability with each one of the neighbours (i.e., distinguish the specific contribution of each one to the overall node’s explainability). On the other hand, and in the case of the occlusion techniques (as described in “Contrastive Graph Neural Network Explanation” by Faber, L., Moghaddam, A.K., Wattenhofer, R. [Reference 5]), these are techniques that are based on modifying the input (e.g., a node-based occlusion method removing adjacent edges) to know how important it is for the model prediction, as described in “Zorro: Valid, sparse, and stable explanations in graph neural networks” by Funke, T., Khosla, M., Rathee, M., &Anand, A. (2023), IEEE Transactions on Knowledge & Data Engineering, 35(8), 8687-8698, [Reference 6], However, if neighbours affect the prediction of a node, the explainability cannot be executed in parallel since modifying a node may affect its neighbour, contaminating its explainability.

[0008] Gradient calculations in gradient descent follow the formula described in Equation 1 :

[0009]

[0010] where X is the input, f (x) is the output based on X, and a is the learning rate.

[0011] To understand the role of the gradient, the information interchanged by the nodes of the graph needs to be understood, both in the forward pass and the backward pass. On the one hand, in the forward pass the nodes will interchange the information related to the use case. For instance, considering a use case presented in this disclosure, for an Uplink Interference Optimizer the parameters will be pZeroNominalPusch and alpha parameters per cell to optimise the Signal to Interference plus Noise Ratio (SINR). On the other hand, the information on the backward pass supports the gradient calculation as indicated in Equation 1.

[0012] In this disclosure, the term “explainability” corresponds to the contribution of neighbours in the graph to the output prediction for a given node.

[0013] Addressing the above in an effective (i.e., identification of each neighbour contribution to the overall explainability of the model in the given node) and in an efficient manner (i.e., quick resolution time practical for large datasets modelling large-scale CSP networks) is of capital importance, and is subject to research. In this regard, recent market research by OMDIA (“CSP Survey on Network Analytics and Al: AIOps still in its infancy” by Roseboro, E. (2024), OMDIA Market research 17-05-2024 [Reference 7]) shows that “trustworthy Al” based on explainability mechanisms is key to accelerate the adoption and buy-in by Communication Service Providers (CSPs) of the Intelligent Radio Access Network (RAN) Automation journey, including Cognitive Loop mechanisms, as described in “Automatic differentiation: Techniques and applications” by Rail, L. B. (Ed.), 1981, Berlin, Heidelberg: Springer Berlin Heidelberg [Reference 8],

[0014] Summary

[0015] There currently exist certain challenge(s). One challenge with gradient-based methods is that, as pointed out in Reference 4, they cannot be executed in batches, since then scores could be due to several nodes being classified simultaneously as part of the batch. Instead, they have to be executed for each node individually, which is extremely slow. Since gradient-based methods depend on executing the backward pass (the pass to compute the gradients from the outputs all the way back to the input), if a node is a neighbour of two different nodes, and the backward pass is executed from these two nodes simultaneously as part of a batch, then the gradient of the neighbour will come from both nodes. This is illustrated for node 8 of Fig. 1. Fig.

[0016] 1 represents a graph of nodes (numbered from 1 to 9), with neighbour relations indicated by solid arrows. The forward pass for making node level predictions is illustrated by the solid arrows, and the backward pass is illustrated with dashed arrows. Node 8 is an incoming neighbour of both node 1 and node 9. That is, node 8 contributes to the prediction output for node 1 and for node 9 during the forward pass. In the backward pass, node 8 computes the gradient with information coming from node 1 and node 9. Therefore, since the explainability for a given node is calculated from the gradients received from the nodes where the given node was a neighbour, and the gradients will be computed with information backward-passed from both node 1 and node 9 that is simultaneously aggregated, it will not be possible to distinguish the specific contribution of each one to the overall explainability of node 8.

[0017] One challenge with explainability techniques, similar to the challenges with techniques based on the gradient as described in Reference 4, is that they cannot be executed in batches as the explainability is contaminated by the influence of the neighbours in many techniques, as explained in the Background section above. This represents a severe challenge in the related bibliography and is subject of state-of-the-art research, limiting its applicability in terms of high required computation, especially for large datasets as highlighted in the Background section above. In addition, some related work proposes GNNShap (as described in “GNNShap: Scalable and Accurate GNN Explanation using Shapley Value” byAkkas, S. Azad, A, The Web Conference 2024 [Reference 9]) for importance scores in edge explainability with Shapley-based explanation methods. There are two main limitations of this approach. Firstly, it is focused on edge explainability. It does not consider the whole node, or that one node can have many edges. Secondly, it does not parallelise the whole network, but all operations for one single target node instead. Therefore, it requires multiple iterations to cover the whole network.

[0018] Two clear cases can be distinguished where it is not possible to execute explainability in batches: gradient based techniques as described in Reference 4, in “Deep inside convolutional networks: Visualising image classification models and saliency maps” by Simonyan, K., Vedaldi, A., &Zisserman, A. (2013) [Reference 10], or in “Gnnexplainer: Generating explanations for graph neural networks” by Ying, Z., Bourgeois, D., You, J., Zitnik, M., & Leskovec, J. (2019), Advances in neural information processing systems, 32 [Reference 11], or occlusion techniques as described in Reference 5.

[0019] In gradient-based techniques, the problems arise when computing the gradient from two nodes that have a common neighbour and that are part of the same batch (i.e. , iteration cycle). As shown in Fig. 1, node 8 is a neighbour of both node 9 and node 1. When a gradient is computed, its value gets contaminated (backward pass, shown by the dashed lines), making it impossible to determine how important each of node 9 and node 1 are to node 8, and instead it is only possible to determine how important the combination of node 9 and node 1 are to node 8. Therefore, with an objective to determine the explainability for each individual neighbour with respect to each node, then these techniques cannot be used to compute explainability in batches.

[0020] The other family of techniques where batch computation may be a problem is occlusion techniques, as in Reference 5. These techniques are based on modifying the inputs to determine their impact in the prediction by using a node-based occlusion method to remove adjacent edges. However, if two neighbours of a common node are modified at the same time, explainability will be contaminated. For example, referring to Fig. 1, if nodes 2 and 3 are modified simultaneously, it is not possible to know the impact of each one of them in the prediction of node 1 , only the sum value from both nodes 2 and 3. It is important to note that ‘modification’ here refers to changing the value of some inputs.

[0021] Two things have been tried to overcome this. Firstly, explainability methods are used that are not based on the gradient, but which tend to perform worse as observed in Reference 4. Given the high performance of gradient-based methods due to the better area under the curve (AUG) for loyalty metric (identify the best neighbours by minimising AUG) and inverse loyalty (identify the least important neighbours by maximising AUG), they are the best alternative for Explainable Artificial Intelligence (XAI) mechanisms. Secondly, the explainability method is run for each node individually, which is extremely slow since that involves running a backward pass for each node of the dataset individually (i.e. as many backward passes as there are nodes in the dataset). The larger the dataset is, the longer it takes to perform all individual backward passes for all the nodes. This makes this method impractical for datasets modelling observations for large CSP networks.

[0022] Certain aspects of the disclosure and their embodiments may provide solutions to these or other challenges. In particular, this disclosure proposes to create batches of independent nodes that will not affect each other, and the explainability can be executed in parallel in these batches since there will not be the problem of neighbours affecting surrounding nodes.

[0023] According to a first aspect, there is provided a computer-implemented method for generating an explainability output for node-level predictions generated by a Graph Neural Network (GNN) on an input graph. The input graph comprises a plurality of nodes and a plurality of edges. The method comprises: dividing the plurality of nodes into a plurality of clusters, with dividing comprising breaking edges between nodes in a cluster and any nodes outside the cluster; and, for each batch of a plurality of batches of nodes, using an explainability method to generate, in parallel, importance scores of incoming neighbour nodes for the nodes in a batch. A batch comprises at most one node from each of the plurality of clusters.

[0024] According to a second aspect, there is provided a computer program product comprising a computer readable medium having computer readable code embodied therein, the computer readable code being configured such that, on execution by a suitable computer or processor, the computer or processor is caused to perform the method according to the first aspect, or any embodiments thereof.

[0025] According to a third aspect, there is provided an apparatus configured to perform the method according to the first aspect, or any embodiments thereof.

[0026] According to a fourth aspect, there is provided an apparatus comprising a processor and a memory, said memory containing instructions executable by said processor whereby said apparatus is operative to perform the method according to the first aspect, or any embodiments thereof.

[0027] Brief Description of the Drawings

[0028] Some of the embodiments contemplated herein will now be described more fully with reference to the accompanying drawings, in which:

[0029] Fig. 1 illustrates a data graph of nodes and edges;

[0030] Fig. 2 is a flow chart illustrating an exemplary method according to the techniques described herein;

[0031] Fig. 3 illustrates how an exemplary graph can be divided into clusters;

[0032] Fig. 4 illustrates the 1-hop reconstruction of broken edges;

[0033] Fig. 5 illustrates the 2-hop reconstruction of broken edges;

[0034] Fig. 6 illustrates an example of a 50% dropout in the example of Fig. 3;

[0035] Fig. 7 illustrates the use of an XAI technique for all nodes in the batches derived above from Fig. 3;

[0036] Fig. 8 illustrates the prediction of a GNN over the original graph and the same graph that has been clustered using a METIS algorithm;

[0037] Fig. 9 is a flow chart illustrating a method performed by an apparatus in accordance with some embodiments; and

[0038] Fig. 10 is a block diagram illustrating functional modules in an example apparatus. Detailed Description

[0039] Some of the embodiments contemplated herein will now be described more fully with reference to the accompanying drawings. Embodiments are provided by way of example to convey the scope of the subject matter to those skilled in the art.

[0040] As noted above, this disclosure proposes to create batches of independent nodes that will not affect each other, and the explainability can be executed in parallel in these batches since there will not be the problem of neighbours affecting surrounding nodes. The flow chart in Fig. 2 illustrates a method in accordance with the techniques described herein.

[0041] In preferred implementations of the techniques described herein, a gradient-based XAI method is used to determine a level of influence of neighbouring nodes. Some examples of gradient-based XAI methods include saliency maps, and smoothgrad. However, the techniques are not limited to use with gradient-based XAI methods, and they can be used with other types of XAI methods, such as occlusion-based XAI methods. Occlusion-based methods that can be used include random erase, and cutout.

[0042] Saliency Maps are visualization techniques that use the of the network output with respect to the input to identify the most important regions of an image. Effectively, they show which pixels in the image most influence the output of the model. Saliency Maps are described in “Deep Inside Convolutional Networks: Visualising Image Classification Models and Saliency Maps” by Karen Simonyan, Andrea Vedaldi, Andrew Zisserman. SmoothGrad is an extension of Saliency Maps that adds Gaussian noise to the image and the Saliency Map is computed. This process is repeated several times and finally the mean of the Saliency Maps is calculated, which obtains a smoother representation. SmoothGrad is described in “SmoothGrad: removing noise by adding noise” by Daniel Smilkov, Nikhil Thorat, Been Kim, Fernanda Viegas, Martin Wattenberg. Random Erase is a technique which selects randomly an area of the image and replaces this area with a uniform color or random values for the pixels to see how this affects the model prediction. Therefore, parts of the image that are more relevant can be identified. This is described in “Random Erasing Data Augmentation” by Zhun Zhong, Liang Zheng, Guoliang Kang, Shaozi Li, Yi Yang. Cutout is a technique similar to Random Erase but now the rectangle that is erased is always of the same dimensions and is usually filled with black. Cutout is described in “Improved Regularization of Convolutional Neural Networks with Cutout” by Terrance DeVries, Graham W. Taylor.

[0043] The flow chart in Fig. 2 comprises four steps, which are grouped into two general stages. The first stage comprises steps 201, 203 and 205 in which batches of independent nodes are created to run the explainability techniques. In the second stage (step 207), an explainability technique is executed to determine the level of influence of neighbouring nodes. It is worth noting that the actual machine learning model / graph neural network (GNN) that is to be explained is executed between steps 205 and 207 to determine the output of each node. Those skilled in the art will appreciate that the techniques described herein are not specific to any particular type of graph neural network (GNN), and so further details of the GNN that is to be explained by the XAI techniques are not provided herein.

[0044] To create batches of independent nodes, the following steps are performed:

[0045] In step 201 the graph of the GNN is divided into independent clusters. These independent clusters are subsequently used (in step 205) to determine groups (batches) of independent nodes, since a batch created with one element from each cluster will be completely independent between them. Creating clusters will break some edges of the graph, and the predictions or explainability will not be the same in the nodes near the border of the clusters. This guarantees that on each iteration, for a given node the explainability will be calculated from the gradient received from one single neighbour, enabling the contribution of this neighbour to be measured individually. The objective in step 203 is to reconstruct these borders to have the same solution.

[0046] The number of clusters that the GNN is divided into in step 201 can be a predetermined value or a configurable parameter of the method. The clustering process aims to divide the GNN into the predetermined or configured number of clusters.

[0047] In some embodiments of step 201 the graph can be divided into clusters randomly, although this approach can take some time to complete the clustering. Therefore, in other, more preferred embodiments, a division / clustering technique is used that divides the GNN into the predetermined or configured number of clusters while minimising the number of edges that will be broken. Fig.

[0048] 3 illustrates how an exemplary graph can be divided into clusters while minimising the number of edges broken. The exemplary graph in Fig. 3 comprises 10 nodes (labelled 1 to 10), and it can be seen that the edge between nodes 2 and 5 is broken to form Cluster 1 with nodes 1, 2, 3 and 4, and the edge between nodes 6 and 7 is broken to form Cluster 2 with nodes 5 and 6 and Cluster 3 with nodes 7, 8, 9 and 10.

[0049] In step 203, a new graph is created. In some embodiments of step 203, the new graph is just comprised of the independent (i.e. disconnected) clusters formed in step 201. This is referred to herein as ‘merging’ the clusters into a single graph. Alternatively, more preferred embodiments of step 203 comprise reconstructing one or more (or all) of the broken edges of one or more (or all) clusters, and merging all the independent clusters (including the reconstructed edges) into a single new graph.

[0050] This reconstruction is performed by adding, to each cluster, copies of one or more of the neighbouring nodes that were originally connected to the nodes in the cluster in order to reconstruct one or more of the original broken edges. In some embodiments, the reconstruction comprises reconstructing as many hops for the explainability mechanism as the GNN has when making its prediction. That is, copies of all of the neighbouring nodes that were originally connected to the nodes in the cluster are added in order to reconstruct all of the original broken edges. In this way, the number of hops after reconstruction is the same for the nodes in the border of the clusters, in order to provide the same result as the original graph (i.e., before the edge breaks in step 201). Fig. 4 illustrates reconstruction fora one hop GNN, and Fig. 5 illustrates reconstruction for a two hop GNN.

[0051] In each embodiment, the neighbouring nodes added to each cluster are copies of the original nodes, which increases the size of the new graph and hence the resulting memory footprint. This process will be repeated for each cluster.

[0052] Fig. 4 illustrates 1-hop reconstruction of broken edges in step 203. Fig. 4 continues the example in Fig. 3 and reconstructs all of the broken edges at the borders of the clusters by copying the original neighbouring (1-hop) nodes. In Fig. 4 reconstruction is only needed in Cluster 2. So, for the nodes in Cluster 2, node 5 was originally connected to node 2, and node 6 was originally connected to node 7. Therefore, step 203 recreates / adds a new node 2 to node 5, and recreates / adds a new node 7 to node 6.

[0053] Fig. 5 illustrates 2-hop reconstruction of broken edges in step 203. Fig. 5 continues the example in Fig. 3 and reconstructs all of the broken edges at the borders of the clusters by copying the original neighbouring (2-hop) nodes, i.e. the immediate neighbouring nodes neighbouring the nodes in the cluster, and the neighbouring nodes to those immediate neighbouring nodes. As with Fig. 4, in Fig. 5 reconstruction is only needed in Cluster 2. So, for the nodes in Cluster 2, node 5 was originally connected to node 2, which was connected to node 3. Node 6 in Cluster 2 was originally connected to node 7, and node 7 was connected to nodes 8 and 9. Therefore, step 203 recreates / adds a new node 2 to node 5 and a new node 3 to new node 2, and recreates / adds a new node 7 to node 6, and new nodes 8 and 9 to new node 7.

[0054] In alternative embodiments, the reconstruction balances the exact result with the memory footprint by using a dropout (i.e. a regularisation technique that will ignore / deactivate some of the nodes) on the reconstructed nodes, meaning that only x% of them are reconstructed. In these embodiments, the reconstruction considers the full set of nodes and edges that were in the original graph (i.e. before the edge breaks in step 201), but only a percentage (x%) or a portion of the broken edges are reconstructed. That is, copies of one or more of the neighbouring nodes that were originally connected to the nodes in the cluster are added in order to reconstruct one or more of the original broken edges. In these embodiments, the number of hops after reconstruction is less for some the nodes in the border of the clusters. The nodes that are reconstructed in this approach can be selected randomly from the full set of edges broken in the clustering step (step 201). In particular, the nodes to copy can be selected based on a uniform distribution. This means that each node has a probability x% of being reconstructed.

[0055] Fig. 6 illustrates the 1-hop reconstruction of broken edges using a 50% dropout in step 203. Fig. 6 continues the example in Fig. 3 and reconstructs 50% of the broken edges at the borders of the clusters by copying the original (1-hop) neighbouring nodes. As in Figs. 4 and 5, in Fig. 6 reconstruction is only needed in Cluster 2. So, in the case of Cluster 2, due to the 50% reconstruction, only the edge between node 6 and node 7 is reconstructed, and the original edge between node 5 and node 2 is not. Therefore, step 203 recreates / adds a new node 7 to node 6.

[0056] In step 205, batches of nodes are created. These batches will be composed of the groups of independent nodes mentioned above. That is, they will be composed of at most one node from each cluster, noting that the reconstructed (i.e. copied) nodes do not count as nodes of each cluster since they are just copies with the purpose of having a correct solution for the nodes in the border. A batch can be created by selecting one node at random from each cluster.

[0057] In the example in Fig. 4, the explainability for nodes 2, 3, 5, 6, 7, 8 and 10 is to be calculated as these are the nodes with incident edges (i.e. a message is passed to each of these nodes from at least one other node). Nodes 2, 5 and 7 can be chosen for the first batch (as node 2 is part of Cluster 1, node 5 is part of Cluster 2, and node 7 is part of Cluster 3), nodes 3, 6 and 8 can be chosen for the second batch, and node 10 can be chosen for the third batch (as it is the only node not yet in a batch).

[0058] In step 207, the explainability of the GNN is calculated for each batch in turn. Any explainability Al (XAI) technique can be used. By calculating the explainability for a batch, the risk of getting contaminated results due to the influence between neighbours is reduced or avoided. Therefore, at this point it will be possible to explain how important each neighbour node is for the GNN when making a node-level prediction.

[0059] Fig. 7 illustrates the use of an XAI technique for all nodes in the batches derived above from Fig. 3. So, an XAI technique is used to calculate the explainability for nodes 2, 5 and 7 in the first batch (Batch 1), the explainability for nodes 3, 6 and 8 in the second batch (Batch 2) and the explainability for node 10 in the third batch (Batch 3).

[0060] It will be noted from the above that the techniques described herein are not directed to explainability, or specifically “gradient-based parallel explainability” itself, but on finding independent neighbour clusters to be able to compute the explainability in parallel, guaranteeing a fidelity result calculation based on border reconstruction, and optimisation of the relation between performance and accuracy by border of cluster reconstruction. This allows XAI techniques to be efficiently applied to all nodes in the batch. Use cases for the techniques described herein include those having geometric properties for which explainability needs to be analysed. This includes applications with data models in which features are organised in a graph or geometric-structured data structure, with relationships between entities. If the use case is modelled with a very high number of inter-related nodes (e.g. of the order of hundreds, thousands, or millions) and therefore requiring parallelisation on the calculation of explainability, then the techniques described herein will be a good match.

[0061] Therefore, more generally the techniques described herein can be applied to applications with geometric properties between the features of their data model with a very high number of inter-related nodes.

[0062] Actual examples include, but are not limited to: explainability in chemistry, such as molecular fingerprints and chemical reactions (e.g., explain the importance of molecules in a chemical compound); explainability in biology, such as protein interface prediction, drug design (e.g., explain protein importance in a new medicament), explainability in natural language processing, such as text classification (e.g., explain the interrelation of documents or words in a very large corpus) or explainability in computer vision, such as such as semantic segmentation or visual reasoning (e.g., explaining the importance of objects in images, leading to semantic segmentation).

[0063] In addition to the above use cases, the techniques described herein can be applied to GNNs used for communication networks and in particular in Radio Access Networks (RANs). For example, communication networks / RANs can use GNNs to perform specific classifications / regressions relating to, e.g., pZeroNominalPusch and alpha parameters per cell as in the Ericsson Uplink Interference Optimizer application (rApp). More generally, implementations can be for use in Open-RAN (O-RAN) deployments, where, for example, the techniques can be easily integrated with any use case of optimisation and root-cause explainability following the O-RAN application specifications.

[0064] Certain embodiments of the disclosed techniques may provide one or more technical advantage(s). One advantage of the techniques is the high saving in computational time while being a general solution, and is easily applicable to parallelise any explainability technique in any scenario. Thus, it allows computing explainability mechanisms in an efficient, parallel manner for both gradient-based techniques (the best ones according to the literature, e.g. Reference 4) and occlusion-based ones by modifying the input, as in Reference 6. Therefore, the techniques in this disclosure allow the deployment of XAI techniques in production scenarios including large interconnected networks, where traditional methods executing the XAI techniques for each neighbour may not be a feasible option.

[0065] Another advantage is the techniques can benefit production-stage scenarios (i.e., large CSP networks), where running explainability for each node sequentially can become a huge bottleneck. This represents a differentiating factor over traditional XAI proposals. Because of this, the solution proposed here has been tried in a product that simulates the cellular network with GNNs, achieving a reduction of 99% of the time, as explained below.

[0066] Thus, the main advantages of various embodiments of the disclosed techniques include: a significant reduction of computational time through a parallelisation strategy based on batches (with production environments showing a 99% reduction in computational time); a reduction of energy consumption in executing the algorithm since it is reducing the number of batches (and therefore the number of iterations) the model has to execute; the techniques provide high-quality explainability as the same explainability results are obtained as non-parallelised methods while the time taken is being dramatically reduced; there can be an adaptive balance between exact explainability results and memory consumption based on dropout that can be adjusted based on per-deployment need; the techniques are a generic black-box method that allow parallelising without having to access the inner workings of the model, as in earlier techniques; the techniques are scalable, allowing the use of explainability in production in larger scenarios, such as large CSP networks or even Massive Internet of Things (MIoT) where datasets may be of order of millions of nodes, which is likely with the rise of Internet and new technologies; the techniques can be used by many companies since it is generic and agnostic to the rest of the architecture that may be in production.

[0067] The following provides a further explanation of the process of Fig. 2. As explained above, the aim is to create batches of independent nodes that will not affect each other, with the explainability being executed in parallel in these batches. The first part, as described above with reference to steps 201-205 of Fig. 2, is to create batches of nodes where explainability can be executed at the same moment without having conflicts due to explanations coming from two neighbours for a common graph node.

[0068] To identify these independent nodes, clusters of nodes are created (step 201) and from there batches are created with one node of each cluster (step 205). In this way, there will be no contamination in the explainability (e.g. a gradient influence combination from two nodes with a common neighbour) as long as the clusters are independent from each other.

[0069] To ensure that clusters are independent, a graph partition technique can be used. However, using this type of technique means that the new graph will not be the same as the old one, as in the graph partitioning some edges will be broken (the ones that connect nodes that belong to different clusters). Distinct ways of dealing with (or ignoring) this problem are explained below, but either way, to reduce the impact of this problem the graph partition algorithm should try to minimise the number of edges that will be broken in step 201. An exemplary algorithm used here can be METIS (“A fast and high quality multilevel scheme for partitioning irregular graphs” by George Karypis and Vipin Kumar. 1998, SIAM J. Sci. Comput.

[0070] 20, 1 (1998), 359-392 [Reference 12]) since it guarantees this condition as justified in the related literature. Reference 9 uses this technique to create batches for training, and in an example of the techniques described herein, the METIS algorithm is used to create clusters (step 201). Reconstruction of one or more nodes per cluster can be performed (step 203), and from these clusters, batches are created (that will comprise one node of each cluster) (step 205). Finally, in step 207, the XAI computation (for example a gradient-based XAI computation or occlusion-based XAI computation) is performed for all nodes in a current batch, before repeating step 207 for each other batch.

[0071] Fig. 8 illustrates the prediction of a GNN over two graphs: the original graph, and the same graph that has been clustered using METIS. In particular, the left-hand side of Fig. 8 shows the prediction of the GNN over the original graph, and the right-hand side shows the prediction of a GNN over the graph clustered with METIS. The prediction is performed on the solid black node and in layer / of the GNN ( / = 1, ..., 4), and the GNN considers up to ( / - 1) hop neighbours. 1-hop neighbours are in shown with cross-hatching, 2-hop neighbours are shown in single hatching, and 3-hop neighbours are dotted. It should be noted that in the exemplary METIS-clustered graph on the right-hand side of Fig. 8, at most 2-hop neighbours is possible.

[0072] After the graph has been partitioned into clusters in step 201 , the next step (step 203) is to create a new graph so that the explainability can be computed for nodes of different clusters at the same time. There are different methods that can be used to merge all clusters into a new graph. The selection of a particular method can depend on the desired precision and the memory footprint of the method that can be tolerated. More generally, the techniques described herein provide a generic framework that is not tied to a specific method or algorithm for graph creation by cluster merging. As indicated, using one method or another will depend on the scenario, i.e. memory and computation power can be more constrained when used in MIoT O-RAN non-real time Radio Intelligent Controller (RIC) rApps, whereas methods that are more computational and memory intensive can be used when the techniques are deployed on a public region on a hyperscaler cloud provider).

[0073] Some different methods that can be used to merge all clusters into a new graph are described below:

[0074] In a first method, the clusters are merged without any extra effort. That is, there is no reconstruction of the edges broken during the clustering. This way does not generate any extra memory footprint, but the results on the cluster-border nodes would not be the same as the original graph as the neighbours have changed through the breaking of some edges in step 201. As noted above, this first method can be a good choice for very resource constrained scenarios, such as MIoT.

[0075] In a second method, the borders are reconstructed in full, so the prediction on the clusterborder nodes does not change. This method is described above with reference to Fig. 4. In this method, it is necessary to reconstruct as many hops as there are GNN layers. However, since the border is reconstructed for each cluster, the new graph will be bigger than the original graph and so the memory footprint of the clusters will be increased. A benefit to this method is that the predictions will be precise since the neighbours are exactly the same as in the original graph for all the nodes in the dataset. This second method is more suitable for use by hyperscaler cloud provider (HCP).

[0076] In a third method (“dropout reconstruction”), only a fixed percentage or proportion of the neighbours of the cluster-border nodes are reconstructed (copied). This method provides a balanced solution between having an exact solution for all the nodes, while not significantly increasing the memory footprint. It will be noted that a value of 1 for the probability of dropout reconstruction would result in a full reconstruction (as in the second method above), and a value of 0 for the probability would lead to merging the clusters without reconstructing any neighbours (as in the first method). An application example for this third method can be O-RAN rApp applications to achieve a suitable balance between resource consumption and the exact solution achieved. As noted above, an example of a 50% dropout in the example of Fig. 3 is shown in Fig. 5. With a 50% dropout rate, half of the broken edges are reconstructed. With a 50% dropout rate, approximately 50% of the extra memory needed to reconstruct the full graph is saved.

[0077] It should be noted that when an x% dropout rate is applied, approximately only x% of the extra memory for a full reconstruction is needed. The quality of the explanation following step 207 would be exactly the same in nodes that do not have neighbours that have not been reconstructed, that is, in the majority of cases. However, in these specific cases the quality prediction (i.e. , predictive power) would depend on the number of neighbours that had not been reconstructed, and if they were actually important for the prediction or not. Therefore, the impact of dropout in the predictive power and the tolerance to the loss in the prediction will depend on many factors, such as use case and predictive loss tolerance by the problem domain, or by the number of neighbours.

[0078] Once the new graph is created in step 203, the next stage is to create the batches (step 205). For this step, the only requirement is to select one node per cluster (that has not already been selected for a batch), noting that reconstructed nodes do not count as nodes of each cluster since they are just copies with the purpose of having a correct solution for the nodes in the border. Nodes can be selected at random from the remaining nodes in each cluster to create the batches. Then, in step 207, the XAI technique is executed per batch to explain the prediction of the nodes in that batch.

[0079] Fig. 9 is a flow chart illustrating a general method for generating an explainability output for node-level predictions generated by a GNN on an input graph according to various embodiments. The input graph comprising a plurality of nodes and a plurality of edges. An apparatus, such as a computer or server, may perform the method in response to executing suitably formulated computer readable code. The computer readable code may be embodied or stored on a computer readable medium, such as a memory chip, optical disc, or other storage medium. The computer readable medium may be part of a computer program product.

[0080] In step 901 , the plurality of nodes are divided into a plurality of clusters by breaking edges between nodes in a cluster and any nodes outside the cluster, for example as shown in Fig. 3. In step 901 the plurality of nodes can be divided into a predetermined or configured number of clusters. Preferably, the plurality of nodes are divided into the predetermined or configured number of clusters while minimising the number of edges that are broken. As noted above, a METIS algorithm can be used to divide the nodes into clusters.

[0081] In step 907, for each batch of a plurality of batches of nodes, an explainability method is used to generate, in parallel, importance scores of incoming neighbour nodes for the nodes in a batch. The explainability method may be a gradient-based explainability method, or an occlusionbased explainability method. A batch comprises at most one node from each of the plurality of clusters. In addition, each node of a cluster is comprised in only one batch of the plurality of batches.

[0082] In some embodiments, prior to step 907, the plurality of batches of nodes can be formed from the nodes in the plurality of clusters. This is shown by optional step 905 in Fig. 9. Step 905 can comprise, for each batch, selecting a node from each cluster that is not already part of a batch. As noted above, each batch comprises at most one node from each of the plurality of clusters.

[0083] In some embodiments, step 907 is performed on the batches of nodes based on the clusters formed in step 901. That is, there is no reconstruction of any edges that were broken in the dividing step (step 901), or addition of any node copies to any clusters. Instead, the independent (disconnected) clusters are merged into a single graph.

[0084] In alternative embodiments, step 907 is performed on the batches of nodes after reconstructing one or more of the edges that were broken in step 901. Thus, in step 903, one or more edges that were broken in step 901 are reconstructed for each cluster. This reconstruction can be performed by adding, to each cluster, copies of one or more of the neighbouring nodes that were originally connected to the nodes in the cluster, as shown in Figs. 4, 5 and 6.

[0085] The reconstructing in step 903 can comprise, for each cluster, multi-hop reconstruction for the one or more edges that were broken in step 901, as shown in Fig. 5.

[0086] Step 903 can comprise, for an edge that was broken between a first node in a first cluster of the plurality of clusters and a second node that is outside the first cluster, reconstructing the broken edge by adding a copy of the second node to the first cluster and connecting the copy of the second node to the first node via an edge. For example, with reference to node 5 in Cluster 2 of Fig. 3, a copy of node 2 from Cluster 1 is added to Cluster 2, and the copy of node 2 is connected to node 5 (as shown in Fig. 4).

[0087] In embodiments where multi-hop reconstruction is performed, then if the second node was connected to one or more further nodes outside the first cluster, then reconstructing the broken edges in step 903 comprises adding copies of the one or more further nodes to the first cluster, and connecting the copies of the one or more further nodes to the copy of the second node via one or more edges. For example, with reference to node 5 in Cluster 2 of Fig. 3, and continuing the example above, a copy of node 3 from Cluster 1 is added to Cluster 2, and the copy of node 3 is connected to the copy of node 2 (that is connected to node 5).

[0088] In some embodiments of step 903, all edges that were broken when dividing the plurality of nodes into the plurality of clusters are reconstructed in each cluster.

[0089] In alternative embodiments of step 903, only a percentage or proportion of the edges that were broken in step 901 are reconstructed in each cluster (this is referred to above as dropout reconstruction), for example as shown in Fig. 6. The percentage or proportion is less than 100%, for example 50%. It will be appreciated that 100% reconstruction corresponds to the reconstruction of all edges that were broken in step 901, and 0% reconstruction corresponds to the embodiment where there is no reconstruction of any of the broken edges.

[0090] Although not shown in Fig. 8, after reconstruction of some or all of the broken edges, the clusters are merged into a single graph.

[0091] The techniques presented in this disclosure can be developed as a cloud implementation, without a significant effort, taking full advantage of a distributed architecture. As an example, the techniques can be implemented either in a private cloud environment or in a public hyperscaler cloud provider (HCP). The only requirement is to divide the network nodes into as many subsets as available cloud nodes. Examples include, but are not limited to, Kubernetes worker nodes, Infrastructure as a Service virtual machines, serverless Amazon Web Services (AWS) Lambdas, Google Cloud Platform CloudRun jobs, or Microsoft Azure functions, among others. This brings a fully elastic and scalable architecture.

[0092] Fig. 10 is a block diagram illustrating an example apparatus 1000 which may implement the method in Fig. 2 or Fig. 9, for example on receipt of suitable instructions from a computer program 1050. Referring to Fig. 10 the apparatus 1000 comprises a processor or processing circuitry 1002 and may comprise a memory 1004 and interfaces 1006. The processing circuitry 1002 may be operable to perform some or all of the steps of the method in Figs. 2 and / or 9. The memory 1004 may contain instructions executable by the processing circuitry 1002 such that the apparatus 1000 is operable to perform some or all of the steps of the method in Figs. 2 and / or 9. The instructions may also include instructions for executing one or more telecommunications and / or data communications protocols. The instructions may be stored in the form of the computer program 1050. In some examples, the processor or processing circuitry 1002 may include one or more microprocessors or microcontrollers, as well as other digital hardware, which may include digital signal processors (DSPs), special-purpose digital logic, etc. The processor or processing circuitry 1002 may be implemented by any type of integrated circuit, such as an Application Specific Integrated Circuit (ASIC), Field Programmable Gate Array (FPGA) etc. The memory 1004 may include one or several types of memory suitable for the processor, such as read-only memory (ROM), random-access memory, cache memory, flash memory devices, optical storage devices, solid state disk, hard disk drive, etc.

[0093] In certain embodiments, some or all of the functionality described herein may be provided by processing circuitry executing instructions stored on in memory, which in certain embodiments may be a computer program product in the form of a non-transitory computer-readable storage medium. In alternative embodiments, some or all of the functionality may be provided by the processing circuitry without executing instructions stored on a separate or discrete device-readable storage medium, such as in a hard-wired manner. In any of those particular embodiments, whether executing instructions stored on a non-transitory computer-readable storage medium or not, the processing circuitry can be configured to perform the described functionality. The benefits provided by such functionality are not limited to the processing circuitry alone or to other components of the computing device, but are enjoyed by the computing device as a whole.

[0094] The foregoing merely illustrates the principles of the disclosure. Various modifications and alterations to the described embodiments will be apparent to those skilled in the art in view of the teachings herein. It will thus be appreciated that those skilled in the art will be able to devise numerous systems, arrangements, and procedures that, although not explicitly shown or described herein, embody the principles of the disclosure and can be thus within the scope of the disclosure. Various exemplary embodiments can be used together with one another, as well as interchangeably therewith, as should be understood by those having ordinary skill in the art.

Claims

Claims1. A computer-implemented method for generating an explainability output for node-level predictions generated by a Graph Neural Network, GNN, on an input graph, the input graph comprising a plurality of nodes and a plurality of edges, the method comprising:dividing (901) the plurality of nodes into a plurality of clusters, wherein dividing comprises breaking edges between nodes in a cluster and any nodes outside the cluster; andfor each batch of a plurality of batches of nodes, using (907) an explainability method to generate, in parallel, importance scores of incoming neighbour nodes for the nodes in a batch; wherein a batch comprises at most one node from each of the plurality of clusters.

2. The method as claimed in claim 1 , wherein each node of a cluster is comprised in only one batch of the plurality of batches.

3. The method as claimed in claim 1 or 2, wherein the plurality of nodes are divided into a predetermined or configured number of clusters.

4. The method as claimed in claim 3, wherein the plurality of nodes are divided into the predetermined or configured number of clusters while minimising the number of edges that are broken.

5. The method as claimed in any of claims 1-4, wherein the method further comprises:forming (905) the plurality of batches of nodes from the nodes in the plurality of clusters.

6. The method as claimed in claim 5, wherein forming (905) the plurality of batches comprises, for each batch, selecting a node from each cluster that is not already part of a batch.

7. The method as claimed in any of claims 1-6, wherein the method further comprises:for each cluster, reconstructing (903) one or more of the edges that were broken when dividing the plurality of nodes into the plurality of clusters.

8. The method as claimed in claim 7, wherein reconstructing (903) comprises, for each cluster, multi-hop reconstruction for the one or more edges that were broken when dividing the plurality of nodes into the plurality of clusters.

9. The method as claimed in claim 7 or 8, wherein, for an edge that was broken between a first node in a first cluster of the plurality of clusters and a second node that is outside the first cluster, reconstructing the broken edge comprises adding a copy of the second node to the first cluster, and connecting the copy of the second node to the first node via an edge.

10. The method as claimed in claim 9, wherein if the second node was connected to one or more further nodes that are outside the first cluster, reconstructing the broken edge comprises adding copies of the one or more further nodes to the first cluster, and connecting the copies of the one or more further nodes to the copy of the second node via one or more edges.

11. The method as claimed in any of claims 7-9, wherein reconstructing comprises, for each cluster, reconstructing all edges that were broken when dividing the plurality of nodes into the plurality of clusters.

12. The method as claimed in any of claims 7-9, wherein reconstructing comprises, for each cluster, reconstructing a percentage or proportion of the edges between nodes in the cluster and any nodes outside the cluster that were broken when dividing the plurality of nodes into the plurality of clusters.

13. The method as claimed in claim 10, wherein the percentage or proportion is less than 100%.

14. The method as claimed in any of claims 1-13, wherein the explainability method is a gradient-based explainability method or an occlusion-based explainability method.

15. A computer program product comprising a computer readable medium having computer readable code embodied therein, the computer readable code being configured such that, on execution by a suitable computer or processor, the computer or processor is caused to perform the method according to any of claims 1-14.

16. An apparatus configured to perform the method according to any of claims 1-14.

17. An apparatus comprising a processor and a memory, said memory containing instructions executable by said processor whereby said apparatus is operative to perform the method according to any of claims 1-14.

Images