Adaptive Graph Capsule Convolutional Networks

1 INTRODUCTION . Graph-structured data is ubiquitous in real-world scenarios such as biological networks , citation networks , recommender systems , and social networks . It has seen a surge in research on extending deep learning methods like Convolutional Neural Networks ( CNNs ) ( LeCun & Bengio , 1998 ) or Recurrent Neural Networks ( RNNs ) ( Mikolov et al. , 2011 ) to process tasks on graphs . Graph Neural Networks ( GNNs ) were first proposed in ( Gori et al. , 2005 ) and further elaborated in ( Scarselli et al. , 2009 ) to handle graphs based on recursive neural networks ( RecGNNs ) . RecGNNs learn to represent nodes by constantly exchanging neighbor information until reaching a stable equilibrium , which is computationally expensive . Encouraged by the success of CNNs , many studies ( Bruna et al. , 2014 ; Henaff et al. , 2015 ; Defferrard et al. , 2016 ; Kipf & Welling , 2017 ) borrowed the idea of convolutions and redefined them for graph data . These convolutional networks on graphs are known as Graph Convolutional Networks ( GCNs ) by stacking multiple graph convolutional layers to present high-level graph representation . Moreover , GCNs can save much time in computing compared to RecGNNs . In this paper , we focus on the research on GCNs . SOTA GCNs methods ( Zhang et al. , 2018 ; Verma & Zhang , 2018 ) generate graph embeddings in the form of scalar , which may not help capture enough node features . Therefore , it is of great necessity to improve the information extraction ability of current GCNs . In 2011 , ( Hinton et al. , 2011 ) pointed out that traditional pooling mechanism ( Scherer et al. , 2010 ) on CNNs may suffer from the information loss problem . Later ( Sabour et al. , 2017 ) proposed a novel neural network called CapsNet without using pooling . CapsNet encodes the features of images as vectors and uses a dynamic routing algorithm to obtain the right local-global relationship . Owing to its capability to capture inner relations among entities , CapsNet has been converged with GCNs to grasp higher quality graph information ( Verma & Zhang , 2018 ; Xinyi & Chen , 2019 ) . CapsGNN ( Xinyi & Chen , 2019 ) extracts multi-scale node features from different convolutional layers and represents the extracted features in the form of capsules . Compared to classic GCN models , CapsGNN has been proven to have better representation ability on graph data . However , CapsGNN still uses a static model structure to conduct training , which inherently restricts its ability to cope with the enhancing abstraction level of graph information during the whole training process . Therefore , it is crucial to explore a method for dynamically adjusting the structure of CapsGNN to improve its classification performance . Many research efforts ( He et al. , 2016 ; Szegedy et al. , 2016 ; Huang et al. , 2017 ; Szegedy et al. , 2017 ; Li et al. , 2018 ; Rong et al. , 2019 ) have demonstrated that the number of convolutional layers ( i.e. , depth , denoted by D ) and the number of neurons in each layer ( i.e. , width , denoted by W ) impact significantly on the performance of neural networks . However , these methods are often inefficient in training due to overly complex model structures . In this paper , we simplify the architecture search problem and focus on the exploration of the best depth-width setting on particular dataset , considering the balance between efficiency and accuracy . To evaluate the effects of the depth and width in CapsGNN , we change them to observe the performance of the model on two graph datasets , ENZYMES and IMDB-MULTI ( Kersting et al. , 2016 ) , in bioinformatics and social fields , respectively . It is shown in Figure 1 that if the model has small D and W , it can not sufficiently extract the features of graphs . On the contrary , when the model structure is too complicated , overfitting occurs frequently . Thus , CapsGNN is sensitive to changes in depth and width just because of the vectorized graph representation in it . Since the impacts of D and W are distinct on different datasets , it is necessary to adaptively adjust the model architecture according to the latent characteristics of particular workloads . With respect to the search for the optimal structure of a model , there has been increasing interest in designing automatic methods in Neural Architecture Search ( NAS ) ( Zoph & Le , 2017 ; Liu et al. , 2018 ; Luo et al. , 2018 ; Real et al. , 2019 ; Pham et al. , 2018 ) . There exist mainly three kinds of techniques to search for the best model architecture in NAS , i.e. , Reinforcement Learning ( RL ) based , Evolution Algorithm ( EA ) based , and gradient-based methods . RL-based methods ( Zoph & Le , 2017 ; Pham et al. , 2018 ; Zoph et al. , 2018 ) use RNN as the controller to train different architectures and select the optimal one according to their validation accuracy results . EA-based methods ( Real et al. , 2017 ; Xie & Yuille , 2017 ; Real et al. , 2019 ; Shu et al. , 2019 ) utilize the evolutionary algorithm to search for superior model structures from a set of initialized candidate networks . Gradient-based methods ( Liu et al. , 2019 ; Wu et al. , 2019 ; Xie et al. , 2019 ) construct a SuperNet and leverage the attention mechanism to remove weak connections after searching . The former two methods can be regarded as offline and are often time-consuming . Although the third method is an online method and shows good efficiency due to gradient descent optimization , it lacks variety in searching for the optimal architecture . To achieve the balance between efficiency and accuracy , we propose Adaptive Graph Capsule Convolutional Networks ( AdaGCCN ) to address the issues discussed above . We utilize Reinforcement Learning ( RL ) to design an online assistant module for evaluating different changes to depth and width . Differing from the RL agent in an RL-based NAS task that considers the choices of various model structures as actions , we move the RL procedure into only one full training and choose one action ( i.e. , one alteration to the model structure ) in a sliding epoch window at one time , according to not only the accuracy results on the validation data set but also the rate of reduction in training loss . However , the introduction of the assistant module would result in extra computational overhead . To accelerate the selection process described above , we further assign multiple workers to train in parallel on the GPU . Three main contributions are made in this paper : • We optimize the model architecture at runtime by tuning depth and width of convolutional layers by observing both the change in validation accuracy and the reduction speed of training loss after each sliding epoch window . Following this scheme , we can dynamically refine our model while sharing the weights parameters learned at previous training stages . • The assistant module is formalized as a Reinforcement Learning ( RL ) agent . We define the depth-width setting of graph convolutions as a state and consider the changes of the setting as actions . We leverage the RL mechanism to update the rewards corresponding to different actions . • To simplify the search space of the assistant module , we discuss the adequacy of only adjusting depth and width of the convolution operations . To ease the computation burden that arises from the assistant module , we split the whole validation process into multiple tasks to run them synchronously . We organize the rest of the paper as follows . Section 2 introduces the background of this work . Section 3 elaborates the fundamental architecture and implementation of AdaGCCN . In Section 4 , we evaluate the classification performance of our model against the baseline methods . We discuss related work in Section 5 and conclude this paper in Section 6 . 2 PRELIMINARIES . Here , we give a brief revisit to common GCNs and a capsule-based GCN , i.e. , CapsGNN . 2.1 GRAPH CONVOLUTIONAL NETWORKS . A graph can be represented by G = ( V , X , A ) , in which V = { v1 , v2 , ... , vN } ( N is the number of nodes ) is the set of nodes in the graph , A ∈ { 0 , 1 } N×N is the adjacency matrix ofG andX ∈ RN×d represents the features of each node ( d is the number of feature dimensions ) . GCNs , inspired by CNNs , extract richer information of one node by aggregating features of the nodes from its neighborhood . At each layer of GCNs , each node and its neighbors are operated through convolutions . Then an activation function is applied to return the updated representation of each node . The procedure in GCNs can be written as : Zl+1 = A ′ ZlW l , X l+1 = f ( Zl+1 ) ( 1 ) whereZl ∈ RN×dl implies node features at layer l ( Z0 = X ) , W l ∈ Rdl×dl+1 is a trainable weights matrix which serves as a convolution filter , A ′ ∈ RN×N is the regularized form of the adjacency matrix A , and f is a nonlinear activation function . 2.2 CAPSULE GRAPH NEURAL NETWORK . Although classic CNNs perform decent classification results in image processing , they face a severe robust problem . For example , when training with human faces , CNNs could learn good statistical representations of them , but can not tell whether the relative positions of different parts of a face are correct . The reason behind this is mainly due to the pooling mechanism in CNNs which extracts information through down-sampling , thus causing the losses on some essential features of images . Unlike extracting image features as scalar values in CNNs , CapsNet was proposed ( Hinton et al. , 2011 ; Sabour et al. , 2017 ; Hinton et al. , 2018 ) to build vector-based capsules to learn the inherent part-whole relationships in images . Inspired by CapsNet , CapsGNN ( Xinyi & Chen , 2019 ) fuses the capsule mechanism with GCNs to handle graph data . CapsGNN extracts multi-dimension node features from different graph convolutional layers to serve as basic node capsules . Then it combines the attention mechanism and dynamic routing to generate higher-level graph capsules . To this end , each graph can be abstracted as multiple graph capsules , and different graph capsules represent the properties of the graph from different aspects . At last , CapsGNN uses dynamic routing again to produce class capsules which are applied to do graph classifications . However , like traditional GCNs models , CapsGNN does not try to adjust the model architecture when more fine-grained graph information needs to be learned as training proceeds , which leaves potential in enhancing its representation power . 3 OVERVIEW OF ADAGCCN . In this section , we outline the overall design of AdaGCCN ( depicted in Figure 2 ) . We first introduce the assistant module ( AM ) and the principle for determining the search space in it . Then we elaborate on how AM dynamically changes the model structure to extract higher-quality graph representations . Finally , we describe the parallel execution in AdaGCCN which accelerates the search process in AM .

Summary: This paper proposes a reinforcement learning based strategy for adaptively adjusting capsule graph convolutional network architectures throughout training. To that end, they introduce an assistant module which continuously adjusts the depth and width of the network based on the loss/validation accuracy reduction rate over a predetermined training epoch window.  The search space is defined by the authors as a list of m combinations of depth and width variables D and W, and an action a_t at epoch t consists of choosing one of the m depth/width architectural changes. The current training epoch with architecture depth D_t and width W_t is treated as the state, and the reward of an action at epoch t is revised via the relative decrease in training loss/validation accuracy over 3 epochs.