Contrastive Graph Similarity Networks

2.1 Pairwise Graph Similarity Computation

In graph theory, pairwise graph similarity calculation is a fundamental problem, which is employed to determine how similar a pair of graphs are. It benefits many real-world application tasks such as object tracking, recommender systems, binary code analysis, and similarity search. The establishment of similarity measures is adopted in early works. For example, Zager et al. [52] employ a linear update to obtain node similarity scores and edge similarity scores. Papadimitriou et al. [33] propose five similarity evaluation methods for web graph anomaly detection. These strategies have been widely adopted in the follow-up works [25]. However, the aforementioned techniques mainly rely on original graph architectures and they are learning-free, making it challenging to effectively utilize features provided by nodes and edges. Benefiting from the deep learning advancement, dramatic development has been made by graph similarity computation [40, 53]. Some GSL works rely on computer vision, and use encoders to extract graphs containing attributes from input images, then perform GSL, and design loss-optimized computer vision encoders. For example, Yu et al. [50] convert the Hungarian algorithm to a hard attention mechanism and incorporate a multi-headed attention mechanism for optimizing deep encoders in deep graph matching. An entire end-to-end pipeline for deep networks modeled by Wang et al. [39] is differentiable to parameterize the affinity functions within and across graphs to learn graph similarity. As the advancement of deep encoders inside the CV field, deep graph kernels have been the focus of some recent studies. Though learning a designed kernel function, deep graph kernels measure the similarity scores in substructure space among any two matched graphs [30].

Kernel-based techniques use kernel functions that correspond to the inner product of Reproducing Kernel Hilbert Space (RKHS) to analyze the similarity of two objects. The challenge for kernel-based techniques is to develop an appropriate kernel function that captures the information of the structures while facilitating computation. Yanardag et al. [48] propose a unified framework for learning potential representations of graph substructures, the DGK framework. The framework defines graph-to-graph similarity by using the information on dependencies between substructures to define the potential representation of graph structures by similarity. The Weisfeiler-Lehman (WL) subtree kernel is a commonly used graph kernel basis. Apart from that, the authors give special cases of other two common kernel application frameworks: Graphlet kernels and shortest path-based graph kernels. An unsupervised graph representation learning approach comes from Alrfou et al. [1], attempts to build a learnable encoder to capture the graph structure. A cross-graph attention network is trained for recording the interaction between two embeddings of each graph pair. They use the predictions of the attention-enhanced encoder to define the divergence scores of each pair of graphs. Finally, they use these pairwise divergence scores to construct an embedding space for all graphs, reducing the reliance on domain-specific knowledge (such as, on the WL kernel).

Different from deep graph kernel methods, GNN-based methods are usually based on graph representation learning. GNN-based methods usually use a GNN as the base encoder. Then a cross-graph attention mechanism is performed by GNN-based methods to learn the extent of the nodes matched with each other between two matching graphs [19]. Concretely, SimGNN [2] combines two strategies. First, to offer global information about a graph, SimGNN constructs an embedding function for transforming the input graph pairs into an embedding space. Second, a pairwise node-level comparison framework is created by SimGNN to supplement graph embeddings with fine-grained node information. Finally, the GNN encoder is optimized through a loss carefully designed for the graph similarity problem. In GMN [26], they propose a GSL framework, which receives graph pairs as inputs. By using a matching mechanism based on a cross-graph attention strategy, the GMN framework then calculates the pairwise graph’s similarity score. The matching mechanism then does joint inference on the pair. Afterward, considering that these graph neural networks are limited by the fixed dimension of graph representation, GraphSim [3] finds that the fixed-dimensional graph-level representations may not fully capture different graphs sizes and structures. Therefore, GraphSim designs a node multi-scale graph representation for similarity computation to find fine-grained differences between two graphs. GraphSim breaks the idea of fixed-dimensional vectors, and directly matches two groups of node embeddings to represent the entire graph. MGMN [28] finds that recent works on GSL mainly consider graph-to-graph (G2G) or N2N interactions while ignoring the cross-level interactions (such as, node-to-graph (N2G) interaction information). With end-to-end computation of graph similarity between the two graphs, MGMN suggests a way for effectively learning cross-level graph interactions between nodes in the two different graphs. Unfortunately, the aforementioned models have a common limitation in cross-graph attention mechanism, which is computationally expensive.

2.2 Graph Representation Learning (GRL)

Recently, GRL focuses on learning graph representations by utilising both the topology and attributed information of graphs [18, 51]. It has been applied in many real-world scenarios, such as recommender systems (RSs) and social networks (SNs) [20]. In early works, DeepWalk [34] vectorizes the graph through a random walk algorithm with few network annotation nodes to learn social network embeddings. The key idea of it is inspired by the Skip-gram method of word2vec in NLP [32]. To handle large-scale graph data, LINE [36] maps all of the network’s nodes into an embedding space and then attempts to preserve the network’s original structure in terms of first-degree and second-degree links. The representation of the network nodes is then modeled by processing the word vectors. GNNs have garnered a fair amount of attention as a result of the advancement of deep graph learning [43, 44, 55]. For instance, a technological architectural domain message-passing method is the GGNN, which takes the Gate Recurrent Unit (GRU) as the foundations. Three categories of processing make up the general methodology of message passing: message passing, update, and read operation. The node’s embedding in the next moment is determined by its current moment embedding, as well as the node’s neighbor’s current moment embeddings and the edges information between the two nodes interacting. GCN [24] aggregates the node features with the central node’s neighbors through a weighted average function to create a new representation of the node in the spectral domain. Subsequently, there are many variants methods of GCN have been studied, for example, GAT [37], graph isomorphism network (GIN) [45]. GAT provides a self-attentive mechanism for aggregating neighbor node information to improve the method’s accuracy, resulting in the adaptive matching of weights to different neighbors. GAT can give various weights to different nodes in the neighborhood without any kind of expensive matrix operations (e.g., inversion) or depending on the pre-knowledge of the graph structure. GIN analyzes GNNs based on graph isomorphism theory, and proves that the WL test is the upper bound of GNN performance. Graph isomorphism is also an important indicator of GSL and the Weifeiler-Lehman test is a powerful algorithm for distinguishing graph structures and can discriminate whether a graph is isomorphic or not. GIN demonstrates that it has equivalent expressive/discriminative abilities to the WL test.

2.3 Contrastive Learning

In self-supervised learning, contrastive learning is an emerging technology that cannot be ignored and originates from computer vision. Contrastive learning compares minute variations across samples in the embedding space for differentiating representation of samples. Recent years have seen a lot of fascinating works. For example, MOCO [15] translates contrastive learning into a dictionary lookup system, where they construct dynamic dictionaries with queues and average-shift encoders. This allows the construction of large and consistent dictionaries to facilitate contrastive unsupervised learning. SimCLR [6] simplifies recently proposed contrastive self-supervised learning algorithms without the need for specialized architectures or memory banks. SimCLR demonstrates that developing effective prediction tasks depends heavily on data augmentation and introduces learnable nonlinear transformations between representations and contrastive losses, which greatly contributes to the quality of learned representations. This is not only true for color distortion but also for other types of data transformations. In general, contrastive training is more sensitive to systematic bias in the data. In machine learning, data bias is a widespread problem, which has a greater impact on contrastive methods (e.g., color distortion). Grill et al. [12] propose BYOL, a contrastive learning method that can not rely on negative sampling and thus avoids the data bias problem. BYOL does not care whether different samples have different representations (i.e., the contrast part of contrastive learning), but simply makes similar samples similarly represented. It may seem inconsequential, but such a setup will significantly improve model training efficiency and generalization. In training, each sample is only sampled once per traversal, and there is no need to focus on negative samples. Since no negative sampling is required, BYOL has higher training efficiency. The BYOL model is insensitive to the systematic bias of the training data, which means that BYOL can have better applicability to unseen samples as well. Barlow Twins [54] doesn’t take into account many complex tricks, such as data augmentation, negative samples, networks of momentum update, predictor and stop gradient operations. Barlow Twins tries to learn the representation from a different perspective, starting from the embedding itself, rather than from the samples. The optimization goal is to make the correlation matrix of the features in different perspectives close to the constant matrix, i.e., making the features in different dimensions represent different information as much as possible can improve the representational power of the features. Given the excellent performance of contrastive learning, some work has introduced contrastive learning into the supervised models, and excellent results have been obtained. For example, to use label information efficiently, some researchers, i.e., Khosla et al. [23], recently adapts a self-supervised contrastive learning method for properly using in a fully supervised setting. In particular, nodes with the same label are brought together while clusters of data from distinct categories are pushed apart in the embedding space.

In addition to computer vision, contrastive learning is an emerging approach for GRL and it works for self-supervised learning [56, 57]. In contrastive learning, the principal objective is to continue improving the mutual information between the two semantically similar instances that have been constructed from the data itself. Contrastive learning reaches state-of-the-art (SOTA) performance [6, 29, 42, 56] and has been applied to graph data. For instance, DGI [38] maximizes the mutual information of local information and global information to enhance representations. By discriminating between the local-global representations, MVGRL [14] is presented in a new way by using contrastive multi-view representation learning for the graph representation learning underlying the DGI idea. GraphCL [49] proposes a graph-level contrastive learning method with four types of graph augmentation technologies. However, all contrastive-learning-based methods are only designed for a single graph representation. This scheme is not suitable for GSL, which normally takes two graphs as input to compare the difference. To fill this gap, we propose CGSim, which can build contrastiveness between different graphs.

3.1 Problem Definition

Suppose that \(G =(V, E, X)\) be an undirected graph with a node set V and an edge set E, where \(E \subseteq V \times V\). \(|\cdot |\) is denoted as the cardinality of numbers. Specifically, \(|V|\) represents the number of nodes. \(X \in \mathbb {R}^{|V| \times d}\) denotes features of nodes, where d is features’ dimension. The similarity scores between two input graphs are defined in terms of the following:

Our object is to train a learnable GNN encoder that regards a pair of graphs as input, and outputs their low-dimensional representations for similarity computation. The trained encoder can then be applied to any unseen graph pairs for similarity calculation during the inference phase. The calculated two graph cosine similarity scores are used in subsequent downstream tasks related to graph similarity.

3.2 Solution Overview

According to the two limitations we mentioned in Section 1, we design the CGSim foundation upon the following intuitions:

Intuition 1. Responsibility of Representations. The graph similarity computation is conducted based on the graph embeddings of input pairs. To create unified dimensional representations that may be used to quantify similarity, graph pairs need to be first mapped to the same low-dimensional space to get unified dimensional representations. Thus, learning representations that well persist in the original graph’s complexity information is essential to the success of this measurement. Graph-level representations are pooled from node-level representations. Therefore, using GNN to learn complex node-level representations to fully express the properties of nodes is one of the key designs in our similarity learning.

Intuition 2. Capability of Cross-graph Interaction. One of the important methods for improving the computation of graph similarity scores is to establish the correspondence between the nodes in two graphs. To enable effective graph matching, a cross-graph interaction module is required to exploit the pairwise relations for graph representation learning. As far as we know, current works normally employ attention mechanisms for cross-graph interactions between nodes. Specifically, each node in one graph needs to perform attention calculations with all nodes in the other graph. The time complexity of these cross-graph attention mechanisms is \(O(|V_1||V_2|)\), which is not conducive to application in real-world datasets. This is because learning the 1-versus-all correspondence (i.e., attending all nodes in another graph with a target node to discover the correspondence) is computationally expensive. The ideal cross-graph interaction module should have a low-computational cost as well as a high representation capability. Contrastive learning, which naturally takes two graphs as input, is a promising solution for cross-graph interaction.

Overall Framework. Following the intuitions, we combine graph representation learning with contrastive learning in a unified framework to learn graph similarity. The overview of our proposed model CGSim, which consists of four components: (a) input graphs, (b) GNN module, (c) cross-graph contrastive learning module, (d) combinatorial loss module, is shown in Figure 2. To train our model, we first input the graph pairs into a GNN module, which outputs node-level embeddings. By aggregating node embeddings, a graph pooling technique can generate embeddings at the graph level. Then, we construct a dual contrastive learning framework with a node-graph matching and a graph-graph matching scheme utilizing the generated different level embeddings. Besides, we refine the generated embeddings by further exploiting the supervision signals with the BCE loss. We jointly train a combinational loss that consists of the aforementioned parts (i.e., node-graph contrastiveness, graph-graph contrastiveness, and cross-entropy loss), so that each component can be beneficial to another. We will discuss more detailedly about these components of CGSim in the following sections.

Fig. 2.

View Figure

3.3 Representation Learning

As shown in Figure 2(a) and 2(b), the first two components of our suggested method (input graphs and GNN module) are illustrated in this section. A siamese network is designed for the purpose of distinguishing visual differences in computer vision by measuring the similarity between two input images [4]. Two inputs are supplied into two neural networks of a siamese neural network. The inputs are mapped to the new space by the two neural networks with the same weight. The similarity of the two inputs is measured by the loss calculation. Generally, a siamese network includes two neural networks with the same parameters, which leads to more robust semantic similarity learning. The architecture of the siamese network natural fits for GSL, which can introduce inductive biases for identifying invariant patterns of similar objects [7, 8, 31]. In our method, we adopt a siamese network architecture as our backbone. Specifically, in our method, the GNN module is made up of two GNN encoders with shared learnable weights. To estimate the matching score of two graphs, we first need to embed two graphs into the vector space. Here, we employ a GNN encoder to acquire node representations by collecting nodes’ local structure information. The GNN encoder may be considered a feature extractor for graphs, which mainly consists of message aggregation and transformation. Specifically, GNN updates node representations iteratively by aggregating its neighboring representations. The whole process is defined as (2) \(\begin{equation} \begin{aligned}h_v^{(l)} &= \texttt {Agg}^{(l)}\left(h_u^{(l-1)} :u\in N(v)\right),\\ h_v^{(l)} &=\texttt {Trans}^{(l)}\left(h_v^{(l-1)}, h_v^{(l)}\right), \end{aligned} \end{equation}\) where \(h_v^{(l)}\) is the representation vector of a node v at the lth layer and \(N(v)\) represents a node sets adjacent to v [45]. Agg(\(\cdot\)) is an aggregate function that aggregates the neighbors’ information to the node itself and Trans(\(\cdot\)) is the transform function that transforms the message to update a new embedding. Then, the graph-level representation \(h_G\) can be obtained via mean-pooling, denoted as Avg(\(\cdot\)) below: (3) \(\begin{equation} h_G = \texttt {Avg}(h_v: v\in V). \end{equation}\) The graph representation learning module is the basic framework of subsequent work. After obtaining graph-level and node-level representations, we perform subsequent cross-graph interaction computation in the following.

3.4 Cross-graph Contrastive Matching

One of the primary limitations of the cross-graph matching mechanism is high computational complexity \(O(|V_1||V_2|)\), which limits the computing capacity of GSL. To confront this challenge, we introduce a low-complexity dual cross-graph contrastive learning module, which allows our model to learn cross-level interactions (i.e., node-graph matching and graph-graph matching) both effectively and efficiently. Graph-graph contrastiveness learns coarse-grained matching between graphs, whereas node-graph contrastiveness learns fine-grained matching between nodes and graphs. Our method reduces the complexity to \(O(|V_1|+|V_2|)\), while maintaining competitive performance.

Contrastive Node-Graph Matching. To reduce the excessive calculational cost, we construct a contrastive node-graph matching mechanism for cross-graph information distillation instead of associating node representations in one graph to node representations in its counterpart pairwisely. Aggregating node embeddings in a graph yields a graph-level embedding, which is an average representation of the node embeddings, and the dimensions of it are the same to the node embeddings, we try to use a graph embedding of one graph to take the place of node embeddings in the other graph. To further explore the matching relations between node representations and graph representations, we construct a cross-graph contrastive learning method based on the following intuitions: if two graphs are similar, all node embeddings in \(G_1\) should be close to the graph-level embedding of \(G_2\). Conversely, if two graphs are different, then node embeddings in \(G_1\) and the graph embedding in \(G_2\) should be pushed away from each other. To achieve such strategies, we exploit mutual information to investigate the correlation between the node embeddings \(h_v\) and the graph embedding \(h_G\) [6, 59]. For an input graph pair \((G_1,G_2)\), we define the node-graph mutual information MI\(_{NG}\) between two graphs as (4) \(\begin{equation} \begin{aligned}\texttt {MI}_{NG}(h_{v}, h_{G_2}) := \sum \limits _{v \in |V_1|}\mathbb {E}(\theta \left(h_{v}, h_{G_2} \right) / \tau), \end{aligned} \end{equation}\) where \(\mathbb {E}(\cdot)\) is an exponential function and \(\tau\) is a temperature parameter that regulates the model’s sensitivity to negative samples. The temperature parameter’s role is to modify the level of focus on challenging samples. The sample is distinguished from the most comparable other samples with greater care as the temperature parameter decreases. To guide message interaction, as shown in Figure 3, we use supervision signals to distinguish whether the input pairs are positive (similar) or negative (dissimilar). In the training dataset, each pair of graphs contains a ground truth label, which represents whether the pair is similar or dissimilar. According to these ground truth labels, we regard similar graph pairs as positive samples, and dissimilar pairs as negative samples. A batch with size K contains positive graph pairs and negative graph pairs. We regard \((h_{G_1},h_{G_2})\) as a graph pair, \((h_{G_1},h_{G_2})_p\) as a positive pair and \((h_{G_1},h_{G_2})_k\) as a graph pair in the batch. We expect to maximize the mutual information between node embeddings \(h_v\) in \(G_1\) and the graph embedding \(h_{G_2}\) for positive pairs. For negative pairs, we should minimize the mutual information between \(h_v\) in \(G_1\) and \(h_{G_2}\) in vector space. Therefore, we define the node-graph loss as (5) \(\begin{equation} \ell _{NG}(h_{G_1},h_{G_2}) = -\log \frac{\sum \nolimits _{p=1}^P \texttt {MI}_{NG}(h_{v},h_{G_2})_p}{\sum \nolimits _{k=1}^K \texttt {MI}_{NG}(h_{v},h_{G_2})_k}, v \in G_1, \end{equation}\) where P is the number of positive pairs in batch size K. By means of the negative, the node-graph loss maximizes the mutual information between positive sample pairs as well as minimizes mutual information between negative sample pairs. Noticed that operations on graph pairs should be symmetric for effects on balance. We defined the final loss \(\ell _{NG}\) as the average of the positive pair to reduce inaccuracy: (6) \(\begin{equation} \mathcal {L}_{NG}(h_{G_1}, h_{G_2})=\frac{1}{2} \left[ \ell _{NG}(h_{G_1},h_{G_2})+\ell _{NG}(h_{G_2},h_{G_1})\right]\!. \end{equation}\)

Fig. 3.

View Figure

Contrastive Graph-Graph Matching. We use node-level embeddings to learn cross-graph interactions with fine-grained contrastiveness, and the global information of graphs is also valuable that cannot be ignored. Thus, we further enrich the contrastiveness with a proposed graph-graph matching (i.e., contrasting between graph-level embeddings) to consolidate the learned representations of graphs. Intuitively, if two graphs are similar, they should keep a high agreement, that is, their mutual information should be maximized and vice versa. In one batch, for positive samples, we enlarge the agreement between the two graphs. For negative samples, we expand their differences macroscopically. We define the graph-graph mutual information MI\(_{GG}\) between two graphs as (7) \(\begin{equation} \begin{aligned}\texttt {MI}_{GG}(h_{G_1}, h_{G_2}) := \mathbb {E}(\theta \left(h_{G_1}, h_{G_2} \right) / \tau). \end{aligned} \end{equation}\) Thus, the aforementioned processes can be formulated with the following loss functions: (8) \(\begin{equation} \ell _{GG}(h_{G_1}, h_{G_2}) = -\log \frac{\sum \nolimits _{p=1}^P \texttt {MI}_{GG}(h_{G_1}, h_{G_2})_p}{\sum \nolimits _{k=1}^K \texttt {MI}_{GG}(h_{G_1}, h_{G_2})_k}. \end{equation}\) Because the operations on \(G_1\) and \(G_2\) is interchangeable, we design the average loss to reduce the error, and the final objection is defined as (9) \(\begin{equation} \mathcal {L}_{GG} (h_{G_1}, h_{G_2})= \frac{1}{2} \left[\ell _{GG}(h_{G_1}, h_{G_2}) + \ell _{GG}(h_{G_2}, h_{G_1})\right]\!. \end{equation}\) To take full advantage of supervision signals, we formulate the optimization object by establishing the relationship between ground truth and the calculated similarity score. Specifically, we employ a binary cross-entropy loss (BCE loss) to minimize distance among the calculated similarity score \(\theta (h_{G_1}, h_{G_2})\) and the given similarity indicator y: (10) \(\begin{equation} \mathcal {L}_{BCE}(h_{G_1}, h_{G_2},y) = \sum _{k = 1}^{K}\texttt {BCE}(\theta (h_{G_1},h_{G_2})_k, y). \end{equation}\)

The BCE loss provides a directed optimization goal for the guarantee of representation. It is discovered that the graph-graph matching loss differs from the BCE loss. Because the similarity score is used as the optimization goal in the BCE loss for graph representation learning. Graph-graph loss is a subsidiary part of the cross-graph matching module, which tries to learn complementary information from different graphs.

3.5 Objective Function

We design a combinatorial loss that is composed of (i) the node-graph contrastiveness loss (Equation (6)), (ii) the graph-graph contrastiveness loss (Equation (9)), and the BCE loss for similarity score adjustment (Equation (10)) to train the whole model in an end-to-end manner. The goal is to minimize the combinatorial loss \(\mathcal {L}\), which is calculated as follows: (11) \(\begin{equation} \mathcal {L} = \alpha \mathcal {L}_{NG}+ \beta \mathcal {L}_{GG} +\lambda \mathcal {L}_{BCE}, \end{equation}\) where \(\alpha\), \(\beta\), and \(\lambda\) are weight parameters. We define that \(\alpha\), \(\beta\), and \(\lambda\) as tunable parameters to regulate the three losses’ impacts (\(\mathcal {L}_{NG}\), \(\mathcal {L}_{GG}\), and \(\mathcal {L}_{BCE}\)). We set the constraint \(\alpha +\beta +\lambda = 1\) to ensure these parameters are in range \([0, 1]\) and weightily summed to 1. This demonstrates how each loss function contributes to the overall loss. We employ the gradient descent to minimize \(\mathcal {L}\) so that three kinds of losses can be trained simultaneously. Therefore, the graph representation learning part and the cross-graph contrastive learning part are not isolated but benefit from each other. The BCE loss optimizes the inputs of cross-graph contrastive learning, in turn, cross-graph contrastive learning also promotes the expression of nodes and graphs. Algorithm 1 depicts a brief description of CGSim.

Model advantages. We present the advantages between our proposed method CGSim and recent studies from two perspectives: (1) responsibility of representations and (2) capability of cross-graph matching. First, CGSim integrates graph representation learning and cross-graph contrastive learning into a unified framework, which facilitates the message propagation in and cross graphs. Second, CGSim reduces the time complexity for cross-graph interaction modeling from \(O(|V_1||V_2|)\) (1-versus-all) to \(O(|V_1|+|V_2|)\) (1-versus-1). This is a significant improvement over existing methods such as GMN [26]. The experiments later will show the superior performance of our proposed framework.

4.1 Q1: Effectiveness of CGSim

To respond to Q1, we evaluate CGSim comparing with the aforementioned baselines on various datasets. The experimental results for OpenSSL and FFmpeg are shown in Tables 3 and 4. Column “[3, 200]” represents the AUC score on dataset [3, 200], “\(-\)” denotes no gain and “\(\pm\)” indicates a numerical range. Column “Outperform (OP)” shows effectiveness of CGSim over other algorithms. Compared results are quoted from the MGMN [28]. The CGSim model performs the best compared with baselines using the AUC score. We can find those graph similarity methods, SimGNN, GMN, GraphSim and MGMN (Max + BiLSTM) performed comparatively poorly. CGSim outperforms all baseline methods, which can be attributed to the dual cross-graph contrastive mechanism. We develop a node-graph contrastive mechanism and graph-graph contrastive mechanism for cross-graph interaction, which not only promotes the message cross-graph propagation but also enriches the graph representation learning in the process of optimization. Though MGMN also considers a multi-level attention mechanism for cross-graph interaction, it heavily relies on the combination of different pooling operations, (i.e., BiLSTM with learnable parameters). With a naive pooling mechanism, mean pooling, CGSim achieves similar or better results than MGMN, which demonstrates the effectiveness of our proposed dual cross-graph contrastive learning. It is of importance to mention that our proposed method CGSim significantly improves graph similarity learning in OpenSSL [50, 200] and FFmpeg [50, 200], which indicates our approach works well on large graph-size datasets.

4.2 Q2: Contribution of \(\mathcal {L}_{NG}\), \(\mathcal {L}_{GG}\), \(\mathcal {L}_{BCE}\)

To analyze the contribution of \(\mathcal {L}_{NG}\), \(\mathcal {L}_{GG}\), \(\mathcal {L}_{BCE}\), we conduct a combinational experiment on the parameters \(\alpha\), \(\beta\) and \(\lambda\). We implement the CGSim on OpenSSL [50, 200]. Table 5 shows the average performance of five experimental iterations. For a single loss comparison, \(\mathcal {L}_{GG}\) provides the best performance, which indicates graph-graph matching strategy \(\mathcal {L}_{GG}\) is superior to the graph representation learning model without cross-graph interaction (i.e., \(\mathcal {L}_{BCE}\)). For a combination of two losses, the \(\mathcal {L}_{NG} + \mathcal {L}_{BCE}\) achieve the highest performance. The best result is produced by the simultaneous application of three losses, which indicates that all mechanisms are effective. As long as \(\alpha =0.4\), \(\beta =0.4\) and \(\lambda =0.2\), CGSim achieves the best results 97.70 on OpenSSL [50, 200]. Accordingly, results can be concluded that both the dual cross-graph contrastive learning as well as graph representation learning can be used to improve the quality of graph similarity learning.

4.3 Q3: Efficiency of CGSim

In this section, we choose MGMN as the baseline to be compared with CGSim. This is because MGMN is the best-performed baseline according to Tables 3 and 4. Furthermore, MGMN is one of the GSL baselines with the lowest time complexity [28]. We record the running time of training 100 epochs on the cross-graph interaction procedure. Figure 4 shows that CGSim consumes much less time in cross-graph interaction. Compared with MGMN, the speed of CGSim is improved by 2 to 4 times in general, which is a huge improvement. As a result of the experiment, we also demonstrate that CGSim has better efficiency than the baselines we are comparing.

Fig. 4.

View Figure

4.4 Others: Analysis of Hyperparameters

In Figure 5, we report the influence of hyperparameters, including parameter \(\tau\) (in Equation (3)) and batch size. These experiments are carried out on the OpenSSL [50, 200] dataset. In Figure 5(a), we report the CGSim performance among a given batch size range. When adding the batch size from 2 to 16, the performance steadily rises. Then, we further increase the batch size, and the performance fluctuates. In Figure 5(b), we report the effect on parameter \(\tau\). There is no doubt that the performance of CGSim improves as the \(\tau\) value grows until it reaches a figure of 0.7. after that, it gradually leveled off. As we can see from the figure above, different \(\tau\) values can have an impact on the model in a significant way. For this reason, we set the \(\tau =0.7\) and batch size as 16 for our model to avoid over-tuning these parameters (such as \(\tau\)) for various datasets and tasks as well as taking resource consumption into consideration.

Fig. 5.

View Figure