Code Attention: Translating Code to Comments by Exploiting Domain Features

09/22/2017 ∙ by Wenhao Zheng, et al. ∙ 0

Appropriate comments of code snippets provide insight for code functionality, which are helpful for program comprehension. However, due to the great cost of authoring with the comments, many code projects do not contain adequate comments. Automatic comment generation techniques have been proposed to generate comments from pieces of code in order to alleviate the human efforts in annotating the code. Most existing approaches attempt to exploit certain correlations (usually manually given) between code and generated comments, which could be easily violated if the coding patterns change and hence the performance of comment generation declines. In this paper, we first build C2CGit, a large dataset from open projects in GitHub, which is more than 20× larger than existing datasets. Then we propose a new attention module called Code Attention to translate code to comments, which is able to utilize the domain features of code snippets, such as symbols and identifiers. We make ablation studies to determine effects of different parts in Code Attention. Experimental results demonstrate that the proposed module has better performance over existing approaches in both BLEU and METEOR.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 5

page 9

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

Introduction

Program comments usually provide insight for code functionality, which are important for program comprehension, maintenance and reusability. For example, comments are helpful for working efficiently in a group or integrating and modifying open-source software. However, because it is time-consuming to create and update comments constantly, plenty of source code, especially the code from open-source software, lack adequate comments [fluri2007code]. Source code without comments would reduce the maintainability and usability of software.

To mitigate the impact, automatic program annotation techniques have been proposed to automatically supplement the missing comments by analyzing source code. [sridhara2010towards]generated summary comments by using variable names in code. [rastkar] managed to give a summary by reading software bug reports. [mcburney2014automatic] leveraged the documentation of API to generate comments of code snippets.

As is well known, source code are usually structured while the comments in natural language are organized in a relatively free form. Therefore, the key in automatic program annotation is to identify the relationship between the functional semantics of the code and its corresponding textual descriptions. Since identifying such relationships from the raw data is rather challenging due to the heterogeneity nature of programming language and natural language, most of the aforementioned techniques usually rely on certain assumptions on the correlation between the code and their corresponding comments (e.g., providing paired code and comment templates to be filled in), based on which the code are converted to comments in natural language. However, the assumptions may highly be coupled with certain projects while invalid on other projects. Consequently, these approaches may have large variance in performances on real-world applications.

In order to improve the applicability of automatic code commenting, machine learning has been introduced to learn how to generate comments in natural language from source code in programming languages. 

[srinivasan2016summarizing] and [cnnforsummarization]

treated source code as natural language texts, and learned a neural network to summarize the words in source code into briefer phrases or sentences. However, as pointed out by 

[huo2016learning], source code carry non-negligible semantics on the program functionality and should not be simply treated as natural language texts. Therefore, the comments generated by [srinivasan2016summarizing] may not well capture the functionality semantics embedded in the program structure. For example, as shown in Figure LABEL:code0, if only considering the lexical information in this code snippet, the comment would be “swap two elements in the array”. However, if considering both the structure and the lexical information, the correct comment should be “shift the first element in the array to the end”.

1  int i = 0;
2  while(i<n){
3    // swap is a build-in function in Java
4    swap(array[i],array[i+1]);
5    i++;}\end{lstlisting}
6    \caption{An example of code snippet. If the structural semantics provided by the \texttt{while} is not considered, comments indicating wrong semantics may be generated.}
7    \label{code0}
8\end{figure}
9
10One question arises: Can we \emph{directly learn a mapping} between two heterogeneous languages? Inspired by the recent advances in neural machine translation (NMT), we propose a novel attention mechanism called Code Attention to directly \emph{translate} the source code in programming language into comments in natural language. Our approach is able to explore domain features in code by attention mechanism, e.g. explicitly modeling the semantics embedded in program structures such as loops and symbols, based on which the functional operations of source code are mapped into words. To verify the effectiveness of Code Attention, we build C2CGit, a large dataset collected from open source projects in Github. The whole framework of our proposed method is as shown in Figure \ref{framework}. Empirical studies indicate that our proposed method can generate better comments than previous work, and the comments we generate would conform to the functional semantics in the program, by explicitly modeling the structure of the code.
11
12The rest of this paper is organized as follows. After briefly introducing the related work and preliminaries, we describe the process of collecting and preprocessing data in Section 4, in which we build a new benchmark dataset called C2CGit.  In Section 5, we introduce the Code Attention module, which is able to leverage the structure of the source code. In Section 6, we report the experimental results by comparing it with five popular approaches against different evaluation metrics. On BLEU and METEOR, our approach outperforms all other approaches and achieves new state-of-the-art performance in C2CGit.
13
14Our contribution can be summarized as:
15\begin{enumerate}[i)]
16    \item A new benchmark dataset for code to comments translation. C2CGit contains over 1k projects from GitHub, which makes it more real and 20$\times$ larger than previous dataset~\cite{srinivasan2016summarizing}.
17
18    \item We explore the possibility of whether recent pure attention model~\cite{attention} can be applied to this translation task. Experimental results show that the attention model is inferior to traditional RNN, which is the opposite to the performance in NLP tasks.
19
20    \item To utilize domain features of code snippets, we propose a Code Attention module which contains three steps to exploit the structure in code. Combined with RNN, our approach achieves the best results on BLEU and METEOR over all other methods in different experiments.
21\end{enumerate}
22
23\section{Related Work}
24
25Previously, there already existed some work on producing code descriptions based on source code. These work mainly focused on how to extract key information from source code, through rule-based matching, information retrieval, or probabilistic methods.~\cite{sridhara2010towards} generated conclusive comments of specific source code by using variable names in code.~\cite{sridhara2011automatically} used several templates to fit the source code. If one piece of source code matches the template, the corresponding comment would be generated automatically.~\cite{movshovitz} predicted class-level comments by utilizing open source Java projects to learn n-gram and topic models, and they tested their models using a character-saving metric on existing comments.
26There are also retrieval methods to generate summaries for source code based on automatic text summarization~\cite{haiduc2010use} or topic modeling~\cite{eddy2013evaluating}, possibly combining with the physical actions of expert engineers~\cite{rodeghero2014improving}.
27
28\textbf{Datasets}. There are different datasets describing the relation between code and comments. Most of datasets are from Stack Overflow~\cite{boa,wong2013autocomment,srinivasan2016summarizing} and GitHub~\cite{wong2015clocom}. Stack Overflow based datasets usually contain lots of pairs in the form of Q\&A, which assume that real world code and comments are also in Q\&A pattern. However, this assumption may not hold all the time because those questions are carefully designed. On the contrary, we argue that current datasets from GitHub are more real but small, for example,~\cite{wong2015clocom} only contains 359 comments. In this paper, our C2CGit is much larger and also has the ability to keep the accuracy.
29
30\textbf{Machine Translation}. In most cases, generating comments from source code is similar to the sub-task named machine translation in natural language processing (NLP). There have been many research work about machine translation in this community.~\cite{mathematicsofml} described a series of five statistical models of the translation process and developed an algorithm for estimating the parameters of these models given a set of pairs of sentences that each pair contains mutual translations, and they also define a concept of word-by-word alignment between such pairs of sentences.
31\cite{koehn2003statistical} proposed a new phrase-based translation model and decoding algorithm that enabled us to evaluate and compare several previously proposed phrase-based translation models. However, the system itself consists of many small sub-components and they are designed to be tuned separately. Although these approaches achieved good performance on NLP tasks, few of them have been applied on code to comments translation. Recently, deep neural networks achieve excellent performance on difficult problems such as speech recognition~\cite{dlforspeech1}, visual object recognition~\cite{alexnet} and machine translation~\cite{seq2seq}. For example, the neural translator proposed in~\cite{seq2seq} is a newly emerging approach which attempted to build and train a single, large neural network which takes a sentence as an input and outputs a corresponding translation.
32
33Two most relevant works are~\cite{srinivasan2016summarizing} and~\cite{cnnforsummarization}.~\cite{cnnforsummarization} mainly focused on extreme summarization of source code snippets into short, descriptive function name-like
34summaries but our goal is to generate human-readable comments of code snippets.~\cite{srinivasan2016summarizing} presented the first completely data driven approach for generating high level summaries of source code by using Long Short Term Memory (LSTM) networks to produce sentences. However, they considered the code snippets as natural language texts and employed roughly the same method in NLP without considering the structure of code.
35
36Although translating source code to comments is similar to language translation, there does exist some differences. For instance, the structure of code snippets is much more complex than that of natural language and usually has some specific features, such as various identifiers and symbols; the length of source code is usually much longer than the comment; some comments are very simple while the code snippets are very complex. All approaches we have mentioned above do not make any optimization for source code translation. In contrast, we design a new attentional unit called Code Attention which is specially optimized for code structure to help make the translation process more specific. By separating the identifiers and symbols from natural code segments, Code Attention is able to understand the code snippets in a more structural way.
37%Also, their dataset is collected from Stack Overflow which make their model highly potential to have failure when source code is from real projects.
38
39\section{Preliminaries}
40\label{preliminaries}
41
42In this section, we introduce the recurrent neural networks (RNNs), a family of neural networks designed for processing sequential data. Some traditional types of neural networks (e.g., convolution neural networks, recursive networks) make an assumption that all elements are independent of each other, while RNNs perform the same task with the output being depended on the previous computations. For instance, in natural language processing, if you want to predict the next word in a sentence you better know which words come before it.
43
44\subsection{seq2seq model}
45A recurrent neural network (RNN) is a neural network that consists of a hidden state \textbf{h} and an optional output \textbf{y} which operates on a variable length sequence. An RNN is able to predict the next symbol in a sequence by modeling a probability distribution over the sequence \textbf{x}$=(x_1, \dots, x_T)$. At each timestep $t$, the hidden state $\textbf{h}_t$ is updated by
46\begin{equation}
47\label{fm1}
48\textbf{h}_t=f_{encoder}(\textbf{h}_{t-1}, \textbf{x}_t)
49\end{equation}
50where $f_{encoder}$ is a non-linear activation function (e.g., sigmoid function \cite{yin2003flexible}, LSTM~\cite{lstms}, GRU~\cite{grus}). One usual way of defining the recurrent unit $f_{encoder}$ is a linear transformation plus a nonlinear activation, e.g.,
51\begin{equation}
52\label{activation}
53\textbf{h}_t=tanh(W[\textbf{h}_{t-1}, \textbf{x}_t]+\textbf{b})
54\end{equation}
55where we parameterized the relation between $\textbf{h}_{t-1}$ and $\textbf{x}_t$ into matrix $W$, and $\textbf{b}$ is the bias term. Each element of its input is activated by the function $tanh$. A simple RNN aims to learn the parameters $W$ and $\textbf{b}$. In this case, we can get the final joint distribution,
56\begin{equation}
57\label{distribution}
58p(\textbf{x})=\prod_{T}^{t=1}p(\textbf{x}_t|\textbf{x}_1,\dots,\textbf{x}_{t-1})
59\end{equation}
60
61The basic cell unit in RNN is important to decide the final performance. A gated recurrent unit is proposed by Cho et al.~\cite{GRU} to make each recurrent unit to
62adaptively capture dependencies of different time scales. GRU has gating units but no separate memory cells when compared with LSTM.
63
64GRU contains two gates: an update gate $\textbf{z}$ and a reset gate $\textbf{r}$ which correspond to forget gate and input gate, respectively. We show the update rules of GRU in the Equations (4) to (7),
65\begin{eqnarray}
66\label{GRU_formula}
67\textbf{z}_t&=& \sigma(W_z[\textbf{h}_{t-1}, \textbf{x}_t]+\textbf{b}_z)\\
68\textbf{r}_t&=& \sigma(W_r[\textbf{h}_{t-1}, \textbf{x}_t]+\textbf{b}_r)\\
69\widetilde{\textbf{h}}_t&=& tanh(W_h[\textbf{r}_{t}\odot\textbf{t}_{t-1}, \textbf{x}_t]+\textbf{b}_h)\\
70\textbf{h}_t&=& (1-\textbf{z}_t)\odot\textbf{h}_{t-1}+\textbf{z}_{t}\odot\widetilde{\textbf{h}}_t
71\end{eqnarray}
72where $\sigma(x) = \frac{1}{1+\exp(-x)}$, $\circ$ is the component-wise product
73between two vectors. For a better understanding, we also provide the data flow and operations in Figure~\ref{GRU}. There are two reasons which make us choose GRU: the first one is that Chung et al.~\cite{Evaluation} found that when LSTM and GRU have the same amount of parameters, GRU slightly outperforms LSTM; the second is that GRU is much easier to implement and train compared with LSTM.
74% a coarse  picture to be modified
75\begin{figure}[!t]
76    \centering
77    {\includegraphics[width=0.8\columnwidth]{GRU.pdf} }
78    \caption{The data flow and operations in GRU.}
79    \label{GRU}
80\end{figure}
81
82In order to learn a better phrase representations, a classical recurrent neural network architecture learns to encode a variable-length inputs into a fixed-length vector representation and then to decode the vector into a variable-length output. To be simple, this architecture bridges the gap between two variable-length vectors. While if we look inside the architecture from a more probabilistic perspective, we can rewrite Eq. (\ref{distribution}) into a more general form, e.g., $p(y_1, \dots, y_K\ |\ x_1, \dots, x_T)$, where it is worth noting that the length of input and output may differ in this case.
83
84Above model contains two RNNs. The first one is the encoder, while the other is used as a decoder. The encoder is an RNN that reads each symbol of an input sequence \textbf{x} sequentially. As it reads each symbol, the hidden state of the encoder updates according to Eq. (\ref{fm1}). At the end of the input sequence, there is always a symbol telling the end, and after reading this symbol, the last hidden state is a summary \textbf{c} of the whole input sequence.
85
86As we have discussed, the decoder is another RNN which is trained to generate the output sequence by predicting the next symbol $\textbf{y}_t$ given the hidden state $\textbf{h}_t$.
87\begin{equation}
88p(\textbf{y}_t\ |\ \textbf{y}_{t-1},\dots,\textbf{y}_1, \textbf{c}) = f_{decoder}(\textbf{h}_t, \textbf{y}_{t-1}, \textbf{c}),
89\end{equation}
90where $\textbf{h}_t = f(\textbf{h}_{t-1}, \textbf{y}_{t-1}, \textbf{c})$ and $f_{decoder}$ is usually a softmax function to produce valid probabilities. Note that there are several differences between this one and the original RNN. The first is the hidden state at timestep $t$ is no longer  based on $\textbf{x}_{t-1}$ but on the $\textbf{y}_{t-1}$ and the summary $\textbf{c}$, and the second is that we model $\textbf{y}_t$ and $\textbf{x}_t$ jointly which may result in a better representation.
91
92\subsection{Attention Mechanism}
93A potential issue with the above encoder-decoder approach is that a recurrent neural network has to compress all the necessary information of $x_1,\ \dots,\ x_T$ into a context vector $\textbf{c}$ for all time, which means the length of vector $\textbf{c}$ is fixed. There are several disadvantages here. This solution may make it difficult for the neural network to cope with long sentences, especially those that are longer than the sentences in the training corpus, and Cho~\cite{SMT} showed that indeed the performance of a basic encoderdecoder deteriorates rapidly as the length of an input sentence increases. Specifically, when backing to code-to-comment case, every word in the code may have different effects on each word in the comment. For instance, some \emph{keywords} in the source code can have direct influences on the comment while others do nothing to affect the result.
94
95Considering all factors we have talked above, a global attention mechanism should be existed in a translation system. An overview of the model is provided in Fig.~\ref{seq2seq}. $\textbf{h}_{i,j}$ is the hidden state located at the $i$th ($i=1,2$) layer and $j$th ($j=1,\dots,T$) position in the encoder. $\textbf{s}_{i,k}$ is the hidden state located at the $i$th ($i=1,2$) layer and $j$th ($k=1,\dots,K$) position in the decoder. Instead of LSTM, GRU~\cite{GRU} could be used as the cell of both $f_{encoder}$ and $f_{decoder}$. Unlike the fixed vector $\textbf{c}$ in the traditional encoder-decoder approach, current context vector $\textbf{c}_t$ varies with the step $t$,
96\begin{equation}
97\textbf{c}_t=\sum_{j=1}^{T}\alpha_{t,j}{\textbf{h}_{2,j}}
98\end{equation}
99and then we can get a new form of $\textbf{y}_t$,
100\begin{equation}
101\textbf{y}_t=f_{decoder}(\textbf{c}_t, \textbf{s}_{2,t-1}, \textbf{s}_{1,t})
102\end{equation}
103where $\alpha_{t,j}$ is the weight term of $j$th location at step $t$ in the input sequence. Note that the weight term $\alpha_{t,j}$ is normalized to $\left[0,1\right]$ using a softmax function,
104\begin{equation}
105\alpha_{t,j}=\frac{\exp(\textbf{e}_{t,j})}{\sum_{i=1}^{T}\exp(\textbf{e}_{t,i})},
106\end{equation}
107where $\textbf{e}_{t,j}=a(\textbf{s}_{2,t-1}, \textbf{h}_{2,j})$ scores how well the inputs around position $j$ and the output at position $t$ match and is a learnable parameter of the model.
108
109%\begin{figure}[!t]
110%   \centering
111%   {\includegraphics[width=1\columnwidth]{rnn.eps} }
112%   \caption{The basic architecture of a RNN}
113%   \label{rnn}
114%\end{figure}
115
116%\begin{figure}[!t]
117%   \centering
118%   {\includegraphics[width=0.6\columnwidth]{encoder-decoder.pdf} }
119%   \caption{RNN Encoder-Decoder}
120%   \label{rnn}
121%\end{figure}
122
123\begin{figure*}[!t]
124    \centering
125    {\includegraphics[width=1.8\columnwidth]{seq2seq.pdf} }
126    \caption{An overview of the translation model. We employ a two-layer recurrent model, where the gray box represents the encoder unit and the blue ones represent the decoder part.}
127    \label{seq2seq}
128\end{figure*}
129
130
131\section{C2CGit: A New Benchmark for Code to Comment Translation}\label{dataset}
132
133For evaluating proposed methods effectively, we build the C2CGit dataset firstly. We collected data from GitHub, a web-based Git repository hosting service. We crawled over 1,600 open source projects from GitHub, and got 1,006,584 Java code snippets. After data cleaning, we finally got \textbf{879,994} Java code snippets and \textbf{the same number of} comment segments. Although these comments are written by different developers with different styles, there exist common characteristics under these styles. For example, the exactly same code could have totally different comments but they all explain the same meaning of the code. In natural language, same source sentence may have more than one reference translations, which is similar to our setups. We name our dataset as \textbf{C2CGit}.
134
135To the best of our knowledge, there does not exist such a large public dataset for code and comment pairs. One choice is using human annotation~\cite{oda2015learning}. By this way, the comments could have high accuracy and reliability. However, it needs many experienced programmers and consumes a lot of time if we want to get big data.  Another choice is to use recent CODE-NN~\cite{srinivasan2016summarizing} which mainly collected data from Stack Overflow which contains some code snippets in answers. For the code snippet from accepted answer of one question, the title of this question is regarded as a comment. Compared with CODE-NN (C$\#$), our C2CGit (Java) holds two obvious advantages:
136\begin{itemize}
137    \item \textbf{Code snippets in C2CGit are more real}. In many real projects from C2CGit, several lines of comments often correspond to a much larger code snippet, for example, a 2-line comment is annotated above 50-line code. However, this seldom appears in Stack Overflow.
138    \item \textbf{C2CGit is much larger and more diversified than CODE-NN}. We make a detailed comparison in Figure~\ref{hist} and Table~\ref{length}. We can see that C2CGit is about 20$\times$ larger than CODE-NN no matter in statements, loops or conditionals. Also, C2CGit holds more tokens and words which demonstrate its diversity.
139\end{itemize}
140
141\begin{figure}[!t]
142    \centering
143    {\includegraphics[width=1\columnwidth]{framework.pdf} }
144    \caption{The whole framework of our proposed method. The main skeleton includes two parts: building C2CGit and code to comments translation.}
145    \label{framework}
146\end{figure}
147
148\textbf{Extraction}. We downloaded projects from the GitHub website by using web crawler.\footnote{The crawler uses the Scrapy framework. Its documentation can be found in \url{http://scrapy.org}} Then, the Java file can be easily extracted from these projects. Source code and comments should be split into segments. If we use the whole code from a Java file as the input and the whole comments as the output, we would get many long sentences and it is hard to handle them both in statistical machine translation and neural machine translation. Through analyzing the abstract syntax tree (AST)~\cite{neamtiu2005understanding} of code, we got code snippets from the complete Java file. By leveraging the method raised by~\cite{wong2015clocom}, the comment extraction is much easier, since it only needs to detect different comment styles in Java.
149
150\begin{table}[!t]
151
152    \footnotesize
153    \setlength{\tabcolsep}{3pt}
154    \caption{Average code and comments together with vocabulary sizes for C2CGit, compared with CODE-NN.}
155    \centering
156    \label{length}
157    \begin{tabular}{c|c|c|c|c}
158        % tokens & words
159        &Avg. code length & Avg. title length & tokens & words \\
160        \hline
161        \hline
162        \textbf{CODE-NN} & 38 tokens & 12 words & 91k & 25k\\
163        \hline
164        \textbf{C2CGit} & \textbf{128 tokens} & \textbf{22 words} & \textbf{129,340k} & \textbf{22,299k}\\
165        \hline
166    \end{tabular}
167\end{table}
168
169\begin{figure}[!tpb]
170    \centering
171    \footnotesize
172    {\includegraphics[width=1\columnwidth]{hist.pdf} }
173    \caption{We make a comparison between C2CGit (blue) and CODE-NN (green). We can see that C2CGit is larger and more diversified.}
174    \label{hist}
175\end{figure}
176
177\textbf{Matching}. Through the above extraction process, one project would generate many code snippets and comment segments. The next step is to find a match between code snippets and comment segments. We extracted all identifiers other than keyword nodes from the AST of code snippets. Besides, the Java code prefer the camel case convention (e.g., StringBuilder can be divided into two terms, string and builder). Each term from code snippets is then broken down based on the camel case convention. Otherwise, if a term uses underline to connect two words, it can also be broken down. After these operations, a code snippet is broken down to many terms. Because comments are natural language, we use a tokenization tool\footnote{http://www.nltk.org/}, widely used in natural language processing to handle the comment segments. If one code snippet shares the most terms with another comment segment, the comment segment can be regarded as a translation matching to this code snippet.
178
179\textbf{Cleaning}. We use some prior knowledge to remove noise in the dataset. The noise is from two aspects. One is that we have various natural languages, the other is that the shared words between code snippets and comment segments are too few. Programmers coming from all around the world can upload projects to GitHub, and their comments usually contain non-English words. These comments would make the task more difficult but only occupy a small portion. Therefore, we deleted instances containing non-English words (non-ASCII characters) if they appear in either code snippets or comment segments. Some code snippets only share one word or two with comment segments, which suggests the comment segment can’t express the meaning of code. These code and comment pairs also should be deleted.
180
181
182
183\section{Proposed method: Code Attention Mechanism}
184\label{cd}
185
186In this section, we mainly talk about the Code Attention mechanism in the model. For the encoder-decoder structure, we first build a 3-layer translation model as Section 3 said, whose basic element is Gated Recurrent Unit (GRU). Then, we modify the classical attention module in encoder. To be specific, we consider the embedding of symbols in code snippets as learnable prior weights to evaluate the importance of different parts of input sequences.
187For convenience, we provide an overview of the entire model in Figure~\ref{attention}.
188
189\begin{figure*}[ht]
190    \centering
191    {\includegraphics[width=2\columnwidth]{arch.pdf} }
192    \caption{The whole model architecture. Note that Code Attention mainly contains 3 steps: Identifier Ordering, Token Encoding and Global Attention. The first two module are followed by two independent embedding layers as shown in the flow diagram above.}
193    \label{attention}
194\end{figure*}
195
196Unlike traditional statistical language translation, code snippets have some different characteristics, such as some identifiers ({\em{for}} and {\em{if}}) and different symbols (e.g., $\times, \div,=$). However, former works usually ignore these differences and employ the common encoding methods in NLP. In order to underline these identifiers and symbols, we simply import two strategies: Identifier Ordering and Token Encoding, after which we then develop a Global Attention module to learn their weights in input code snippets. We will first introduce details of Identifier Ordering and Token Encoding in the following.
197
198\textbf{Identifier Ordering}. As the name suggests, we directly sort {\em{for}} and {\em{if}} in code snippets based on the order they appear. After sorting,
199\begin{eqnarray}
200for/if \longrightarrow for/if + N \nonumber
201\end{eqnarray}
202where N is decided by the order of each identifier in its upper nest. For example, when we have multiple {\em if} and {\em for}, after identifier sorting, we have such forms,
203
204\begin{figure}[!htp]
205    \begin{lstlisting}[language=JAVA,morekeywords={FOR1,FOR2,IF1,IF2,ENDIF1,ENDIF2,ENDFOR1,ENDFOR2}]
206  FOR1(i=0; i<len - 1; i++)
207    FOR2(j=0; j<len - 1 - i; j++)
208      IF1(arr[j] > arr[j + 1])
209        temp = arr[j]
210        arr[j] = arr[j+1]
211        arr[j+1] = temp
212      ENDIF1
213    ENDFOR2
214  ENDFOR1\end{lstlisting}
215    \caption{An example of collected code snippet after identifier sorting.}
216    \label{idsort}
217\end{figure}
218We can see that replaced identifiers are able to convey the original order of each of them. It is worth noting that Identifier Ordering makes a difference among \em{fors} or \em{ifs} appeared in different loop levels.
219
220\textbf{Token Encoding}. In order to stress the distinction among tokens e.g. symbols, variables and keywords in code snippets, these tokens should be encoded in a way which helps make them more conspicuous than naive encoded inputs. To be specific, we first build a dictionary including all symbols, like $\times,\ \div,\ ;,\ \left\{,\ \right\}$ and keywords, such as $int, float, public, ...$  in code snippets. The tokens not containing in this dictionary are regarded as variables. Next, we construct an independent token vocabulary which is the same size as the vocabulary of all input snippets, and encode these tokens using an extra embedding matrix. The embedded tokens can be treated as learnable weights in Global Attention.
221
222\subsection{Global Attention}
223In order to underline the importance of symbols in code, we import a novel attention mechanism called Global Attention. We represent $\textbf{x}$ as a set of inputs. Let $Ident(\cdot)$ and $Sym(\cdot)$ stand for our \emph{Identifier ordering} and \emph{Token Encoding}, respectively. $E(\cdot)$ be used to represent the embedding method. The whole Global Attention operation can be summarized as,
224\begin{eqnarray}
225E(Sym\left(Ident\left(\textbf{x}\right)\right))\ \textcircled{$\times$}\ f_{e}(\textbf{x})
226\end{eqnarray}
227where $f_e(\cdot)$ is the encoder, \textcircled{$\times$} represents dot product to stress the effects of encoded tokens.
228
229After Token Encoding, we now have another token embedding matrix: $\textbf{F}$ for symbols. We set m as a set of 1-hot vectors $\textbf{m}_1,...,\textbf{m}_T\ \in\ \left\{0,1\right\}^{|F|}$ for each source code token.
230We represent the results of $E(Sym\left(Ident\left(CS\right)\right))$ as a set of vectors $\left\{\textbf{w}_{1}, ..., \textbf{w}_{T}\right\}$, which can be regarded as a learnable parameter for each token,
231\begin{eqnarray}
232\textbf{w}_{i}=\textbf{m}_i\textbf{F}
233\end{eqnarray}
234Since the context vector $\textbf{c}_t$ varies with time, the formation of context vector $c_t$ is as follows,
235\begin{equation}
236\textbf{c}_t=\sum_{i=1}^{T}\alpha_{t,i}(\textbf{w}_{i}\ \textcircled{$\times$}\ {\textbf{e}_{3,i}})
237\end{equation}
238where $\textbf{e}_{3, i}$ is the hidden state located at the 3rd layer and $i$th position ($i=1,\dots,T$) in the encoder, $T$ is the input size. $\alpha_{t,i}$ is the weight term of $i$th location at step $t$ in the input sequence, which is used to tackle the situation when input piece is overlength. Then we can get a new form of $\textbf{y}_t$,
239\begin{equation}
240\textbf{y}_t=f_{d}(\textbf{c}_t, \textbf{d}_{3,t-1}, \textbf{d}_{2,t}, \textbf{y}_{t-1})
241\end{equation}
242$f_d(\cdot)$ is the decoder function. $\textbf{d}_{3,t}$ is the hidden state located at the 3rd layer and $t$th step ($t=1,\dots,K$) in the decoder. Here, we assume that the length of output is $K$. Instead of LSTM in~\cite{attention}, we take GRU~\cite{GRU} as basic unit in both $f_{e}\left(\cdot\right)$ and $f_{d}\left(\cdot\right)$.  Note that the weight term $\alpha_{t,i}$ is normalized to $\left[0,1\right]$ using a softmax function,
243\begin{equation}
244\alpha_{t,i}=\frac{\exp(\textbf{s}_{t,i})}{\sum_{i=1}^{T}\exp(\textbf{s}_{t,i})},
245\end{equation}
246where $\textbf{s}_{t,i}=score(\textbf{d}_{3,t-1}, \textbf{e}_{3,i})$ scores how well the inputs around position $i$ and the output at position $t$ match. As in~\cite{bahdanau2014neural}, we parametrize the score function $score(\cdot)$ as a feed-forward neural network which is jointly trained with all the other components of the proposed architecture.
247
248\subsection{Ablation Study}
249For a better demonstration of the effect of Code Attention, we make a naive ablation study about it.
250\begin{table}[t]
251    \caption{Ablation study about effects of different parts in Code Attention. This table reports the BLEU-4 results of different combinations.}
252    \label{ab}
253    \centering
254    \footnotesize
255    \begin{tabular}{c|c|c|c|c}
256        & BLEU-4 & Ident & Token & Global Attention \\
257        \hline
258        \hline
259        \textcolor{gray} {1} & 16.72 & w/o & w/o & w/o \\
260        \textcolor{gray} {2} & 18.35 & w/ & w/o & w/o \\
261        \textcolor{gray} {3} & 22.38 & w/ & w/ & \textcircled{+}\\
262        \textcolor{gray} {4} & 24.62 & w/ & w/