ArieL: Adversarial Graph Contrastive Learning

For graph representation learning, let \(G=\lbrace \mathcal {V},\mathcal {E},\mathbf {X}\rbrace\) be an attributed graph, where \(\mathcal {V}=\lbrace v_1,v_2,\dots ,v_n\rbrace\) denotes the set of nodes, \(\mathcal {E}\subseteq \mathcal {V}\times \mathcal {V}\) denotes the set of edges, and \(\mathbf {X}\in \mathbb {R}^{n\times d}\) denotes the feature matrix. Each node \(v_i\) has a d-dimensional feature \(\mathbf {X}[i,:]\) , and all edges are assumed to be unweighted and undirected. We use a binary adjacency matrix \(\mathbf {A}\in \lbrace 0,1\rbrace ^{n\times n}\) to represent the information of nodes and edges, where \(\mathbf {A}[i,j]=1\) if and only if the node pair \((v_i,v_j) \in \mathcal {E}\) . In the following text, we will use \(G=\lbrace \mathbf {A},\mathbf {X}\rbrace\) to represent the graph.

The objective of the graph representation learning is to learn an encoder \(f: \mathbb {R}^{n\times n}\times \mathbb {R}^{n\times d}\rightarrow \mathbb {R}^{n\times d^{\prime }}\) , which maps the nodes in the graph into low-dimensional embeddings. Denote the node embedding matrix \(\mathbf {H}=f(\mathbf {A},\mathbf {X})\) , where \(\mathbf {H}[i,:]\in \mathbb {R}^{d^{\prime }}\) is the embedding for node \(v_i\) . This representation could be used for downstream tasks such as node classification. Based on the node-embedding matrix, we can further obtain the graph embedding through an order-invariant readout function \(R(\cdot)\) , which generates the graph representation as \(R(\mathbf {H})\in \mathbb {R}^{d^{\prime \prime }}\) .

InfoNCE loss [49] is the predominant workhorse of the contrastive learning loss, which maximizes the lower bound of the mutual information between two random variables. For each positive pair \((\mathbf {x},\mathbf {x}^+)\) associated with k negative samples of \(\mathbf {x}\) , denoted as \(\lbrace \mathbf {x}_1^-, \mathbf {x}_2^-, \cdots ,\mathbf {x}_k^-\rbrace\) , InfoNCE loss could be written asHere, \(g(\cdot)\) is the density ratio with the property that \(g(\mathbf {a},\mathbf {b}) \propto \frac{p(\mathbf {a}|\mathbf {b})}{p(\mathbf {a})}\) , where \(\propto\) stands for proportional to. It has been shown by the authors of [49] that \(-L_k\) actually serves as the lower bound of the mutual information \(I(\mathbf {x};\mathbf {x}^+)\) with

We build the proposed method upon the framework of SimCLR [5], which is also the basic framework that GCA [65] and GraphCL [62] are built on.

A Projected Gradient Descent (PGD) attack [32] is an iterative attack method that projects perturbation onto the ball of interest at the end of each iteration. Assuming that the loss \(L(\cdot)\) is a function of the input matrix \(\mathbf {Z} \in \mathbb {R}^{n\times d}\) , at the t-th iteration, the perturbation matrix \(\mathbf {\Delta }_t\in \mathbb {R}^{n\times d}\) under an \(l_{\infty }\) -norm constraint could be written aswhere \(\eta\) is the step size, \(\text{sgn}(\cdot)\) takes the sign of each element in the input matrix, and \(\Pi _{\Vert \mathbf {\Delta }\Vert _{\infty }\le \delta }\) projects the perturbation onto the \(\delta\) -ball in the \(l_{\infty }\) -norm.

Many GNNs are known to be vulnerable to adversarial attacks [2, 66]. Thus, we first investigate the vulnerability of the GNNs trained with the contrastive learning objective in Equation (3). We generate a sequence of 60 graphs by iteratively dropping edges and masking the features. Let \(G_0=G\) ; for the t-th iteration, we generate \(G_t\) from \(G_{t-1}\) by randomly dropping the edges in \(G_{t-1}\) and randomly masking the unmasked features, both with probability \(p=0.03\) . Since \(G_t\) is guaranteed to contain less information than \(G_{t-1}\) , \(G_t\) should be less similar to \(G_0\) than \(G_{t-1}\) on both the graph and node level. Denote the node embeddings of \(G_t\) as \(\mathbf {H}_t\) ; we measure the similarity \(\theta (\mathbf {H}_t[i,:], \mathbf {H}_0[i,:])\) and it is expected that the similarity decreases as the iteration goes on.

We generate the sequences on two datasets, Amazon-Computers and Amazon-Photo [43]. The results are shown in Figure 1. At the 30-th iteration, with \(0.97^{30}=40.10\%\) edges and features left, the average similarity of the positive samples is under 0.5 on Amazon-Photo. At the 60-th iteration, with \(0.97^{60}=16.08\%\) edges and features left, the average similarity drops under 0.2 on both Amazon-Computers and Amazon-Photo. Additionally, starting from the 30-th iteration, the cosine similarity has around 0.3 standard deviation for both datasets, which indicates that a lot of nodes are actually very sensitive to the external perturbations, even if we do not add any adversarial component but just mask out some information. These results demonstrate that the current graph contrastive learning framework is not trained over enough high-quality contrastive samples and is not robust to adversarial attacks.

Given this observation, we are motivated to build an adversarial graph contrastive learning framework that could improve the performance and robustness of the previous graph contrastive learning methods. The overview of our framework is shown in Figure 2.

Adversarial training uses the samples generated through the adversarial attack methods to improve the generalization ability and robustness of the original method during training. Although most existing attack frameworks are targeted at supervised learning, it is natural to generalize these methods to contrastive learning by replacing the classification loss with the contrastive loss. The goal of the adversarial attack on graph contrastive learning is to maximize the contrastive loss by adding a small perturbation on the contrastive samples, which can be formulated aswhere \(G^{\prime }=\lbrace \mathbf {A}^{\prime }, \mathbf {X}^{\prime }\rbrace\) is generated from the original graph G, and the change is constrained by the budget \(\Delta _{\mathbf {A}}\) and \(\Delta _{\mathbf {X}}\) asWe treat adversarial attacks as one kind of data augmentation. Although we find it effective to make the adversarial attack on one or two augmented views as well, we follow the typical contrastive learning procedure as in SimCLR [5] to make the attack on the original graph in this work. In addition, it does not matter whether \(G_1\) , \(G_2\) , or G is chosen as the anchor for the adversary; each choice works in our framework and it can also be sampled as a third view. In our experiments, we use the PGD attack [32] as our attack method.

We generally follow the method proposed by Xu et al. [57] to make the PGD attack on the graph structure and apply the regular PGD attack method on the node features. Define the supplement of the adjacency matrix as \(\mathbf {\bar{A}}=\mathbf {1}_{n\times n}-\mathbf {I}_n-\mathbf {A}\) , where \(\mathbf {1}_{n\times n}\) is the ones matrix of size \(n\times n\) . The perturbed adjacency matrix can be written aswhere \(\circ\) is the element-wise product and \(\mathbf {L}_{\mathbf {A}}\in \lbrace 0,1\rbrace ^{n\times n}\) is a symmetric matrix with each element \(\mathbf {L}_{\mathbf {A}}[i,j]\) corresponding to the modification (e.g., add, delete, or no modification) of the edge between the node pair \((v_i,v_j)\) . The perturbation on \(\mathbf {X}\) follows the regular PGD attack procedure and the perturbed feature matrix can be written aswhere \(\mathbf {L}_{\mathbf {X}}\in \mathbb {R}^{n\times d}\) is the perturbation on the feature matrix.

For ease of optimization, \(\mathbf {L}_{\mathbf {A}}\) is relaxed to its convex hull \(\tilde{\mathbf {L}}_{\mathbf {A}}\in [0,1]^{n\times n}\) , which satisfies \(\mathcal {S}_{\mathbf {A}}=\lbrace \tilde{\mathbf {L}}_{\mathbf {A}}|\sum \nolimits _{i,j}\tilde{\mathbf {L}}_{\mathbf {A}}\le \Delta _{\mathbf {A}}, \tilde{\mathbf {L}}_{\mathbf {A}}\in [0,1]^{n\times n}\rbrace\) . The constraint on \(\mathbf {L}_{\mathbf {X}}\) can be written as \(\mathcal {S}_{\mathbf {X}}=\lbrace \mathbf {L}_{\mathbf {X}}|\Vert \mathbf {L}_{\mathbf {X}}\Vert _{\infty }\le \delta _{\mathbf {X}}, \mathbf {L}_{\mathbf {X}}\in \mathbb {R}^{n\times d}\rbrace\) , where we directly treat \(\delta _{\mathbf {X}}\) as the constraint on the feature perturbation. In each iteration, we make the updateswhere t denotes the current number of iterations, anddenote the gradients of the loss with respect to \(\tilde{\mathbf {L}}_{\mathbf {A}}\) at \(\tilde{\mathbf {L}}_{\mathbf {A}}^{(t-1)}\) and \(\mathbf {L}_{\mathbf {X}}\) at \(\mathbf {L}_{\mathbf {X}}^{(t-1)}\) , respectively. Here, \(G_{\text{adv}}^{(t-1)}\) is defined as \(\lbrace \mathbf {A}+ \mathbf {C}\circ \tilde{\mathbf {L}}_{\mathbf {A}}^{(t-1)}, \mathbf {X} + \mathbf {L}_{\mathbf {X}}^{(t-1)}\rbrace\) . The projection operation \(\Pi _{\mathcal {S}_{\mathbf {X}}}\) simply clips \(\mathbf {L}_{\mathbf {X}}\) into the range \([-\delta _{\mathbf {X}}, \delta _{\mathbf {X}}]\) element-wisely. The projection operation \(\Pi _{\mathcal {S}_{\mathbf {A}}}\) is calculated aswhere \(P_{[0,1]}[\mathbf {Z}]\) clips \(\mathbf {Z}\) into the range \([0,1]\) . We use the bisection method [4] to solve the equation \(\sum \nolimits _{i,j} P_{[0,1]}[\mathbf {Z}-\mu \mathbf {1}_{n\times n}]=\Delta _{\mathbf {A}}\) with respect to the dual variable \(\mu\) .

To finally obtain \(\mathbf {L}_{\mathbf {A}}\) from \(\tilde{\mathbf {L}}_{\mathbf {A}}\) , each element is independently sampled from a Bernoulli distribution as \(\mathbf {L}_{\mathbf {A}}[i,j]\sim \text{Bernoulli}(\tilde{\mathbf {L}}_{\mathbf {A}}[i,j])\) . To obtain a symmetric matrix, we only sample the upper triangular part (the elements on the diagonal are known to be 0 in our formulation) and obtain the lower triangular part through transposition.

To assimilate the graph contrastive learning and adversarial training together, we treat the adversarial view \(G_{\text{adv}}\) obtained from Equation (11) as another view of the graph. We define the adversarial contrastive loss as the contrastive loss between \(G_1\) and \(G_{\text{adv}}\) . The adversarial contrastive loss is added to the original contrastive loss in Equation (3), which becomeswhere \(\epsilon _1 \gt 0\) is the adversarial contrastive loss coefficient. We further adopt two additional subtleties on top of this basic framework: subgraph sampling and curriculum learning. For each iteration, a subgraph \(G_s\) with a fixed size is first sampled from the original graph G. Then, the data augmentation and adversarial attack are both conducted on this subgraph. The subgraph sampling could avoid the gradient derivation on the whole graph, which will lead to heavy computation on a large network. We also observe that subgraph sampling could increase the randomness of the sample and sometimes boost the performance. To avoid the imbalanced sample on the isolated nodes, we uniformly sample a random set of nodes and then construct the subgraph on top of them. For every T epochs, the adversarial contrastive loss coefficient is multiplied by a weight \(\gamma\) . When \(\gamma \gt 1\) , the portion of the adversarial contrastive loss is gradually increasing and the contrastive learning becomes harder as the training goes on.

Adversarial training could effectively improve the model’s robustness to perturbations. Nonetheless, we find that these hard training samples could impose the additional risk of training collapsing, i.e., the model will be located at a bad parameter area at the early stage of the training, assigning higher probability to a highly perturbed sample than a mildly perturbed one. In our experiment, we find that this vanilla adversarial training method may fail to converge in some cases (e.g., Amazon-Photo dataset). To stabilize the training, we add one constraint termed information regularization, whose main goal is to regularize the instance similarity in the feature space.

Data processing inequality [6] states that for three random variables \(\mathbf {Z}_1\) , \(\mathbf {Z}_2\) , and \(\mathbf {Z}_3\in \mathbb {R}^{n\times d^{\prime }}\) , if they satisfy the Markov relation \(\mathbf {Z_1}\rightarrow \mathbf {Z}_2\rightarrow \mathbf {Z}_3\) , then the inequality \(I(\mathbf {Z}_1;\mathbf {Z}_3)\le I(\mathbf {Z}_1;\mathbf {Z}_2)\) holds. As proved by Zhu et al. [65], since the node embeddings of two views \(\mathbf {H}_1\) and \(\mathbf {H}_2\) are conditionally independent given the node embeddings of the original graph \(\mathbf {H}\) , they also satisfy the Markov relation with \(\mathbf {H}_1\rightarrow \mathbf {H}\rightarrow \mathbf {H}_2\) and vice versa. Therefore, we can derive the following properties over their mutual information:In fact, this inequality holds on each node. A sketch of the proof is that the embedding of each node \(v_i\) is determined by all the nodes from its l-hop neighborhood if an l-layer GNN is used as the encoder, and this subgraph composed of its l-hop neighborhood also satisfies the Markov relation. Therefore, we can derive the more strict inequalities:Since \(-L_{\text{con}}(G_1,G_2)\) is only a lower bound of the mutual information, directly applying the above constraints is har; we only consider the constraints on the density ratio. Using the Markov relation for each node, we give the following theorem.

Note that \(g(\cdot ,\cdot)\) is symmetric for the two inputs. Thus, we get two upper bounds for \(g(\mathbf {H}_1[i,:], \mathbf {H}_2[i,:])\) . According to the previous definition, \(g(\mathbf {a},\mathbf {b})=e^{\theta (\mathbf {a},\mathbf {b})/\tau }\) , we can simply replace \(g(\cdot , \cdot)\) with \(\theta (\cdot ,\cdot)\) in the inequalities. Then, we combine these two upper bounds into one:This bound intuitively requires the similarity between \(\mathbf {H}_1[i,:]\) and \(\mathbf {H}_2[i,:]\) to be less than the similarity between \(\mathbf {H}[i,:]\) and \(\mathbf {H}_1[i,:]\) or \(\mathbf {H}_2[i,:]\) . Equipped with this upper bound, we define the following information regularization to penalize the higher probability of a less similar contrastive pair:Specifically, information regularization could be defined over any three graphs that satisfy the Markov relation. However, for our framework, to save memory and time complexity, we avoid additional sampling and directly ground information regularization on the existing graphs. It is also fine to apply information regularization on G, \(G_1\) and \(G_{\text{adv}}\) or G, \(G_2\) and \(G_{\text{adv}}\) .

The final loss of ArieL can be written aswhere \(\epsilon _2 \gt 0\) controls the strength of the information regularization.

The entire algorithm of ArieL is summarized in Algorithm 1.

For a batch of graphs \(\mathcal {B}\) and the batch of their augmentation views \(\mathcal {B}^+\) , we aim to generate a batch of adversarial views, which we denote as \(\mathcal {B}_{\text{adv}}\) . Denote the combined graph of each batch as \(G^*\) , \({G^+}^*\) , and \(G_{\text{adv}}^*\) . The objective of adversarial graph contrastive learning on the graph level can be formulated asIt is worth noting that the constraints we use here are applied on the batch rather than each graph, i.e., we only constrain the total perturbations over all graphs rather than the perturbations on each graph. This can greatly reduce the computational cost in solving the above-constrained maximization problem in that it reduces the number of constraints from twice the batch size to 2. However, it also introduces the additional risk that the perturbations could be severely imbalanced among the graphs in the batch, e.g., a graph is heavily perturbed while others are almost unchanged. In our experiment, we do not observe this problem but it could theoretically happen. A good practice is to start from this simple form and then gradually add constraints to the vulnerable graphs in the batch if the imbalanced perturbations are observed.

During the attack stage, the perturbation matrix \(\mathbf {L}_{\mathbf {A}}\) and its convex hull \(\tilde{\mathbf {L}}_{\mathbf {A}}\) are further subject to the constraints that they should be block diagonal matrices with 0 at position \((i,j)\) if node i and node j are the nodes from two graphs in the batch. This could be easily implemented by using a block diagonal mask to zero out the gradients during the forward propagation:where \(n_i\) is the number of nodes in the graph \(G_i\) in the batch. With this processing, the projection operation on the adjacency matrix remains the same as in Equation (21). In the case that we need to apply the constraints for each graph in the batch, we just need to apply the projection operation defined in Equation (21) on the adjacency matrix of each graph using the bisection method to solve \(\mu\) for each graph separately. The projection operation on the feature perturbation matrix is not affected on the graph level, which still clips \(\mathbf {L}_{\mathbf {X}}\) into the range \([-\delta _{\mathbf {X}},\delta _{\mathbf {X}}]\) element-wisely.

Information regularization also applies to graph-level contrastive learning, in which we only need to replace the node embedding with the graph embedding in Equation (30). Hence, we can derive the bound atop different views of the same graph in \(\mathcal {B}\) , \(\mathcal {B}^+\) , and \(\mathcal {B}_{\text{adv}}\) :

The final loss of ArieL for the graph-level contrastive learning could be written asThe graph-level adversarial contrastive learning could also follow the steps outlined in Algorithm 1 for training by simply replacing the input graph with the input batch in loss functions.

For node-level contrastive learning, we use the same parameters and design choices for ArieL’s network architecture, optimizer, and training scheme as in GRACE and GCA on each dataset. However, we find that GCA does not behave well on Cora, with a significant performance drop. Thus, we re-search the parameters for GCA on Cora separately and use a different temperature for it. Other contrastive learning–specific parameters are kept the same over GRACE, GCA, and ArieL. On graph-level contrastive learning, we keep ArieL’s hyperparameters the same as the ones used by GraphCL except for its own parameters.

All GNN-based baselines on node-contrastive learning use a two-layer GCN as the encoder. For each method, we compare its default hyperparameters and the ones used by ArieL and use the hyperparameters leading to better performance. Other algorithm-specific hyperparameters all respect the default setting in its official implementation. For graph-level contrastive learning, ArieL uses a three-layer GIN as the encoder, and we take the results for each baseline from its original paper under the same experimental setting.

Other hyperparameters of ArieL are summarized as follows:

The comparison results of node classification on all eight datasets are summarized in Table 3. Our method ArieL outperforms baselines over all datasets except on Cora and Facebook, with results only \(0.11\%\) and \(0.40\%\) lower in accuracy than MVGRL. It can be seen that the previous state-of-the-art method GCA does not bear significant improvements over previous methods. In contrast, ArieL can achieve consistent improvements over GRACE and GCA on all datasets, especially on Amazon-Computers, with almost \(3\%\) gain.

In addition, we find MVGRL a solid baseline whose performance is close to or even better than GCA on these datasets. It achieves the highest score on Cora and Facebook, and the second-highest on Amazon-Computers and Amazon-Photo. However, it does not behave well on CiteSeer, where GCA can effectively increase the score of GRACE. To sum up, previous modifications over the grounded frameworks are mostly based on specific knowledge, for example, MVGRL introduces the diffusion matrix to DGI and GCA defines the importance on the edges and features, and they cannot consistently take effect on all datasets. However, ArieL uses the adversarial attack to automatically construct high-quality contrastive samples and achieves more stable performance improvements.

In comparison with the supervised methods, ArieL also achieves a clear advantage over all of them. Although it would be premature to conclude that ArieL is more powerful than these supervised methods since they are usually tested under the specific training–testing split, these results do demonstrate that ArieL can indeed generate highly expressive node embeddings for the node classification task, which can achieve comparable performance to the supervised methods.

The graph classification results are summarized in Table 4. Compared with our basic framework GraphCL, which uses naïve augmentation methods, ArieL achieves even stronger performance on all datasets. GraphCL does not show a clear advantage against previous baselines such as InfoGraph and it does not behave well on datasets with small graph sizes (e.g., NCI1 and MUTAG). However, ArieL can take the lead on three of the datasets and greatly reduce the performance gap on NCI1 with the graph kernel methods. It can be clearly seen that ArieL behaves better than GraphCL on NCI1 and MUTAG, with at least \(1\%\) improvement in accuracy. In comparison with another graph contrastive learning method, InfoGraph, we can also see that ArieL takes an overall lead on all datasets, even on MUTAG, where InfoGraph shows a dominant advantage against other baselines.

The above empirical results on the node classification and graph classification tasks clearly demonstrate the advantage of ArieL on real-world graphs, which indicates the better augmentation strategy of ArieL.

The results on attacked graphs are summarized in Table 5. Specifically, we evaluate all these methods on the attacked subgraph of Amazon-Computers, Amazon-Photo, Coauthor-CS, Coauthor-Physics, Facebook, and LastFM Asia. Thus, their results are not directly comparable to the results in Table 3. To compare with the previous results, we look at the datasets in which ArieL takes the lead and then find the performance of the second-best method on each dataset for both the original graph and the attacked one. If ArieL outperforms the second-best method by a much larger margin on the attacked graph compared with that on the original graph, we claim that ArieL is significantly robust on that dataset.

Under this principle, we can see that ArieL is significantly robust on CiteSeer, with the margin to the second-best method increasing from \(0.58\%\) to \(3.96\%\) , Amazon-Computers, with the margin increasing from \(2.11\%\) to \(3.56\%\) , and Coauthor-CS, with the margin increasing from \(0.74\%\) to \(1.71\%\) . On Coauthor-Physics, ArieL and GCA both show clear robustness against the remaining methods. Although some baselines are robust on specific datasets, for example, MVGRL on Cora, GMI on CiteSeer, GCN on Facebook, and GCA on Coauthor-CS and Coauthor-Physics, they fail to achieve consistent robustness over all datasets. Although GCA indeed makes GRACE more robust for most datasets, it is still vulnerable on Cora, CiteSeer, and Amazon-Computers, with more than \(3\%\) lower than ArieL in the final accuracy.

We can also see that ArieL still shows high robustness on the datasets in which it cannot take the lead. On Cora and Facebook, ArieL is only less than \(1\%\) lower in accuracy than the best method and it is still better than most baselines. It does not show a sudden performance drop on any dataset, such as MVGRL on CiteSeer and GCA on Facebook.

Basically, MVGRL and GCA can improve the robustness of their respective grounded frameworks over specific datasets. However, we find this kind of improvement to be relatively minor. Instead, ArieL has more significant improvements and greatly increases robustness. It is worth noting that though RDGI is also developed to improve the robustness of graph representation learning, it does not show a clear advantage against DGI in our evaluation. This is mainly because the original RDGI considers the attack at test time and what we evaluate is the robustness against the attack at training time, which is more common for the graph learning tasks [2, 66, 67]. Based on the comparative results, we claim that ArieL is more robust than previous graph contrastive learning methods in the face of an adversarial attack.

For this section, we first set \(\epsilon _2\) as 0 and investigate the role of adversarial contrastive loss. The adversarial contrastive loss coefficient \(\epsilon _1\) controls the portion of the adversarial contrastive loss in the final loss. When \(\epsilon _1=0\) , the final loss reduces to the regular contrastive loss in Equation (3). To explore the effect of the adversarial contrastive loss, we fix other parameters in our best models on Cora and CiteSeer and gradually increase \(\epsilon _1\) from 0 to 2. The changes in the final performance are shown in Figure 3.

The dashed line represents the performance of GRACE with subgraph sampling, i.e., \(\epsilon _1=0\) . Although there exist some variations, ArieL is always above the baseline under a positive \(\epsilon _1\) with around \(2\%\) improvement. The subgraph sampling trick may sometimes help the model; for example, it improves GRACE without subgraph sampling by \(1\%\) on CiteSeer. However, it could be detrimental as well, such as on Cora. This is understandable since subgraph sampling can simultaneously enrich data augmentation and lessen the number of negative samples, both critical to contrastive learning. At the same time, for the adversarial contrastive loss, it has a stable and significant improvement on GRACE with subgraph sampling, which demonstrates that the performance improvement of ArieL mainly stems from the adversarial loss rather than the subgraph sampling.

Next, we fix all other parameters and check the behavior of \(\epsilon _2\) . Information regularization is mainly designed to stabilize the training of ArieL. We find that ArieL would experience collapsing at the early training stage and that information regularization could mitigate this issue. We choose the best run on Amazon-Photo, where the collapsing frequently occurs, and similar to before, we gradually increase \(\epsilon _2\) from 0 to 2. The results are shown in Figure 4 (left). As can be seen, without using information regularization, ArieL could collapse without learning anything, whereas setting \(\epsilon _2\) greater than 0 can effectively avoid this situation. To further illustrate this, we draw the training curve of the regular contrastive loss in Figure 4 (right), for the best ArieL model on Amazon-Photo and the same model by simply removing the information regularization. Without information regularization, the model could get stuck in a bad parameter area and fail to converge, whereas information regularization can resolve this issue.

Here, we compare the training of ArieL on node-level contrastive learning to other methods on our NVIDIA Tesla V100S GPU with 32 G memory.

Adversarial attacks on graphs tend to be highly computationally expensive since the attack requires the gradient calculation over the entire adjacency matrix, which is of size \(O(n^2)\) . For ArieL, we resolve this bottleneck with subgraph sampling on large graphs and empirically show that the adversarial training on the subgraph still yields significant improvements without increasing the number of training iterations. In our experiments, we find GMI to be the most memory inefficient, which cannot be trained on Coauthor-CS, Coauthor-Physics, and Facebook. For DGI, MVGRL, GRACE, and GCA, their training also amounts to 30G GPU memory on Coauthor-Physics whereas the training of ArieL requires no more than 8G GPU memory. In terms of the training time, DGI and MVGRL are the fastest to converge. However, it takes MVGRL a long time to compute the diffusion matrix on large graphs. ArieL is slower than GRACE and GCA on Cora and CiteSeer. However, it is faster on large graphs such as Coauthor-CS and Coauthor-Physics, with the training time for each iteration invariant to the graph size due to the subgraph sampling. On the largest graph, Coauthor-Physics, each iteration takes GRACE 0.875 second and GCA 1.264 seconds, while it only takes ArieL 0.082 second. This demonstrates that ArieL has even better scalability than GRACE and GCA.

Subgraph sampling, under some mild assumptions, could be an efficient way to reduce the computational cost for any node-level contrastive learning algorithm. In addition to this general trick, we want to point out that the attack is in fact not always needed on the whole graph to generate the adversarial view. Another solution to avoid explosive memory is to select some anchor nodes and only perturb the edges among these anchor nodes and their features. Since the scalability issue has been resolved by subgraph sampling on all datasets appearing in this work, we will not further discuss the details of this method and empirically prove its effectiveness. We leave this for future work.

Contrastive learning is known for its simplicity and strong expressivity. Traditional methods ground the contrastive samples on the node proximity in the graph, such as DeepWalk [37] and node2vec [9], which use random walks to generate the node sequences and approximate the co-occurrence probability of node pairs. However, these methods can only learn the embeddings for the graph structures regardless of the node features.

GNNs [27, 50] can easily capture the local proximity and node features [19, 22, 51, 62, 63]. To further improve the performance, the Information Maximization (InfoMax) principle [30] has been introduced. DGI [51] is adapted from Deep InfoMax [12] to maximize the mutual information between the local and global features. It generates the negative samples with a corrupted graph and contrasts the node embeddings with the original graph embedding and the corrupted one. Based on a similar idea, GMI [36] generalizes the concept of mutual information to the graph domain by separately defining the mutual information on the features and edges. Graph Community Infomax (GCI) [45] instead tries to maximize the mutual information between the community representation and the node representation for those positive pairs. Another follow-up work of DGI, MVGRL [10], maximizes the mutual information between the first-order neighbors and graph diffusion. On the graph level, InfoGraph [44] makes use of a similar idea to maximize the mutual information between the global representation and patch representation from the same graph. HDI [18] introduces high-order mutual information to consider both intrinsic and extrinsic training signals. However, mutual information-based methods generate the corrupted graphs by simply randomly shuffling the node features. Recent methods exploit the graph topology and features to generate better-augmented graphs. GCC [38] adopts a random walk–based strategy to generate different views of the context graph for a node, but it ignores the augmentation on the feature level. GCA [64], instead, considers the data augmentation from both the topology and feature level, and introduces the adaptive augmentation by considering the importance of each edge and feature dimension. To investigate the power of different data augmentations in graph domains, GraphCL [62] systematically studies the different combinations of graph augmentation strategies and applies them to different graph learning settings. Unlike the above methods, which construct the data augmentation samples based on domain knowledge, ArieL uses an adversarial attack to construct the view that maximizes the contrastive loss, which is more informative with broader applicability.

Deep learning methods are known to be vulnerable to adversarial attacks; this is also the case in the graph domain. As shown by Bojchevski and Günnemann [2], both random walk–based methods and GNN-based methods could be attacked by flipping a small portion of edges. Xu et al. [57] propose a PGD attack and min-max attack on the graph structure from the optimization perspective. NETTACK [66] is the first to attack GNNs using both structure attack and feature attack, causing a significant performance drop of GNNs on the benchmarks. After that, Metattack [67] formulates the poisoning attack of GNNs as a meta-learning problem and achieves remarkable performance by only perturbing the graph structure. Node Injection Poisoning Attacks [46] use a hierarchical reinforcement learning approach to sequentially manipulate the labels and links of the injected nodes. Recently, InfoMax [31] formulated the adversarial attack on GNNs as an influence maximization problem.

The concept of adversarial contrastive learning is first proposed on visual domains [13, 16, 26]. All of these works propose a similar idea to use the adversarial sample as a form of data augmentation in contrastive learning. This can bring better downstream task performance and higher robustness. ACL [26] studies the different paradigms of adversarial contrastive learning by replacing one or two of the augmentation views with the adversarial view generated by PGD attack [32]. CLAE [13] and RoCL [16] use FGSM [8] to generate an additional adversarial view atop the two standard augmentation views. RDGI [56] and AD-GCL [47] are the most relevant work to ours in graph domains. RDGI quantifies the robustness of node representation as the decrease in mutual information between the graph and its embedding under adversarial attacks. It learns a robust node representation by simultaneously minimizing the standard contrastive learning loss and improving the robustness. Nonetheless, its objective sacrifices the expressiveness of the node representation for robustness while ArieL can improve both of them. AD-GCL formulates adversarial graph contrastive learning in a min-max form and uses a parameterized network for edge dropping. However, AD-GCL is designed for the graph classification task only and does not explore the robustness of graph contrastive learning. Finally, all previous adversarial contrastive learning methods do not take scalability into consideration, with visual models and AD-GCL dealing with independent instances and RDGI only working on small graphs, but ArieL can work for both interconnected instances (node embedding) and independent instances (graph embedding) on a large scale.

Some recent theoretical analyses further reveal the vulnerability of contrastive learning. Jing et al. [23] show that dimensional collapse could happen if the variation of the data augmentation exceeds the variation of the data itself in contrastive learning. Wang et al. [54] prove that contrastive learning could cluster the instances from the same class only when the support of different intra-class samples overlaps under data augmentation. The representations learned by contrastive learning may fail in downstream tasks when either under-overlapping or excessive overlapping happens. From these perspectives, searching for adversarial contrastive samples in a safe area is more likely to generate useful representations for downstream tasks.