CoaCor: Code Annotation for Code Retrieval with Reinforcement Learning

TL;DR

This paper introduces CoaCor, a reinforcement learning framework that generates detailed code annotations to improve code retrieval accuracy by better capturing the semantic meaning of code snippets.

Contribution

It presents a novel reinforcement learning approach to jointly optimize code annotation for enhanced code retrieval performance, bridging the gap between the two tasks.

Findings

Generated annotations are more detailed and semantically meaningful.

The framework significantly improves code retrieval accuracy.

Annotations enhance the distinguishability of relevant code snippets.

Abstract

To accelerate software development, much research has been performed to help people understand and reuse the huge amount of available code resources. Two important tasks have been widely studied: code retrieval, which aims to retrieve code snippets relevant to a given natural language query from a code base, and code annotation, where the goal is to annotate a code snippet with a natural language description. Despite their advancement in recent years, the two tasks are mostly explored separately. In this work, we investigate a novel perspective of Code annotation for Code retrieval (hence called `CoaCor'), where a code annotation model is trained to generate a natural language annotation that can represent the semantic meaning of a given code snippet and can be leveraged by a code retrieval model to better distinguish relevant code snippets from others. To this end, we propose an effective framework based on reinforcement learning, which explicitly encourages the code annotation model to generate annotations that can be used for the retrieval task. Through extensive experiments, we show that code annotations generated by our framework are much more detailed and more useful for code retrieval, and they can further improve the performance of existing code retrieval models significantly.

Figures

Tables

Table 1. Table 1 . The main code retrieval results (MRR). * denotes significantly different from DCS (Gu et al . , 2018 ) in one-tailed t-test (p ¡ 0.01).

Model	DEV	EVAL	StaQC-val	StaQC-test
Existing (QC-based) CR Baselines
DCS (Gu et al., 2018)	0.566	0.555	0.534	0.529
CODE-NN (Iyer et al., 2016)	0.530	0.514	0.526	0.522
QN-based CR Variants
QN-CodeNN	0.369	0.360	0.336	0.333
QN-MLE	0.429	0.411	0.427	0.424
QN-RLBLEU	0.426	0.402	0.386	0.381
QN-RLMRR (ours)	0.534	0.512	0.516	0.523
Ensemble CR Variants
QN-CodeNN + DCS	0.566	0.555	0.534	0.529
QN-MLE + DCS	0.571	0.561	0.543	0.537
QN-RLBLEU + DCS	0.570	0.559	0.541	0.534
QN-RLMRR + DCS (ours)	0.582∗	0.572∗	0.558∗	0.559∗
QN-RLMRR + CODE-NN (ours)	0.586∗	0.571∗	0.575∗	0.576∗

Table 2. Table 2 . Two examples of code snippets and their annotations generated by different CA models. “Human-provided” refers to (multiple) human-provided NL annotations or queries. Words semantically aligned between the generated and the human-provided annotations are highlighted.

Model	Annotation
Example 1 from EVAL set
SQL Code	SELECT col3, Format(Avg([col2]-[col1]),”hh:mm:ss”) AS TimeDiff FROM Table1 GROUP BY col3;
Human-provided	(1) find the average time in hours , mins and seconds between 2 values and show them in groups of another column (2) group rows of a table and find average difference between them as a formatted date (3) ms access average after subtracting
CODE-NN	how do i get the average of a column in sql?
MLE	how to get average of the average of a column in sql
RLBLEU	how to average in sql query
RLMRR	average avg calculating difference day in access select distinct column value sql group by month mysql format date function?
Example 2 from StaQC-test set
SQL Code	SELECT Group_concat(DISTINCT( p.products_id )) AS comma_separated, COUNT(DISTINCT p.products_id) AS product_count FROM …
Human-provided	how to count how many comma separated values in a group_concat
CODE-NN	how do i get the count of distinct rows?
MLE	mysql query to get count of distinct values in a column
RLBLEU	how to count in mysql sql query
RLMRR	group_concat count concatenate distinct comma group mysql concat column in one row rows select multiple columns of same id result

Table 3. Table 3 . The BLEU score of each code annotation model.

Model	DEV	EVAL	StaQC-val	StaQC-test
CODE-NN (Iyer et al., 2016)	17.43	16.73	8.89	8.96
MLE	18.99	19.87	10.52	10.55
RLBLEU	21.12	18.52	12.72	12.78
RLMRR	8.09	8.52	5.56	5.60

Equations

$$C^{\ast }=\underset{C\in \text{mathds}C}{\mathrm{argmax}}{F}_r(Q,C)$$

$$N^{\ast }=\underset{N}{\mathrm{argmax}}{F}_a(C,N)$$

$$i=\sigma ({\mathbf{W}}_i{h}_{t-1}+{\mathbf{U}}_i{x}_t+b_i)$$

$$f=\sigma ({\mathbf{W}}_f{h}_{t-1}+{\mathbf{U}}_f{x}_t+b_f)$$

$$o=\sigma ({\mathbf{W}}_o{h}_{t-1}+{\mathbf{U}}_o{x}_t+b_o)$$

$$g=\tanh ({\mathbf{W}}_g{h}_{t-1}+{\mathbf{U}}_g{x}_t+b_g)$$

$$g_t=f\odot g_{t-1}+i\odot g$$

$$h_t=o\odot \tanh (g_t)$$

$$h_t=\mathrm{LSTM}(x_t,h_{t-1})$$

$$\overrightarrow{h_t}=\mathrm{LSTM}(x_t,\overrightarrow{h_{t-1}})$$

$$\overleftarrow{h_t}=\mathrm{LSTM}(x_t,\overleftarrow{h_{t+1}})$$

$$h_t=[\overrightarrow{h_t},\overleftarrow{h_t}]$$

$$v=\tanh (\mathrm{maxpooling}([h_1,h_2,...,h_T]))$$

$$\mathcal{L}(\theta )=\sum _{<Q,C,C^{-}>}max(0,ϵ-cos(v_q,v_c)+cos(v_q,v_{c^{-}}))$$

$$P(N|C)=P(n_1|n_0,C)\prod _{t=2}^{|N|}P(n_t|n_{\mathrm{1..}t-1},C)$$

$$h_t^{\text{dec}}=\mathrm{LSTM}(n_{t-1},h_{t-1}^{\text{dec}}),\forall t=1,...,|N|$$

$${\tilde{h}}_t^{\text{dec}}=\tanh ({\mathbf{W}}_{\alpha }[v_{\text{attn}},h_t^{\text{dec}}])$$

$$v_{\text{attn}}=\sum _{t^{\prime }=1}^{|C|}{\alpha }_{t^{\prime }}{h}_{t^{\prime }}^{\text{enc}}$$

$${\alpha }_{t^{\prime }}=\mathrm{softmax}((h_{t^{\prime }}^{\text{enc}}{)}^T{h}_t^{\text{dec}})$$

$$P(n_t|n_{\mathrm{0..}t-1},C)=\mathrm{softmax}(\mathbf{W}{\tilde{h}}_t^{\text{dec}}+b)$$

$$r(s_t,n_t)=\{\begin{array}{ll}\text{RetrievalReward}(C,n_{\mathrm{1..}t})& \text{if }{n}_t=\text{<EOS>}\\ 0& \text{otherwise}\end{array}$$

$$P(n_t|s_t)=P(n_t|n_{\mathrm{1..}t-1},C)=\mathrm{softmax}(\mathbf{W}{\tilde{h}}_t^{dec}+b)$$

$$\underset{\varphi }{\max }\mathcal{L}(\varphi )=\underset{\varphi }{\max }\text{mathds}{E}_{N\sim P(\cdot |C;\varphi )}[R(C,N)]$$

$$\begin{array}{rl}{\nabla }_{\varphi }\mathcal{L}(\varphi )& =\text{mathds}{E}_{N\sim P(\cdot |C;\varphi )}[R(C,N){\nabla }_{\varphi }\log P(N|C;\varphi )]\\ & =\text{mathds}{E}_{n_{1..|N|}\sim P(\cdot |C;\varphi )}[\sum _{t=1}^{|N|}{R}_t(s_t,n_t){\nabla }_{\varphi }\log P(n_t|n_{\mathrm{1..}t-1},C;\varphi )]\end{array}$$

$${\nabla }_{\varphi }\mathcal{L}(\varphi )=\text{mathds}E[\sum _{t=1}^{|N|}{A}_t{\nabla }_{\varphi }\log P(n_t|n_{\mathrm{1..}t-1},C;\varphi )]$$

$$A_t=R_t(s_t,n_t)-V(s_t)$$

$$V(s_t)=\text{mathds}{E}_{{\hat{n}}_t\sim P(\cdot |n_{\mathrm{1..}t-1},C)}[R_t(s_t,{\hat{n}}_t)]$$

$$V(s_t;\rho )={\mathbf{w}}_{\rho }^T({\tilde{h}}_t^{dec}{)}_{crt}+b_{\rho }$$

$$\underset{\rho }{\min }\mathcal{L}(\rho )=\underset{\rho }{\min }\text{mathds}{E}_{N\sim P(\cdot |C)}[\sum _{t=1}^{|N|}(V(s_t;\rho )-R(C,N){)}^2]$$

$$\mathrm{score}(Q,C)=\lambda \ast cos(v_q,v_n)+(1-\lambda )\ast cos(v_q,v_c)$$

$$MRR=\frac{1}{|\mathcal{D}|}\sum _{i=1}^{|\mathcal{D}|}\frac{1}{Ran{k}_i}$$

Full text

Code Annotation; Code Retrieval; Reinforcement Learning

††journalyear: 2019††copyright: iw3c2w3††conference: Proceedings of the 2019 World Wide Web Conference; May 13–17, 2019; San Francisco, CA, USA††booktitle: Proceedings of the 2019 World Wide Web Conference (WWW ’19), May 13–17, 2019, San Francisco, CA, USA††doi: 10.1145/3308558.3313632††isbn: 978-1-4503-6674-8/19/05††ccs: Information systems Novelty in information retrieval††ccs: Information systems Summarization††ccs: Software and its engineering††ccs: Computing methodologies Reinforcement learning††ccs: Computing methodologies Markov decision processes††ccs: Computing methodologies Neural networks

1. Introduction

Software engineering plays an important role in modern society. Almost every aspect of human life, including health care, education, transportation and web security, depends on reliable software (Allamanis et al., 2018). Unfortunately, developing and maintaining large code bases are very costly. Understanding and reusing billions of lines of code in online open-source repositories can significantly speed up the software development process. Towards that, code retrieval (CR) and code annotation (CA) are two important tasks that have been widely studied in the past few years (Allamanis et al., 2018; Gu et al., 2018; Iyer et al., 2016; Hu et al., 2018a; Wan et al., 2018), where the former aims to retrieve relevant code snippets based on a natural language (NL) query while the latter is to generate natural language descriptions to describe what a given code snippet does.

Most existing work (Gu et al., 2018; Hu et al., 2018a; Wan et al., 2018; Allamanis et al., 2016; Jiang et al., 2017; Wang et al., 2018) study either code annotation or code retrieval individually. Earlier approaches for code retrieval drew inspiration from the information retrieval field (Haiduc et al., 2013; Lu et al., 2015; Hill et al., 2014; Keivanloo et al., 2014) and suffered from surface form mismatches between natural language queries and code snippets (Biggerstaff et al., 1994; McMillan et al., 2012). More recently, advanced deep learning approaches have been successfully applied to both code retrieval and code annotation (Allamanis et al., 2018; Gu et al., 2018; Allamanis et al., 2016; Hu et al., 2018a; Iyer et al., 2016; Wang et al., 2018; Jiang et al., 2017; Loyola et al., 2017; Hu et al., 2018b; Wan et al., 2018; Chen and Zhou, 2018). For example, the code retrieval model proposed by Gu et al. (2018) utilized two deep neural networks to learn the vector representation of a natural language query and that of a code snippet respectively, and adopted cosine similarity to measure their matching degree. For code annotation, Iyer et al. (2016) and Hu et al. (2018a) utilized encoder-decoder models with an attention mechanism to generate an NL annotation for a code snippet. They aim to generate annotations similar to the human-provided ones, and therefore trained the models using the standard maximum likelihood estimation (MLE) objective. For the same purpose, Wan et al. (2018) trained the code annotation model in a reinforcement learning (RL) framework with reward being the BLEU score (Papineni et al., 2002), which measures n-gram matching precision between the currently generated annotation and the human-provided one.

In this work, we explore a novel perspective - code annotation for code retrieval (CoaCor), which is to generate an NL annotation for a code snippet so that the generated annotation can be used for code retrieval (i.e.,* can represent the semantic meaning of a code snippet and distinguish it from others w.r.t. a given NL query in the code retrieval task*). As exemplified by (Vinayakarao et al., 2017), such an annotation can be taken as the representation of the corresponding code snippet, based on which the aforementioned lexical mismatch issue in a naive keyword-based search engine can be alleviated. A similar idea of improving retrieval by adding extra annotations to items is also explored in document retrieval (Scholer et al., 2004) and image search (Wikipedia contributors, 2019). However, most of them rely on humans to provide the annotations. Intuitively, our perspective can be interpreted as one type of machine-machine collaboration: On the one hand, the NL annotation generated by the code annotation model can serve as a second view of a code snippet (in addition to its programming content) and can be utilized to match with an NL query in code retrieval. On the other hand, with a goal to facilitate code retrieval, the code annotation model can be stimulated to produce rich and detailed annotations. Unlike existing work (Iyer et al., 2016; Hu et al., 2018a; Wan et al., 2018; Hu et al., 2018b), our goal is not to generate an NL annotation as close as possible to a human-provided one; hence, the MLE objective or the BLEU score as rewards for code annotation will not fit our setting. Instead, we design a novel rewarding mechanism in an RL framework, which guides the code annotation model directly based on how effectively the currently generated code annotation distinguishes the code snippet from a candidate set.

Leveraging collaborations and interactions among machine learning models to improve the task performance has been explored in other scenarios. Goodfellow et al. (2014) proposed the Generative Adversatial Nets (GANs), where a generative model produces difficult examples to fool a discriminative model and the latter is further trained to conquer the challenge. He et al. (2016) proposed another framework called dual learning, which jointly learns two dual machine translation tasks (e.g., En -¿ Fr and Fr -¿ En). However, none of the existing frameworks are directly applicable to accomplish our goal (i.e., to train a code annotation model for generating annotations that can be utilized for code retrieval).

Figure 1 shows our reinforcement learning-based CoaCor framework. In the training phase, we first train a CR model based on ¡natural language query, code snippet¿ (QC) pairs (referred to as QC-based CR model). Then given a code snippet, the CA model generates a sequence of NL tokens as its annotation and receives a reward from the trained CR model, which measures how effectively the generated annotation can distinguish the code snippet from others. We formulate the annotation generation process as a Markov Decision Process (Bellman, 1957) and train the CA model to maximize the received reward via an advanced reinforcement learning (Sutton and Barto, 1998) framework called Advantage Actor-Critic or A2C (Mnih et al., 2016). Once the CA model is trained, we use it to generate an NL annotation $N$ for each code snippet $C$ in the code base. Therefore, for each QC pair we originally have, we can derive a QN pair. We utilize the generated annotation as a second view of the code snippet to match with a query and train another CR model based on the derived QN pairs (referred to as QN-based CR model). In the testing phase, given an NL query, we rank code snippets by combining their scores from both the QC-based as well as QN-based CR models, which utilize both the programming content as well as the NL annotation of a code snippet.

On a widely used benchmark dataset (Iyer et al., 2016) and a recently collected large-scale dataset (Yao et al., 2018), we show that the automatically generated annotation can significantly improve the retrieval performance. More impressively, without looking at the code content, the QN-based CR model trained on our generated code annotations obtains a retrieval performance comparable to one of the state-of-the-art QC-based CR models. It also surpasses other QN-based CR models trained using code annotations generated by existing CA models.

To summarize, our major contributions are as follows:

• •

First, we explored a novel perspective of generating useful code annotations for code retrieval. Unlike existing work (Iyer et al., 2016; Hu et al., 2018a; Wan et al., 2018), we do not emphasize the n-gram overlap between the generated annotation and the human-provided one. Instead, we examined the real usefulness of the generated annotations and developed a machine-machine collaboration paradigm, where a code annotation model is trained to generate annotations that can be used for code retrieval.

• •

Second, in order to accomplish our goal, we developed an effective RL-based framework with a novel rewarding mechanism, in which a code retrieval model is directly used to formulate rewards and guide the annotation generation.

• •

Last, we conducted extensive experiments by comparing our framework with various baselines including state-of-the-art models and variants of our framework. We showed significant improvements of code retrieval performance on both a widely used benchmark dataset and a recently collected large-scale dataset.

The rest of this paper is organized as follows. Section 2 introduces the background on code annotation and code retrieval tasks. Section 3 gives an overview of our proposed framework, with algorithm details followed in Section 4. Experiments are shown in Section 5. Finally, we discuss related work and conclude in Section 6 and 7.

2. Background

We adopt the same definitions for code retrieval and code annotation as previous work (Iyer et al., 2016; Chen and Zhou, 2018). Given a natural language query $Q$ and a set of code snippet candidates $\mathds{C}$, code retrieval is to retrieve code snippets $C^{*}$ $\in$ $\mathds{C}$ that can match with the query. On the other hand, given a code snippet $C$, code annotation is to generate a natural language (NL) annotation $N^{*}$ which describes the code snippet appropriately. In this work, we use code search and code retrieval interchangeably (and same for code annotation/summary/description).

Formally, for a training corpus with ¡natural language query, code snippet¿ pairs, e.g., those collected from Stack Overflow (Stack Overflow, 2018) by (Iyer et al., 2016; Yao et al., 2018), we define the two tasks as:

Code Retrieval (CR): Given an NL Query $Q$, a model $F_{r}$ will be learnt to retrieve the highest scoring code snippet $C^{*}$ $\in$ $\mathds{C}$.

[TABLE]

Code Annotation (CA): For a given code snippet $C$, the goal is to generate an NL annotation $N^{*}$ that maximizes a scoring function $F_{a}$:

[TABLE]

Note that one can use the same scoring model for $F_{r}$ and $F_{a}$ as in (Iyer et al., 2016; Chen and Zhou, 2018), but for most of the prior work (Gu et al., 2018; Hu et al., 2018a, b; Wan et al., 2018), which consider either code retrieval or code annotation, researchers usually develop their own models and objective functions for $F_{r}$ or $F_{a}$. In our work, we choose two vanilla models as our base models for CR and CA, but explore a novel perspective of how to train $F_{a}$ so that it can generate NL annotations that can be used for code retrieval. This perspective is inspired by various machine-machine collaboration mechanisms (He et al., 2016; Wang et al., 2017; Tang et al., 2017; Li et al., 2018a) where one machine learning task can help improve another.

3. Framework Overview

In this section, we first introduce our intuition and give an overview of the entire framework, before diving into more details.

3.1. Intuition behind CoaCor

To the best of our knowledge, previous code annotation work like (Iyer et al., 2016; Hu et al., 2018a, b; Wan et al., 2018) focused on getting a large n-gram overlap between generated and human-provided annotations. However, it is still uncertain (and non-trivial to test) how helpful the generated annotations can be. Driven by this observation, we are the first to examine the real usefulness of the generated code annotations and how they can help a relevant task, of which we choose code retrieval as an example.

Intuitively, CoaCor can be interpreted as a collaboration mechanism between code annotation and code retrieval. On the one hand, the annotation produced by the CA model provides a second view of a code snippet (in addition to its programming content) to assist code retrieval. On the other hand, when the CA model is trained to be useful for the retrieval task, we expect it to produce richer and more detailed annotations, which we verify in experiments later.

3.2. Overview

The main challenge to realize the above intuition lies in how to train the CA model effectively. Our key idea to address the challenge is shown in Figure 1.

We first train a base CR model on $<$natural language query, code snippet$>$ (QC) pairs. Intuitively, a QC-based CR model ranks a code snippet $C$ by measuring how well it matches with the given query $Q$ (in comparison with other code snippets in the code base). From another point of view, a well-trained QC-based CR model can work as a measurement on whether the query $Q$ describes the code snippet $C$ precisely or not. Drawing inspiration from this view, we propose using the trained QC-based CR model to determine whether an annotation describes its code snippet precisely or not and thereby, train the CA model to generate rich annotations to maximize the retrieval-based reward from the CR model. Specifically, given a code snippet $C$, the CA model generates a sequence of NL words as its annotation $N$. At the end of the sequence, we let the trained QC-based CR model use $N$ to search for relevant code snippets from the code base. If $C$ can be ranked at top places, the annotation $N$ is treated as well-written and gets a high reward; otherwise, a low reward will be returned. We formulate this generation process as the Markov Decision Process (Bellman, 1957) and train the CA model with reinforcement learning (Sutton and Barto, 1998) (specifically, the Advantage Actor-Critic algorithm (Mnih et al., 2016)) to maximize the retrieval-based rewards it can receive from the QC-based CR model. We elaborate the CR and CA model details as well as the RL algorithm for training the CA model in Section 4.1 $\sim$ 4.3.

Once the CA model is trained, in the testing phase, it generates an NL annotation $N$ for each code snippet $C$ in the code base. Now for each $<$NL query, code snippet$>$ pair originally in the datasets, we derive an $<$NL query, code annotation$>$ (QN) pair and train another CR model based on such QN pairs. This QN-based CR model complements the QC-based CR model, as they respectively use the annotation and programming content of a code snippet to match with the query. We finally combine the matching scores from the two CR models to rank code snippets for a given query.

Note that we aim to outline a general paradigm to explore the perspective of code annotation for code retrieval, where the specific model structures for the two CR models and the CA model can be instantiated in various ways. In this work, we choose one of the simplest and most fundamental deep structures for each of them. Using more complicated model structures will make the training more challenging and we leave it as future work.

4. Code Annotation for Code Retrieval

Now we introduce model and algorithm details in our framework.

4.1. Code Retrieval Model

Both QC-based and QN-based code retrieval models adopt the same deep learning structure as the previous CR work (Gu et al., 2018). Here for simplicity, we only illustrate the QC-based CR model in detail, and the QN-based model structure is the same except that we use the generated annotation on the code snippet side.

As shown in Figure 2, given an NL query $Q=w_{1..|Q|}$ and a code snippet $C=c_{1..|C|}$, we first embed the tokens of both code and NL query into vectors through a randomly initialized word embedding matrix, which will be learned during model training. We then use a bidirectional Long Short-Term Memory (LSTM)-based Recurrent Neural Network (RNN) (Hochreiter and Schmidhuber, 1997; Gers et al., 1999; Medsker and Jain, 1999; Schuster and Paliwal, 1997; Goller and Kuchler, 1996; Zaremba et al., 2014) to learn the token representation by summarizing the contextual information from both directions. The LSTM unit is composed of three multiplicative gates. At every time step $t$, it tracks the state of sequences by controlling how much information is updated into the new hidden state $h_{t}$ and memory cell $g_{t}$ from the previous state $h_{t-1}$, the previous memory cell $g_{t-1}$ and the current input $x_{t}$. On the code side, $x_{t}$ is the embedding vector for $c_{t}$, and on the NL query side, it is the embedding vector for $w_{t}$. At every time step $t$, the LSTM hidden state is updated as:

[TABLE]

where $\sigma$ is the element-wise sigmoid function and $\odot$ is the element-wise product. $\mathbf{U}_{i}$, $\mathbf{U}_{f}$, $\mathbf{U}_{g}$, $\mathbf{U}_{o}$ denote the weight matrices of different gates for input $x_{t}$ and $\mathbf{W}_{i}$, $\mathbf{W}_{f}$, $\mathbf{W}_{g}$, $\mathbf{W}_{o}$ are the weight matrices for hidden state $h_{t}$, while $b_{i}$, $b_{f}$, $b_{g}$, $b_{o}$ denote the bias vectors. For simplicity, we denote the above calculation as below (the memory cell vector $g_{t-1}$ is omitted):

[TABLE]

The vanilla LSTM’s hidden state $h_{t}$ takes information from the past, knowing nothing about the future. Our CR model instead incorporates a bidirectional LSTM (Schuster and Paliwal, 1997) (i.e., Bi-LSTM in Figure 2), which contains a forward LSTM reading a sequence $X$ from start to end and a backward LSTM which reads from end to start. The basic idea of using two directions is to capture past and future information at each step. Then the two hidden states at each time step $t$ are concatenated to form the final hidden state $h_{t}$.

[TABLE]

Finally, we adopt the commonly used max pooling strategy (Kim, 2014) followed by a $tanh$ layer to get the embedding vector for a sequence of length $T$.

[TABLE]

By applying the above encoding algorithm, we encode the code snippet $C$ and the NL query $Q$ into $v_{c}$ and $v_{q}$, respectively. Similar to Gu et al. (2018), to measure the relevance between the code snippet and the query, we use cosine similarity denoted as $cos(v_{q},v_{c})$.

The higher the similarity, the more related the code is to the query.

Training. The CR model is trained by minimizing a ranking loss similar to (Gu et al., 2018). Specifically, for each query $Q$ in the training corpus, we prepare a triple of ¡$Q,C,C^{-}$¿ as a training instance, where $C$ is the correct code snippet that answers Q and $C^{-}$ is a negative code snippet that does not answer $Q$ (which is randomly sampled from the entire code base). The ranking loss is defined as:

[TABLE]

where $\theta$ denotes the model parameters, $\epsilon$ is a constant margin, and $v_{q}$, $v_{c}$ and $v_{c^{-}}$ are the encoded vectors of $Q$, $C$ and $C^{-}$ respectively. Essentially, the ranking loss is a kind of hinge loss (Rosasco et al., 2004) that promotes the cosine similarity between $Q$ and $C$ to be greater than that between $Q$ and $C^{-}$ by at least a margin $\epsilon$. The training leads the model to project relevant queries and code snippets to be close in the vector space.

4.2. Code Annotation Model

Formally, given a code snippet $C$, the CA model computes the probability of generating a sequence of NL tokens $n_{1..|N|}=(n_{1},n_{2},...,n_{|N|})$ as its annotation $N$ by:

[TABLE]

where $n_{0}$ is a special token ”¡START¿” indicating the start of the annotation generation, $n_{1..t-1}=(n_{1},...,n_{t-1})$ is the partially generated annotation till time step $t$-1, and $P(n_{t}|n_{1..t-1},C)$ is the probability of producing $n_{t}$ as the next word given the code snippet $C$ and the generated $n_{1..t-1}$. The generation stops once a special token ”¡EOS¿” is observed.

In this work, we choose the popular sequence-to-sequence model (Sutskever et al., 2014) as our CA model structure, which is composed of an encoder and a decoder. We employ the aforementioned bidirectional LSTM-based RNN structure as the encoder for code snippet $C$, and use another LSTM-based RNN as the decoder to compute Eqn. (6):

[TABLE]

where $h_{t}^{\text{dec}}$ is the decoder hidden state at step $t$, and $h_{0}^{\text{dec}}$ is initialized by concatenating the last hidden states of the code snippet encoder in both directions. In addition, a standard global attention layer (Luong et al., 2015) is applied in the decoder, in order to attend to important code tokens in $C$:

[TABLE]

where $\alpha_{t^{\prime}}$ is the attention weight on the $t^{\prime}$-th code token when generating the $t$-th word in the annotation, and $\mathbf{W}_{\alpha}$ is a learnable weight matrix. Finally, the $t$-th word is selected based on:

[TABLE]

where $\mathbf{W}\in R^{|V_{n}|\times d},b\in R^{|V_{n}|}$ project the $d$-dim hidden state $\tilde{h}_{t}^{\text{dec}}$ to the NL vocabulary of size $|V_{n}|$.

4.3. Training Code Annotation via RL

4.3.1. Code Annotation as Markov Decision Process.

Most previous work (Iyer et al., 2016; Hu et al., 2018a; Chen and Zhou, 2018) trained the CA model by maximizing the log-likelihood of generating human annotations, which suffers from two drawbacks: (1) The exposure bias issue (Ranzato et al., 2015; Bahdanau et al., 2016; Rennie et al., 2017). That is, during training, the model predicts the next word given the ground-truth annotation prefix, while at testing time, it generates the next word based on previous words generated by itself. This mismatch between training and testing may result in error accumulation in testing phase. (2) More importantly, maximizing the likelihood is not aligned with our goal to produce annotations that can be useful for code retrieval.

To address the above issues, we propose to formulate code annotation within the reinforcement learning (RL) framework (Sutton and Barto, 1998). Specifically, the annotation generation process is viewed as a Markov Decision Process (MDP) (Bellman, 1957) consisting of four main components:

State. At step $t$ during decoding, a state $s_{t}$ maintains the source code snippet and the previously generated words $n_{1..t-1}$, i.e., $s_{t}=\{C,n_{1..t-1}\}$. In particular, the initial decoding state $s_{0}=\{C\}$ only contains the given code snippet $C$. In this work, we take the hidden state vector $\tilde{h}_{t}^{dec}$ as the vector representation of state $s_{t}$, and the MDP is thus processing on a continuous and infinite state space.

Action. The CA model decides the next word (or action) $n_{t}\in V_{n}$, where $V_{n}$ is the NL vocabulary. Thus, the action space in our formulation is the NL vocabulary.

Reward. As introduced in Section 3, to encourage it to generate words useful for the code retrieval task, the CA model is rewarded by a well-trained QC-based CR model based on whether the code snippet $C$ can be ranked at the top positions if using the generated complete annotation $N$ as a query. Therefore, we define the reward at each step $t$ as:

[TABLE]

where we use the popular ranking metric Mean Reciprocal Rank (Voorhees et al., 1999) (defined in Section 5.2) as the $\text{RetrievalReward}(C,{N})$ value. Note that, in this work, we let the CR model give a valid reward only when the annotation generation stops, and assign a zero reward to intermediate steps. However, other designs such as giving rewards to a partial generation with the reward shaping technique (Bahdanau et al., 2016) can be reasonable and explored in the future.

Policy. The policy function $P(n_{t}|s_{t})$ takes as input the current state $s_{t}$ and outputs the probability of generating $n_{t}$ as the next word. Given our definition about state $s_{t}$ and Eqn. (7),

[TABLE]

Here, the policy function is stochastic in that the next word can be sampled according to the probability distribution, which allows action space exploration and can be optimized using policy gradient methods (Sutton and Barto, 1998).

The objective of the CA model training is to find a policy function $P(N|C)$ that maximizes the expected accumulative future reward:

[TABLE]

where $\phi$ is the parameter of $P$ and $R(C,N)=\sum_{t=1}^{|N|}r(s_{t},n_{t})$ is the accumulative future reward (called “return”).

The gradient of the above objective is derived as below.

[TABLE]

where $R_{t}(s_{t},n_{t})=\sum_{t^{\prime}\geq t}r(s_{t^{\prime}},n_{t^{\prime}})$ is the return for generating word $n_{t}$ given state $s_{t}$.

4.3.2. Advantage Actor-Critic for Code Annotation.

Given the gradient in Eqn. (10), the objective in Eqn. (9) can be optimized by policy gradient approaches such as REINFORCE (Williams, 1992) and Q-value Actor-Critic algorithm (Sutton et al., 2000; Bahdanau et al., 2016). However, such methods may yield very high variance when the action space (i.e., the NL vocabulary) is large and suffer from biases when estimating the return of rarely taken actions (Nguyen et al., 2017), leading to unstable training. To tackle the challenge, we resort to the more advanced Advantage Actor-Critic or A2C algorithm (Mnih et al., 2016), which has been adopted in other sequence generation tasks (Nguyen et al., 2017; Wan et al., 2018). Specifically, the gradient function in Eqn. (10) is replaced by an advantage function:

[TABLE]

where $V(s_{t})$ is the state value function that estimates the future reward given the current state $s_{t}$. Intuitively, $V(s_{t})$ works as a baseline function (Williams, 1992) to help the model assess its action $n_{t}$ more precisely: When advantage $A_{t}$ is greater than zero, it means that the return for taking action $n_{t}$ is better than the “average” return over all possible actions, given state $s_{t}$; otherwise, action $n_{t}$ performs worse than the average.

Following previous work (Mnih et al., 2016; Nguyen et al., 2017; Wan et al., 2018), we approximate $V(s_{t})$ by learning another model $V(s_{t};\rho)$ parameterized by $\rho$, and the RL framework thus contains two components: the policy function $P(N|C;\phi)$ that generates the annotation (called “Actor”), and the state value function $V(s_{t};\rho)$ that approximates the return under state $s_{t}$ (called “Critic”). Similar to the actor model (i.e., the CA model in Section 4.2), we train a separate attention-based sequence-to-sequence model as the critic network. The critic value is finally computed by:

[TABLE]

where $(\tilde{h}_{t}^{dec})_{crt}\in R^{d}$ is the critic decoder hidden state at step $t$, and $\mathbf{w}_{\rho}\in R^{d}$, $b_{\rho}\in R$ are trainable parameters that project the hidden state to a scalar value (i.e., the estimated state value).

The critic network is trained to minimize the Mean Square Error between its estimation and the true state value:

[TABLE]

The entire training procedure of CoaCor is shown in Algorithm 1.

4.4. Generated Annotations for Code Retrieval

As previously shown in Figure 1, in the testing phase, we utilize the generated annotations to assist the code retrieval task. Now we detail the procedure in Algorithm 2. Specifically, for each ¡NL query, code snippet¿ pair (i.e., QC pair) in the dataset, we first derive an ¡NL query, code annotation¿ pair (i.e., QN pair) using the code annotation model. We then build another code retrieval (CR) model based on the QN pairs in our training corpus. In this work, for simplicity, we choose the same structure as the QC-based CR model (Section 4.1) to match QN pairs. However, more advanced methods for modeling the semantic similarity between two NL sentences (e.g., previous work on NL paraphase detection (He and Lin, 2016; Lan and Xu, 2018)) are applicable and can be explored as future work.

The final matching score between query $Q$ and code snippet $C$ combines those from the QN-based and QC-based CR model:

[TABLE]

where $v_{q},v_{c},v_{n}$ are the encoded vectors of $Q$, $C$, and the code annotation $N$ respectively. $\lambda\in[0,1]$ is a weighting factor for the two scores to be tuned on the validation set.

5. Experiments

In this section, we conduct extensive experiments and compare our framework with various models to show its effectiveness.

5.1. Experimental Setup

Dataset. (1) We experimented with the StaQC dataset presented by Yao et al. (2018). The dataset contains 119,519 SQL ¡question title, code snippet¿ pairs mined from Stack Overflow (Stack Overflow, 2018), making itself the largest-to-date in SQL domain. In our code retrieval task, the question title is considered as the NL query $Q$, which is paired with the code snippet $C$ to form the QC pair. We randomly selected 75% of the pairs for training, 10% for validation (containing 11,900 pairs), and the left 15% for testing (containing 17,850 pairs). As mentioned in (Yao et al., 2018), the dataset may contain multiple code snippets for the same NL query. We examine the dataset split to ensure that alternative relevant code snippets for the same query would not be sampled as negative code snippets when training the CR model. For pretraining the CA model, we consider the question title as a code annotation $N$ and form QN pairs accordingly. (2) Iyer et al. (2016) collected two small sets of SQL code snippets (called “DEV” and “EVAL” respectively) from Stack Overflow for validation and testing. In addition to the originally paired question title, each code snippet is manually annotated by two different NL descriptions. Therefore, in total, each set contains around 100 code snippets with three NL descriptions (resulting in around 300 QC pairs). We use them as additional datasets for model comparison.222Previous work (Iyer et al., 2016; Chen and Zhou, 2018) used only one of the three descriptions while we utilize all of them to enrich and enlarge the datasets for a more reliable evaluation. Following (Iyer et al., 2016), QC pairs occuring in DEV and EVAL set or being used as negative code snippets by them are removed from the StaQC training set.

Data Preprocessing. We followed (Iyer et al., 2016) to perform code tokenization, which replaced table/column names with placeholder tokens and numbered them to preserve their dependencies. For text tokenization, we utilized the ”word_tokenize” tool in the NLTK toolkit (Bird and Loper, 2004). All code tokens and NL tokens with a frequency of less than 2 were replaced with an ¡UNK¿ token, resulting in totally 7726 code tokens and 7775 word tokens in the vocabulary. The average lengths of the NL query and the code snippet are 9 and 60 respectively.

5.2. Evaluation

We evaluate a model’s retrieval performance on four datasets: the validation (denoted as “StaQC-val”) and test set (denoted as “StaQC-test”) from StaQC (Yao et al., 2018), and the DEV and EVAL set from (Iyer et al., 2016). For each ¡NL query $Q$, code snippet $C$¿ pair (or QC pair) in a dataset, we take $C$ as a positive code snippet and randomly sample $K$ negative code snippets from all others except $C$ in the dataset,333For DEV and EVAL, we use the same negative examples as (Iyer et al., 2016). and calculate the rank of $C$ among the $K+1$ candidates. We follow (Iyer et al., 2016; Chen and Zhou, 2018; Yao et al., 2018) to set $K=49$. The retrieval performance of a model is then assessed by the Mean Reciprocal Rank (MRR) metric (Voorhees et al., 1999) over the entire set $\mathcal{D}=\{(Q_{1},C_{1}),(Q_{2},C_{2}),...,(Q_{|\mathcal{D}|},C_{|\mathcal{D}|})\}$:

[TABLE]

where $Rank_{i}$ is the rank of $C_{i}$ for query $Q_{i}$. The higher the MRR value, the better the code retrieval performance.

5.3. Methods to Compare

In order to test the effectiveness of our CoaCor framework, we compare it with both existing baselines and our proposed variants.

Existing Baselines. We choose the following state-of-the-art code retrieval models, which are based on QC pairs, for comparison.

• •

Deep Code Search (DCS) (Gu et al., 2018). The original DCS model (Gu et al., 2018) adopts a similar structure as Figure 2 for CR in Java domain. To learn the vector representations for code snippets, in addition to code tokens, it also considers features like function names and API sequences, all of which are combined into a fully connected layer. In our dataset, we do not have these features, and thus slightly modify their original model to be the same as our QC-based CR model (Figure 2).

• •

CODE-NN (Iyer et al., 2016). CODE-NN is one of the state-of-the-art models for both code retrieval and code annotation. Its core component is an LSTM-based RNN with an attention mechanism, which models the probability of generating an NL sentence conditioned on a given code snippet. For code retrieval, given an NL query, CODE-NN computes the likelihood of generating the query as an annotation for each code snippet and ranks code snippets based on the likelihood.

QN-based CR Variants. As discussed in Section 4.4, a trained CA model is used to annotate each code snippet $C$ in our datasets with an annotation $N$. The resulting ¡NL query $Q$, code annotation $N$¿ pairs can be used to train a QN-based CR model. Depending on how we train the CA model, we have the following variants:

• •

QN-MLE. Similar to most previous work (Iyer et al., 2016; Hu et al., 2018a; Chen and Zhou, 2018), we simply train the CA model in the standard MLE manner, i.e., by maximizing the likelihood of a human-provided annotation.

• •

QN-RLBLEU. As introduced in Section 1, Wan et al. (2018) proposed to train the CA model via reinforcement learning with BLEU scores (Papineni et al., 2002) as rewards. We compare this variant with our rewarding mechanism.

• •

QN-RLMRR. In our CoaCor framework, we propose to train the CA model using retrieval rewards from a QC-based CR model (see Section 3). Here we use the MRR score as the retrieval reward.

Since CODE-NN (Iyer et al., 2016) can be used for code annotation as well, we also use its generated code annotations to train a QN-based CR model, denoted as “QN-CodeNN”.444There is another recent code annotation method named DeepCom (Hu et al., 2018a). We did not include it as baseline, since it achieved a similar performance as our MLE-based CA model (see Table 3) when evaluated with the standard BLEU script by (Iyer et al., 2016).

Ensemble CR Variants. As introduced in Section 4.4, we tried ensembling the QC-based CR model and the QN-based CR model to improve the retrieval performance. We choose the DCS structure as the QC-based CR model as mentioned in Section 4.1. Since different QN-based CR models can be applied, we present the following 4 variants: (1) QN-MLE + DCS, (2) QN-RLBLEU + DCS, (3) QN-RLMRR + DCS, and (4) QN-CodeNN + DCS, where QN-MLE, QN-RLBLEU, QN-RLMRR, and QN-CodeNN have been introduced.

5.4. Implementation Details

Our implementation is based on Pytorch (Paszke et al., 2017). For CR models, we set the embedding size of words and code tokens to 200, and chose batch size in {128, 256, 512}, LSTM unit size in {100, 200, 400} and dropout rate (Srivastava et al., 2014) in {0.1, 0.35, 0.5}. A small, fixed $\epsilon$ value of 0.05 is used in all the experiments. Hyper-parameters for each model were chosen based on the DEV set. For CODE-NN baseline, we followed Yao et al. (2018) to use the same model hyper-parameters as the original paper, except that the dropout rate is tuned in {0.5, 0.7}. The StaQC-val set was used to decay the learning rate and the best model parameters were decided based on the retrieval performance on the DEV set.

For CA models, the embedding size of words and code tokens and the LSTM unit size were selected from {256, 512}. The dropout rate is selected from {0.1, 0.3, 0.5} and the batch size is 64. We updated model parameters using the Adam optimizer (Kingma and Ba, 2014) with learning rate 0.001 for MLE training and 0.0001 for RL training. The maximum length of the generated annotation is set to 20. For CodeNN, MLE-based and RLBLEU-based CA models, the best model parameters were picked based on the model’s BLEU score on DEV, while for RLMRR-based CA model, we chose the best model according to its MRR reward on StaQC-val. For RL models, after pretraining the actor network via MLE, we first pretrain the critic network for 10 epochs, then jointly train the two networks for 40 epochs. Finally, for ensemble variants, the ensemble weight $\lambda$ in all variants is selected from $0.0\sim 1.0$ based on its performance on DEV.

5.5. Results

To understand our CoaCor framework, we first show several concrete examples to understand the differences between annotations generated by our model and by baseline/variant models, and then focus on two research questions (RQs):

• •

RQ1 (CR improves CA): Is the proposed retrieval reward-driven CA model capable of generating rich code annotations that can be used for code retrieval (i.e., can represent the code snippet and distinguish it from others)?

• •

RQ2 (CA improves CR): Can the generated annotations further improve existing QC-based code retrieval models?

5.5.1. Qualitative Analysis

Table 2 presents two examples of annotations generated by each CA model. Note that we do not target at human language-like annotations; rather, we focus on annotations that can describe/capture the functionality of a code snippet. In comparison with baseline CA models, our proposed RLMRR-based CA model can produce more concrete and precise descriptions for corresponding code snippets. As shown in Example 1, the annotation generated by RLMRR covers more conceptual keywords semantically aligned with the three NL queries (e.g., “average”, “difference”, “group”), while the baseline CODE-NN and the variants generate short descriptions covering a very limited amount of conceptual keywords (e.g., without mentioning the concept “subtracting”).

We also notice that our CA model can generate different forms of a stem word (e.g., “average”, “avg” in Example 1), partly because the retrieval-based reward tends to make the generated annotation semantically aligned with the code snippet and these diverse forms of words can help strengthen such semantic alignment and benefit the code retrieval task when there are various ways to express user search intent.

5.5.2. Code Retrieval Performance Evaluation

Table 1 shows the code retrieval evaluation results, based on which we discuss RQ1 and RQ2 as below:

RQ1: To examine whether or not the code annotations generated by a CA model can represent the corresponding code snippet in the code retrieval task, we analyze its corresponding QN-based CR model, which retrieves relevant code snippets by matching the NL query $Q$ with the code annotation $N$ generated by this CA model. Across all of the four datasets, our proposed QN-RLMRR model, which is based on a retrieval reward-driven CA model, achieves the best results and outperforms other QN-based CR models by a wide margin of around 0.1 $\sim$ 0.2 absolute MRR. More impressively, its performance is already on a par with the CODE-NN model, which is one of the state-of-the-art models for the code retrieval task, even though it understands a code snippet solely based on its annotation and without looking at the code content. This demonstrates that the code annotation generated by our proposed framework can reflect the semantic meaning of each code snippet more precisely.

To further understand whether or not the retrieval-based reward can serve as a better reward metric than BLEU (in terms of stimulating a CA model to generate useful annotations), we present the BLEU score of each CA model in Table 3.555BLEU is evaluated with the script provided by Iyer et al. (2016): https://github.com/sriniiyer/codenn/blob/master/src/utils/bleu.py. When connecting this table with Table 1, we observe an inverse trend: For the RLBLEU model which is trained for a higher BLEU score, although it can improve the MLE-based CA model by more than 2% absolute BLEU on three sets, it harms the latter’s ability on producing useful code annotations (as revealed by the performance of QN-RLBLEU in Table 1, which is worse than QN-MLE by around 0.04 absolute MRR on StaQC-val and StaQC-test). In contrast, our proposed RLMRR model, despite getting the lowest BLEU score, is capable of generating annotations useful for the retrieval task. This is mainly because that BLEU score calculates surface form overlaps while the retrieval-based reward measures the semantically aligned correspondences.

These observations imply an interesting conclusion: Compared with BLEU, a (task-oriented) semantic measuring reward, such as our retrieval-based MRR score, can better stimulate the model to produce detailed and useful generations. This is in line with the recent discussions on whether the automatic BLEU score is an appropriate evaluation metric for generation tasks or not (Liu et al., 2016; Novikova et al., 2017). In our work, we study the potential to use the performance of a relevant model to guide the learning of the target model, which can be generalized to many other scenarios, e.g., conversation generation (Li et al., 2016), machine translation (Bahdanau et al., 2016; Ranzato et al., 2015), etc.

RQ2: We first inspect whether the generated code annotations can assist the base code retrieval model (i.e., DCS) or not by comparing several ensemble CR variants. It is shown that, by simply combining the matching scores from QN-RLMRR and DCS with a weighting factor, our proposed model is able to significantly outperform the DCS model by 0.01 $\sim$ 0.03 and the CODE-NN baseline by 0.03 $\sim$ 0.06 consistently across all datasets, showing the advantage of utilizing code annotations for code retrieval. Particularly, the best performance is achieved when the ensemble weight $\lambda=0.4$ (i.e., 0.4 weight on the QN-based CR score and 0.6 on the QC-based CR score), meaning that the model relies heavily on the code annotation to achieve better performance.

In contrast, QN-CodeNN, QN-MLE and QN-RLBLEU can hardly improve the base DCS model, and their best performances are all achieved when the ensemble weight $\lambda=0.0$ $\sim$ $0.2$, indicating little help from annotations generated by CODE-NN, MLE-based and BLEU-rewarded CA. This is consistent with our conclusions to RQ1.

We also investigate the benefit of our generated annotations to other code retrieval models (besides DCS) by examining a baseline “QN-RLMRR + CODE-NN”, which combines QN-RLMRR and CODE-NN (as a QC-based CR model) to score a code snippet candidate. As mentioned in Section 5.3, CODE-NN scores a code snippet by the likelihood of generating the given NL query when taking this code snippet as the input. Since the score is in a different range from the cosine similarity given by QN-RLMRR, we first rescale it by taking its log value and dividing it by the largest absolute log score among all code candidates. The rescaled score is then combined with the cosine similarity score from QN-RLMRR following Eqn. (14). The result is shown in the last row of Table 1. It is very impressive that, with the help of QN-RLMRR, the CODE-NN model can be improved by $\geq$ 0.05 absolute MRR value across all test sets.

In summary, through extensive experiments, we show that our proposed framework can generate code annotations that are much more useful for building effective code retrieval models, in comparison with existing CA models or those trained by MLE or BLEU-based RL. Additionally, the generated code annotations can further improve the retrieval performance, when combined with existing CR models like DCS and CODE-NN.

6. Discussion

In this work, we propose a novel perspective of using a relevant downstream task (i.e., code retrieval) to guide the learning of a target task (i.e., code annotation), illustrating a novel machine-machine collaboration paradigm. It is shown that the annotations generated by the RLMRR CA model (trained with rewards from the DCS model) can boost the performance of the CODE-NN model, which was not involved in any stage of the training process. It is interesting to explore more about machine-machine collaboration mechanisms, where multiple models for either the same task or relevant tasks can be utilized in tandem to provide different views or effective rewards to improve the final performance.

In terms of training, we also experimented with directly using a QN-based CR model or an ensemble CR model for rewarding the CA model. However, these approaches do not work well, since we do not have a rich set of QN pairs as training data in the beginning. Collecting paraphrases of queries to form QN pairs is non-trivial, which we leave to the future.

Finally, our CoaCor framework is applicable to other programming languages, such as Python and C#, extension to which is interesting to study as future work.

7. Related Work

Code Retrieval. As introduced in Section 1, code retrieval has been studied widely with information retrieval methods (Haiduc et al., 2013; Lu et al., 2015; Hill et al., 2014; Keivanloo et al., 2014; Vinayakarao et al., 2017) and recent deep learning models (Allamanis et al., 2015; Iyer et al., 2016; Gu et al., 2018). Particularly, Keivanloo et al. (2014) extracted abstract programming patterns and their associated NL keywords from code snippets in a code base, with which a given NL query can be projected to a set of associated programming patterns facilitating code content-based search. Similarly, Vinayakarao et al. (2017) built an entity discovery system to mine NL phrases and their associated syntactic patterns, based on which they annotated each line of code snippets with NL phrases. Such annotations were utilized to improve NL keyword-based search engines. Different from these work, we construct a neural network-based code annotation model to describe the functionality of an entire code snippet. Our code annotation model is explicitly trained to produce meaningful words that can be used for code search. In our framework, the code retrieval model adopts a similar deep structure as the Deep Code Search model proposed by Gu et al. (2018), which projects a NL query and a code snippet into a vector space and measures the cosine similarity between them.

Code Annotation. Code annotation/summarization has drawn a lot of attention in recent years. Earlier works tackled the problem using template-based approaches (Sridhara et al., 2010; Moreno et al., 2013) and topic n-grams models (Movshovitz-Attias and Cohen, 2013) while the recent techniques (Allamanis et al., 2016; Hu et al., 2018a; Iyer et al., 2016; Hu et al., 2018b; Jiang et al., 2017; Loyola et al., 2017) are mostly built upon deep neural networks. Specifically, Sridhara et al. (2010) developed a software word usage model to identify action, theme and other arguments from a given code snippet, and generated code comments with templates. Allamanis et al. (2016) employed convolution on the input tokens to detect local time-invariant and long-range topical attention features to summarize a code snippet into a short, descriptive function name-like summary. Most related to our work are (Hu et al., 2018a) and (Wan et al., 2018), which utilized sequence-to-sequence networks with attention over code tokens to generate natural language annotations. They aimed to generate NL annotations as close as possible to human-provided annotations for human readability, and hence adopted the Maximum Likelihood Estimation (MLE) or BLEU score optimization as the objective. However, our goal is to generate code annotations which can be used for code retrieval, and therefore we design a retrieval-based reward to drive our training.

Deep Reinforcement Learning for Sequence Generation. Reinforcement learning (RL) (Sutton and Barto, 1998) has shown great success in various tasks where an agent has to perform multiple actions before obtaining a reward or when the metric to optimize is not differentiable. The sequence generation tasks, such as machine translation (Ranzato et al., 2015; Nguyen et al., 2017; Bahdanau et al., 2016), image captioning (Rennie et al., 2017), dialogue generation (Li et al., 2016) and text summarization (Paulus et al., 2017), have all benefitted from RL to address the exposure bias issue (Bahdanau et al., 2016; Rennie et al., 2017; Ranzato et al., 2015) and to directly optimize the model towards a certain metric (e.g., BLEU).

Particularly, Ranzato et al. (2015) were among the first to successfully apply the REINFORCE algorithm (Williams, 1992) to train RNN models for several sequence generation tasks, indicating that directly optimizing the metric used at test time can lead to significantly better models than those trained via MLE. Bahdanau et al. (2016) additionally learned a critic network to better estimate the return (i.e., future rewards) of taking a certain action under a specific state, and trained the entire generation model via the Actor-Critic algorithm (Sutton et al., 2000). We follow Nguyen et al. (2017) and Wan et al. (2018) to further introduce an advantage function and train the code annotation model via the Advantage Actor-Critic algorithm (Mnih et al., 2016), which is helpful for reducing biases from rarely taken actions. However, unlike their work, the reward in our framework is based on the performance on a different yet relevant task (i.e., code retrieval), rather than the BLEU metric.

**Machine-Machine Collaboration via Adversarial Training

and Dual/Joint Learning.** Various kinds of machine-machine collaboration mechanisms have been studied in many scenarios (Goodfellow et al., 2014; He et al., 2016; Wang et al., 2017; Tang et al., 2017; Li et al., 2018a). For example, Goodfellow et al. (2014) proposed the Generative Adversarial Nets (GANs) framework, where a generative model generates images to fool a discriminative classifier, and the latter is further improved to distinguish the generated from the real ones. He et al. (2016) proposed the dual learning framework and jointly optimized the machine translation from English to French and from French to English. Li et al. (2018b) trained a paraphrase generator by rewards from a paraphrase evaluator model. In the context of code retrieval and annotation, Chen and Zhou (2018) and Iyer et al. (2016) showed that their models can be used directly or with slight modification for both tasks, but their training objective only considered one of the two tasks. All these frameworks are not directly applicable to achieve our goal, i.e., training a code annotation model to generate rich NL annotations that can be used for code search.

8. Conclusion

This paper explored a novel perspective of generating code annotations for code retrieval. To this end, we proposed a reinforcement learning-based framework (named “CoaCor”) to maximize a retrieval-based reward. Through comprehensive experiments, we demonstrated that the annotation generated by our framework is more detailed to represent the semantic meaning of a code snippet. Such annotations can also improve the existing code content-based retrieval models significantly. In the future, we will explore other usages of the generated code annotations, as well as generalizing our framework to other tasks such as machine translation.

Acknowledgments

This research was sponsored in part by the Army Research Office under cooperative agreements W911NF-17-1-0412, NSF Grant IIS1815674, Fujitsu gift grant, and Ohio Supercomputer Center (Center, 1987). The views and conclusions contained herein are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the Army Research Office or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notice herein.