# [UOM - Free5 gc]
## 5 B5 gemini AI Components
### Novel Deep Learning Architectures  
Graph Neural Networks (GNN) are neural network architectures able to process graphs as inputs to produce useful embeddings exploiting the concept of message passing between nodes in the graph [PERSON] et al. (2016). GNNs have yielded groundbreaking results in many fields where data is fundamentally structured as graphs, such as the field of communication networks, where this innovative type of neural networks is deemed as a key technology to model complex graphs (e.g., traffic routing optimization, resource allocation, anomaly detection). Due to their unique capabilities over traditional neural networks, we envision GNN as a key player in the construction of NDT for communication network modeling. Several studies have demonstrated that GNNs are able to remain robust to changes in network topology, routing policies and traffic distribution [PERSON] et al. (2018), a key advantage over alternatives such as traditional neural networks (e.g., recurrent neural networks, convolutional neural networks, variational autoencoders) or Deep Reinforcement Learning techniques that are severely deprived of this capacity [PERSON] et al. (2018). However, GNNs present a limiting factor due to weak scalability, which inevitably must come as a trade-off that sacrifices graph completeness, either losing node neighbors when using a graph sample strategy or structural information when opting for a graph clustering method [PERSON] et al. (2016), ultimately resulting in lower performance in either form. On the other hand, in convolutional graph networks (GCN), one of the most successful GNN architectures, the graph convolution operation can be interpreted as a Laplacian smoothing. It has been demonstrated that repeated application of Laplacian smoothing on the same graph leads to the convergence of all node embeddings to the same value [PERSON] et al. (2018). This result leads to the conclusion that stacking multiple convolutional layers will not always result in a more powerful model; in fact, it has been demonstrated that the performance of GCNs significantly decreases as more layers are added [PERSON] et al. (2018). This finding makes scalability of GNNs an even more concerning problem. For the above reasons, we consider this issue as the most important challenge to be solved for the adoption of building NDTs. In the field of communication networks, DRL has recently received more attention because it is emerging as a natural candidate to effectively address various problems and challenges intrinsic of this domain. Network devices need to make autonomous decisions to achieve different objectives or meet QoS requirements. Most of the decision-makingproblems in network optimization scenarios can be formulated using Markov Decision Processes (MDP). Reinforcement Learning (RL) techniques have been widely adopted to solve MDP problems [63]. However, RL techniques are not always applicable, especially when the problem is too complex, or the state and action spaces are too large. Deep Reinforcement Learning (DRL) has been demonstrated to be promising in these cases. DRL is a subfield of RL that uses DL techniques to allow machines to learn how to achieve a certain goal by trial and error, without the need of labeled data. More precisely, a DRL agent is trained by interacting with an environment, and the environment returns a state and a reward after each action. The first phase of the training process is composed of two main parts: first, the DRL agent collects all the states and rewards from the environment, and second, the DRL agent's past experiences are used to train the weights of a Deep Neural Network (DNN) in a supervised manner. Similar to GNNs, DRL-based algorithms often suffer from poor scalability. The reason is that, as stated above, the DRL agent learns from sequential interactions with the environment. For that reason, when DRL is applied to large networks or complex optimization problems when the interaction with the environment occurs slowly, the problem becomes computationally expensive.