EP4635145A1

EP4635145A1 - Methods, central node and edge node for training a graph neural network (gnn) model through federated machine learning (fml), for network performance assessment within a large network

Info

Publication number: EP4635145A1
Application number: EP22835890.9A
Authority: EP
Inventors: Zhongwen Zhu
Original assignee: Telefonaktiebolaget LM Ericsson AB
Current assignee: Telefonaktiebolaget LM Ericsson AB
Priority date: 2022-12-12
Filing date: 2022-12-12
Publication date: 2025-10-22
Also published as: WO2024127059A1

Abstract

The disclosure relates to a method, central node and edge node, for training a graph neural network (GNN) model through federated machine learning (FML) for network performance assessment within a large network. The method comprises defining at least two local networks within the large network. The method comprises selecting one edge node for each of the at least two local networks for training a local GNN model. The method comprises sending, to each edge node, a network topology for the local network, the local GNN model selected, and information about nodes in the local network. The method comprises sending initial weights for the local GNN model to each edge node and receiving updated weights from each edge node. The method comprises updating the GNN model using the updated weights received from each edge node, using FML.

Description

METHODS, CENTRAL NODE AND EDGE NODE FOR TRAINING A GRAPH NEURAL NETWORK (GNN) MODEL THROUGH FEDERATED MACHINE LEARNING (FML), FOR NETWORK PERFORMANCE ASSESSMENT WITHIN A LARGE NETWORK

TECHNICAL FIELD

[0001] The present disclosure relates to a graph neural network (GNN) based federated machine learning solution for network operation performance prediction in a large operator network.

BACKGROUND

[0002] With the rapid deployment of fifth generation (5G) networks around the world, new infrastructure and mechanisms are provided to support not only traditional voice, messaging, and video talk/chat services, but also applications from different industries, especially applications under the ultra-reliable low latency communication (URLLC) category, such as remote surgery in health services, or automobile selfdriving in transportation services.

[0003] To operate 5G networks efficiently, network operators are demanding to have a more intelligent network management system (NMS) to monitor their network performance. When network operation performance deteriorates, it is expected that the NMS can detect the faults in the network accurately and quickly. Then the NMS can notify the operator to take action to avoid or mitigate any potential damage or catastrophe.

[0004] On the other hand, artificial intelligence (Al)/ machine learning (ML) technology has been evolving at a record pace during the past decade. With the help of vast computational power and storage, deep machine learning has gained ground and built a reputation for overcoming certain challenges that ordinary people have difficulties to deal with.

[0005] Recently, the graph neural network (GNN) has become more and more popular due to its flexibility in dealing with an unstructured and dynamically changing dataset. GNN can capture node features and a network structure through the mechanism of message passing among neighbor nodes.

[0006] In GNN, each node in the network has its own neural network architecture. Due to different numbers of neighbor nodes, the GNN architecture for one node might be totally different from that for another node. But the parameters given for message passing are the same among all the nodes. Hence, the model training can be done on a subset of nodes (either randomly picked or targeted) in the network.

[0007] One of the advantages of GNN is that the trained model can be directly applied to those nodes that are not seen in the training process. GNN is a good fit for building an AI/ML model that captures network performance information from the datasets. The trained model can detect if the network performance is “normal” or “abnormal”.

[0008] However, successfully training an AI/ML model, especially for a large network, depends upon the quality of the dataset and the size of the network. This raises a challenge on how to build a computational graph that can be managed within the capacity of the existing hardware, such as graphical processing unit (GPU)/central processing unit (CPU), storage, as well as network bandwidth, which is required to transfer the dataset.

SUMMARY

[0009] To mitigate these data storage related issues and data transfer cost, the federated machine learning (FML) model is considered. FML allows to divide the whole network into subnets, which can be handled by local GNNs instead of having one global GNN model. This federated learning approach reduces the computational graph significantly.

[0010] Furthermore, the GNN model training can be dynamically pushed to the edge node, which is closer to the local network. This reduces the network bandwidth usage required for transferring the datasets from the network nodes to the model training node, i.e., the edge node.

[0011] There is provided a computer implemented method, executed in a central node, for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network. The method comprises defining at least two local networks within the large network. The method comprises selecting one edge node for each of the at least two local networks for training a local GNN model. The method comprises sending, to each edge node, a network topology for the local network, the local GNN model selected, and information about nodes in the local network. The method comprises sending initial weights for the local GNN model to each edge node and receiving updated weights from each edge node. The method comprises updating the GNN model using the updated weights received from each edge node, using FML.

[0012] There is provided a computer implemented method, executed in an edge node, for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network. The method comprises receiving a network topology for a local network, a GNN model with initial weights and information about nodes in the local network, from a central node. The method comprises acquiring datasets from nodes in the local network. The method comprises verifying and labelling the datasets. The method comprises training the GNN model using the datasets. The method comprises sending updated weights to the central node.

[0013] There is provided a central node for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network. The central node comprises processing circuits and a memory, the memory containing instructions executable by the processing circuits whereby the central node is operative to define at least two local networks within the large network. The central node is operative to select one edge node for each of the at least two local networks for training a local GNN model. The central node is operative to send, to each edge node, a network topology for the local network, the local GNN model selected, and information about nodes in the local network. The central node is operative to send initial weights for the local GNN model to each edge node and receive updated weights from each edge node. The central node is operative to update the GNN model using the updated weights received from each edge node, using FML.

[0014] There is provided an edge node for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network. The edge node comprises processing circuits and a memory, the memory containing instructions executable by the processing circuits whereby the edge node is operative to receive a network topology for a local network, a GNN model with initial weights and information about nodes in the local network, from a central node. The edge node is operative to acquire datasets from nodes in the local network. The edge node is operative to verify and label the datasets. The edge node is operative to train the GNN model using the datasets. The edge node is operative to send updated weights to the central node. [0015] There is provided a non-transitory computer readable media having stored thereon instructions for training a graph neural network (GNN) model through federated machine learning (FML) for network performance assessment within a large network. The instructions comprise any of the steps described herein.

[0016] The method, central node and edge node provided herein present improvements to the way evaluation of network performances operate.

BRIEF DESCRIPTION OF THE DRAWINGS

[0017] Figure 1 is a schematic illustration of the overview of the proposed solution. [0018] Figure 2 is a block diagram of the component view of the central management system.

[0019] Figure 3 is a flowchart of the logical flow in the GFML master.

[0020] Figure 4 is a flowchart of the logical flow in the GFML Client.

[0021] Figure 5 is a block diagram of two-layer GNN architecture with local network for node Ri.

[0022] Figure 6 is a block diagram of two-layer GNN architecture with local network for node Ci and R2.

[0023] Figure 7a is a flowchart of a method, executed in a central node, for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network.

[0024] Figure 7b is a flowchart of a method, executed in an edge node, for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network.

[0025] Figure 8 is a schematic illustration of a hardware in which steps and/or method described herein can be executed.

[0026] Figure 9 is a schematic illustration of a virtualization environment in which the different methods and apparatuses described herein can be deployed.

DETAILED DESCRIPTION

[0027] Various features will now be described with reference to the drawings to fully convey the scope of the disclosure to those skilled in the art.

[0028] Sequences of actions or functions may be used within this disclosure. It should be recognized that some functions or actions, in some contexts, could be performed by specialized circuits, by program instructions being executed by one or more processors, or by a combination of both.

[0029] Further, computer readable carrier or carrier wave may contain an appropriate set of computer instructions that would cause a processor to carry out the techniques described herein.

[0030] The functions/actions described herein may occur out of the order noted in the sequence of actions or simultaneously. Furthermore, in some illustrations, some blocks, functions or actions may be optional and may or may not be executed; these are generally illustrated with dashed lines.

[0031] At least some aspects of the techniques described herein may be implemented using artificial intelligence, which comprises a variety of techniques as would be apparent to a person skilled in the art, including machine learning techniques.

Machine learning techniques include neural network (NN), or artificial neural network (ANN), and both terms may be used interchangeably herein. In some contexts, an artificial neural network could include biological portions.

[0032] A detailed description of federated machine learning can be found in Qinbin Li, Zeyi Wen, Zhaomin Wu, Sixu Hu, Naibo Wang, Yuan Li, Xu Liu and Bingsheng He, “A Survey on Federated Learning Systems: Vision, Hype and Reality for Data Privacy and Protection”, Institute of Electrical and Electronics Engineers (IEEE), IEEE Transactions on Knowledge and Data Engineering, 2021, which is included herein by reference in its entirety.

[0033] A GNN-based FML solution for industrial applications, such as for monitoring network performance, in an edge cloud infrastructure is disclosed herein. The solution addresses how to select a subset of the network for local training, how to select an edge node to serve as a GNN training node, how to do the node embedding, including network representation at edge node, how to exchange the model among the edge nodes for building a global GNN model.

[0034] For a large network 100, in order to avoid ending up with a huge computational graph for the GNN, instead of taking a whole network into account, the proposed solution introduces a mechanism to select local, or subset of, networks 105 within the large target network for building the global model. The edge nodes 110 selected for training the local GNNs are dynamically located in order to be closer to the target local networks and to the nodes 125. As shown in Figure 1, edge node 1 (on the left) is assigned to local network 1, edge node k (on the right) is assigned to local network k.

[0035] The selection can be done either in a random fashion or following a given distribution. The selection can also be done through a rule/policy that is defined or configured according to an analytic report.

[0036] For example, based on the selected local network, the computational nodes deployed at the edge that are selected for training the GNN models can be selected to optimize: an average cost to transfer the dataset from local network nodes to the edge nodes;

- the capacity of the edge nodes (computational power, storage, the capacity on the network bandwidth); and

- the footprint of the selected GNN model, i.e. the size of the memory required to execute the GNN model.

[0037] After the edge nodes are selected, the local networks information (node + network topology) is provided to the selected edge nodes (e.g. via instructions) so that the edge nodes can pull the datasets from the network nodes.

[0038] The instructions sent to the edge nodes, might include settings for advanced options, such as: specifying features or key performance indicators (KPIs) that the edge nodes should request from the network nodes; and a turn on, turn off schedule, that specify when to generate the required data/features at the network node.

[0039] The GNN model proposed herein is built for simple binary classification at network level (network performance is normal vs. abnormal). The mechanism can be easily extended to other classification.

[0040] As shown in figure 1, two components are designed to train the model for the network operation performance using GNN.

One is deployed in the central server located in the cloud. It is called as GFML4NM-CMS (Central Management System) 115.

The other component is deployed to the edge platform closer to the local network to be targeted, it is a GFML4NM-Client 120. [0041] The detailed view on those two components is given in figure 2. Central management system GFML4NM-CMS 115 consists of four modules, in addition to storage 215:

GFML Master 225 is responsible for selecting the edge nodes for the target local networks, and also to select the GNN model. The GFML Master 225 provides the advanced options mentioned above to the edge nodes 110. The GFML Master 225 sends the instruction to the edge nodes and monitors the status of all the edge nodes involved in the FML.

- FML module 220, deals with the basics of federated machine learning, such as aggregating the model weights collected from different edge nodes.

- DX4FML module 205 oversees data exchanging for federated machine learning. This module is responsible for exchanging the model data under the federated machine learning framework between GFML4NM clients 120 and the central management system 115, GFML4NS-CMS, including data synchronization, and any other relevant data.

- DPM4FML module 210 is the data processing module for federated machine learning. This module is responsible for preparing the data for the federated machine learning, including, for example, cleaning and repairing data, and any other relevant data processing.

[0042] The client, GFML4NM-Client 120, consists of four modules, in addition to storage 240:

GFML Agent 250 is responsible for receiving the instruction from the GFML Master 225. The instruction includes the target local network (nodes and network topology), the GNN model and corresponding node level data/features, selected by the GFML Master, for harvesting at the network nodes.

GNN Module 245, or graph neural network module, is the framework to host different GNN models, which are trained using the dataset collected from the network nodes in target local networks via the data collection module (DCM).

- Data processing module (DPM) 235 is responsible for processing the raw datasets and make them ready for training the GNN model.

- DCM 230 is responsible to collect the dataset (e.g., KPI measurement, packet loss ratio, or retransmission ratio, etc.) from the nodes in the target local network. [0043] Figure 3 is a flowchart illustrating the logical flow 300 executed in the GFML master 225 to select the edge nodes.

[0044] The flow starts at step 301, with the selection of several target locations to build the network performance classification model based on pre-defined rules. This can be based on random selection.

[0045] At step 302, the GFML master 225 selects the model to be considered (e.g., GNN, etc.).

[0046] At step 303, the GFML master 225 builds up data quality verification rules according to the selected model. For example, the data quality verification rules can include a minimum number of nodes in the network, the size of the datasets, balancing ratios for the datasets, normalization of the data, labelling criteria, etc. [0047] At step 304, the GFML master 225 locates the edge nodes closely deployed in or next to the target local network, which is defined through the GFML master 225. [0048] At step 305, the GFML master 225 sends instructions for dataset preparation to the edge nodes, including the data quality verification rules and the target local network topologies.

[0049] At step 306, the GFML master 225 waits for responses from the target edge nodes.

[0050] Depending on the response from the edge nodes, steps 307 to 311 or steps 312 to 314 and 311 are executed. These steps may occur in parallel for different responses of different edge nodes.

[0051] At step 307, the GFML master 225 receives a response indicating dataset readiness from an edge node. At step 308, the GFML master 225 checks if all the edge nodes provided a response. If all responses are not received, the GFML master 225 return to the waiting stage, step 306. If the GFML master 225 has received a response from all the edge nodes, at step 309, the GFML master 225 checks if the initial setup for FML is ready. If not ready, the GFML master 225 return to the waiting stage, step 306. If ready, step 310, the GFML master 225 sets up the initialization weights for the selected model. At step 311, the GFML master 225 sends the model weights to the edge nodes. In the initialization stage, the initialization weights are provided.

[0052] At step 312, the GFML master 225 receives updated model weights from the edge nodes. At step 313, the GFML master 225 checks if all the edge nodes provided the updated model weights. If all edge nodes have not provided the updated model weights, the GFML master 225 return to the waiting stage, step 306. If yes, at step 314, FML is applied to update the global model. Then the GFML master 225, sends, at step 311, the model weights to the edge nodes

[0053] In summary, the main functions in GFML Master 225 are listed hereafter: select the edge nodes to run the GNN model based on target local networks;

- pass the local network information (node and network topology) to the edge nodes; select the GNN model to be executed on GFML clients; define the data quality verification rules to be used in GFML clients;

- manage the model weight exchange by following FML; control the training cycles in the edge node via GFML client via the instructions;

- provide the schedule for edge node to turn on/off the dataset generation and collection at the network node level (referring to the advanced options).

[0054] In Federated learning, one common algorithm that can be selected is the federated averaging algorithm, which is also called “FedAvg”. It is the very first vanilla federated learning algorithm developed by Google®. The corresponding algorithm is provided below, as reference. Basically, it averages the model weights from randomly selected clients, which participate in the global model training process.

Algorithm 1 FederatedA veraging. The K clients are indexed by k

B is the local minibatch size, E is the number of local epochs, and r is the learning rate. _

Server executes: initialize wo for each round t = 1,2,... do m <— max(C • K. 1)

S_t (random set of m clients) for each client k e St in parallel do

Wf₊₁ <— ClientUpdate(/c, w_z)

... , yK ⁿk k wt+l 2 k=l _n ^wt+l

ClientUpdate (k w) //Run on client k

B (split Pk into batches of size B) for each local epoch i from 1 to E do for batch b e B do return w to server

[0055] Many other variants of FedAvg algorithms such as “FedProx”, “FedMa”,

“FedOpt”, “Scaffold”, etc. have been developed to address issues encountered in the federated learning problems area. A person skilled in the art would understand that any one of these models could be selected, based on the needs.

[0056] Figure 4 is a flowchart illustrating the logical flow executed in the GFML Client 120, which runs in the edge nodes 110.

[0057] The flow starts at step 401, with the GFML Client 120, running in the edge node 110, receiving instructions from the GFML Master 225, or central server, to prepare certain amount of data, the instructions including data quality verification rules.

[0058] At step 402, the GFML Client 120 collects the data from the nodes 125 in the target local network 105 with which it is associated, for training the model. At step 403, the GFML Client 120 builds the node embedding, described further down in details, and network representation using both node features and network topology. At step 404, the GFML Client 120 normalizes the dataset acquired from the nodes 125 using standard deviation. At step 405, the GFML Client 120 labels the dataset by applying predetermined criteria such as packet loss rate, retransmission rate, etc. for binary classification (normal or abnormal network performances. Then, at step 406, the GFML Client 120 verifies that the amount of data that qualifies corresponds to the amount of data requested by the GFML master 225. If the amount of data is not sufficient, the GFML Client 120 returns to the collection of data step, 402. If yes, the GFML Client 120 notifies the GFML master 225 on the readiness of the dataset (this can take the form of a success or failure indication), step 408.

[0059] Once this is done, the GFML Client 120 transitions to a waiting state where it waits for instructions or for a model update from the GFML Master 225. At this point there are two possibilities, the GFML Client 120 can receive instructions to acquire further data (returning to step 401), or the GFML Client 120 can receive the global model (initial or updated model weights) from the GFML Master 225, step 410. Once weights are received, the GFML Client 120 updates the GNN model it keeps locally, step 411. At step 412, the GFML Client 120 selects a subset of the dataset acquired locally, step 412, and trains the local GNN model using the selected subset of the dataset, for local network operation performance classification, step 413. At step 414, the GFML Client 120 checks if the stop training criteria are met. If it is determined that more training needs to be done, the GFML Client 120 returns to the step 412. If the training is sufficient to meet the criteria, the GFML Client 120 retrieves the model weights and sends the weights to the GFML Master 225, step 415. Then it returns to the waiting state, step 409.

[0060] In summary, the GFML client 120 collects the dataset from the nodes 125 in the target the local network 105. It does the node embedding and network representation by using node features plus the network topology received from the GFML master 225.

[0061] It also does the labelling of the dataset collected from the nodes 125 in target local network 105 by applying given criteria. It performs the model training by involving the GNN module 245.

[0062] In the proposed solution, there are two major components, one is the central management server, GFML4NM-CMS, 115 that is deployed in a central control office, the other is GFML4NM-Client 120, which is deployed in the edge nodes 110 closer to the potential target networks 105, referring to figures 1 and 2.

[0063] When a request to build the binary classification model for the network at a given location is received, the central management server verifies the size of the target network and decides if the target network should be broken into several small networks 105 to apply the proposed GNN based FML solution or not.

[0064] The policy for breaking a single network into multiple ones might be made based on:

- the network size,

- the computational capacity of the resource at the edge,

- the storage capacity of the resource at the edge.

[0065] The default value of the network size can be selected based on experimental results obtained from either design lab or test net in an operator’s network, for example the default value could be one hundred network nodes.

[0066] A modified GNN mode, GraphSAGE was reported in Hamilton, William L. and Ying, Rex and Leskovec, Jure, “Inductive Representation Learning on Large Graphs”, 31st Conference on Neural Information Processing Systems (NIPS 2017), Long Beach, CA, USA, which is included herein by reference it its entirety. GraphSAGE is used as a baseline for the proposed GNN-based FML method.

[0067] The detailed implementation will be described below, including the GNN architecture, GraphSAGE algorithm, the node embedding and network representation and the binary classification for network performance. [0068] Reference will be made to figure 5, which illustrates the two-layer GNN architecture with local network for node R1 and figure 6, which illustrates the two- layer GNN architecture with local network for node Cl and R2.

[0069] Referring to figures 5 and 6, two-layer GNN architectures for the given local network are present. Each layer contains both a message 505 and an aggregation parts 510. Each node 125 (Ri, R2, R3) in the local network has its own GNN architecture. Three nodes are used to demonstrate how their GNN architectures look like.

[0070] In figure 5, Ri is taken as a target node 125. For the first layer, it has five neighbors, one is the router R2, the other four instances are cells Ci to C4 located in different places. For the second layer, the cell nodes have only one neighbor, Ri. The router R2, which has two neighbor nodes Ri and R3. The inputs for layer 2 are all the routers, in this example.

[0071] In figure 6, two other nodes are used as target nodes. In figure 6 (a), cell Ci, has only one neighbor node at the first layer, Ri, and five nodes at second layer, Ci, C2, C3, C4 and R2.

[0072] In figure 6 (b), the GNN architecture is shown for router R2, which has two nodes Ri and R3 at the first layer and total seven nodes at the second layer, with Ci, C2, C3 C4 and R2 neighboring Ri and C5 and R2 neighboring R3.

[0073] The pseudocode of GraphSAGE, used for training the GNN, is provided for reference.

Algorithm 1: GraphSAGE embedding generation (i.e., forward propagation) algorithm

Input : Graph G (V, E); input features {xy , Vv G V }; depth K ; weight matrices

W^, Vk G { 1, ..., K},- non-linearity : differentiable aggregator functions

AGGREGATE^, k G { 1, .... V[ : neighborhood function N : v 2^

Output : Vector representations zy for all v G V

6 end

7 h^k ^h^k/\\h^k\\2, Vv G V

8 end

9 z y <— h^k, Vv G V [0074] Among different GNN models, a GraphSAGE neural network was selected to demonstrate how the graph representation for a network can be done. It should be noted that different models can be used, as would be apparent to a person skilled in the art.

[0075] Node embedding and network representation is discussed below.

[0076] In the network performance evaluation, the following KPIs and counters are commonly considered: network bandwidth (BW), data re-transmission ratio (DRR), packet loss ratio (PLR), central processing unit (CPU) load or usage, memory (Mem) usage.

[0077] As one example for the proposed solution, those parameters, measured on a node, are taken as the node features. The node embedding is presented in the following equation h_u = {CPU, Mem, BW, DRR, PLR, ... }, (1) where h_u represents a network node u.

[0078] Following the concept of message passing and aggregation, the node embedding z_u can be built up after L layers by following the multi-layer GNN architecture referring to equations (2) and (3).

[0079] Then, the representation of the network can be built using a simple mean function.

[0080] In these equations, v is the representation of a network node next to the node w, W represents the weights in the GNN model, B represents the bias in the GNN model, K is the number of layers and Z_u is the representation of node u after an L-layer message passing from its neighbor nodes.

[0081] In order to label the dataset collected from the nodes 125 in the target local network 105, an auto-labelling mechanism based on given criteria is used. One example of the auto-labelling rules is described hereafter. If one or more KPIs measured on the nodes in the target local network exceed a given threshold, the network performance is considered to be “abnormal”, vice versa, it will be considered “normal”. For instance, the following thresholds can be applied for labelling the network performance. The packet loss ratio exceeds 80% (PLR).

The data retransmissions ratio exceeds 40% (DRR).

- Etc.

[0082] The values for the thresholds should be configurable.

[0083] For the binary classification of the network performance, the graph representation yGraph, as shown in equation (4), can be used and a Multi-layer Perceptron (MLP) can be applied on it using SoftMax; then the predication can be done.

[0084] Since only a binary classification is considered in the example presented herein, a cross-entropy function can be used to measure the loss. where y_graph is the prediction, and yGraph is the label.

[0085] This loss function is used to train the GNN model for network operation performance classification. Stochastic gradient descent (SDG) can be used to minimize the loss. When the loss is minimized or the model training converges, the network performance characteristics is well captured by the GNN model.

[0086] As one example, the detailed implementation for network performance using GNN is explained in C. Yen, W. Sun, H. Purmehdi, and W. Park, “Graph Neural Network based Root Cause Analysis Using Multivariate Time-series KPIs for Wireless Network”, 2022 IEEE/IFIP Network Operations and Management Symposium, July, 2022, which is included herein by reference in its entirety.

[0087] The proposed solution described herein provides a mechanism to train a network performance classification model by combining GNN and FML techniques efficiently.

[0088] The solution reduces the network bandwidth usage by avoiding moving the datasets in the network for training the network performance model. The solution allows to manage the network nodes to generate the dataset according to a schedule. The nodes generate the dataset based on the request from the edge node for training the GNN model. The solution enables selecting or deciding the model training period based on ongoing network traffic so the infrastructure can be utilized more efficiently through the resource sharing among end user traffic and network operation traffic [0089] Figure 7a illustrates a method 700, executed in a central node, for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network

[0090] The method comprises defining, step 705, at least two local networks within the large network. The method comprises selecting, step 710, one edge node for each of the at least two local networks for training a local GNN model. The method comprises sending, step 715, to each edge node, a network topology for the local network, the local GNN model selected, and information about nodes in the local network. The method comprises sending, step 720, initial weights for the local GNN model to each edge node and receiving updated weights from each edge node. The method comprises updating, step 725, the GNN model using the updated weights received from each edge node, using FML.

[0091] The GNN model may be selected among binary classification models or multiclassification models.

[0092] The method may further comprise defining data quality verification rules, according to the selected GNN model and sending the data quality verification rules to each edge node, the data quality verification rules being for use by each edge node to verify data quality of acquired datasets.

[0093] The data quality verification rules may comprise any one or more among: a minimum number of nodes in the local network from which to obtain data, a size of a dataset to acquire from each node, balancing ratios for the datasets, rules for normalization of data of the dataset, labelling criteria for data of the dataset.

[0094] The method may further comprise sending timing information to each edge node for controlling training cycles in each edge node.

[0095] The timing information may further comprise a schedule to turn on and turn off generation of datasets at the network node level and collection of the dataset by the edge node.

[0096] The method may further comprise, after updating the GNN model, sending updated weights for the local GNN models to the edge nodes and receiving updated weights from the edge nodes.

[0097] Figure 7b illustrates a method 750, executed in an edge node, for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network. [0098] The method comprises receiving, step 755, a network topology for a local network, a GNN model with initial weights and information about nodes in the local network, from a central node. The method comprises acquiring, step 760, datasets from nodes in the local network. The method comprises verifying and labelling, step 765, the datasets. The method comprises training, step 770, the GNN model using the datasets. The method comprises sending, step 775, updated weights to the central node.

[0099] The method may further comprise receiving the data quality verification rules from the central node for verifying the datasets.

[00100] The data quality verification rules may comprise any one or more among: a minimum number of nodes in the local network from which to obtain data, a size of a dataset to acquire from each node, balancing ratios for the datasets, rules for normalization of data of the dataset, labelling criteria for data of the dataset.

[00101] A subset of the datasets may be selected for training the GNN model. [00102] The method may further comprise receiving timing information from the central node, for controlling training cycles.

[00103] The timing information may further comprise a schedule to turn on and turn off generation of datasets at the network node level.

[00104] The method may further comprise receiving updated weights from the central node and updating the GNN model.

[00105] It should be noted that methods and steps described herein are, generally, computer implemented methods and steps. The term computer may be interpreted as having different meanings, such as explained next, for example.

[00106] Referring to figure 8, there is provided a hardware (HW) 801, in which functions and steps described herein can be implemented.

[00107] The hardware 801 may be a server in the cloud or in any other type of network, a network node, a radio base station, an edge node or another computing device which may be part of a cloud computing system, edge computing system, or which, in some cases, may be a standalone device.

[00108] The hardware 801 when it executes the central management system is operative set up target local networks for creating a model, to determine or predict network performance, using federated learning, as explained previously. The hardware 801 when it is an edge node, is operative to receive instructions as previously explained to get data and train a model as well as to perform inference using the model.

[00109] The hardware 801 comprises processing circuitry 803 and memory 805. The memory 805 can contain instructions executable by the processing circuitry 803 whereby functions and steps described herein may be executed to provide any of the relevant features and benefits disclosed herein.

[00110] The hardware 801 may also include non-transitory, persistent, machine-readable storage media 807 having stored therein software and/or instruction 809 executable by the processing circuitry 803 to execute functions and steps described herein. The hardware may also include network interface(s) and a power source.

[00111] The instructions 809 may include a computer program for configuring the processing circuitry 803. The computer program may be stored in a physical memory local to the device, which can be removable, or it could alternatively, or in part, be stored in the cloud. The computer program may also be embodied in a carrier such as an electronic signal, optical signal, radio signal, or computer readable storage medium.

[00112] Referring to figure 9, there is provided a virtualization environment 900 in which functions and steps described herein can be implemented.

[00113] The virtualization environment 900 (which may go beyond what is illustrated in figure 9), may comprise systems, networks, servers, nodes, devices, etc., that are in communication with each other either through wire or wirelessly, e.g., through a network interface component (NIC) comprising physical network interface(s). Some or all of the functions and steps described herein may be implemented as one or more virtual components (e.g., via one or more applications, components, functions, virtual machines, containers, etc.) executing on one or more physical apparatus in one or more networks, systems, environment, etc.

[00114] A virtualization environment provides hardware 901 comprising processing circuitry 903 and memory 905. The memory 905 can contain instructions executable by the processing circuitry 903 whereby functions and steps described herein may be executed to provide any of the relevant features and benefits disclosed herein.

[00115] The hardware 901 may also include non-transitory, persistent, machine-readable storage media 907 having stored therein software and/or instruction 909 executable by the processing circuitry 903 to execute functions and steps described herein.

[00116] The instructions 909 may include a computer program for configuring the processing circuitry 903. The computer program may be stored in a removable memory, such as a portable compact disc, portable digital video disc, or other removable media. The computer program may be stored in a physical memory local to the hardware 901, which can be removable, or it could alternatively, or in part, be stored in the cloud. The computer program may also be embodied in a carrier such as an electronic signal, optical signal, radio signal, or computer readable storage medium.

[00117] Referring to figures 8 and 9, there is provided a central node 801, 901, for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network. The central node comprises processing circuits 803, 903, and a memory, 805, 905. The memory contains instructions executable by the processing circuits whereby the central node is operative to define at least two local networks within the large network. The central node is operative to select one edge node for each of the at least two local networks for training a local GNN model. The central node is operative to send, to each edge node, a network topology for the local network, the local GNN model selected, and information about nodes in the local network. The central node is operative to send initial weights for the local GNN model to each edge node and receive updated weights from each edge node. The central node is operative to update the GNN model using the updated weights received from each edge node, using FML.

[00118] The GNN model may be selected among binary classification models or multi-classification models.

[00119] The central node may be further operative to define data quality verification rules, according to the selected GNN model and send the data quality verification rules to each edge node, the data quality verification rules being for use by each edge node to verify data quality of acquired datasets.

[00120] The data quality verification rules may comprise any one or more among: a minimum number of nodes in the local network from which to obtain data, a size of a dataset to acquire from each node, balancing ratios for the datasets, rules for normalization of data of the dataset, labelling criteria for data of the dataset. [00121] The central node may be further operative to send timing information to each edge node for controlling training cycles in each edge node.

[00122] The timing information may further comprise a schedule to turn on and turn off generation of datasets at the network node level and collection of the dataset by the edge node.

[00123] The central node may be further operative to, after updating the GNN model, send updated weights for the local GNN models to the edge nodes and receiving updated weights from the edge nodes.

[00124] Still referring to figure 8, there is provided an edge node 801 for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network. The edge node comprises processing circuits 803 and a memory 805, the memory containing instructions executable by the processing circuits whereby the edge node is operative to receive a network topology for a local network, a GNN model with initial weights and information about nodes in the local network, from a central node. The edge node is operative to acquire datasets from nodes in the local network. The edge node is operative to verify and label the datasets. The edge node is operative to train the GNN model using the datasets. The edge node is operative to send updated weights to the central node.

[00125] The edge node may be further operative to receive the data quality verification rules from the central node for verifying the datasets.

[00126] The data quality verification rules may comprise any one or more among: a minimum number of nodes in the local network from which to obtain data, a size of a dataset to acquire from each node, balancing ratios for the datasets, rules for normalization of data of the dataset, labelling criteria for data of the dataset.

[00127] A subset of the datasets may be selected for training the GNN model.

[00128] The edge node may be further operative to receive timing information from the central node, for controlling training cycles.

[00129] The timing information may further comprise a schedule to turn on and turn off generation of datasets at the network node level.

[00130] The edge node may be further operative to receive updated weights from the central node and updating the GNN model.

[00131] Referring to figures 8 and 9, there is provided a non-transitory computer readable media 807, 907 having stored thereon instructions 809, 909 for training a graph neural network (GNN) model through federated machine learning (FML) for network performance assessment within a large network. The instructions may comprise any of the steps described herein.

[00132] Modifications will come to mind to one skilled in the art having the benefit of the teachings presented in the foregoing description and the associated drawings. Therefore, it is to be understood that modifications, such as specific forms other than those described above, are intended to be included within the scope of this disclosure. The previous description is merely illustrative and should not be considered restrictive in any way. The scope sought is given by the appended claims, rather than the preceding description, and all variations and equivalents that fall within the range of the claims are intended to be embraced therein. Although specific terms may be employed herein, they are used in a generic and descriptive sense only and not for purposes of limitation.

Claims

CLAIMS A computer implemented method, executed in a central node, for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network, comprising: defining at least two local networks within the large network; selecting one edge node for each of the at least two local networks for training a local GNN model; sending, to each edge node, a network topology for the local network, the local GNN model selected, and information about nodes in the local network; sending initial weights for the local GNN model to each edge node and receiving updated weights from each edge node; and

- updating the GNN model using the updated weights received from each edge node, using FML. The method of claim 1, wherein the GNN model is selected among binary classification models or multi-classification models. The method of claim 2, further comprising: defining data quality verification rules, according to the selected GNN model; and sending the data quality verification rules to each edge node, the data quality verification rules being for use by each edge node to verify data quality of acquired datasets. The method of claim 3, wherein the data quality verification rules comprise any one or more among: a minimum number of nodes in the local network from which to obtain data, a size of a dataset to acquire from each node, balancing ratios for the datasets, rules for normalization of data of the dataset, labelling criteria for data of the dataset. The method of claim 1, further comprising sending timing information to each edge node for controlling training cycles in each edge node.

6. The method of claim 5, wherein the timing information further comprise a schedule to turn on and turn off generation of datasets at the network node level and collection of the dataset by the edge node.

7. The method of claim 1, further comprising, after updating the GNN model, sending updated weights for the local GNN models to the edge nodes and receiving updated weights from the edge nodes.

8. A computer implemented method, executed in an edge node, for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network, comprising:

- receiving a network topology for a local network, a GNN model with initial weights and information about nodes in the local network, from a central node; acquiring datasets from nodes in the local network;

- verifying and labelling the datasets;

- training the GNN model using the datasets; and sending updated weights to the central node.

9. The method of claim 8, further comprising receiving the data quality verification rules from the central node for verifying the datasets.

10. The method of claim 8, wherein the data quality verification rules comprise any one or more among: a minimum number of nodes in the local network from which to obtain data, a size of a dataset to acquire from each node, balancing ratios for the datasets, rules for normalization of data of the dataset, labelling criteria for data of the dataset.

11. The method of claim 8, wherein a subset of the datasets is selected for training the GNN model.

12. The method of claim 8, further comprising receiving timing information from the central node, for controlling training cycles. The method of claim 12, wherein the timing information further comprise a schedule to turn on and turn off generation of datasets at the network node level. The method of claim 8, further comprising receiving updated weights from the central node and updating the GNN model. A central node for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network, comprising processing circuits and a memory, the memory containing instructions executable by the processing circuits whereby the central node is operative to: define at least two local networks within the large network; select one edge node for each of the at least two local networks for training a local GNN model; send, to each edge node, a network topology for the local network, the local GNN model selected, and information about nodes in the local network; send initial weights for the local GNN model to each edge node and receive updated weights from each edge node; and

- update the GNN model using the updated weights received from each edge node, using FML. The central node of claim 15, wherein the GNN model is selected among binary classification models or multi-classification models. The central node of claim 16, further operative to: define data quality verification rules, according to the selected GNN model; and send the data quality verification rules to each edge node, the data quality verification rules being for use by each edge node to verify data quality of acquired datasets. The central node of claim 17, wherein the data quality verification rules comprise any one or more among: a minimum number of nodes in the local network from which to obtain data, a size of a dataset to acquire from each node, balancing ratios for the datasets, rules for normalization of data of the dataset, labelling criteria for data of the dataset.

19. The central node of claim 15, further operative to send timing information to each edge node for controlling training cycles in each edge node.

20. The central node of claim 19, wherein the timing information further comprise a schedule to turn on and turn off generation of datasets at the network node level and collection of the dataset by the edge node.

21. The central node of claim 15, further operative to, after updating the GNN model, send updated weights for the local GNN models to the edge nodes and receiving updated weights from the edge nodes.

22. An edge node for training a graph neural network (GNN) model through federated machine learning (FML), for network performance assessment within a large network comprising processing circuits and a memory, the memory containing instructions executable by the processing circuits whereby the edge node is operative to:

- receive a network topology for a local network, a GNN model with initial weights and information about nodes in the local network, from a central node; acquire datasets from nodes in the local network;

- verify and label the datasets;

- train the GNN model using the datasets; and send updated weights to the central node.

23. The edge node of claim 22, further operative to receive the data quality verification rules from the central node for verifying the datasets.

24. The edge node of claim 22, wherein the data quality verification rules comprise any one or more among: a minimum number of nodes in the local network from which to obtain data, a size of a dataset to acquire from each node, balancing ratios for the datasets, rules for normalization of data of the dataset, labelling criteria for data of the dataset.

25. The edge node of claim 22, wherein a subset of the datasets is selected for training the GNN model. 26. The edge node of claim 22, further operative to receive timing information from the central node, for controlling training cycles.

27. The edge node of claim 26, wherein the timing information further comprise a schedule to turn on and turn off generation of datasets at the network node level.

28. The edge node of claim 22, further operative to receive updated weights from the central node and updating the GNN model.

29. A non-transitory computer readable media having stored thereon instructions for training a graph neural network (GNN) model through federated machine learning

(FML) for network performance assessment within a large network, the instructions comprising the steps of any of the claims 1 to 14.