Towards Generation of Visual Attention Map for Source Code

TL;DR

This paper proposes a framework to analyze programmers' gaze behavior in source code comprehension by comparing it with importance maps generated by attention models like code2vec, aiming to better understand and reflect component importance.

Contribution

It introduces a novel conceptual framework that uses attention maps from models to quantify component importance and analyze gaze behavior during code comprehension.

Findings

Preliminary experiment results show potential for aligning gaze data with attention-based importance.

The framework offers a new approach to understanding source code comprehension processes.

It bridges the gap between model-derived importance and human gaze behavior in programming.

Abstract

Program comprehension is a dominant process in software development and maintenance. Experts are considered to comprehend the source code efficiently by directing their gaze, or attention, to important components in it. However, reflecting the importance of components is still a remaining issue in gaze behavior analysis for source code comprehension. Here we show a conceptual framework to compare the quantified importance of source code components with the gaze behavior of programmers. We use "attention" in attention models (e.g., code2vec) as the importance indices for source code components and evaluate programmers' gaze locations based on the quantified importance. In this report, we introduce the idea of our gaze behavior analysis using the attention map, and the results of a preliminary experiment.

Tables

Table 1. Listing 1: A substring search algorithm written in Java

#	Line number	Token	Attention value
1	11	if	1.33
2	11	"END_OF_TEXT"	1.31
3	9	while	1.17
4	2	args	0.89
5	7	word111The one at the left-hand side of the equal symbol.	0.48

Equations

$$C_{x,y}^{\mathrm{bin}}=\{\begin{array}{ll}1& \mathrm{if}{C}_{x,y}>\mathrm{threshold}\\ 0& \mathrm{otherwise},\end{array}$$

$$\mathrm{TPR}$$

$$\mathrm{FPR}$$

Full text

1 Introduction

Program comprehension is a dominant process in software development and maintenance. Programmers spent 50 % to 60 % of their time on program comprehension in a large-scale field study [1]. The study has also shown that the senior programmers spent less time on program comprehension. In other words, the time for program comprehension can be reduced through the appropriate experience or education. Such efficient program comprehension might lead to productivity enhancement of the software development process.

A clue to improve the efficiency of program comprehension might be the gaze behavior of experts. We consider that expert programmers can comprehend source code efficiently by directing their gaze, or attention, to important components in it. In previous studies, researchers conducted gaze measurement experiments with programmers to identify the attended targets. Uwano et al. [2] analyzed individual performance in reviewing source code of computer programs with gaze data. Their result showed that the subjects with high performance were likely to first read the whole lines of the source code from the top to the bottom briefly, and then to concentrate their gaze to some particular areas. Crosby et al. [3] conducted gaze experiments to examine how programmers from different experience levels understand source code. Their results showed that experienced programmers were likely to focus their gaze on complex statements. However, reflecting the importance of components is still a remaining issue in gaze behavior analysis for source code comprehension.

Apart from program comprehension, visual attention has been modeled to clarify its underlying mechanism. One of the representative studies of visual attention modeling is the saliency map as an indicator of stimulus-driven visual selection [4, 5]. The saliency map has been proposed by mimicking the neural mechanism of the early visual system of humans. In the saliency map theory, visual attention is assumed to be guided by high contrast locations of three elementary features: color, intensity, and orientation. Koide et al. [6] investigated the relationship between art-related expertise and the saliency map. They recorded the gaze behavior of artists and novices during the free viewing of various abstract paintings, and evaluated the consistency between the gaze distribution and the saliency map. The gaze distributions of artists were less consistent with the saliency map than novices. This discrepancy between the experts’ gaze behavior and the saliency map, which is a bottom-up attention model, could be explained by the existence of top-down, goal-oriented attention mechanism which can be modified by experience or education.

This study aims to develop a visual attention map that can identify important components of source code in the top-down, goal-oriented manner. To do this, we used “code2vec”, a neural network model for classification of source code with an attention mechanism, to identify important components in source code. Also, we conducted preliminary gaze experiments and a comparison analysis between the gaze behavior of a human subject and the visual attention map generated with our proposed method. Here, we assume the consistency between the attention map and gaze distribution could be the support for the feasibility of this method to identify important factors.

The rest of this paper is organized as follows: Sec. 2 reviews the mechanism of code2vec program summarization model and introduces our idea on how the attention map on top of code2vec’s attention model contributes to analyzing programmers’ gaze behavior. Sec. 3 explains the procedure to generate the attention map and gaze experiment design using human subjects. Sec. 4 summarizes the results of preliminary experiments. Finally, Sec. 5 concludes this proposal with some discussion.

2 Attention Map for Source Code

Code2vec [7, 8] is a machine learning model to learn a vector embedding of source code, called the “code vector”. Code2vec has an attention mechanism to recognize important components in source code for accurate name discrimination. The model has shown good performance in discriminating function names which concisely represent their functionalities, and the authors showed the attention mechanism is necessary for achieving good performance.

The upper half of Fig. 1 illustrates how code2vec estimates the code vectors and how its attention mechanism defines the importance of source code components. First, the input source code is converted into an abstract syntax tree (AST), which is a tree data structure representing normalized syntactic information. Then, code2vec extracts “path contexts” from the AST. A path context consists of three elements: two terminal nodes (leaves) in the AST and the route connecting those terminal nodes. Code2vec extracts up to 200 path contexts estimates a path context vector for each, and finally the code vector is computed as a weighted sum of these path context vector (this step is not depicted in Fig. 1). The “attention” of code2vec defines this weight for the path contexts. A higher attention value means the correspondent path context contains important information for discriminating function name, and hence the path context vector for such path context greatly affects the final code vector.

In the present study, we assume the expertise of a programmer could be represented using the consistency between the code2vec’s attention and a programmer’s gaze focus. Based on this assumption, we evaluate how much a programmer focuses on the source code components that are estimated as important by code2vec’s attention mechanism. However, code2vec’s attention is difficult to directly compare with subjects’ spatial gaze distribution since the attention model estimates the importance of path contexts appearing on AST. To fill the gap, we propose a method to generate spatial “attention map” on source code, using the attention value estimated by code2vec. The detailed procedure of attention map generation is explained in Sec. 3.2.

3 Preliminary Experiments

3.1 Acquisition of source code

To test the feasibility of visual attention map generation, we conducted a preliminary experiment using a set of code snippets implementing fundamental algorithms. Based on two popular textbooks about computer algorithms [9, 10], we first selected eleven fundamental algorithms: binary search, linear search, bubble sort, selection sort, insertion sort, greatest common divisor, power, primality testing, run-length encoding, string sort, and substring search. We then collected 1251 Java code snippets implementing the selected algorithms from an open codeset provided by AIZU ONLINE JUDGE [11]. In the present study, we used a set of 72 code snippets with minimum deviations of superficial characteristics i.e. lines of code (LOC) and characters per line (CPL). To further mitigate non-semantic visual variations, the indentation styles of all code snippets were normalized by replacing a tab-space with two white-spaces. For keeping algorithmic diversity, the selected codeset included six snippets for each algorithm but twelve snippets for linear search. The codeset allowed us to examine the feasibility of our proposed method based on a variety of fundamental algorithms.

3.2 Attention Map Generation

To quantify the “importance” of each component in the given source code, we used the attention model of code2vec [7, 8]. Since code2vec computes the attention for each path context in the given AST of source code, we reconstructed a spatial attention map based on the attention value of each path context. The bottom half of Fig. 1 illustrates the attention map generation procedure. In short, we first computed attention values of the nodes appearing in the given AST, then generated a spatial map over a source code image using those node attention values.

First, each path context was decomposed into a list of nodes in the AST. Then, the attention value for each path context was added to the attention value of each node in this list. Repeating this procedure for each path context, the attention distribution over the set of AST nodes was obtained. Next, we converted this node attention distribution into a spatial attention map as a mixture of Gaussian functions. Some of the nodes had their correspondent tokens in the source code, like if for IfStmt, and > symbol for GreaterThan. For those correspondent tokens, a two-dimensional Gaussian function was allocated to each token such that

its center was located at the coordinate of the center of the token in the stimulus image, 2. 2.

its maximum height was equal to the attention value defined in the attention distribution over AST nodes, and 3. 3.

its variance corresponded to the spatial size of the token in an image.

The spatial map was obtained as the summation of these Gaussian functions for all tokens.

3.3 Gaze Experiment

Given the spatial attention map introduced above, the consistency between the map and the programmer’s gaze distribution was quantified. We recorded a programmer’s gaze distribution using Tobii Pro TX300 [12] (Tobii Technology, Sweden), while presenting the source code image as visual stimuli (see Sec. 3.1). The device has a 23-inch display of full HD resolution (1920 px in width and 1080 px in height). We recorded the subject’s gaze points with the sampling rate of 120 Hz. The experimental procedure was controlled by PsychoPy [13, 14].

After the experiment, the stimulus images were clipped into squares 840 px on a side prior to the further analysis to avoid excessively high consistency due to the inclusion of the blank area in the images. Outliers in the recorded gaze data which exceed these square boundaries were removed. The proportion of removed data points against the whole data was less than 0.1 %.

3.4 Evaluation

To quantify the consistency, we adopted an evaluation method proposed in [6]. The receiver operating characteristics (ROC) curve was calculated by defining the ground truth as the subject’s gaze distribution and the estimation as the binarized attention map computed with code2vec. Having defined the threshold of attention, the code2vec attention map $C$ was binarized into $C^{\mathrm{bin}}$:

[TABLE]

where $C_{x,y}$ and $C^{\mathrm{bin}}_{x,y}$ represent the attention value for pixel $(x,y)$ in $C$ and $C^{\mathrm{bin}}$, respectively. With this binarized attention map, the true positive rate (TPR) and the false positive rate (FPR) given a gaze distribution is calculated as follows.

[TABLE]

where $G^{+}$ is the gaze distribution which counts the gaze point per pixel, while $G^{-}$ is a binary negation of $G^{+}$, s.t. ${G^{-}_{x,y}=1\Leftrightarrow G^{+}_{x,y}=0}$ and $G^{-}_{x,y}=0\Leftrightarrow G^{+}_{x,y}>0$. Also, $\circ$ denotes the Hadamard product (pixel-wise product) of two maps or distributions. ROC curve was obtained by computing these TPR and FPR with varying the threshold and plotting those values.

After calculating the ROC curve, the area under the curve (AUC) was obtained. The AUC quantifies the consistency between the subject’s gaze distribution and the attention map. Higher AUC value indicates that the subject strongly focused their gaze on important components in source code, and thus it is assumed to represent their expertise in reading source code.

4 Results

As a preliminary experiment, we quantified the attention maps for the target source code (see Sec. 3.1), and evaluated the consistency of those maps against gaze distributions recorded from a human subject. In the rest of this section, we describe a representative result obtained using a substring search algorithm shown in Listing LABEL:javasrc.

Fig. 2(a) shows the estimated spatial attention map for the source code. The attention map was sparse, and there were only a few tokens with high attention value (deep orange color). Table 1 lists the top 5 of those highly attended tokens. Given this source code implements a substring search algorithm that counts the number of words until the word “END_OF_TEXT” appears, these highly attended tokens, especially the tokens if, while, and "END_OF_TEXT", match our intuitive evaluation of token importance.

We recorded the gaze behavior of a research student in the information science division who had a little experience in Java programming (i.e. not an expert programmer). Fig. 2(b) shows the raw recorded gaze data. Each blue dot represents a gaze point. The subject scanned the entire code region without noticeable focuses.

Having the gaze distribution recorded, we evaluated the coincidence between this distribution and the attention map. The calculated ROC curve is shown in Fig. 2(c). The AUC of this ROC curve was 0.85, and this was regarded as moderate consistency.

5 Discussions

We proposed the attention map for source code using code2vec and evaluated the consistency between the attention map and gaze distribution recorded with a subject. The AUC of 0.85 can be regarded as moderate consistency. This result supports the feasibility of our proposed method as the attention model to some extent. The proposed method enables us to evaluate the behavior related to higher cognitive function like program comprehension. This approach might be applicable to other higher cognitive functions. On the other hand, the generated visual attention map showed sparser distribution than the gaze distribution. Since the subject in this experiment was not an expert programmer, gaze distribution was not so concentrated. Expert programmers may have sparser gaze distributions since such fewer gaze points should lead to a reduction of the time for program comprehension. In our future experiment, we will recruit multiple expert programmers and novices to show the validity of this attention map.

Other attention models, like code2seq [15], can be alternatives to generate different types of attention maps. For example, the seq2seq type attention model like code2seq can model the dynamic transition of attention although this study considered static attention [16]. By giving attended words as the output of a decoder, it may be possible to model actual dynamic attention. Note that introducing attended words to attention in a model is different from the current study since this study merely evaluated the correspondence of gaze distribution and attention weights of code2vec. In the future, we will develop such models in parallel with the experimental study mentioned above.

Acknowledgments

We would like to thank Dr. Nishanth Koganti for his valuable advice and comments. This work was supported by JSPS KAKENHI Grant Numbers JP19J20669, JP18J22957, JP18K18108, JP16H06569, and JP16H05857.