A Novel Source Code Clone Detection Method Based on Dual-GCN and IVHFS

Abstract

Source code clone detection, which can identify code fragments with similar functions, plays a significant role in software development and quality assurance. Existing methods either extract single syntactic or semantic information, or ignore the associated information between code statements in different structures. It is difficult for these methods to effectively detect clone pairs with similar functions. In this paper, we propose a new model based on a dual graph convolutional network (GCN) and interval-valued hesitant fuzzy set (IVHFS), which we named DG-IVHFS. Specifically, we simplified and grouped the abstract syntax tree (AST) of source code to obtain the group representations. The group representations of the AST, as well as the control flow graph (CFG) representations, were transformed into graph structures, and then we applied GCNs on them to learn dependencies between nodes. In addition, we introduced IVHFS into the model for a more comprehensive evaluation of similarity. Our experimental results demonstrated that the precision, recall, and F1-scores of DG-IVHFS on the BigCloneBench and GoogleCodeJam datasets reached 98, 97 and 97% and 98, 93 and 95%, respectively, exceeding current state-of-the-art models. Moreover, our model performed well in terms of time consumption.

1. Introduction

Code cloning refers to two identical or similar code fragments. It enables faster software development and can save developers’ time and effort. However, the misuse of code cloning is a great problem in software development, so the research of code clone detection has received wide attention in software engineering.

Code clones include syntactic clones and semantic clones. Based on these two categories, code clones can be further separated into Types 1–4 [1]. Types 1–3 are syntactic clones and Type 4 is a semantic clone. The purpose of code clone detection is to evaluate the similarity between two code snippets. As Type 4 clones contain highly distinct clones on the syntactic level, they differ significantly in text, making it the most difficult type to detect.

1.1. Related Work

Current clone detection methods mainly include token-based, text-based, tree-based, graph-based and hybrid methods.

Token-based methods [2,3,4,5,6] transform the source code into token sequences, scan them, and find reduplicate subsequences to complete code clone detection. CCFinder [3] utilizes lexical analysis to extract token sequences from the source code and transforms them using transformation rules. All the substrings on the transformed token are used for match detection. CCAligner [4] uses a code window that considers a mismatch index and asymmetric similarity coefficient to calculate similarity.

Text-based methods [7,8,9,10,11] treat the code as a series of strings to compare two pieces of source code. NiCad [7] treats source code as code text and compares the sequences of text. Ducass et al. [8] designed a method that detected code clones by treating source code as strings and matching them for similarity assessments.

Although token-based and text-based methods need little time to execute, they cannot deal with the detection of Type 4 clones or even Type 3 clones because they do not consider code structure information. In order to overcome the disadvantages of the above clone detection methods, researchers have started to focus on the structure of source code and proposed tree-based and graph-based methods.

Tree-based methods [12,13,14,15,16,17,18,19,20] convert the code into an abstract syntax tree (AST) and perform a series of operations on the AST to obtain the structure information of the code. Deckard [12] generated feature vectors according to AST subtrees to represent the code. CDLH [14] uses an AST-based long short-term memory (LSTM) to learn hash codes while considering the syntactic and lexical information of code. ASTNN [15] splits the original AST into multiple statement subtrees and encodes them, then generates a vector representation of the AST. TreeCen [19] represents the AST into a tree graph and adopts specific analyses to transform it into a vector. Wu et al. [20] proposed a method that converted the AST into a Markov chain-based matrix and measured the distance of two matrices.

Graph-based methods [21,22,23,24,25,26] represent code as graphs to extract structure information from it, such as the control flow graph (CFG) or program dependency graph (PDG). Komondoor [21] and Krinke [22] matched subgraphs to identify the similarity of two code fragments. DeepSim [23] encodes data flow and control flow into matrices, then utilizes feedforward neural networks to detect code clones.

ASTs can effectively represent the syntactic structure of the code, but they cannot represent the control flow structure between code statements. CFGs do not contain information of low-level syntactic structures within code blocks and methods using PDG suffer from scalability problems and high time costs. Due to the limitations of trees and graphs in code representations, syntactic and semantic features of source code cannot be comprehensively obtained using graph-based or tree-based methods alone. Therefore, hybrid methods [27,28,29,30] have been proposed. FCCA [28] uses code tokens, AST and CFG to represent the code. Tree-based LSTM is used to process the AST, but it lacks the ability to explore the dependency relationships between statement nodes. FA-AST [29] takes AST as the main part and adds sequential execution, $While$ loop, $For$ loop and other basic control flows to it. However, FA-AST ignores structures such as $Do$-$While$ statements and $Case$ blocks, resulting in insufficient learning of semantic information in some code fragments. Moreover, current hybrid methods do not effectively deal with ASTs, resulting in important syntactic features being susceptible to interference from redundant nodes and long training times. In contrast, the model proposed in this paper simplifies AST structure while capturing the semantic and syntactic dependencies between statement nodes.

1.2. Contributions

We propose a new model DG-IVHFS, which is based on a dual graph convolutional networks (GCN) and interval-valued hesitant fuzzy set (IVHFS). A simplified and grouped AST (SGA) was constructed, and the multiple layers of GCN were applied on the SGA and CFG to capture dependencies between nodes in different representations. Specifically, we removed the redundant nodes in the AST to enhance the connections between key nodes, then divided the simplified AST into multiple groups. We used the attention mechanism and bidirectional gated recurrent unit (Bi-GRU) to obtain the group representations. In order to obtain the semantic and syntactic information of the code more comprehensively and accurately, we constructed the CFG-GCN and SGA-GCN to process CFG and group representations. The Dual-GCN enhanced the syntactic and semantic representations by aggregating features of neighbors. In addition, we used IVHFS to complete better feature fusion. For the semantic and syntactic feature matrices enhanced by Dual-GCN, we designed corresponding membership functions to utilize the information contained in each vector of the matrices, which allowed for a comprehensive similarity evaluation.

In summary, the main contributions are as follows:

• Considering the complex structure of AST, we design a new representation of syntactic features that simplifies the structure of AST while preserving important syntactic information and making subsequent convolution operations more convenient.
• We propose a Dual-GCN to learn the relationships between statements, which enhances the syntactic and semantic features of the source code.
• We introduce IVHFS into the model and develop a new feature fusion method, which enables our model to achieve accurate similarity calculations. Subsequent ablation experiment results demonstrate the effectiveness of IVHFS.
• To verify the time performance and effectiveness of DG-IVHFS, we conduct experiments on BigCloneBench and GoogleCodeJam datasets. Our experimental results demonstrate that DG-IVHFS achieves a significant improvement over other baseline methods.

The rest of this paper is organized as follows: Section 2 defines the problem. Section 3 describes our method in detail. Section 4 provides the experimental design, results, discussions, and limitations of our model. Section 5 concludes our work.

2. Problem Definition

Given the two code fragments $C_i$ and $C_j$, we use the form of a triple $(C_i,C_j,y_{ij})$ to represent them, where $y_{ij}$ is the label. If $(C_i,C_j)$ is a clone pair, then $y_{ij}=1$; otherwise $y_{ij}=0$. For example, $sum\_fun1.java$ in Listing and $sum\_fun2.java$ in Listing implement the sum from 1 to $n-1$ through a $for$ loop and a $while$ loop, respectively. They perform the same semantic function, although their syntactic structures are different. Therefore, they belong to Type 4 clones, and the label between them is set to 1.

Listing 1. $sum\_fun1.java$

Listing 2. $sum\_fun2.java$

A training dataset $\left\{(C_i,C_j,y_{ij})\right|i,j\in n,i<j\left)\right\}$ with labels can be constructed from n code fragments $\{C_1,C_2,\cdots ,C_n\}$. We aim to train a deep learning model to learn two functions, $\varphi$ and $\omega$, where $\varphi$ and $\omega$ map code fragment into syntactic feature matrix M and semantic feature matrix N, respectively, so that for any code pair $(C_i,C_j)$, the similarity $S_{ij}$ between $\{M_i,N_i\}$ and $\{M_j,N_j\}$ calculated by IVHFS theory is as close as possible to $y_{i,j}$:

$$S_{ij}=\mathrm{IVHFS}(\{M_i,N_i\},\{M_j,N_j\}),$$

(1)

where $\{M_i,N_i\}=\{\varphi \left(C_i\right),\omega \left(C_i\right)\}$, $\{M_j,N_j\}=\{\varphi \left(C_j\right),\omega \left(C_j\right)\}$ and $S_{ij}\in [0,1]$.

In the prediction phase, in order to infer whether two code fragments were a clone pair, we set a threshold k between true and false clone pairs. If the predicted similarity was greater than k, two code fragments were considered a clone pair; otherwise, they were considered a non-clone pair.

3. Material and Methods

We propose a novel code clone detection method called DG-IVHFS. The overall framework is shown in Figure 1. It includes three main parts: (a) initial representation generation, (b) Dual-GCN and (c) feature fusion and similarity calculation. Initial representation generation includes syntax representation generation and semantics representation generation.

3.1. Syntax Representation Generation

The process of syntax representation generation involves three steps: simplifying and grouping AST, group embedding and generation of dependencies.

3.1.1. Simplifying and Grouping AST

Most of the nodes in the AST are attribute nodes with weak connection information, which weaken the relationships between important nodes. Figure 2 shows the whole AST of the code fragment $sum\_fun1.java$. It shows that the AST structure is quite complex, even for a function with a simple $for$ loop, and most attribute nodes are redundant. For example, the attribute node $body$ weakens the relationship between $MethodDeclaration$ and $ForStatement$.

For this reason, we removed the redundant nodes from the original AST and then reconstructed the tree. We extracted the AST from source code fragments using javalang [31]. Given a group of AST nodes N, for the nodes in N, we removed them if they were attribute nodes. Significantly, we considered $Declaration$ and $Statement$ as special attribute nodes, such attribute nodes were kept because they contain strong connection information. In order to assure the wholeness of the tree, we connected the child nodes of deleted nodes directly to the parent nodes of deleted nodes and rebuilt the connections between the nodes. Taking the AST in Figure 2 as an example, the simplified AST is shown in Figure 3.

Even when the AST is simplified by removing most attribute nodes, the simplified AST still has high complexity if the source code is complicated. Thus, if the GCN is directly applied to the simplified AST, the convolutional process will become complex due to the high number of AST nodes; this is not conducive to learning dependencies between nodes. Therefore, we designed an approach to group the simplified AST. Specifically, we traversed the simplified AST using a depth-first traversal algorithm to obtain the sequence of nodes $X=[x_1,x_2,\cdots ,x_n]$ and mark the $Declaration$ and $Statement$ nodes, then divide these marked nodes and their respective leaf nodes into a group. As shown in Figure 3, the nodes in a dotted box are a group. Finally, we can obtain the grouped node sequence $S=[s_1,s_2,\cdots ,s_i,\cdots ,s_g]$, where g represents the number of groups.

3.1.2. Group Embedding

Given a group $s_i$, the node embedding ${\mathbf{E}}_i=[{\mathbf{e}}_1,{\mathbf{e}}_2,\cdots ,{\mathbf{e}}_w]$ was obtained by using word2vec [32], where w denotes the number of nodes in this group. Then, we used the attention mechanism to generate a group representation of $s_i$:

$${\mathbf{v}}_t=\tan \mathrm{h}(\mathbf{W}{\mathbf{e}}_t,\mathbf{b}),$$

(2)

$${\alpha }_t=\frac{exp({\mathbf{v}}_t^{\top }·{\mathbf{v}}_a)}{{\sum }_{k=1}^{w}exp({\mathbf{v}}_k^{\top }·{\mathbf{v}}_a)},$$

(3)

$$\mathbf{r}=\sum _{t=1}^w{\alpha }_t·{\mathbf{e}}_{\mathbf{t}}.$$

(4)

In Formula (2), a linear layer converts ${\mathbf{e}}_t$ into the hidden representation ${\mathbf{v}}_t$. Formula (3) uses the softmax function to generate a weight coefficient for the t-th node in the group. ${\mathbf{v}}_a$ is a randomly initialized context vector, which is constantly learned during model training. Group representation $\mathbf{r}$ was obtained by a weighted summation of all nodes in the group according to Formula (4). The generation process of group representation is shown in Figure 4.

To capture the naturalness of all groups, we fed the matrix $\mathbf{R}=\{{\mathbf{r}}_1,{\mathbf{r}}_2,\cdots ,{\mathbf{r}}_g\}$, which contained the representations of all groups, into Bi-GRU:

$$\mathbf{H}=\mathrm{Bi}-\mathrm{GRU}\left(\mathbf{R}\right)=\{{\mathbf{h}}_{\mathbf{1}},{\mathbf{h}}_{\mathbf{2}},\cdots ,{\mathbf{h}}_{\mathbf{g}}\},$$

(5)

where g means the number of groups generated in Section 3.1.1.

3.1.3. Dependencies Generation

Before performing graph convolution operations, the dependencies between groups need to be constructed. If the attribute nodes in two groups have a father-child relationship on the simplified AST, we believe the two groups are interdependent. For the values of the dependencies between any arbitrary two groups $s_i$ and $s_j$, we have the following regulations:

$$A_{ij}=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}{s}_i\mathrm{and}{s}_j\mathrm{are}\mathrm{interdependent}\hfill \\ 0,\hfill & \mathrm{otherwise}\hfill \end{array}\right..$$

(6)

Then, the dependencies matrix ${\mathbf{A}}^{\mathrm{sga}}$ is obtained.

3.2. Semantics Representation Generation

Figure 5 gives the CFG of the source code $sum\_fun1.java$. The CFG describes the logical structure and execution order of code snippets, and these structures can be easily located from the CFG. Therefore, we use the CFG to capture semantic structure information of the code snippets.

We used Soot [33] to generate CFGs from source code fragments. A CFG is composed of a node sequence $X{}^{\prime }=\left[x_1{}^{\prime },x_2{}^{\prime },\cdots x_i{}^{\prime },\cdots ,x_j{}^{\prime },\cdots ,x_m{}^{\prime }\right]$ and a set of directed edges that represent the execution order of statements. The edges represent the control flows between nodes. According to these edges, we construct the adjacency matrix ${\mathbf{A}}^{\mathrm{cfg}}$ of CFG. For the elements in ${\mathbf{A}}^{\mathrm{cfg}}$, $A_{ij}^{\mathrm{cfg}}=1$ if there is a directed edge of node $x_i{}^{\prime }$ pointing to node $x_j{}^{\prime }$, otherwise $A_{ij}^{\mathrm{cfg}}=0$. Then, the statements are converted into corresponding vector representations $\mathbf{H}{}^{\prime }=\{{\mathbf{h}}_1{}^{\prime },{\mathbf{h}}_2{}^{\prime },\cdots ,{\mathbf{h}}_m{}^{\prime }\}$ using Doc2Vec [34].

3.3. Dual-GCN

In this section, we design the Dual-GCN to explore the dependencies between nodes in trees and graphs and enrich the feature representations. The Dual-GCN is composed of SGA-GCN and CFG-GCN.

3.3.1. Related Theory

Traditional convolutional neural networks and recurrent neural networks are very effective in extracting the features of Euclidean space data. However, their performance on non-Euclidean space data, such as graphs, is unsatisfactory. Therefore, the use of graph neural networks (GNN), which can effectively deal with graph structures with complex relationships, was proposed. Current GNNs can be divided into graph convolution networks, graph attention networks and graph generative networks [35].

GCN is an efficient CNN variant that directly operates on graphs [36]. For graph-structured data, GCN applies convolution operations to directly connected nodes to encode local information. For each node in the graph, it can learn more global information and update the node by aggregating its neighbors. GCN has had widespread use in software engineering [37,38] in recent years. Lu et al. [37] used graph attention network and GCN to extract feature representations from an AST. Gao et al. [38] proposed a GTsum model for a code summarization task, which used GCN to learn the feature information in a local application programming interface (API) dependency graph and AST. In this study, we use GCN to enhance the syntactic and semantic features of the source code.

3.3.2. SGA-GCN

SGA-GCN takes the group representations $\mathbf{H}$ and the dependencies matrix ${\mathbf{A}}^{\mathrm{sga}}$ as input. The nodes in each layer of GCN are updated by aggregating information of their neighboring nodes, and the calculation formula is:

$${\mathbf{H}}_{k+1}^{\mathrm{sga}}=\mathrm{ReLU}\left({\left(D^{\mathrm{sga}}\right)}^{-\frac{1}{2}}{\tilde{\mathbf{A}}}^{\mathrm{sga}}{\left(D^{\mathrm{sga}}\right)}^{-\frac{1}{2}}{\mathbf{H}}_k^{\mathrm{sga}}{\mathbf{W}}_k^{\mathrm{sga}}+{\mathbf{b}}_k^{\mathrm{sga}}\right).$$

(7)

In (7), ${\tilde{\mathbf{A}}}^{\mathrm{sga}}={\mathbf{A}}^{\mathrm{sga}}+\mathbf{E}$, where $\mathbf{E}$ denotes the unit matrix. If only ${\mathbf{A}}^{\mathrm{sga}}$ is used, only the neighbors of a node are considered when multiplying with the vector matrix ${\mathbf{H}}_k^{\mathrm{sga}}$ of all nodes, as the diagonal of ${\mathbf{A}}^{\mathrm{sga}}$ is 0. To ensure that the information of the node itself is also taken into account, $\mathbf{E}$ is added to ${\mathbf{A}}^{\mathrm{sga}}$ so that the diagonal elements of the matrix become 1. ${\left(D^{\mathrm{sga}}\right)}^{-\frac{1}{2}}{\tilde{\mathbf{A}}}^{\mathrm{sga}}{\left(D^{\mathrm{sga}}\right)}^{-\frac{1}{2}}$ is similar to a symmetric Laplacian matrix and can be used for normalizing ${\mathbf{A}}^{\mathrm{sga}}$, where $D^{\mathrm{sga}}$ denotes the degree of ${\tilde{\mathbf{A}}}^{\mathrm{sga}}$. We chose ReLU as the activation function. ${\mathbf{H}}_k^{\mathrm{sga}}$ is the hidden representation generated by the k layer of the GCN. ${\mathbf{W}}_k^{\mathrm{sga}}$ and ${\mathbf{b}}_k^{\mathrm{sga}}$ represent the weight matrix and bias vector, respectively. The final node representation obtained from the SGA-GCN is ${\mathbf{H}}^{\mathrm{sga}}=\{{\mathbf{h}}_1^{\mathrm{sga}},{\mathbf{h}}_2^{\mathrm{sga}},{\mathbf{h}}_3^{\mathrm{sga}},...,{\mathbf{h}}_g^{\mathrm{sga}}\}$, with g representing the number of groups.

3.3.3. CFG-GCN

CFG-GCN models the semantic information of CFG and enhances the node representations through their neighboring nodes. The node representations $\mathbf{H}{}^{\prime }$ of CFG and the adjacency matrix ${\mathbf{A}}^{\mathrm{cfg}}$, representing control flow information, which was generated in Section 3.2, served as the initial input for CFG-GCN. The convolution operation follows the equation:

$${\mathbf{H}}_{k+1}^{\mathrm{cfg}}=\mathrm{ReLU}\left({\left(D^{\mathrm{cfg}}\right)}^{-1}{\tilde{\mathbf{A}}}^{\mathrm{cfg}}{\mathbf{H}}_k^{\mathrm{cfg}}{\mathbf{W}}_k^{\mathrm{cfg}}+{\mathbf{b}}_k^{\mathrm{cfg}}\right),$$

(8)

where ${\tilde{\mathbf{A}}}^{\mathrm{cfg}}={\mathbf{A}}^{\mathrm{cfg}}+\mathbf{E}$ and E is the unit matrix. $D^{\mathrm{cfg}}$ is the degree of ${\tilde{\mathbf{A}}}^{\mathrm{cfg}}$. The k layer of the GCN generates the hidden representation ${\mathbf{H}}_k^{\mathrm{cfg}}$. ${\mathbf{W}}_k^{\mathrm{cfg}}$ and ${\mathbf{b}}_k^{\mathrm{cfg}}$ represent the weight matrix and bias vector, respectively. The final node representation obtained from the CFG-GCN is ${\mathbf{H}}^{\mathrm{cfg}}=\{{\mathbf{h}}_1^{\mathrm{cfg}},{\mathbf{h}}_2^{\mathrm{cfg}},{\mathbf{h}}_3^{\mathrm{cfg}},\cdots ,{\mathbf{h}}_m^{\mathrm{cfg}}\}$, where m represents the number of nodes in the CFG.

3.4. Feature Fusion and Similarity Calculations

3.4.1. Related Theory

In 1965, Zadeh [39] proposed the fuzzy set that used membership degree to describe uncertain information in the real world. However, it lacked the ability to solve decision-making problems with multi-attributes. Therefore, Torra [40] proposed the hesitant fuzzy set (HFS). It reflected human hesitancy objectively. Chen et al. [41] extended HFS in 2013 and proposed IVHFS, which used multiple interval values to represent the possible membership values. The introduction of interval values enhanced the degree of hesitation preference of decision information and made the decision results more reasonable and relevant to reality. IVHFS is a powerful tool for addressing the problem of interval-valued evaluations with many uncertainties. In this study, we use IVHFS to process multiple sets of code features for more comprehensive similarity evaluations.

3.4.2. Feature Fusion Based on IVHFS

In this paper, IVHFS was used to fuse multiple features of source code by applying membership functions sequentially to each vector in vector matrices. For the non-empty attribute set $X=\{x_1,x_2,...,x_n\}$, the IVHFS on X can be expressed as $E=\{<x,{\tilde{h}}_E\left(x\right)>|x\in X\}$. ${\tilde{h}}_E\left(x\right)$ denotes the set of possible interval numbers where the element x is subordinate to E, and these possible intervals are the subsets of $\left[0,1\right]$.

${\mathbf{H}}_A^{\mathrm{sga}}=\{{\mathbf{h}}_{A_1}^{\mathrm{sga}},{\mathbf{h}}_{A_2}^{\mathrm{sga}},...,{\mathbf{h}}_{A_i}^{\mathrm{sga}},...,{\mathbf{h}}_{A_{g1}}^{\mathrm{sga}}\}$ and ${\mathbf{H}}_B^{\mathrm{sga}}=\{{\mathbf{h}}_{B_1}^{\mathrm{sga}},{\mathbf{h}}_{B_2}^{\mathrm{sga}},...,{\mathbf{h}}_{B_j}^{\mathrm{sga}},...,{\mathbf{h}}_{B_{g2}}^{\mathrm{sga}}\}$ are the vector matrices of code fragment A and code fragment B obtained by the SGA-GCN. $g_1$ and $g_2$ are the number of groups in the SGA. We take code fragment A as the subject and define the membership function of syntactic features as:

$$U_{A_i}^{\mathrm{sga}}=\left[f_{\mathrm{sga}}^{-},f_{\mathrm{sga}}^{+}\right]=\left[e^{-d_{max}\left({\mathbf{h}}_{A_i}^{\mathrm{sga}},{\mathbf{h}}_B^{\mathrm{sga}}\right)},e^{-d_{min}\left({\mathbf{h}}_{A_i}^{\mathrm{sga}},{\mathbf{h}}_B^{\mathrm{sga}}\right)}\right].$$

(9)

In (9), $f_{\mathrm{sga}}^{-}$ and $f_{\mathrm{sga}}^{+}$ represent the upper and lower limits of membership values. $d_{max}\left({\mathbf{h}}_{A_i}^{\mathrm{sga}},{\mathbf{h}}_B^{\mathrm{sga}}\right)=ma{x}_{j=1}^{g_2}\frac{{\mathbf{h}}_{A_i}^{\mathrm{sga}}·{\mathbf{h}}_{B_j}^{\mathrm{sga}}}{\left|{\mathbf{h}}_{A_i}^{\mathrm{sga}}\right|\left|{\mathbf{h}}_{B_j}^{\mathrm{sga}}\right|}$. Similarly, $d_{min}\left({\mathbf{h}}_{A_i}^{\mathrm{sga}},{\mathbf{h}}_B^{\mathrm{sga}}\right)=mi{n}_{j=1}^{g_2}\frac{{\mathbf{h}}_{A_i}^{\mathrm{sga}}·{\mathbf{h}}_{B_j}^{\mathrm{sga}}}{\left|{\mathbf{h}}_{A_i}^{\mathrm{sga}}\right|\left|{\mathbf{h}}_{B_j}^{\mathrm{sga}}\right|}$. The schematic diagram of Formula (9) is shown in Figure 6. It can be seen from the figure that each vector ${\mathbf{h}}_{A_i}^{\mathrm{sga}}$ in ${\mathbf{H}}_A^{\mathrm{sga}}$ is calculated with all vectors in ${\mathbf{H}}_B^{\mathrm{sga}}$. The maximum and minimum values are selected from the calculation results, and their negative numbers are taken as the exponential of the natural logarithm e, to obtain the membership value interval $U_{A_i}^{\mathrm{sga}}$.

${\mathbf{H}}_A^{\mathrm{cfg}}=\{{\mathbf{h}}_{A_1}^{\mathrm{cfg}},{\mathbf{h}}_{A_2}^{\mathrm{cfg}},...,{\mathbf{h}}_{A_i}^{\mathrm{cfg}},...,{\mathbf{h}}_{A_{m1}}^{\mathrm{cfg}}\}$ and ${\mathbf{H}}_B^{\mathrm{cfg}}=\{{\mathbf{h}}_{B_1}^{\mathrm{cfg}},{\mathbf{h}}_{B_2}^{\mathrm{cfg}},...,{\mathbf{h}}_{B_j}^{\mathrm{cfg}},...,{\mathbf{h}}_{B_{m2}}^{\mathrm{cfg}}\}$ are the vector matrices of code fragment A and code fragment B obtained by the CFG-GCN. $m_1$ and $m_2$ are the number of nodes in the CFG. Similarly, we take code fragment A as the subject and define the membership function of semantic features as:

$$U_{A_i}^{\mathrm{cfg}}=\left[f_{\mathrm{cfg}}^{-},f_{\mathrm{cfg}}^{+}\right]=\left[mi{n}_{j=1}^{m_2}E\left({\mathbf{h}}_{A_i}^{\mathrm{cfg}},{\mathbf{h}}_{B_j}^{\mathrm{cfg}}\right),ma{x}_{j=1}^{m_2}E\left({\mathbf{h}}_{A_i}^{\mathrm{cfg}},{\mathbf{h}}_{B_j}^{\mathrm{cfg}}\right)\right].$$

(10)

$E\left({\mathbf{h}}_{A_i}^{\mathrm{cfg}},{\mathbf{h}}_{B_j}^{\mathrm{cfg}}\right)$ in (10) represents the Euclidean distance between ${\mathbf{h}}_{A_i}^{\mathrm{cfg}}$ and ${\mathbf{h}}_{B_j}^{\mathrm{cfg}}$:

$$E\left({\mathbf{h}}_{A_i}^{\mathrm{cfg}},{\mathbf{h}}_{B_j}^{\mathrm{cfg}}\right)={\left(\sum _{l=1}^k{\left({\left({\mathbf{h}}_{A_i}^{\mathrm{cfg}}\right)}_l-{\left({\mathbf{h}}_{B_j}^{\mathrm{cfg}}\right)}_l\right)}^2\right)}^{\frac{1}{2}},$$

(11)

where k denotes the dimension of ${\mathbf{h}}^{\mathrm{cfg}}$. The schematic diagram of Formula (10) is shown in Figure 7. The calculation process is similar to that in Figure 6. ${\mathbf{h}}_{A_i}^{\mathrm{cfg}}$ in ${\mathbf{H}}_A^{\mathrm{cfg}}$ is calculated with all vectors in ${\mathbf{H}}_B^{\mathrm{cfg}}$. The maximum and minimum values in the calculated results are taken as the upper and lower limits of the membership value interval $U_{A_i}^{\mathrm{cfg}}$.

The membership function converts the relationship between code fragments A and B into the corresponding IVHFS. With code fragment A as the subject, the IVHFS between code fragments A and B is calculated as:

$$S=\{\left[U_{A_1}^{\mathrm{sga}},...,U_{A_{g1}}^{\mathrm{sga}}\right],\left[U_{A_1}^{\mathrm{cfg}},...,U_{A_{m1}}^{\mathrm{cfg}}\right]\}.$$

(12)

We set the interval membership value between the code fragment and itself as $\left[1,1\right]$ to construct the ideal IVHFS $S_p$, which will be used as a measure of similarity between code pairs. For example, the IVHFS of code fragment A and itself can be expressed as $\{\left[\left[1,1\right],...,\left[1,1\right]\right],\left[\left[1,1\right],...,\left[1,1\right]\right]\}$.

We conducted the same experiments with code fragment B as the subject and our experimental results showed little difference. Therefore, it was shown that with either code fragment A or B as the subject, the feature information contained in each vector of the vector matrix could be fully utilized, and the syntactic feature matrix and semantic feature matrix could be evaluated comprehensively.

3.4.3. Similarity Calculation

For ideal IVHFS $S_p$ and real IVHFS S, $U_{S_p}\left(x_i\right)$ and $U_S\left(x_i\right)$ are the two interval-valued hesitant fuzzy elements of $S_P$ and S. The generalized interval hesitation Hamming distance of $S_P$ and S is expressed as

$$d_{Hamming}\left(S_p,S\right)=\frac{1}{k}\sum _{i=1}^k\frac{1}{2l_{x_{\sigma \left(i\right)}}}\sum _{j=1}^{l_{x_{\sigma \left(i\right)}}}\left(\begin{array}{c}|U_{S_p}^{\sigma \left(j\right)}{\left(x_{\sigma \left(i\right)}\right)}^{+}-U_S^{\sigma \left(j\right)}{\left(x_{\sigma \left(i\right)}\right)}^{+}|\\ +|U_{S_p}^{\sigma \left(j\right)}{\left(x_{\sigma \left(i\right)}\right)}^{-}-U_S^{\sigma \left(j\right)}{\left(x_{\sigma \left(i\right)}\right)}^{-}|\end{array}\right),$$

(13)

where k is the number of evaluation indicators. $U_{S_p}^{\sigma \left(j\right)}\left(x_{\sigma \left(i\right)}\right)$ and $U_S^{\sigma \left(j\right)}\left(x_{\sigma \left(i\right)}\right)$ are the j-th largest interval number of $U_{S_p}\left(x_i\right)$ and $U_S\left(x_i\right)$. $l_{x_{\sigma }\left(i\right)}$ denotes the maximum of $l_{S_p}\left(x_i\right)$ and $l_S\left(x_i\right)$, i.e., $l_{x_{\sigma }\left(i\right)}=max\left(l_{S_p}\left(x_i\right),l_S\left(x_i\right)\right)$. $l_{S_p}\left(x_i\right)$ and $l_S\left(x_i\right)$ denote the number of interval values of $U_{S_p}\left(x_i\right)$ and $U_S\left(x_i\right)$. The similarity of two IVHFS is inversely proportional to the distance between them. Therefore, the similarity formula can be expressed as

$$sim\left(S_p,S\right)=1-d_{Hamming}\left(S_p,S\right).$$

(14)

Then, we can treat the output $sim\left(S_p,S\right)$ as the similarity value $\widehat{s}$ of two code fragments. The loss function is defined as binary cross-entropy:

$$\mathcal{L}=\sum (-(y·log\left(\widehat{s}\right)+(1-y)·log(1-\widehat{s}))),$$

(15)

where y represents the label of two code fragments.

The DG-IVHFS is stored after all the parameters are optimized. In the prediction phase, we take two code fragments as input, then we can obtain the predicted value by the following definitions:

$$\mathrm{prediction}=\left\{\begin{array}{cc}1,\hfill & \widehat{s}>\delta \hfill \\ 0,\hfill & \widehat{s}\le \delta \hfill \end{array}\right.,$$

(16)

where $\delta$ is the threshold between true and false clones.

4. Experiments

4.1. Datasets

We evaluated DG-IVHFS on two public datasets written in Java.

One of them was Google Code Jam (GCJ) [42], which contains 1669 items solving 12 competition problems. Each competition topic is designed to solve the same problem. Two code files are considered a clone pair if they solve the same problem. Otherwise, they are considered a non-clone pair.

The other dataset was BigCloneBench (BCB) [43], a widely used dataset for clone detection. The BCB consists of 25,000 items covering 10 functions and contains over 6 million clone pairs with a true label and 260,000 clone pairs with a false label. In the experiments, code fragments without labels were discarded, leaving 9134 code fragments at the end.

The basic information of clone and non-clone pairs we selected in the experiment is shown in

Table 1. Basic information about BCB and GCJ in our experiment.

	BCB	GCJ
Code fragments	9134	1669
Clone pairs	270,000	275,570
Non-clone pairs	270,000	275,570

.

4.2. Comparison Models

Tree-based methods:

• CDLH [14] is an AST-based clone detection method that uses Tree-LSTM to encode AST and compares Hamming distance between hash vectors.
• ASTNN [15] is an advanced AST-based clone detection method that first decomposes the AST into multiple statement trees, and then encodes them separately using recursive encoders to generate vector representations.

Graph-based method:

• DeepSim [23] is a graph-based clone detection method that uses semantic matrices to encode control flow and data flow information.

Hybrid methods:

• FCCA [28] is a hybrid method that retains three types of information (text, AST and CFG) in the code representations.
• FA-AST [29] is a hybrid method that expands the AST with control flow edges and data flow edges to learn semantic and syntactic information.

4.3. Experimental Setting

We obtained the embedding of nodes in SGA using word2vec with the Skip-gram algorithm and the embedding dimension was set to 128. The hidden dimension in Bi-GRU was 100. Doc2vec was used to generate vectors of the nodes in the CFG, and the dimension of vectors was 300. We used the Adam [44] optimizer to train DG-IVHFS. The initial learning rate was 0.001. The mini-batch size was set to 64. The number of GCN layers was 2, which was the optimal number of layers we tested in our experiments. The threshold $\delta$ of code cloning was set to 0.5. To ensure the accuracy of the results, we used 10-fold cross-validation for training and testing in both two datasets. Specifically, we divided the dataset we built into 10 subsets. One was used as a test set and the remaining nine were used as training sets. We constructed 10 different experiments with different test sets. Finally, the average of these 10 results was reported. In order to ensure the fairness of the comparison, we compared our model and baseline models under the same experimental settings, and used the same evaluation metrics used in previous work: precision (P), recall (R) and F1-score (F1).

We conducted the experiments on a server with 10 cores of 3.7GHz CPU and two NVIDIA GeForce RTX 3080 GPUs.

4.4. Research Questions

We conducted the experiments and analyzed the results according to the following research questions (RQs):

• RQ1: What is the overall effectiveness of DG-IVHFS compared with other baseline approaches?
• RQ2: What is the time consumption of DG-IVHFS compared with other baseline approaches?
• RQ3: How do the group representations obtained by simplifying and grouping the AST affect the effectiveness of DG-IVHFS?
• RQ4: How does the Dual-GCN affect the effectiveness of DG-IVHFS?
• RQ5: How does the IVHFS affect the effectiveness of DG-IVHFS?

4.5. Results and Discussion

4.5.1. RQ1: What Is the Overall Effectiveness of DG-IVHFS Compared with Other Baseline Approaches?

The detailed comparison results on BCB and GCJ are shown in

Table 2. Comparison of detection performance on BCB and GCJ.

Groups	Approaches	BCB			GCJ
		P	R	F1	P	R	F1
Tree-based	CDLH	0.92	0.74	0.82	0.47	0.73	0.57
	ASTNN	0.99	0.88	0.93	0.95	0.87	0.91
Graph-based	DeepSim	0.92	0.94	0.93	0.70	0.83	0.76
Hybrid	FCCA	0.98	0.92	0.94	0.95	0.90	0.92
	FA-AST	0.95	0.91	0.92	0.96	0.88	0.91
	DG-IVHFS	0.98	0.97	0.97	0.98	0.93	0.95

.

From the results in Table 2, we can see that DG-IVHFS improved the F1 scores from 94 to 97% on BCB, and from 92 to 95% on GCJ. CDLH and DeepSim only modeled syntactic or semantic information of code snippets. The single feature information made it difficult for them to deal with the complicated code clone detection task. ASTNN also used single syntactic information, but it performed better than CDLH and DeepSim. This is because ASTNN divided the AST into several subtrees, which simplified the AST structure to some extent. However, it ignored the dependencies between nodes in the AST. FCCA and FA-AST used multiple features of source code, but they still did not fully explore the relationships between code statements.

Compared with these methods, we believe that there are four main reasons for the higher performance of our model. First, we obtained syntactic and semantic information from AST and CFG levels, respectively, which made the obtained code features more comprehensive and sufficient. Secondly, we simplified and grouped the AST, which enhanced the connection information between nodes. Thirdly, we constructed graph representations of the simplified and grouped AST, as well as the CFG, and modeled them using a Dual-GCN to capture better semantic and syntactic features. Finally, we used IVHFS to fully utilize the feature information contained in each vector to achieve better feature fusion.

4.5.2. RQ2: What Is the Time Consumption of DG-IVHFS Compared with Other Baseline Approaches?

We conducted experiments on the time performance of these methods on the BCB dataset. The time consumption of DG-IVHFS and the baseline models in the training and prediction phases are visually represented in Figure 8 and Figure 9.

CDLH and FCCA took the longest training time because they used a large number of RNNs with low parallelism. ASTNN used the complicated recursive traversal algorithm in the encoding of statement subtrees, which increased training time consumption. In addition, it had the longest prediction time. FA-AST used a graph matching network to transmit information between two graphs. Each node of one graph match similar nodes in the other, which leads to high complexity and long training time. Our model used a highly parallel GCN to process graph and tree structures, while simplifying and grouping the AST reduced the complexity of the convolution operations. DeepSim consumed a little less training time than our model, but it was far inferior in terms of detection effectiveness.

4.5.3. RQ3: How Do the Group Representations Obtained by Simplifying and Grouping the AST Affect the Effectiveness of DG-IVHFS?

In this section, we design Variant 1 to illustrate the importance of simplifying and grouping the AST. The node representations of the whole AST were obtained and the Bi-GRU was utilized to model the naturalness of the statements. The syntactic feature representations and adjacency matrix were fed into the syntax-based GCN. Other settings remained unchanged. The ablation experiment results are reported in

Table 3. The ablation experiment results on BCB and GCJ of group representations.

Approaches	BCB			GCJ
	P	R	F1	P	R	F1
Variant 1	0.96	0.94	0.94	0.95	0.89	0.91
DG-IVHFS	0.98	0.97	0.97	0.98	0.93	0.95

.

The results show that the process of simplifying and grouping the AST to obtain group representations improves the performance of the model. This is because simplifying the AST can effectively remove redundant information and direct more attention to the important nodes. Grouping the simplified AST further simplifies the structure of AST, which is conducive to subsequent convolution operations in the GCN.

4.5.4. RQ4: How Does the Dual-GCN Affect the Effectiveness of DG-IVHFS?

In this section, we consider three variants of DG-IVHFS to explore the effectiveness of the Dual-GCN.

• Variant 2: The SGA-GCN and CFG-GCN, i.e., Dual-GCN, were removed on the basis of DG-IVHFS. We used IVHFS to directly handle the original semantic and syntactic feature vectors. Other settings remained unchanged.
• Variant 3: The CFG-GCN was removed on the basis of DG-IVHFS. We used IVHFS to deal with the initial semantic feature vectors, as well as the syntactic feature vectors enhanced by the SGA-GCN. Other settings remained unchanged.
• Variant 4: The SGA-GCN was removed on the basis of DG-IVHFS. We used IVHFS to deal with the initial syntactic feature vectors, as well as the semantic feature vectors enhanced by the CFG-GCN. Other settings remained unchanged.

We compared our original model with the three variants in P, R and F1. The results are shown in

Table 4. The ablation experiment results on BCB and GCJ of Dual-GCN.

Approaches	BCB			GCJ
	P	R	F1	P	R	F1
Variant 2	0.71	0.79	0.74	0.69	0.75	0.71
Variant 3	0.89	0.82	0.85	0.86	0.83	0.84
Variant 4	0.92	0.87	0.89	0.90	0.88	0.88
DG-IVHFS	0.98	0.97	0.97	0.98	0.93	0.95

.

The performance of Variant 2 was the worst, because it did not learn the enhanced semantic and syntactic structure information in the AST and CFG. When GCN was applied to the simplified AST on the basis of Variant 2, Variant 3 was obtained and its performance substantially improved. Variant 3 could learn the enhanced syntactic information in the AST and the connection information between nodes from the GCN. When applying the GCN to the CFG on the basis of Variant 2, Variant 4 was obtained. Variant 4 improved performance significantly more than Variant 3, indicating that the enhanced semantic information and relationships between statement nodes learned from the CFG have a great impact on code clone detection. When the SGA-GCN and CFG-GCN were added to Variant 2, DG-IVHFS was obtained and it achieved the best performance. It could fully learn the enhanced semantic information from the CFG, the enhanced syntactic information from the AST, and the relationships between nodes in the graph representations.

4.5.5. RQ5: How Does the IVHFS Affect the Effectiveness of DG-IVHFS?

In this section, we consider Variant 5 to explore the effectiveness of the IVHFS. Variant 5 was given by removing the IVHFS part from the original model DG-IVHFS. We applied average pooling to vector matrices generated by the SGA-GCN and the CFG-GCN, and concatenated the pooling results to obtain the final representation of code snippets. Then, we usee a deep neural network (DNN) classifier with a softmax layer and two hidden layers to complete clone detection. The feature concatenation process in Variant 5 is shown in Figure 10. Other settings remained unchanged.

We compare our original model DG-IVHFS with Variant 5 for P, R and F1. The results are shown in

Table 5. The ablation experiment results on BCB and GCJ of IVHFS.

Approaches	BCB			GCJ
	P	R	F1	P	R	F1
Variant 5	0.92	0.95	0.93	0.92	0.93	0.92
DG-IVHFS	0.98	0.97	0.97	0.98	0.93	0.95

.

The experimental results show that DG-IVHFS has better performance than Variant 5. This is because simple pooling and concatenation strategies lead to the loss of feature information when semantic and syntactic features are merged. In contrast, we exploit the unique advantage of IVHFS in dealing with multiple attributes and fully utilize the feature information contained in each vector of the vector matrices. DG-IVHFS achieves better feature fusion.

4.6. Limitations

First, we only selected five baseline methods to compare because most code clone detection methods are not available. We would like to compare with more methods in the future. Second, DG-IVHFS focuses on detecting code clones on Java code fragments, so its detection performance in other languages need to be verified. Future studies should extend DG-IVHFS to accommodate other programming languages.

5. Conclusions

This paper proposes a code clone detection model based on Dual-GCN and IVHFS, which can effectively extract and fuse semantic and syntactic features of source code. We constructed the AST and CFG structures according to the code pairs. Multiple structures help the model obtain abundant feature information of source code. Considering that the complexity of AST can have negative effects on feature extraction, we removed redundant nodes in AST and designed a method to divide AST into several groups. Dual-GCN was used to extract more precise semantic and syntactic features from the CFG, as well as from the simplified and grouped AST. Finally, we utilized the IVHFS theory to process the comprehensive features extracted by Dual-GCN.

The results of these comparative experiments show that DG-IVHFS not only achieves higher performance in a code clone detection task, but also performs well in terms of time consumption. Subsequent ablation experiments showed that simplifying and grouping AST significantly improved the detection performance of the model. The Dual-GCN sufficiently learned the dependencies between code statements in different structures. The use of IVHFS effectively avoids the loss of feature information and achieves better similarity calculation.

In future work, we plan to apply our model to other software engineering tasks, explore more advanced methods of simplifying and grouping AST, and try to simplify the structure of CFG to further improve the performance of the model.